terraconstructs 0.0.8

package/lib/aws/notify/input.js

@@ -0,0 +1,282 @@
+"use strict";
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventField = exports.RuleTargetInput = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const cdktf_1 = require("cdktf");
+const aws_stack_1 = require("../aws-stack");
+/**
+ * The input to send to the event target
+ */
+class RuleTargetInput {
+    /**
+     * Pass text to the event target
+     *
+     * May contain strings returned by `EventField.from()` to substitute in parts of the
+     * matched event.
+     *
+     * The Rule Target input value will be a single string: the string you pass
+     * here.  Do not use this method to pass a complex value like a JSON object to
+     * a Rule Target.  Use `RuleTargetInput.fromObject()` instead.
+     */
+    static fromText(text) {
+        return new FieldAwareEventInput(text, InputType.Text);
+    }
+    /**
+     * Pass text to the event target, splitting on newlines.
+     *
+     * This is only useful when passing to a target that does not
+     * take a single argument.
+     *
+     * May contain strings returned by `EventField.from()` to substitute in parts
+     * of the matched event.
+     */
+    static fromMultilineText(text) {
+        return new FieldAwareEventInput(text, InputType.Multiline);
+    }
+    /**
+     * Pass a JSON object to the event target
+     *
+     * May contain strings returned by `EventField.from()` to substitute in parts of the
+     * matched event.
+     */
+    static fromObject(obj) {
+        return new FieldAwareEventInput(obj, InputType.Object);
+    }
+    /**
+     * Take the event target input from a path in the event JSON
+     */
+    static fromEventPath(path) {
+        return new LiteralEventInput({ inputPath: path });
+    }
+    constructor() { }
+}
+exports.RuleTargetInput = RuleTargetInput;
+_a = JSII_RTTI_SYMBOL_1;
+RuleTargetInput[_a] = { fqn: "terraconstructs.aws.notify.RuleTargetInput", version: "0.0.8" };
+/**
+ * Event Input that is directly derived from the construct
+ */
+class LiteralEventInput extends RuleTargetInput {
+    constructor(props) {
+        super();
+        this.props = props;
+    }
+    /**
+     * Return the input properties for this input object
+     */
+    bind(_rule) {
+        return this.props;
+    }
+}
+/**
+ * Input object that can contain field replacements
+ *
+ * Evaluation is done in the bind() method because token resolution
+ * requires access to the construct tree.
+ *
+ * Multiple tokens that use the same path will use the same substitution
+ * key.
+ *
+ * One weird exception: if we're in object context, we MUST skip the quotes
+ * around the placeholder. I assume this is so once a trivial string replace is
+ * done later on by EventBridge, numbers are still numbers.
+ *
+ * So in string context:
+ *
+ *    "this is a string with a <field>"
+ *
+ * But in object context:
+ *
+ *    "{ \"this is the\": <field> }"
+ *
+ * To achieve the latter, we postprocess the JSON string to remove the surrounding
+ * quotes by using a string replace.
+ */
+class FieldAwareEventInput extends RuleTargetInput {
+    constructor(input, inputType) {
+        super();
+        this.input = input;
+        this.inputType = inputType;
+    }
+    bind(rule) {
+        let fieldCounter = 0;
+        const pathToKey = new Map();
+        const inputPathsMap = {};
+        function keyForField(f) {
+            const existing = pathToKey.get(f.path);
+            if (existing !== undefined) {
+                return existing;
+            }
+            fieldCounter += 1;
+            const key = f.displayHint || `f${fieldCounter}`;
+            pathToKey.set(f.path, key);
+            return key;
+        }
+        class EventFieldReplacer extends cdktf_1.DefaultTokenResolver {
+            constructor() {
+                super(new cdktf_1.StringConcat());
+            }
+            resolveToken(t, _context) {
+                if (!isEventField(t)) {
+                    return cdktf_1.Token.asString(t);
+                }
+                const key = keyForField(t);
+                if (inputPathsMap[key] && inputPathsMap[key] !== t.path) {
+                    throw new Error(`Single key '${key}' is used for two different JSON paths: '${t.path}' and '${inputPathsMap[key]}'`);
+                }
+                inputPathsMap[key] = t.path;
+                return `<${key}>`;
+            }
+        }
+        const stack = aws_stack_1.AwsStack.ofAwsConstruct(rule);
+        let resolved;
+        if (this.inputType === InputType.Multiline) {
+            // JSONify individual lines
+            resolved = cdktf_1.Tokenization.resolve(this.input, {
+                scope: rule,
+                resolver: new EventFieldReplacer(),
+            });
+            resolved = resolved.split("\n").map(stack.toJsonString).join("\n");
+        }
+        else {
+            resolved = stack.toJsonString(cdktf_1.Tokenization.resolve(this.input, {
+                scope: rule,
+                resolver: new EventFieldReplacer(),
+            }));
+        }
+        const keys = Object.keys(inputPathsMap);
+        if (keys.length === 0) {
+            // Nothing special, just return 'input'
+            return { input: resolved };
+        }
+        return {
+            inputTemplate: this.unquoteKeyPlaceholders(resolved, keys),
+            inputPathsMap,
+        };
+    }
+    /**
+     * Removing surrounding quotes from any object placeholders
+     * when key is the lone value.
+     *
+     * Those have been put there by JSON.stringify(), but we need to
+     * remove them.
+     *
+     * Do not remove quotes when the key is part of a larger string.
+     *
+     * Valid: { "data": "Some string with \"quotes\"<key>" } // key will be string
+     * Valid: { "data": <key> } // Key could be number, bool, obj, or string
+     */
+    unquoteKeyPlaceholders(sub, keys) {
+        if (this.inputType !== InputType.Object) {
+            return sub;
+        }
+        return cdktf_1.Lazy.stringValue({
+            produce: (ctx) => cdktf_1.Token.asString(deepUnquote(ctx.resolve(sub))),
+        });
+        function deepUnquote(resolved) {
+            if (Array.isArray(resolved)) {
+                return resolved.map(deepUnquote);
+            }
+            else if (typeof resolved === "object" && resolved !== null) {
+                for (const [key, value] of Object.entries(resolved)) {
+                    resolved[key] = deepUnquote(value);
+                }
+                return resolved;
+            }
+            else if (typeof resolved === "string") {
+                return keys.reduce((r, key) => r.replace(new RegExp(`(?<!\\\\)\"\<${key}\>\"`, "g"), `<${key}>`), resolved);
+            }
+            return resolved;
+        }
+    }
+}
+/**
+ * Represents a field in the event pattern
+ */
+class EventField {
+    /**
+     * Extract the event ID from the event
+     */
+    static get eventId() {
+        return this.fromPath("$.id");
+    }
+    /**
+     * Extract the detail type from the event
+     */
+    static get detailType() {
+        return this.fromPath("$.detail-type");
+    }
+    /**
+     * Extract the source from the event
+     */
+    static get source() {
+        return this.fromPath("$.source");
+    }
+    /**
+     * Extract the account from the event
+     */
+    static get account() {
+        return this.fromPath("$.account");
+    }
+    /**
+     * Extract the time from the event
+     */
+    static get time() {
+        return this.fromPath("$.time");
+    }
+    /**
+     * Extract the region from the event
+     */
+    static get region() {
+        return this.fromPath("$.region");
+    }
+    /**
+     * Extract a custom JSON path from the event
+     */
+    static fromPath(path) {
+        return new EventField(path).toString();
+    }
+    /**
+     *
+     * @param path the path to a field in the event pattern
+     */
+    constructor(path) {
+        this.path = path;
+        this.displayHint = this.path
+            .replace(/^[^a-zA-Z0-9_-]+/, "")
+            .replace(/[^a-zA-Z0-9_-]/g, "-");
+        Object.defineProperty(this, EVENT_FIELD_SYMBOL, { value: true });
+        // TODO: Implement stack traces
+        // ref: https://github.com/hashicorp/terraform-cdk/blob/v0.20.7/packages/cdktf/lib/app.ts#L111
+        // ref: https://github.com/hashicorp/terraform-cdk/blob/v0.20.9/packages/cdktf/lib/tokens/private/stack-trace.ts#L9
+        // 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(_ctx) {
+        return this.path;
+    }
+    toString() {
+        return cdktf_1.Token.asString(this, { displayHint: this.displayHint });
+    }
+    /**
+     * Convert the path to the field in the event pattern to JSON
+     */
+    toJSON() {
+        return `<path:${this.path}>`;
+    }
+}
+exports.EventField = EventField;
+_b = JSII_RTTI_SYMBOL_1;
+EventField[_b] = { fqn: "terraconstructs.aws.notify.EventField", version: "0.0.8" };
+var InputType;
+(function (InputType) {
+    InputType[InputType["Object"] = 0] = "Object";
+    InputType[InputType["Text"] = 1] = "Text";
+    InputType[InputType["Multiline"] = 2] = "Multiline";
+})(InputType || (InputType = {}));
+function isEventField(x) {
+    return EVENT_FIELD_SYMBOL in x;
+}
+const EVENT_FIELD_SYMBOL = Symbol.for("terraconstructs/lib/aws/notify.EventField");
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"input.js","sourceRoot":"","sources":["../../../src/aws/notify/input.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  // captureStackTrace,\n  DefaultTokenResolver,\n  IResolvable,\n  IResolveContext,\n  Lazy,\n  StringConcat,\n  Token,\n  Tokenization,\n} from \"cdktf\";\nimport { IRule } from \"./rule\";\nimport { AwsStack } from \"../aws-stack\";\n\n/**\n * The input to send to the event target\n */\nexport abstract class RuleTargetInput {\n  /**\n   * Pass text to the event target\n   *\n   * May contain strings returned by `EventField.from()` to substitute in parts of the\n   * matched event.\n   *\n   * The Rule Target input value will be a single string: the string you pass\n   * here.  Do not use this method to pass a complex value like a JSON object to\n   * a Rule Target.  Use `RuleTargetInput.fromObject()` instead.\n   */\n  public static fromText(text: string): RuleTargetInput {\n    return new FieldAwareEventInput(text, InputType.Text);\n  }\n\n  /**\n   * Pass text to the event target, splitting on newlines.\n   *\n   * This is only useful when passing to a target that does not\n   * take a single argument.\n   *\n   * May contain strings returned by `EventField.from()` to substitute in parts\n   * of the matched event.\n   */\n  public static fromMultilineText(text: string): RuleTargetInput {\n    return new FieldAwareEventInput(text, InputType.Multiline);\n  }\n\n  /**\n   * Pass a JSON object to the event target\n   *\n   * May contain strings returned by `EventField.from()` to substitute in parts of the\n   * matched event.\n   */\n  public static fromObject(obj: any): RuleTargetInput {\n    return new FieldAwareEventInput(obj, InputType.Object);\n  }\n\n  /**\n   * Take the event target input from a path in the event JSON\n   */\n  public static fromEventPath(path: string): RuleTargetInput {\n    return new LiteralEventInput({ inputPath: path });\n  }\n\n  protected constructor() {}\n\n  /**\n   * Return the input properties for this input object\n   */\n  public abstract bind(rule: IRule): RuleTargetInputProperties;\n}\n\n/**\n * The input properties for an event target\n */\nexport interface RuleTargetInputProperties {\n  /**\n   * Literal input to the target service (must be valid JSON)\n   *\n   * @default - input for the event target. If the input contains a paths map\n   *   values wil be extracted from event and inserted into the `inputTemplate`.\n   */\n  readonly input?: string;\n\n  /**\n   * JsonPath to take input from the input event\n   *\n   * @default - None. The entire matched event is passed as input\n   */\n  readonly inputPath?: string;\n\n  /**\n   * Input template to insert paths map into\n   *\n   * @default - None.\n   */\n  readonly inputTemplate?: string;\n\n  /**\n   * Paths map to extract values from event and insert into `inputTemplate`\n   *\n   * @default - No values extracted from event.\n   */\n  readonly inputPathsMap?: { [key: string]: string };\n}\n\n/**\n * Event Input that is directly derived from the construct\n */\nclass LiteralEventInput extends RuleTargetInput {\n  constructor(private readonly props: RuleTargetInputProperties) {\n    super();\n  }\n\n  /**\n   * Return the input properties for this input object\n   */\n  public bind(_rule: IRule): RuleTargetInputProperties {\n    return this.props;\n  }\n}\n\n/**\n * Input object that can contain field replacements\n *\n * Evaluation is done in the bind() method because token resolution\n * requires access to the construct tree.\n *\n * Multiple tokens that use the same path will use the same substitution\n * key.\n *\n * One weird exception: if we're in object context, we MUST skip the quotes\n * around the placeholder. I assume this is so once a trivial string replace is\n * done later on by EventBridge, numbers are still numbers.\n *\n * So in string context:\n *\n *    \"this is a string with a <field>\"\n *\n * But in object context:\n *\n *    \"{ \\\"this is the\\\": <field> }\"\n *\n * To achieve the latter, we postprocess the JSON string to remove the surrounding\n * quotes by using a string replace.\n */\nclass FieldAwareEventInput extends RuleTargetInput {\n  constructor(\n    private readonly input: any,\n    private readonly inputType: InputType,\n  ) {\n    super();\n  }\n\n  public bind(rule: IRule): RuleTargetInputProperties {\n    let fieldCounter = 0;\n    const pathToKey = new Map<string, string>();\n    const inputPathsMap: { [key: string]: string } = {};\n\n    function keyForField(f: EventField) {\n      const existing = pathToKey.get(f.path);\n      if (existing !== undefined) {\n        return existing;\n      }\n\n      fieldCounter += 1;\n      const key = f.displayHint || `f${fieldCounter}`;\n      pathToKey.set(f.path, key);\n      return key;\n    }\n\n    class EventFieldReplacer extends DefaultTokenResolver {\n      constructor() {\n        super(new StringConcat());\n      }\n\n      public resolveToken(t: Token, _context: IResolveContext) {\n        if (!isEventField(t)) {\n          return Token.asString(t);\n        }\n\n        const key = keyForField(t);\n        if (inputPathsMap[key] && inputPathsMap[key] !== t.path) {\n          throw new Error(\n            `Single key '${key}' is used for two different JSON paths: '${t.path}' and '${inputPathsMap[key]}'`,\n          );\n        }\n        inputPathsMap[key] = t.path;\n\n        return `<${key}>`;\n      }\n    }\n\n    const stack = AwsStack.ofAwsConstruct(rule);\n    let resolved: string;\n    if (this.inputType === InputType.Multiline) {\n      // JSONify individual lines\n      resolved = Tokenization.resolve(this.input, {\n        scope: rule,\n        resolver: new EventFieldReplacer(),\n      });\n      resolved = resolved.split(\"\\n\").map(stack.toJsonString).join(\"\\n\");\n    } else {\n      resolved = stack.toJsonString(\n        Tokenization.resolve(this.input, {\n          scope: rule,\n          resolver: new EventFieldReplacer(),\n        }),\n      );\n    }\n\n    const keys = Object.keys(inputPathsMap);\n\n    if (keys.length === 0) {\n      // Nothing special, just return 'input'\n      return { input: resolved };\n    }\n\n    return {\n      inputTemplate: this.unquoteKeyPlaceholders(resolved, keys),\n      inputPathsMap,\n    };\n  }\n\n  /**\n   * Removing surrounding quotes from any object placeholders\n   * when key is the lone value.\n   *\n   * Those have been put there by JSON.stringify(), but we need to\n   * remove them.\n   *\n   * Do not remove quotes when the key is part of a larger string.\n   *\n   * Valid: { \"data\": \"Some string with \\\"quotes\\\"<key>\" } // key will be string\n   * Valid: { \"data\": <key> } // Key could be number, bool, obj, or string\n   */\n  private unquoteKeyPlaceholders(sub: string, keys: string[]) {\n    if (this.inputType !== InputType.Object) {\n      return sub;\n    }\n\n    return Lazy.stringValue({\n      produce: (ctx: IResolveContext) =>\n        Token.asString(deepUnquote(ctx.resolve(sub))),\n    });\n\n    function deepUnquote(resolved: any): any {\n      if (Array.isArray(resolved)) {\n        return resolved.map(deepUnquote);\n      } else if (typeof resolved === \"object\" && resolved !== null) {\n        for (const [key, value] of Object.entries(resolved)) {\n          resolved[key] = deepUnquote(value);\n        }\n        return resolved;\n      } else if (typeof resolved === \"string\") {\n        return keys.reduce(\n          (r, key) =>\n            r.replace(new RegExp(`(?<!\\\\\\\\)\\\"\\<${key}\\>\\\"`, \"g\"), `<${key}>`),\n          resolved,\n        );\n      }\n      return resolved;\n    }\n  }\n}\n\n/**\n * Represents a field in the event pattern\n */\nexport class EventField implements IResolvable {\n  /**\n   * Extract the event ID from the event\n   */\n  public static get eventId(): string {\n    return this.fromPath(\"$.id\");\n  }\n\n  /**\n   * Extract the detail type from the event\n   */\n  public static get detailType(): string {\n    return this.fromPath(\"$.detail-type\");\n  }\n\n  /**\n   * Extract the source from the event\n   */\n  public static get source(): string {\n    return this.fromPath(\"$.source\");\n  }\n\n  /**\n   * Extract the account from the event\n   */\n  public static get account(): string {\n    return this.fromPath(\"$.account\");\n  }\n\n  /**\n   * Extract the time from the event\n   */\n  public static get time(): string {\n    return this.fromPath(\"$.time\");\n  }\n\n  /**\n   * Extract the region from the event\n   */\n  public static get region(): string {\n    return this.fromPath(\"$.region\");\n  }\n\n  /**\n   * Extract a custom JSON path from the event\n   */\n  public static fromPath(path: string): string {\n    return new EventField(path).toString();\n  }\n\n  /**\n   * Human readable display hint about the event pattern\n   */\n  public readonly displayHint: string;\n  public readonly creationStack: string[];\n\n  /**\n   *\n   * @param path the path to a field in the event pattern\n   */\n  private constructor(public readonly path: string) {\n    this.displayHint = this.path\n      .replace(/^[^a-zA-Z0-9_-]+/, \"\")\n      .replace(/[^a-zA-Z0-9_-]/g, \"-\");\n    Object.defineProperty(this, EVENT_FIELD_SYMBOL, { value: true });\n\n    // TODO: Implement stack traces\n    // ref: https://github.com/hashicorp/terraform-cdk/blob/v0.20.7/packages/cdktf/lib/app.ts#L111\n    // ref: https://github.com/hashicorp/terraform-cdk/blob/v0.20.9/packages/cdktf/lib/tokens/private/stack-trace.ts#L9\n    // ref: https://github.com/aws/aws-cdk/blob/v2.143.0/packages/aws-cdk-lib/core/lib/stack-trace.ts#L22\n    this.creationStack = [\"stack traces disabled\"];\n  }\n\n  public resolve(_ctx: IResolveContext): any {\n    return this.path;\n  }\n\n  public toString() {\n    return Token.asString(this, { displayHint: this.displayHint });\n  }\n\n  /**\n   * Convert the path to the field in the event pattern to JSON\n   */\n  public toJSON() {\n    return `<path:${this.path}>`;\n  }\n}\n\nenum InputType {\n  Object,\n  Text,\n  Multiline,\n}\n\nfunction isEventField(x: any): x is EventField {\n  return EVENT_FIELD_SYMBOL in x;\n}\n\nconst EVENT_FIELD_SYMBOL = Symbol.for(\n  \"terraconstructs/lib/aws/notify.EventField\",\n);\n"]}

package/lib/aws/notify/kinesis-canned-metrics.generated.d.ts

@@ -0,0 +1,68 @@
+export interface MetricWithDims<D> {
+    readonly namespace: string;
+    readonly metricName: string;
+    readonly statistic: string;
+    readonly dimensionsMap: D;
+}
+export declare class KinesisMetrics {
+    static readProvisionedThroughputExceededSum(dimensions: {
+        StreamName: string;
+    }): MetricWithDims<{
+        StreamName: string;
+    }>;
+    static writeProvisionedThroughputExceededSum(dimensions: {
+        StreamName: string;
+    }): MetricWithDims<{
+        StreamName: string;
+    }>;
+    static getRecordsIteratorAgeMillisecondsMaximum(dimensions: {
+        StreamName: string;
+    }): MetricWithDims<{
+        StreamName: string;
+    }>;
+    static putRecordSuccessSum(dimensions: {
+        StreamName: string;
+    }): MetricWithDims<{
+        StreamName: string;
+    }>;
+    static putRecordsSuccessSum(dimensions: {
+        StreamName: string;
+    }): MetricWithDims<{
+        StreamName: string;
+    }>;
+    static putRecordsBytesSum(dimensions: {
+        StreamName: string;
+    }): MetricWithDims<{
+        StreamName: string;
+    }>;
+    static getRecordsSuccessSum(dimensions: {
+        StreamName: string;
+    }): MetricWithDims<{
+        StreamName: string;
+    }>;
+    static getRecordsBytesSum(dimensions: {
+        StreamName: string;
+    }): MetricWithDims<{
+        StreamName: string;
+    }>;
+    static getRecordsRecordsSum(dimensions: {
+        StreamName: string;
+    }): MetricWithDims<{
+        StreamName: string;
+    }>;
+    static getRecordsLatencyMaximum(dimensions: {
+        StreamName: string;
+    }): MetricWithDims<{
+        StreamName: string;
+    }>;
+    static incomingBytesSum(dimensions: {
+        StreamName: string;
+    }): MetricWithDims<{
+        StreamName: string;
+    }>;
+    static incomingRecordsSum(dimensions: {
+        StreamName: string;
+    }): MetricWithDims<{
+        StreamName: string;
+    }>;
+}

package/lib/aws/notify/kinesis-canned-metrics.generated.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KinesisMetrics = void 0;
+class KinesisMetrics {
+    static readProvisionedThroughputExceededSum(dimensions) {
+        return {
+            "namespace": "AWS/Kinesis",
+            "metricName": "ReadProvisionedThroughputExceeded",
+            "dimensionsMap": dimensions,
+            "statistic": "Sum"
+        };
+    }
+    static writeProvisionedThroughputExceededSum(dimensions) {
+        return {
+            "namespace": "AWS/Kinesis",
+            "metricName": "WriteProvisionedThroughputExceeded",
+            "dimensionsMap": dimensions,
+            "statistic": "Sum"
+        };
+    }
+    static getRecordsIteratorAgeMillisecondsMaximum(dimensions) {
+        return {
+            "namespace": "AWS/Kinesis",
+            "metricName": "GetRecords.IteratorAgeMilliseconds",
+            "dimensionsMap": dimensions,
+            "statistic": "Maximum"
+        };
+    }
+    static putRecordSuccessSum(dimensions) {
+        return {
+            "namespace": "AWS/Kinesis",
+            "metricName": "PutRecord.Success",
+            "dimensionsMap": dimensions,
+            "statistic": "Sum"
+        };
+    }
+    static putRecordsSuccessSum(dimensions) {
+        return {
+            "namespace": "AWS/Kinesis",
+            "metricName": "PutRecords.Success",
+            "dimensionsMap": dimensions,
+            "statistic": "Sum"
+        };
+    }
+    static putRecordsBytesSum(dimensions) {
+        return {
+            "namespace": "AWS/Kinesis",
+            "metricName": "PutRecords.Bytes",
+            "dimensionsMap": dimensions,
+            "statistic": "Sum"
+        };
+    }
+    static getRecordsSuccessSum(dimensions) {
+        return {
+            "namespace": "AWS/Kinesis",
+            "metricName": "GetRecords.Success",
+            "dimensionsMap": dimensions,
+            "statistic": "Sum"
+        };
+    }
+    static getRecordsBytesSum(dimensions) {
+        return {
+            "namespace": "AWS/Kinesis",
+            "metricName": "GetRecords.Bytes",
+            "dimensionsMap": dimensions,
+            "statistic": "Sum"
+        };
+    }
+    static getRecordsRecordsSum(dimensions) {
+        return {
+            "namespace": "AWS/Kinesis",
+            "metricName": "GetRecords.Records",
+            "dimensionsMap": dimensions,
+            "statistic": "Sum"
+        };
+    }
+    static getRecordsLatencyMaximum(dimensions) {
+        return {
+            "namespace": "AWS/Kinesis",
+            "metricName": "GetRecords.Latency",
+            "dimensionsMap": dimensions,
+            "statistic": "Maximum"
+        };
+    }
+    static incomingBytesSum(dimensions) {
+        return {
+            "namespace": "AWS/Kinesis",
+            "metricName": "IncomingBytes",
+            "dimensionsMap": dimensions,
+            "statistic": "Sum"
+        };
+    }
+    static incomingRecordsSum(dimensions) {
+        return {
+            "namespace": "AWS/Kinesis",
+            "metricName": "IncomingRecords",
+            "dimensionsMap": dimensions,
+            "statistic": "Sum"
+        };
+    }
+}
+exports.KinesisMetrics = KinesisMetrics;
+//# sourceMappingURL=data:application/json;base64,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