terraconstructs 0.0.11 → 0.0.12

package/lib/aws/compute/ec2-util.js

@@ -0,0 +1,138 @@
+"use strict";
+// https://github.com/aws/aws-cdk/blob/v2.175.1/packages/aws-cdk-lib/aws-ec2/lib/util.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportSubnetGroup = void 0;
+exports.slugify = slugify;
+exports.defaultSubnetName = defaultSubnetName;
+exports.subnetGroupNameFromConstructId = subnetGroupNameFromConstructId;
+exports.subnetId = subnetId;
+exports.range = range;
+exports.allRouteTableIds = allRouteTableIds;
+exports.flatten = flatten;
+const vpc_1 = require("./vpc");
+// import { IVersion } from "./function-version";
+/**
+ * Turn an arbitrary string into one that can be used as a CloudFormation identifier by stripping special characters
+ *
+ * (At the moment, no efforts are taken to prevent collisions, but we can add that later when it becomes necessary).
+ */
+function slugify(x) {
+    return x.replace(/[^a-zA-Z0-9]/g, "");
+}
+/**
+ * The default names for every subnet type
+ */
+function defaultSubnetName(type) {
+    switch (type) {
+        case vpc_1.SubnetType.PUBLIC:
+            return "Public";
+        case vpc_1.SubnetType.PRIVATE_WITH_NAT:
+        case vpc_1.SubnetType.PRIVATE_WITH_EGRESS:
+        case vpc_1.SubnetType.PRIVATE:
+            return "Private";
+        case vpc_1.SubnetType.PRIVATE_ISOLATED:
+        case vpc_1.SubnetType.ISOLATED:
+            return "Isolated";
+    }
+}
+/**
+ * Return a subnet name from its construct ID
+ *
+ * All subnet names look like NAME <> "Subnet" <> INDEX
+ */
+function subnetGroupNameFromConstructId(subnet) {
+    return subnet.node.id.replace(/Subnet\d+$/, "");
+}
+/**
+ * Make the subnet construct ID from a name and number
+ */
+function subnetId(name, i) {
+    return `${name}Subnet${i + 1}`;
+}
+class ImportSubnetGroup {
+    constructor(subnetIds, names, routeTableIds, ipv4CidrBlocks, type, availabilityZones, idField, nameField, routeTableIdField, ipv4CidrBlockField) {
+        this.availabilityZones = availabilityZones;
+        this.subnetIds = subnetIds || [];
+        this.routeTableIds = routeTableIds || [];
+        this.ipv4CidrBlocks = ipv4CidrBlocks || [];
+        this.groups = this.subnetIds.length / this.availabilityZones.length;
+        if (Math.floor(this.groups) !== this.groups) {
+            // eslint-disable-next-line max-len
+            throw new Error(`Number of ${idField} (${this.subnetIds.length}) must be a multiple of availability zones (${this.availabilityZones.length}).`);
+        }
+        if (this.routeTableIds.length !== this.subnetIds.length &&
+            routeTableIds != null) {
+            // We don't err if no routeTableIds were provided to maintain backwards-compatibility. See https://github.com/aws/aws-cdk/pull/3171
+            /* eslint-disable max-len */
+            throw new Error(`Number of ${routeTableIdField} (${this.routeTableIds.length}) must be equal to the amount of ${idField} (${this.subnetIds.length}).`);
+        }
+        if (this.ipv4CidrBlocks.length !== this.subnetIds.length &&
+            ipv4CidrBlocks != null) {
+            // We don't err if no ipv4CidrBlocks were provided to maintain backwards-compatibility.
+            /* eslint-disable max-len */
+            throw new Error(`Number of ${ipv4CidrBlockField} (${this.ipv4CidrBlocks.length}) must be equal to the amount of ${idField} (${this.subnetIds.length}).`);
+        }
+        this.names = this.normalizeNames(names, defaultSubnetName(type), nameField);
+    }
+    import(scope) {
+        return range(this.subnetIds.length).map((i) => {
+            const k = Math.floor(i / this.availabilityZones.length);
+            return vpc_1.Subnet.fromSubnetAttributes(scope, subnetId(this.names[k], i), {
+                availabilityZone: this.pickAZ(i),
+                subnetId: this.subnetIds[i],
+                routeTableId: this.routeTableIds[i],
+                ipv4CidrBlock: this.ipv4CidrBlocks[i],
+            });
+        });
+    }
+    /**
+     * Return a list with a name for every subnet
+     */
+    normalizeNames(names, defaultName, fieldName) {
+        // If not given, return default
+        if (names === undefined || names.length === 0) {
+            return [defaultName];
+        }
+        // If given, must match given subnets
+        if (names.length !== this.groups) {
+            throw new Error(`${fieldName} must have an entry for every corresponding subnet group, got: ${JSON.stringify(names)}`);
+        }
+        return names;
+    }
+    /**
+     * Return the i'th AZ
+     */
+    pickAZ(i) {
+        return this.availabilityZones[i % this.availabilityZones.length];
+    }
+}
+exports.ImportSubnetGroup = ImportSubnetGroup;
+/**
+ * Generate the list of numbers of [0..n)
+ */
+function range(n) {
+    const ret = [];
+    for (let i = 0; i < n; i++) {
+        ret.push(i);
+    }
+    return ret;
+}
+/**
+ * Return the union of table IDs from all selected subnets
+ */
+function allRouteTableIds(subnets) {
+    const ret = new Set();
+    for (const subnet of subnets) {
+        if (subnet.routeTable && subnet.routeTable.routeTableId) {
+            ret.add(subnet.routeTable.routeTableId);
+        }
+    }
+    return Array.from(ret);
+}
+/**
+ * Flatten a list of lists into a list of elements
+ */
+function flatten(xs) {
+    return Array.prototype.concat.apply([], xs);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ec2-util.js","sourceRoot":"","sources":["../../../src/aws/compute/ec2-util.ts"],"names":[],"mappings":"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","sourcesContent":["// https://github.com/aws/aws-cdk/blob/v2.175.1/packages/aws-cdk-lib/aws-ec2/lib/util.ts\n\nimport { Construct } from \"constructs\";\nimport { ISubnet, Subnet, SubnetType } from \"./vpc\";\n// import { IVersion } from \"./function-version\";\n\n/**\n * Turn an arbitrary string into one that can be used as a CloudFormation identifier by stripping special characters\n *\n * (At the moment, no efforts are taken to prevent collisions, but we can add that later when it becomes necessary).\n */\nexport function slugify(x: string): string {\n  return x.replace(/[^a-zA-Z0-9]/g, \"\");\n}\n\n/**\n * The default names for every subnet type\n */\nexport function defaultSubnetName(type: SubnetType) {\n  switch (type) {\n    case SubnetType.PUBLIC:\n      return \"Public\";\n    case SubnetType.PRIVATE_WITH_NAT:\n    case SubnetType.PRIVATE_WITH_EGRESS:\n    case SubnetType.PRIVATE:\n      return \"Private\";\n    case SubnetType.PRIVATE_ISOLATED:\n    case SubnetType.ISOLATED:\n      return \"Isolated\";\n  }\n}\n\n/**\n * Return a subnet name from its construct ID\n *\n * All subnet names look like NAME <> \"Subnet\" <> INDEX\n */\nexport function subnetGroupNameFromConstructId(subnet: ISubnet) {\n  return subnet.node.id.replace(/Subnet\\d+$/, \"\");\n}\n\n/**\n * Make the subnet construct ID from a name and number\n */\nexport function subnetId(name: string, i: number) {\n  return `${name}Subnet${i + 1}`;\n}\n\nexport class ImportSubnetGroup {\n  private readonly subnetIds: string[];\n  private readonly names: string[];\n  private readonly routeTableIds: string[];\n  private readonly ipv4CidrBlocks: string[];\n  private readonly groups: number;\n\n  constructor(\n    subnetIds: string[] | undefined,\n    names: string[] | undefined,\n    routeTableIds: string[] | undefined,\n    ipv4CidrBlocks: string[] | undefined,\n    type: SubnetType,\n    private readonly availabilityZones: string[],\n    idField: string,\n    nameField: string,\n    routeTableIdField: string,\n    ipv4CidrBlockField: string,\n  ) {\n    this.subnetIds = subnetIds || [];\n    this.routeTableIds = routeTableIds || [];\n    this.ipv4CidrBlocks = ipv4CidrBlocks || [];\n    this.groups = this.subnetIds.length / this.availabilityZones.length;\n\n    if (Math.floor(this.groups) !== this.groups) {\n      // eslint-disable-next-line max-len\n      throw new Error(\n        `Number of ${idField} (${this.subnetIds.length}) must be a multiple of availability zones (${this.availabilityZones.length}).`,\n      );\n    }\n    if (\n      this.routeTableIds.length !== this.subnetIds.length &&\n      routeTableIds != null\n    ) {\n      // We don't err if no routeTableIds were provided to maintain backwards-compatibility. See https://github.com/aws/aws-cdk/pull/3171\n      /* eslint-disable max-len */\n      throw new Error(\n        `Number of ${routeTableIdField} (${this.routeTableIds.length}) must be equal to the amount of ${idField} (${this.subnetIds.length}).`,\n      );\n    }\n    if (\n      this.ipv4CidrBlocks.length !== this.subnetIds.length &&\n      ipv4CidrBlocks != null\n    ) {\n      // We don't err if no ipv4CidrBlocks were provided to maintain backwards-compatibility.\n      /* eslint-disable max-len */\n      throw new Error(\n        `Number of ${ipv4CidrBlockField} (${this.ipv4CidrBlocks.length}) must be equal to the amount of ${idField} (${this.subnetIds.length}).`,\n      );\n    }\n\n    this.names = this.normalizeNames(names, defaultSubnetName(type), nameField);\n  }\n\n  public import(scope: Construct): ISubnet[] {\n    return range(this.subnetIds.length).map((i) => {\n      const k = Math.floor(i / this.availabilityZones.length);\n      return Subnet.fromSubnetAttributes(scope, subnetId(this.names[k], i), {\n        availabilityZone: this.pickAZ(i),\n        subnetId: this.subnetIds[i],\n        routeTableId: this.routeTableIds[i],\n        ipv4CidrBlock: this.ipv4CidrBlocks[i],\n      });\n    });\n  }\n\n  /**\n   * Return a list with a name for every subnet\n   */\n  private normalizeNames(\n    names: string[] | undefined,\n    defaultName: string,\n    fieldName: string,\n  ) {\n    // If not given, return default\n    if (names === undefined || names.length === 0) {\n      return [defaultName];\n    }\n\n    // If given, must match given subnets\n    if (names.length !== this.groups) {\n      throw new Error(\n        `${fieldName} must have an entry for every corresponding subnet group, got: ${JSON.stringify(names)}`,\n      );\n    }\n\n    return names;\n  }\n\n  /**\n   * Return the i'th AZ\n   */\n  private pickAZ(i: number) {\n    return this.availabilityZones[i % this.availabilityZones.length];\n  }\n}\n\n/**\n * Generate the list of numbers of [0..n)\n */\nexport function range(n: number): number[] {\n  const ret: number[] = [];\n  for (let i = 0; i < n; i++) {\n    ret.push(i);\n  }\n  return ret;\n}\n/**\n * Return the union of table IDs from all selected subnets\n */\nexport function allRouteTableIds(subnets: ISubnet[]): string[] {\n  const ret = new Set<string>();\n  for (const subnet of subnets) {\n    if (subnet.routeTable && subnet.routeTable.routeTableId) {\n      ret.add(subnet.routeTable.routeTableId);\n    }\n  }\n  return Array.from(ret);\n}\n\n/**\n * Flatten a list of lists into a list of elements\n */\nexport function flatten<A>(xs: A[][]): A[] {\n  return Array.prototype.concat.apply([], xs);\n}\n"]}

package/lib/aws/compute/elasticloadbalancing-canned-metrics.generated.d.ts

@@ -0,0 +1,176 @@
+export interface MetricWithDims<D> {
+    readonly namespace: string;
+    readonly metricName: string;
+    readonly statistic: string;
+    readonly dimensionsMap: D;
+}
+export declare class ELBMetrics {
+    static backendConnectionErrorsSum(dimensions: {
+        LoadBalancerName: string;
+    }): MetricWithDims<{
+        LoadBalancerName: string;
+    }>;
+    static backendConnectionErrorsSum(dimensions: {
+        AvailabilityZone: string;
+        LoadBalancerName: string;
+    }): MetricWithDims<{
+        AvailabilityZone: string;
+        LoadBalancerName: string;
+    }>;
+    static desyncMitigationModeNonCompliantRequestCountSum(dimensions: {
+        LoadBalancerName: string;
+    }): MetricWithDims<{
+        LoadBalancerName: string;
+    }>;
+    static desyncMitigationModeNonCompliantRequestCountSum(dimensions: {
+        AvailabilityZone: string;
+        LoadBalancerName: string;
+    }): MetricWithDims<{
+        AvailabilityZone: string;
+        LoadBalancerName: string;
+    }>;
+    static httpCodeBackend2XxSum(dimensions: {
+        LoadBalancerName: string;
+    }): MetricWithDims<{
+        LoadBalancerName: string;
+    }>;
+    static httpCodeBackend2XxSum(dimensions: {
+        AvailabilityZone: string;
+        LoadBalancerName: string;
+    }): MetricWithDims<{
+        AvailabilityZone: string;
+        LoadBalancerName: string;
+    }>;
+    static httpCodeBackend3XxSum(dimensions: {
+        LoadBalancerName: string;
+    }): MetricWithDims<{
+        LoadBalancerName: string;
+    }>;
+    static httpCodeBackend3XxSum(dimensions: {
+        AvailabilityZone: string;
+        LoadBalancerName: string;
+    }): MetricWithDims<{
+        AvailabilityZone: string;
+        LoadBalancerName: string;
+    }>;
+    static httpCodeBackend4XxSum(dimensions: {
+        LoadBalancerName: string;
+    }): MetricWithDims<{
+        LoadBalancerName: string;
+    }>;
+    static httpCodeBackend4XxSum(dimensions: {
+        AvailabilityZone: string;
+        LoadBalancerName: string;
+    }): MetricWithDims<{
+        AvailabilityZone: string;
+        LoadBalancerName: string;
+    }>;
+    static httpCodeBackend5XxSum(dimensions: {
+        LoadBalancerName: string;
+    }): MetricWithDims<{
+        LoadBalancerName: string;
+    }>;
+    static httpCodeBackend5XxSum(dimensions: {
+        AvailabilityZone: string;
+        LoadBalancerName: string;
+    }): MetricWithDims<{
+        AvailabilityZone: string;
+        LoadBalancerName: string;
+    }>;
+    static httpCodeElb4XxSum(dimensions: {
+        LoadBalancerName: string;
+    }): MetricWithDims<{
+        LoadBalancerName: string;
+    }>;
+    static httpCodeElb4XxSum(dimensions: {
+        AvailabilityZone: string;
+        LoadBalancerName: string;
+    }): MetricWithDims<{
+        AvailabilityZone: string;
+        LoadBalancerName: string;
+    }>;
+    static httpCodeElb5XxSum(dimensions: {
+        LoadBalancerName: string;
+    }): MetricWithDims<{
+        LoadBalancerName: string;
+    }>;
+    static httpCodeElb5XxSum(dimensions: {
+        AvailabilityZone: string;
+        LoadBalancerName: string;
+    }): MetricWithDims<{
+        AvailabilityZone: string;
+        LoadBalancerName: string;
+    }>;
+    static healthyHostCountAverage(dimensions: {
+        LoadBalancerName: string;
+    }): MetricWithDims<{
+        LoadBalancerName: string;
+    }>;
+    static healthyHostCountAverage(dimensions: {
+        AvailabilityZone: string;
+        LoadBalancerName: string;
+    }): MetricWithDims<{
+        AvailabilityZone: string;
+        LoadBalancerName: string;
+    }>;
+    static latencyAverage(dimensions: {
+        LoadBalancerName: string;
+    }): MetricWithDims<{
+        LoadBalancerName: string;
+    }>;
+    static latencyAverage(dimensions: {
+        AvailabilityZone: string;
+        LoadBalancerName: string;
+    }): MetricWithDims<{
+        AvailabilityZone: string;
+        LoadBalancerName: string;
+    }>;
+    static requestCountSum(dimensions: {
+        LoadBalancerName: string;
+    }): MetricWithDims<{
+        LoadBalancerName: string;
+    }>;
+    static requestCountSum(dimensions: {
+        AvailabilityZone: string;
+        LoadBalancerName: string;
+    }): MetricWithDims<{
+        AvailabilityZone: string;
+        LoadBalancerName: string;
+    }>;
+    static spilloverCountSum(dimensions: {
+        LoadBalancerName: string;
+    }): MetricWithDims<{
+        LoadBalancerName: string;
+    }>;
+    static spilloverCountSum(dimensions: {
+        AvailabilityZone: string;
+        LoadBalancerName: string;
+    }): MetricWithDims<{
+        AvailabilityZone: string;
+        LoadBalancerName: string;
+    }>;
+    static surgeQueueLengthAverage(dimensions: {
+        LoadBalancerName: string;
+    }): MetricWithDims<{
+        LoadBalancerName: string;
+    }>;
+    static surgeQueueLengthAverage(dimensions: {
+        AvailabilityZone: string;
+        LoadBalancerName: string;
+    }): MetricWithDims<{
+        AvailabilityZone: string;
+        LoadBalancerName: string;
+    }>;
+    static unHealthyHostCountAverage(dimensions: {
+        LoadBalancerName: string;
+    }): MetricWithDims<{
+        LoadBalancerName: string;
+    }>;
+    static unHealthyHostCountAverage(dimensions: {
+        AvailabilityZone: string;
+        LoadBalancerName: string;
+    }): MetricWithDims<{
+        AvailabilityZone: string;
+        LoadBalancerName: string;
+    }>;
+}

package/lib/aws/compute/elasticloadbalancing-canned-metrics.generated.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ELBMetrics = void 0;
+class ELBMetrics {
+    static backendConnectionErrorsSum(dimensions) {
+        return {
+            "namespace": "AWS/ELB",
+            "metricName": "BackendConnectionErrors",
+            "dimensionsMap": dimensions,
+            "statistic": "Sum"
+        };
+    }
+    static desyncMitigationModeNonCompliantRequestCountSum(dimensions) {
+        return {
+            "namespace": "AWS/ELB",
+            "metricName": "DesyncMitigationMode_NonCompliant_Request_Count",
+            "dimensionsMap": dimensions,
+            "statistic": "Sum"
+        };
+    }
+    static httpCodeBackend2XxSum(dimensions) {
+        return {
+            "namespace": "AWS/ELB",
+            "metricName": "HTTPCode_Backend_2XX",
+            "dimensionsMap": dimensions,
+            "statistic": "Sum"
+        };
+    }
+    static httpCodeBackend3XxSum(dimensions) {
+        return {
+            "namespace": "AWS/ELB",
+            "metricName": "HTTPCode_Backend_3XX",
+            "dimensionsMap": dimensions,
+            "statistic": "Sum"
+        };
+    }
+    static httpCodeBackend4XxSum(dimensions) {
+        return {
+            "namespace": "AWS/ELB",
+            "metricName": "HTTPCode_Backend_4XX",
+            "dimensionsMap": dimensions,
+            "statistic": "Sum"
+        };
+    }
+    static httpCodeBackend5XxSum(dimensions) {
+        return {
+            "namespace": "AWS/ELB",
+            "metricName": "HTTPCode_Backend_5XX",
+            "dimensionsMap": dimensions,
+            "statistic": "Sum"
+        };
+    }
+    static httpCodeElb4XxSum(dimensions) {
+        return {
+            "namespace": "AWS/ELB",
+            "metricName": "HTTPCode_ELB_4XX",
+            "dimensionsMap": dimensions,
+            "statistic": "Sum"
+        };
+    }
+    static httpCodeElb5XxSum(dimensions) {
+        return {
+            "namespace": "AWS/ELB",
+            "metricName": "HTTPCode_ELB_5XX",
+            "dimensionsMap": dimensions,
+            "statistic": "Sum"
+        };
+    }
+    static healthyHostCountAverage(dimensions) {
+        return {
+            "namespace": "AWS/ELB",
+            "metricName": "HealthyHostCount",
+            "dimensionsMap": dimensions,
+            "statistic": "Average"
+        };
+    }
+    static latencyAverage(dimensions) {
+        return {
+            "namespace": "AWS/ELB",
+            "metricName": "Latency",
+            "dimensionsMap": dimensions,
+            "statistic": "Average"
+        };
+    }
+    static requestCountSum(dimensions) {
+        return {
+            "namespace": "AWS/ELB",
+            "metricName": "RequestCount",
+            "dimensionsMap": dimensions,
+            "statistic": "Sum"
+        };
+    }
+    static spilloverCountSum(dimensions) {
+        return {
+            "namespace": "AWS/ELB",
+            "metricName": "SpilloverCount",
+            "dimensionsMap": dimensions,
+            "statistic": "Sum"
+        };
+    }
+    static surgeQueueLengthAverage(dimensions) {
+        return {
+            "namespace": "AWS/ELB",
+            "metricName": "SurgeQueueLength",
+            "dimensionsMap": dimensions,
+            "statistic": "Average"
+        };
+    }
+    static unHealthyHostCountAverage(dimensions) {
+        return {
+            "namespace": "AWS/ELB",
+            "metricName": "UnHealthyHostCount",
+            "dimensionsMap": dimensions,
+            "statistic": "Average"
+        };
+    }
+}
+exports.ELBMetrics = ELBMetrics;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"elasticloadbalancing-canned-metrics.generated.js","sourceRoot":"","sources":["../../../src/aws/compute/elasticloadbalancing-canned-metrics.generated.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable prettier/prettier,max-len */\nexport interface MetricWithDims<D> {\n  readonly namespace: string;\n\n  readonly metricName: string;\n\n  readonly statistic: string;\n\n  readonly dimensionsMap: D;\n}\n\nexport class ELBMetrics {\n  public static backendConnectionErrorsSum(dimensions: { LoadBalancerName: string; }): MetricWithDims<{ LoadBalancerName: string; }>;\n\n  public static backendConnectionErrorsSum(dimensions: { AvailabilityZone: string; LoadBalancerName: string; }): MetricWithDims<{ AvailabilityZone: string; LoadBalancerName: string; }>;\n\n  public static backendConnectionErrorsSum(dimensions: any): MetricWithDims<any> {\n    return {\n      \"namespace\": \"AWS/ELB\",\n      \"metricName\": \"BackendConnectionErrors\",\n      \"dimensionsMap\": dimensions,\n      \"statistic\": \"Sum\"\n    };\n  }\n\n  public static desyncMitigationModeNonCompliantRequestCountSum(dimensions: { LoadBalancerName: string; }): MetricWithDims<{ LoadBalancerName: string; }>;\n\n  public static desyncMitigationModeNonCompliantRequestCountSum(dimensions: { AvailabilityZone: string; LoadBalancerName: string; }): MetricWithDims<{ AvailabilityZone: string; LoadBalancerName: string; }>;\n\n  public static desyncMitigationModeNonCompliantRequestCountSum(dimensions: any): MetricWithDims<any> {\n    return {\n      \"namespace\": \"AWS/ELB\",\n      \"metricName\": \"DesyncMitigationMode_NonCompliant_Request_Count\",\n      \"dimensionsMap\": dimensions,\n      \"statistic\": \"Sum\"\n    };\n  }\n\n  public static httpCodeBackend2XxSum(dimensions: { LoadBalancerName: string; }): MetricWithDims<{ LoadBalancerName: string; }>;\n\n  public static httpCodeBackend2XxSum(dimensions: { AvailabilityZone: string; LoadBalancerName: string; }): MetricWithDims<{ AvailabilityZone: string; LoadBalancerName: string; }>;\n\n  public static httpCodeBackend2XxSum(dimensions: any): MetricWithDims<any> {\n    return {\n      \"namespace\": \"AWS/ELB\",\n      \"metricName\": \"HTTPCode_Backend_2XX\",\n      \"dimensionsMap\": dimensions,\n      \"statistic\": \"Sum\"\n    };\n  }\n\n  public static httpCodeBackend3XxSum(dimensions: { LoadBalancerName: string; }): MetricWithDims<{ LoadBalancerName: string; }>;\n\n  public static httpCodeBackend3XxSum(dimensions: { AvailabilityZone: string; LoadBalancerName: string; }): MetricWithDims<{ AvailabilityZone: string; LoadBalancerName: string; }>;\n\n  public static httpCodeBackend3XxSum(dimensions: any): MetricWithDims<any> {\n    return {\n      \"namespace\": \"AWS/ELB\",\n      \"metricName\": \"HTTPCode_Backend_3XX\",\n      \"dimensionsMap\": dimensions,\n      \"statistic\": \"Sum\"\n    };\n  }\n\n  public static httpCodeBackend4XxSum(dimensions: { LoadBalancerName: string; }): MetricWithDims<{ LoadBalancerName: string; }>;\n\n  public static httpCodeBackend4XxSum(dimensions: { AvailabilityZone: string; LoadBalancerName: string; }): MetricWithDims<{ AvailabilityZone: string; LoadBalancerName: string; }>;\n\n  public static httpCodeBackend4XxSum(dimensions: any): MetricWithDims<any> {\n    return {\n      \"namespace\": \"AWS/ELB\",\n      \"metricName\": \"HTTPCode_Backend_4XX\",\n      \"dimensionsMap\": dimensions,\n      \"statistic\": \"Sum\"\n    };\n  }\n\n  public static httpCodeBackend5XxSum(dimensions: { LoadBalancerName: string; }): MetricWithDims<{ LoadBalancerName: string; }>;\n\n  public static httpCodeBackend5XxSum(dimensions: { AvailabilityZone: string; LoadBalancerName: string; }): MetricWithDims<{ AvailabilityZone: string; LoadBalancerName: string; }>;\n\n  public static httpCodeBackend5XxSum(dimensions: any): MetricWithDims<any> {\n    return {\n      \"namespace\": \"AWS/ELB\",\n      \"metricName\": \"HTTPCode_Backend_5XX\",\n      \"dimensionsMap\": dimensions,\n      \"statistic\": \"Sum\"\n    };\n  }\n\n  public static httpCodeElb4XxSum(dimensions: { LoadBalancerName: string; }): MetricWithDims<{ LoadBalancerName: string; }>;\n\n  public static httpCodeElb4XxSum(dimensions: { AvailabilityZone: string; LoadBalancerName: string; }): MetricWithDims<{ AvailabilityZone: string; LoadBalancerName: string; }>;\n\n  public static httpCodeElb4XxSum(dimensions: any): MetricWithDims<any> {\n    return {\n      \"namespace\": \"AWS/ELB\",\n      \"metricName\": \"HTTPCode_ELB_4XX\",\n      \"dimensionsMap\": dimensions,\n      \"statistic\": \"Sum\"\n    };\n  }\n\n  public static httpCodeElb5XxSum(dimensions: { LoadBalancerName: string; }): MetricWithDims<{ LoadBalancerName: string; }>;\n\n  public static httpCodeElb5XxSum(dimensions: { AvailabilityZone: string; LoadBalancerName: string; }): MetricWithDims<{ AvailabilityZone: string; LoadBalancerName: string; }>;\n\n  public static httpCodeElb5XxSum(dimensions: any): MetricWithDims<any> {\n    return {\n      \"namespace\": \"AWS/ELB\",\n      \"metricName\": \"HTTPCode_ELB_5XX\",\n      \"dimensionsMap\": dimensions,\n      \"statistic\": \"Sum\"\n    };\n  }\n\n  public static healthyHostCountAverage(dimensions: { LoadBalancerName: string; }): MetricWithDims<{ LoadBalancerName: string; }>;\n\n  public static healthyHostCountAverage(dimensions: { AvailabilityZone: string; LoadBalancerName: string; }): MetricWithDims<{ AvailabilityZone: string; LoadBalancerName: string; }>;\n\n  public static healthyHostCountAverage(dimensions: any): MetricWithDims<any> {\n    return {\n      \"namespace\": \"AWS/ELB\",\n      \"metricName\": \"HealthyHostCount\",\n      \"dimensionsMap\": dimensions,\n      \"statistic\": \"Average\"\n    };\n  }\n\n  public static latencyAverage(dimensions: { LoadBalancerName: string; }): MetricWithDims<{ LoadBalancerName: string; }>;\n\n  public static latencyAverage(dimensions: { AvailabilityZone: string; LoadBalancerName: string; }): MetricWithDims<{ AvailabilityZone: string; LoadBalancerName: string; }>;\n\n  public static latencyAverage(dimensions: any): MetricWithDims<any> {\n    return {\n      \"namespace\": \"AWS/ELB\",\n      \"metricName\": \"Latency\",\n      \"dimensionsMap\": dimensions,\n      \"statistic\": \"Average\"\n    };\n  }\n\n  public static requestCountSum(dimensions: { LoadBalancerName: string; }): MetricWithDims<{ LoadBalancerName: string; }>;\n\n  public static requestCountSum(dimensions: { AvailabilityZone: string; LoadBalancerName: string; }): MetricWithDims<{ AvailabilityZone: string; LoadBalancerName: string; }>;\n\n  public static requestCountSum(dimensions: any): MetricWithDims<any> {\n    return {\n      \"namespace\": \"AWS/ELB\",\n      \"metricName\": \"RequestCount\",\n      \"dimensionsMap\": dimensions,\n      \"statistic\": \"Sum\"\n    };\n  }\n\n  public static spilloverCountSum(dimensions: { LoadBalancerName: string; }): MetricWithDims<{ LoadBalancerName: string; }>;\n\n  public static spilloverCountSum(dimensions: { AvailabilityZone: string; LoadBalancerName: string; }): MetricWithDims<{ AvailabilityZone: string; LoadBalancerName: string; }>;\n\n  public static spilloverCountSum(dimensions: any): MetricWithDims<any> {\n    return {\n      \"namespace\": \"AWS/ELB\",\n      \"metricName\": \"SpilloverCount\",\n      \"dimensionsMap\": dimensions,\n      \"statistic\": \"Sum\"\n    };\n  }\n\n  public static surgeQueueLengthAverage(dimensions: { LoadBalancerName: string; }): MetricWithDims<{ LoadBalancerName: string; }>;\n\n  public static surgeQueueLengthAverage(dimensions: { AvailabilityZone: string; LoadBalancerName: string; }): MetricWithDims<{ AvailabilityZone: string; LoadBalancerName: string; }>;\n\n  public static surgeQueueLengthAverage(dimensions: any): MetricWithDims<any> {\n    return {\n      \"namespace\": \"AWS/ELB\",\n      \"metricName\": \"SurgeQueueLength\",\n      \"dimensionsMap\": dimensions,\n      \"statistic\": \"Average\"\n    };\n  }\n\n  public static unHealthyHostCountAverage(dimensions: { LoadBalancerName: string; }): MetricWithDims<{ LoadBalancerName: string; }>;\n\n  public static unHealthyHostCountAverage(dimensions: { AvailabilityZone: string; LoadBalancerName: string; }): MetricWithDims<{ AvailabilityZone: string; LoadBalancerName: string; }>;\n\n  public static unHealthyHostCountAverage(dimensions: any): MetricWithDims<any> {\n    return {\n      \"namespace\": \"AWS/ELB\",\n      \"metricName\": \"UnHealthyHostCount\",\n      \"dimensionsMap\": dimensions,\n      \"statistic\": \"Average\"\n    };\n  }\n}"]}