terraconstructs 0.0.8

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

@@ -0,0 +1,43 @@
+import { cloudwatchLogResourcePolicy } from "@cdktf/provider-aws";
+import { Construct } from "constructs";
+import { AwsConstructBase, AwsConstructProps } from "../aws-construct";
+import { PolicyDocument, PolicyStatement } from "../iam";
+/**
+ * Properties to define Cloudwatch log group resource policy
+ */
+export interface ResourcePolicyProps extends AwsConstructProps {
+    /**
+     * Name of the log group resource policy
+     * @default - Uses a unique id based on the construct path
+     */
+    readonly resourcePolicyName?: string;
+    /**
+     * Initial statements to add to the resource policy
+     *
+     * @default - No statements
+     */
+    readonly policyStatements?: PolicyStatement[];
+}
+/**
+ * Resource Policy for CloudWatch Log Groups
+ *
+ * Policies define the operations that are allowed on this resource.
+ *
+ * You almost never need to define this construct directly.
+ *
+ * All AWS resources that support resource policies have a method called
+ * `addToResourcePolicy()`, which will automatically create a new resource
+ * policy if one doesn't exist yet, otherwise it will add to the existing
+ * policy.
+ *
+ * Prefer to use `addToResourcePolicy()` instead.
+ */
+export declare class ResourcePolicy extends AwsConstructBase {
+    readonly resource: cloudwatchLogResourcePolicy.CloudwatchLogResourcePolicy;
+    get outputs(): Record<string, any>;
+    /**
+     * The IAM policy document for this resource policy.
+     */
+    readonly document: PolicyDocument;
+    constructor(scope: Construct, id: string, props?: ResourcePolicyProps);
+}

package/lib/aws/cloudwatch/policy.js

@@ -0,0 +1,50 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourcePolicy = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+//https://github.com/aws/aws-cdk/blob/v2.170.0/packages/aws-cdk-lib/aws-logs/lib/policy.ts
+const provider_aws_1 = require("@cdktf/provider-aws");
+const aws_construct_1 = require("../aws-construct");
+const iam_1 = require("../iam");
+/**
+ * Resource Policy for CloudWatch Log Groups
+ *
+ * Policies define the operations that are allowed on this resource.
+ *
+ * You almost never need to define this construct directly.
+ *
+ * All AWS resources that support resource policies have a method called
+ * `addToResourcePolicy()`, which will automatically create a new resource
+ * policy if one doesn't exist yet, otherwise it will add to the existing
+ * policy.
+ *
+ * Prefer to use `addToResourcePolicy()` instead.
+ */
+class ResourcePolicy extends aws_construct_1.AwsConstructBase {
+    get outputs() {
+        return {
+            // The name of the CloudWatch log resource policy
+            id: this.resource.id,
+        };
+    }
+    constructor(scope, id, props = {}) {
+        super(scope, id, props);
+        const policyName = props.resourcePolicyName ||
+            this.stack.uniqueResourceName(this, {
+                prefix: this.gridUUID,
+            });
+        this.document = new iam_1.PolicyDocument(this, "Policy");
+        this.resource = new provider_aws_1.cloudwatchLogResourcePolicy.CloudwatchLogResourcePolicy(this, "Resource", {
+            policyDocument: this.document.json,
+            policyName,
+        });
+        if (props?.policyStatements) {
+            this.document.addStatements(...props.policyStatements);
+        }
+    }
+}
+exports.ResourcePolicy = ResourcePolicy;
+_a = JSII_RTTI_SYMBOL_1;
+ResourcePolicy[_a] = { fqn: "terraconstructs.aws.cloudwatch.ResourcePolicy", version: "0.0.8" };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/aws/cloudwatch/private/drop-empty-object-at-the-end-of-an-array-token.d.ts

@@ -0,0 +1,14 @@
+import { IResolvable, IResolveContext, IPostProcessor } from "cdktf";
+/**
+ * A Token object that will drop the last element of an array if it is an empty object
+ *
+ * Necessary to prevent options objects that only contain "region" and "account" keys
+ * that evaluate to "undefined" from showing up in the rendered JSON.
+ */
+export declare class DropEmptyObjectAtTheEndOfAnArray implements IResolvable, IPostProcessor {
+    private readonly value;
+    readonly creationStack: string[];
+    constructor(value: any);
+    resolve(context: IResolveContext): any;
+    postProcess(o: any, _context: IResolveContext): any;
+}

package/lib/aws/cloudwatch/private/drop-empty-object-at-the-end-of-an-array-token.js

@@ -0,0 +1,37 @@
+"use strict";
+// https://github.com/aws/aws-cdk/blob/v2.170.0/packages/aws-cdk-lib/aws-cloudwatch/lib/private/drop-empty-object-at-the-end-of-an-array-token.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DropEmptyObjectAtTheEndOfAnArray = void 0;
+const object_1 = require("./object");
+/**
+ * A Token object that will drop the last element of an array if it is an empty object
+ *
+ * Necessary to prevent options objects that only contain "region" and "account" keys
+ * that evaluate to "undefined" from showing up in the rendered JSON.
+ */
+class DropEmptyObjectAtTheEndOfAnArray {
+    constructor(value) {
+        this.value = value;
+        // TODO: Implement stack traces
+        // ref: https://github.com/aws/aws-cdk/blob/v2.143.0/packages/aws-cdk-lib/core/lib/stack-trace.ts#L22
+        this.creationStack = ["stack traces disabled"];
+    }
+    resolve(context) {
+        context.registerPostProcessor(this);
+        return context.resolve(this.value);
+    }
+    postProcess(o, _context) {
+        if (!Array.isArray(o)) {
+            return o;
+        }
+        const lastEl = o[o.length - 1];
+        if (typeof lastEl === "object" &&
+            lastEl !== null &&
+            Object.keys((0, object_1.dropUndefined)(lastEl)).length === 0) {
+            return o.slice(0, o.length - 1);
+        }
+        return o;
+    }
+}
+exports.DropEmptyObjectAtTheEndOfAnArray = DropEmptyObjectAtTheEndOfAnArray;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/aws/cloudwatch/private/env-tokens.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Make a Token that renders to given region if used in a different stack, otherwise undefined
+ */
+export declare function regionIfDifferentFromStack(region: string): string;
+/**
+ * Make a Token that renders to given account if used in a different stack, otherwise undefined
+ */
+export declare function accountIfDifferentFromStack(account: string): string;

package/lib/aws/cloudwatch/private/env-tokens.js

@@ -0,0 +1,48 @@
+"use strict";
+// https://github.com/aws/aws-cdk/blob/v2.170.0/packages/aws-cdk-lib/aws-cloudwatch/lib/private/env-tokens.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.accountIfDifferentFromStack = exports.regionIfDifferentFromStack = void 0;
+const cdktf_1 = require("cdktf");
+const __1 = require("../../");
+/**
+ * Make a Token that renders to given region if used in a different stack, otherwise undefined
+ */
+function regionIfDifferentFromStack(region) {
+    return cdktf_1.Token.asString(new StackDependentToken(region, (stack) => stack.region));
+}
+exports.regionIfDifferentFromStack = regionIfDifferentFromStack;
+/**
+ * Make a Token that renders to given account if used in a different stack, otherwise undefined
+ */
+function accountIfDifferentFromStack(account) {
+    return cdktf_1.Token.asString(new StackDependentToken(account, (stack) => stack.account));
+}
+exports.accountIfDifferentFromStack = accountIfDifferentFromStack;
+/**
+ * A lazy token that requires an instance of Stack to evaluate
+ */
+class StackDependentToken {
+    constructor(originalValue, fn) {
+        this.originalValue = originalValue;
+        this.fn = fn;
+        // TODO: Implement stack traces
+        // ref: https://github.com/aws/aws-cdk/blob/v2.143.0/packages/aws-cdk-lib/core/lib/stack-trace.ts#L22
+        this.creationStack = ["stack traces disabled"];
+    }
+    resolve(context) {
+        const stackValue = this.fn(__1.AwsStack.ofAwsConstruct(context.scope));
+        // Don't render if the values are definitely the same. If the stack
+        // is unresolved we don't know, better output the value.
+        if (!cdktf_1.Token.isUnresolved(stackValue) && stackValue === this.originalValue) {
+            return undefined;
+        }
+        return this.originalValue;
+    }
+    toString() {
+        return cdktf_1.Token.asString(this);
+    }
+    toJSON() {
+        return this.originalValue;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/aws/cloudwatch/private/metric-util.d.ts

@@ -0,0 +1,60 @@
+import { Duration } from "../../../duration";
+import { IMetric, MetricConfig, MetricExpressionConfig, MetricStatConfig } from "../metric-types";
+/**
+ * Return a unique string representation for this metric.
+ *
+ * Can be used to determine as a hash key to determine if 2 Metric objects
+ * represent the same metric. Excludes rendering properties.
+ */
+export declare function metricKey(metric: IMetric): string;
+/**
+ * Return the period of a metric
+ *
+ * For a stat metric, return the immediate period.
+ *
+ * For an expression metric, all metrics used in it have been made to have the
+ * same period, so we return the period of the first inner metric.
+ */
+export declare function metricPeriod(metric: IMetric): Duration;
+/**
+ * Given a metric object, inspect it and call the correct function for the type of output
+ *
+ * In addition to the metric object itself, takes a callback object with two
+ * methods, to be invoked for the particular type of metric.
+ *
+ * If the metric represent a metric query (nominally generated through an
+ * instantiation of `Metric` but can be generated by any class that implements
+ * `IMetric`) a particular field in its `toMetricConfig()` output will be set
+ * (to wit, `metricStat`) and the `withStat()` callback will be called with
+ * that object.
+ *
+ * If the metric represents an expression (usually by instantiating `MathExpression`
+ * but users can implement `IMetric` arbitrarily) the `mathExpression` field
+ * will be set in the object returned from `toMetricConfig` and the callback
+ * called `withExpression` will be applied to that object.
+ *
+ * Will return the values returned by the callbacks.
+ *
+ * To be used as such:
+ *
+ * ```ts
+ * const ret = dispatchMetric(someMetric, {
+ *   withStat(stat) {
+ *     // do something with stat
+ *     return 1;
+ *   },
+ *   withExpression(expr) {
+ *     // do something with expr
+ *     return 2;
+ *   },
+ * });
+ * ```
+ *
+ * This function encapsulates some type analysis that would otherwise have to be
+ * repeated in all places where code needs to make a distinction on the type
+ * of metric object that is being passed.
+ */
+export declare function dispatchMetric<A, B>(metric: IMetric, fns: {
+    withStat: (x: MetricStatConfig, c: MetricConfig) => A;
+    withExpression: (x: MetricExpressionConfig, c: MetricConfig) => B;
+}): A | B;

package/lib/aws/cloudwatch/private/metric-util.js

@@ -0,0 +1,132 @@
+"use strict";
+// https://github.com/aws/aws-cdk/blob/v2.170.0/packages/aws-cdk-lib/aws-cloudwatch/lib/private/metric-util.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dispatchMetric = exports.metricPeriod = exports.metricKey = void 0;
+const duration_1 = require("../../../duration");
+const METRICKEY_SYMBOL = Symbol("terraconstructs/lib/aws/cloudwatch.MetricKey");
+/**
+ * Return a unique string representation for this metric.
+ *
+ * Can be used to determine as a hash key to determine if 2 Metric objects
+ * represent the same metric. Excludes rendering properties.
+ */
+function metricKey(metric) {
+    // Cache on the object itself. This is safe because Metric objects are immutable.
+    if (metric.hasOwnProperty(METRICKEY_SYMBOL)) {
+        return metric[METRICKEY_SYMBOL];
+    }
+    const parts = new Array();
+    const conf = metric.toMetricConfig();
+    if (conf.mathExpression) {
+        parts.push(conf.mathExpression.expression);
+        for (const id of Object.keys(conf.mathExpression.usingMetrics).sort()) {
+            parts.push(id);
+            parts.push(metricKey(conf.mathExpression.usingMetrics[id]));
+        }
+        if (conf.mathExpression.searchRegion) {
+            parts.push(conf.mathExpression.searchRegion);
+        }
+        if (conf.mathExpression.searchAccount) {
+            parts.push(conf.mathExpression.searchAccount);
+        }
+    }
+    if (conf.metricStat) {
+        parts.push(conf.metricStat.namespace);
+        parts.push(conf.metricStat.metricName);
+        for (const [dimName, dimValue] of Object.entries(conf.metricStat.dimensions || {})) {
+            parts.push(dimName);
+            parts.push(dimValue);
+        }
+        if (conf.metricStat.statistic) {
+            parts.push(conf.metricStat.statistic);
+        }
+        if (conf.metricStat.period) {
+            parts.push(`${conf.metricStat.period.toSeconds()}`);
+        }
+        if (conf.metricStat.region) {
+            parts.push(conf.metricStat.region);
+        }
+        if (conf.metricStat.account) {
+            parts.push(conf.metricStat.account);
+        }
+    }
+    const ret = parts.join("|");
+    Object.defineProperty(metric, METRICKEY_SYMBOL, { value: ret });
+    return ret;
+}
+exports.metricKey = metricKey;
+/**
+ * Return the period of a metric
+ *
+ * For a stat metric, return the immediate period.
+ *
+ * For an expression metric, all metrics used in it have been made to have the
+ * same period, so we return the period of the first inner metric.
+ */
+function metricPeriod(metric) {
+    return dispatchMetric(metric, {
+        withStat(stat) {
+            return stat.period;
+        },
+        withExpression() {
+            return metric.period || duration_1.Duration.minutes(5);
+        },
+    });
+}
+exports.metricPeriod = metricPeriod;
+/**
+ * Given a metric object, inspect it and call the correct function for the type of output
+ *
+ * In addition to the metric object itself, takes a callback object with two
+ * methods, to be invoked for the particular type of metric.
+ *
+ * If the metric represent a metric query (nominally generated through an
+ * instantiation of `Metric` but can be generated by any class that implements
+ * `IMetric`) a particular field in its `toMetricConfig()` output will be set
+ * (to wit, `metricStat`) and the `withStat()` callback will be called with
+ * that object.
+ *
+ * If the metric represents an expression (usually by instantiating `MathExpression`
+ * but users can implement `IMetric` arbitrarily) the `mathExpression` field
+ * will be set in the object returned from `toMetricConfig` and the callback
+ * called `withExpression` will be applied to that object.
+ *
+ * Will return the values returned by the callbacks.
+ *
+ * To be used as such:
+ *
+ * ```ts
+ * const ret = dispatchMetric(someMetric, {
+ *   withStat(stat) {
+ *     // do something with stat
+ *     return 1;
+ *   },
+ *   withExpression(expr) {
+ *     // do something with expr
+ *     return 2;
+ *   },
+ * });
+ * ```
+ *
+ * This function encapsulates some type analysis that would otherwise have to be
+ * repeated in all places where code needs to make a distinction on the type
+ * of metric object that is being passed.
+ */
+// eslint-disable-next-line max-len
+function dispatchMetric(metric, fns) {
+    const conf = metric.toMetricConfig();
+    if (conf.metricStat && conf.mathExpression) {
+        throw new Error("Metric object must not produce both 'metricStat' and 'mathExpression'");
+    }
+    else if (conf.metricStat) {
+        return fns.withStat(conf.metricStat, conf);
+    }
+    else if (conf.mathExpression) {
+        return fns.withExpression(conf.mathExpression, conf);
+    }
+    else {
+        throw new Error("Metric object must have either 'metricStat' or 'mathExpression'");
+    }
+}
+exports.dispatchMetric = dispatchMetric;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"metric-util.js","sourceRoot":"","sources":["../../../../src/aws/cloudwatch/private/metric-util.ts"],"names":[],"mappings":"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","sourcesContent":["// https://github.com/aws/aws-cdk/blob/v2.170.0/packages/aws-cdk-lib/aws-cloudwatch/lib/private/metric-util.ts\n\nimport { Duration } from \"../../../duration\";\nimport { MathExpression } from \"../metric\";\nimport {\n  IMetric,\n  MetricConfig,\n  MetricExpressionConfig,\n  MetricStatConfig,\n} from \"../metric-types\";\n\nconst METRICKEY_SYMBOL = Symbol(\"terraconstructs/lib/aws/cloudwatch.MetricKey\");\n\n/**\n * Return a unique string representation for this metric.\n *\n * Can be used to determine as a hash key to determine if 2 Metric objects\n * represent the same metric. Excludes rendering properties.\n */\nexport function metricKey(metric: IMetric): string {\n  // Cache on the object itself. This is safe because Metric objects are immutable.\n  if (metric.hasOwnProperty(METRICKEY_SYMBOL)) {\n    return (metric as any)[METRICKEY_SYMBOL];\n  }\n\n  const parts = new Array<string>();\n\n  const conf = metric.toMetricConfig();\n  if (conf.mathExpression) {\n    parts.push(conf.mathExpression.expression);\n    for (const id of Object.keys(conf.mathExpression.usingMetrics).sort()) {\n      parts.push(id);\n      parts.push(metricKey(conf.mathExpression.usingMetrics[id]));\n    }\n    if (conf.mathExpression.searchRegion) {\n      parts.push(conf.mathExpression.searchRegion);\n    }\n    if (conf.mathExpression.searchAccount) {\n      parts.push(conf.mathExpression.searchAccount);\n    }\n  }\n  if (conf.metricStat) {\n    parts.push(conf.metricStat.namespace);\n    parts.push(conf.metricStat.metricName);\n    for (const [dimName, dimValue] of Object.entries(\n      conf.metricStat.dimensions || {},\n    )) {\n      parts.push(dimName);\n      parts.push(dimValue);\n    }\n    if (conf.metricStat.statistic) {\n      parts.push(conf.metricStat.statistic);\n    }\n    if (conf.metricStat.period) {\n      parts.push(`${conf.metricStat.period.toSeconds()}`);\n    }\n    if (conf.metricStat.region) {\n      parts.push(conf.metricStat.region);\n    }\n    if (conf.metricStat.account) {\n      parts.push(conf.metricStat.account);\n    }\n  }\n\n  const ret = parts.join(\"|\");\n  Object.defineProperty(metric, METRICKEY_SYMBOL, { value: ret });\n  return ret;\n}\n\n/**\n * Return the period of a metric\n *\n * For a stat metric, return the immediate period.\n *\n * For an expression metric, all metrics used in it have been made to have the\n * same period, so we return the period of the first inner metric.\n */\nexport function metricPeriod(metric: IMetric): Duration {\n  return dispatchMetric(metric, {\n    withStat(stat) {\n      return stat.period;\n    },\n    withExpression() {\n      return (metric as MathExpression).period || Duration.minutes(5);\n    },\n  });\n}\n\n/**\n * Given a metric object, inspect it and call the correct function for the type of output\n *\n * In addition to the metric object itself, takes a callback object with two\n * methods, to be invoked for the particular type of metric.\n *\n * If the metric represent a metric query (nominally generated through an\n * instantiation of `Metric` but can be generated by any class that implements\n * `IMetric`) a particular field in its `toMetricConfig()` output will be set\n * (to wit, `metricStat`) and the `withStat()` callback will be called with\n * that object.\n *\n * If the metric represents an expression (usually by instantiating `MathExpression`\n * but users can implement `IMetric` arbitrarily) the `mathExpression` field\n * will be set in the object returned from `toMetricConfig` and the callback\n * called `withExpression` will be applied to that object.\n *\n * Will return the values returned by the callbacks.\n *\n * To be used as such:\n *\n * ```ts\n * const ret = dispatchMetric(someMetric, {\n *   withStat(stat) {\n *     // do something with stat\n *     return 1;\n *   },\n *   withExpression(expr) {\n *     // do something with expr\n *     return 2;\n *   },\n * });\n * ```\n *\n * This function encapsulates some type analysis that would otherwise have to be\n * repeated in all places where code needs to make a distinction on the type\n * of metric object that is being passed.\n */\n// eslint-disable-next-line max-len\nexport function dispatchMetric<A, B>(\n  metric: IMetric,\n  fns: {\n    withStat: (x: MetricStatConfig, c: MetricConfig) => A;\n    withExpression: (x: MetricExpressionConfig, c: MetricConfig) => B;\n  },\n): A | B {\n  const conf = metric.toMetricConfig();\n  if (conf.metricStat && conf.mathExpression) {\n    throw new Error(\n      \"Metric object must not produce both 'metricStat' and 'mathExpression'\",\n    );\n  } else if (conf.metricStat) {\n    return fns.withStat(conf.metricStat, conf);\n  } else if (conf.mathExpression) {\n    return fns.withExpression(conf.mathExpression, conf);\n  } else {\n    throw new Error(\n      \"Metric object must have either 'metricStat' or 'mathExpression'\",\n    );\n  }\n}\n"]}

package/lib/aws/cloudwatch/private/object.d.ts

@@ -0,0 +1 @@
+export declare function dropUndefined<T extends object>(x: T): T;

package/lib/aws/cloudwatch/private/object.js

@@ -0,0 +1,18 @@
+"use strict";
+// https://github.com/aws/aws-cdk/blob/v2.170.0/packages/aws-cdk-lib/aws-cloudwatch/lib/private/object.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dropUndefined = void 0;
+function dropUndefined(x) {
+    if (x === null) {
+        return x;
+    }
+    const ret = {};
+    for (const [key, value] of Object.entries(x)) {
+        if (value !== undefined) {
+            ret[key] = value;
+        }
+    }
+    return ret;
+}
+exports.dropUndefined = dropUndefined;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib2JqZWN0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2F3cy9jbG91ZHdhdGNoL3ByaXZhdGUvb2JqZWN0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSx5R0FBeUc7OztBQUV6RyxTQUFnQixhQUFhLENBQW1CLENBQUk7SUFDbEQsSUFBSSxDQUFDLEtBQUssSUFBSSxFQUFFLENBQUM7UUFDZixPQUFPLENBQUMsQ0FBQztJQUNYLENBQUM7SUFDRCxNQUFNLEdBQUcsR0FBUSxFQUFFLENBQUM7SUFDcEIsS0FBSyxNQUFNLENBQUMsR0FBRyxFQUFFLEtBQUssQ0FBQyxJQUFJLE1BQU0sQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQztRQUM3QyxJQUFJLEtBQUssS0FBSyxTQUFTLEVBQUUsQ0FBQztZQUN4QixHQUFHLENBQUMsR0FBRyxDQUFDLEdBQUcsS0FBSyxDQUFDO1FBQ25CLENBQUM7SUFDSCxDQUFDO0lBQ0QsT0FBTyxHQUFHLENBQUM7QUFDYixDQUFDO0FBWEQsc0NBV0MiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBodHRwczovL2dpdGh1Yi5jb20vYXdzL2F3cy1jZGsvYmxvYi92Mi4xNzAuMC9wYWNrYWdlcy9hd3MtY2RrLWxpYi9hd3MtY2xvdWR3YXRjaC9saWIvcHJpdmF0ZS9vYmplY3QudHNcblxuZXhwb3J0IGZ1bmN0aW9uIGRyb3BVbmRlZmluZWQ8VCBleHRlbmRzIG9iamVjdD4oeDogVCk6IFQge1xuICBpZiAoeCA9PT0gbnVsbCkge1xuICAgIHJldHVybiB4O1xuICB9XG4gIGNvbnN0IHJldDogYW55ID0ge307XG4gIGZvciAoY29uc3QgW2tleSwgdmFsdWVdIG9mIE9iamVjdC5lbnRyaWVzKHgpKSB7XG4gICAgaWYgKHZhbHVlICE9PSB1bmRlZmluZWQpIHtcbiAgICAgIHJldFtrZXldID0gdmFsdWU7XG4gICAgfVxuICB9XG4gIHJldHVybiByZXQ7XG59XG4iXX0=

package/lib/aws/cloudwatch/private/rendering.d.ts

@@ -0,0 +1,60 @@
+import { IMetric } from "../metric-types";
+/**
+ * Return the JSON structure which represents these metrics in a graph.
+ *
+ * Depending on the metric type (stat or expression), one `Metric` object
+ * can render to multiple time series.
+ *
+ * - Top-level metrics will be rendered visibly, additionally added metrics will
+ *   be rendered invisibly.
+ * - IDs used in math expressions need to be either globally unique, or refer to the same
+ *   metric object.
+ *
+ * This will be called by GraphWidget, no need for clients to call this.
+ */
+export declare function allMetricsGraphJson(left: IMetric[], right: IMetric[]): any[];
+/**
+ * A single metric in a MetricSet
+ */
+export interface MetricEntry<A> {
+    /**
+     * The metric object
+     */
+    readonly metric: IMetric;
+    /**
+     * The tag, added if the object is a primary metric
+     */
+    tag?: A;
+    /**
+     * ID for this metric object
+     */
+    id?: string;
+}
+/**
+ * Contain a set of metrics, expanding math expressions
+ *
+ * "Primary" metrics (added via a top-level call) can be tagged with an additional value.
+ */
+export declare class MetricSet<A> {
+    private readonly metrics;
+    private readonly metricById;
+    private readonly metricByKey;
+    /**
+     * Add the given set of metrics to this set
+     */
+    addTopLevel(tag: A, ...metrics: IMetric[]): void;
+    /**
+     * Access all the accumulated timeseries entries
+     */
+    get entries(): ReadonlyArray<MetricEntry<A>>;
+    /**
+     * Add a metric into the set
+     *
+     * The id may not be the same as a previous metric added, unless it's the same metric.
+     *
+     * It can be made visible, in which case the new "metric" object replaces the old
+     * one (and the new ones "renderingPropertieS" will be honored instead of the old
+     * one's).
+     */
+    private addOne;
+}