terraconstructs 0.0.8

package/lib/aws/notify/event-pattern.js

@@ -0,0 +1,197 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Match = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+// ref: https://github.com/aws/aws-cdk/blob/v2.156.0/packages/aws-cdk-lib/aws-events/lib/event-pattern.ts
+const cdktf_1 = require("cdktf");
+/**
+ * An event pattern matcher
+ */
+class Match {
+    /**
+     * Matches a null value in the JSON of the event
+     */
+    static nullValue() {
+        return this.fromObjects([null]);
+    }
+    /**
+     * Matches when the field is present in the JSON of the event
+     */
+    static exists() {
+        return this.fromObjects([{ exists: true }]);
+    }
+    /**
+     * Matches when the field is absent from the JSON of the event
+     */
+    static doesNotExist() {
+        return this.fromObjects([{ exists: false }]);
+    }
+    /**
+     * Matches a string, exactly, in the JSON of the event
+     */
+    static exactString(value) {
+        return this.fromObjects([value]);
+    }
+    /**
+     * Matches a string, regardless of case, in the JSON of the event
+     */
+    static equalsIgnoreCase(value) {
+        return this.fromObjects([{ "equals-ignore-case": value }]);
+    }
+    /**
+     * Matches strings with the given prefix in the JSON of the event
+     */
+    static prefix(value) {
+        return this.fromObjects([{ prefix: value }]);
+    }
+    /**
+     * Matches strings with the given suffix in the JSON of the event
+     */
+    static suffix(value) {
+        return this.fromObjects([{ suffix: value }]);
+    }
+    /**
+     * Matches IPv4 and IPv6 network addresses using the Classless Inter-Domain Routing (CIDR) format
+     */
+    static cidr(range) {
+        const ipv4Regex = /^([0-9]{1,3}\.){3}[0-9]{1,3}(\/([0-9]|[1-2][0-9]|3[0-2]))?$/gim;
+        const ipv6Regex = /^s*((([0-9A-Fa-f]{1,4}:){7}([0-9A-Fa-f]{1,4}|:))|(([0-9A-Fa-f]{1,4}:){6}(:[0-9A-Fa-f]{1,4}|((25[0-5]|2[0-4]d|1dd|[1-9]?d)(.(25[0-5]|2[0-4]d|1dd|[1-9]?d)){3})|:))|(([0-9A-Fa-f]{1,4}:){5}(((:[0-9A-Fa-f]{1,4}){1,2})|:((25[0-5]|2[0-4]d|1dd|[1-9]?d)(.(25[0-5]|2[0-4]d|1dd|[1-9]?d)){3})|:))|(([0-9A-Fa-f]{1,4}:){4}(((:[0-9A-Fa-f]{1,4}){1,3})|((:[0-9A-Fa-f]{1,4})?:((25[0-5]|2[0-4]d|1dd|[1-9]?d)(.(25[0-5]|2[0-4]d|1dd|[1-9]?d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){3}(((:[0-9A-Fa-f]{1,4}){1,4})|((:[0-9A-Fa-f]{1,4}){0,2}:((25[0-5]|2[0-4]d|1dd|[1-9]?d)(.(25[0-5]|2[0-4]d|1dd|[1-9]?d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){2}(((:[0-9A-Fa-f]{1,4}){1,5})|((:[0-9A-Fa-f]{1,4}){0,3}:((25[0-5]|2[0-4]d|1dd|[1-9]?d)(.(25[0-5]|2[0-4]d|1dd|[1-9]?d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){1}(((:[0-9A-Fa-f]{1,4}){1,6})|((:[0-9A-Fa-f]{1,4}){0,4}:((25[0-5]|2[0-4]d|1dd|[1-9]?d)(.(25[0-5]|2[0-4]d|1dd|[1-9]?d)){3}))|:))|(:(((:[0-9A-Fa-f]{1,4}){1,7})|((:[0-9A-Fa-f]{1,4}){0,5}:((25[0-5]|2[0-4]d|1dd|[1-9]?d)(.(25[0-5]|2[0-4]d|1dd|[1-9]?d)){3}))|:)))(%.+)?s*(\/([0-9]|[1-9][0-9]|1[0-1][0-9]|12[0-8]))?$/gim;
+        if (!ipv4Regex.test(range) && !ipv6Regex.test(range)) {
+            throw new Error(`Invalid IP address range: ${range}`);
+        }
+        return this.fromObjects([{ cidr: range }]);
+    }
+    /**
+     * Matches IPv4 and IPv6 network addresses using the Classless Inter-Domain Routing (CIDR) format.
+     * Alias of `cidr()`.
+     */
+    static ipAddressRange(range) {
+        return Match.cidr(range);
+    }
+    /**
+     * Matches anything except what's provided in the rule. The list of provided values must contain
+     * only strings or only numbers.
+     */
+    static anythingBut(...values) {
+        if (values.length === 0) {
+            throw new Error("anythingBut matchers must be non-empty lists");
+        }
+        const allNumbers = values.every((v) => typeof v === "number");
+        const allStrings = values.every((v) => typeof v === "string");
+        if (!(allNumbers || allStrings)) {
+            throw new Error("anythingBut matchers must be lists that contain only strings or only numbers.");
+        }
+        return this.fromObjects([{ "anything-but": values }]);
+    }
+    /**
+     * Matches any string that doesn't start with the given prefix.
+     */
+    static anythingButPrefix(prefix) {
+        return this.fromObjects([{ "anything-but": { prefix: prefix } }]);
+    }
+    /**
+     * Matches numbers greater than the provided value
+     */
+    static greaterThan(value) {
+        return this.numeric(">", value);
+    }
+    /**
+     * Matches numbers greater than, or equal to, the provided value
+     */
+    static greaterThanOrEqual(value) {
+        return this.numeric(">=", value);
+    }
+    /**
+     * Matches numbers less than the provided value
+     */
+    static lessThan(value) {
+        return this.numeric("<", value);
+    }
+    /**
+     * Matches numbers less than, or equal to, the provided value
+     */
+    static lessThanOrEqual(value) {
+        return this.numeric("<=", value);
+    }
+    /**
+     * Matches numbers equal to the provided value
+     */
+    static equal(value) {
+        return this.numeric("=", value);
+    }
+    /**
+     * Matches numbers inside a closed numeric interval. Equivalent to:
+     *
+     *    Match.allOf(Match.greaterThanOrEqual(lower), Match.lessThanOrEqual(upper))
+     *
+     * @param lower Lower bound (inclusive)
+     * @param upper Upper bound (inclusive)
+     */
+    static interval(lower, upper) {
+        if (lower > upper) {
+            throw new Error(`Invalid interval: [${lower}, ${upper}]`);
+        }
+        return Match.allOf(Match.greaterThanOrEqual(lower), Match.lessThanOrEqual(upper));
+    }
+    /**
+     * Matches an event if any of the provided matchers do. Only numeric matchers are accepted.
+     */
+    static allOf(...matchers) {
+        if (matchers.length === 0) {
+            throw new Error("A list of matchers must contain at least one element.");
+        }
+        return this.fromMergedObjects(matchers);
+    }
+    /**
+     * Matches an event if any of the provided matchers does.
+     */
+    static anyOf(...matchers) {
+        if (matchers.length === 0) {
+            throw new Error("A list of matchers must contain at least one element.");
+        }
+        return this.fromObjects(matchers);
+    }
+    static numeric(operator, value) {
+        return this.fromObjects([{ numeric: [operator, value] }]);
+    }
+    static fromObjects(values) {
+        return new Match(values, { mergeMatchers: false }).asList();
+    }
+    static fromMergedObjects(values) {
+        return new Match(values, { mergeMatchers: true }).asList();
+    }
+    constructor(matchers, options) {
+        this.matchers = matchers;
+        this.options = options;
+        // TODO: Implement stack traces
+        // 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(context) {
+        const matchers = this.matchers.flatMap((matcher) => context.resolve(matcher));
+        return this.options.mergeMatchers ? this.merge(matchers) : matchers;
+    }
+    merge(matchers) {
+        // This is the only supported case for merging at the moment.
+        // We can generalize this logic if EventBridge starts supporting more cases in the future.
+        if (!matchers.every((matcher) => matcher?.numeric)) {
+            throw new Error("Only numeric matchers can be merged into a single matcher.");
+        }
+        return [{ numeric: matchers.flatMap((matcher) => matcher.numeric) }];
+    }
+    toString() {
+        return cdktf_1.Token.asString(this);
+    }
+    /**
+     * A representation of this matcher as a list of strings
+     */
+    asList() {
+        return cdktf_1.Token.asList(this);
+    }
+}
+exports.Match = Match;
+_a = JSII_RTTI_SYMBOL_1;
+Match[_a] = { fqn: "terraconstructs.aws.notify.Match", version: "0.0.8" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"event-pattern.js","sourceRoot":"","sources":["../../../src/aws/notify/event-pattern.ts"],"names":[],"mappings":"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","sourcesContent":["// ref: https://github.com/aws/aws-cdk/blob/v2.156.0/packages/aws-cdk-lib/aws-events/lib/event-pattern.ts\nimport { IResolvable, IResolveContext, Token } from \"cdktf\";\n\ntype ComparisonOperator = \">\" | \">=\" | \"<\" | \"<=\" | \"=\";\n\n/**\n * Options for how to construct matchers\n */\ninterface MatchOptions {\n  /**\n   * Whether the list of matchers should be merged into a single matcher\n   */\n  readonly mergeMatchers: boolean;\n}\n\n/**\n * An event pattern matcher\n */\nexport class Match implements IResolvable {\n  /**\n   * Matches a null value in the JSON of the event\n   */\n  public static nullValue(): string[] {\n    return this.fromObjects([null]);\n  }\n\n  /**\n   * Matches when the field is present in the JSON of the event\n   */\n  public static exists(): string[] {\n    return this.fromObjects([{ exists: true }]);\n  }\n\n  /**\n   * Matches when the field is absent from the JSON of the event\n   */\n  public static doesNotExist(): string[] {\n    return this.fromObjects([{ exists: false }]);\n  }\n\n  /**\n   * Matches a string, exactly, in the JSON of the event\n   */\n  public static exactString(value: string): string[] {\n    return this.fromObjects([value]);\n  }\n\n  /**\n   * Matches a string, regardless of case, in the JSON of the event\n   */\n  public static equalsIgnoreCase(value: string): string[] {\n    return this.fromObjects([{ \"equals-ignore-case\": value }]);\n  }\n\n  /**\n   * Matches strings with the given prefix in the JSON of the event\n   */\n  public static prefix(value: string): string[] {\n    return this.fromObjects([{ prefix: value }]);\n  }\n\n  /**\n   * Matches strings with the given suffix in the JSON of the event\n   */\n  public static suffix(value: string): string[] {\n    return this.fromObjects([{ suffix: value }]);\n  }\n\n  /**\n   * Matches IPv4 and IPv6 network addresses using the Classless Inter-Domain Routing (CIDR) format\n   */\n  public static cidr(range: string): string[] {\n    const ipv4Regex =\n      /^([0-9]{1,3}\\.){3}[0-9]{1,3}(\\/([0-9]|[1-2][0-9]|3[0-2]))?$/gim;\n    const ipv6Regex =\n      /^s*((([0-9A-Fa-f]{1,4}:){7}([0-9A-Fa-f]{1,4}|:))|(([0-9A-Fa-f]{1,4}:){6}(:[0-9A-Fa-f]{1,4}|((25[0-5]|2[0-4]d|1dd|[1-9]?d)(.(25[0-5]|2[0-4]d|1dd|[1-9]?d)){3})|:))|(([0-9A-Fa-f]{1,4}:){5}(((:[0-9A-Fa-f]{1,4}){1,2})|:((25[0-5]|2[0-4]d|1dd|[1-9]?d)(.(25[0-5]|2[0-4]d|1dd|[1-9]?d)){3})|:))|(([0-9A-Fa-f]{1,4}:){4}(((:[0-9A-Fa-f]{1,4}){1,3})|((:[0-9A-Fa-f]{1,4})?:((25[0-5]|2[0-4]d|1dd|[1-9]?d)(.(25[0-5]|2[0-4]d|1dd|[1-9]?d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){3}(((:[0-9A-Fa-f]{1,4}){1,4})|((:[0-9A-Fa-f]{1,4}){0,2}:((25[0-5]|2[0-4]d|1dd|[1-9]?d)(.(25[0-5]|2[0-4]d|1dd|[1-9]?d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){2}(((:[0-9A-Fa-f]{1,4}){1,5})|((:[0-9A-Fa-f]{1,4}){0,3}:((25[0-5]|2[0-4]d|1dd|[1-9]?d)(.(25[0-5]|2[0-4]d|1dd|[1-9]?d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){1}(((:[0-9A-Fa-f]{1,4}){1,6})|((:[0-9A-Fa-f]{1,4}){0,4}:((25[0-5]|2[0-4]d|1dd|[1-9]?d)(.(25[0-5]|2[0-4]d|1dd|[1-9]?d)){3}))|:))|(:(((:[0-9A-Fa-f]{1,4}){1,7})|((:[0-9A-Fa-f]{1,4}){0,5}:((25[0-5]|2[0-4]d|1dd|[1-9]?d)(.(25[0-5]|2[0-4]d|1dd|[1-9]?d)){3}))|:)))(%.+)?s*(\\/([0-9]|[1-9][0-9]|1[0-1][0-9]|12[0-8]))?$/gim;\n\n    if (!ipv4Regex.test(range) && !ipv6Regex.test(range)) {\n      throw new Error(`Invalid IP address range: ${range}`);\n    }\n\n    return this.fromObjects([{ cidr: range }]);\n  }\n\n  /**\n   * Matches IPv4 and IPv6 network addresses using the Classless Inter-Domain Routing (CIDR) format.\n   * Alias of `cidr()`.\n   */\n  public static ipAddressRange(range: string): string[] {\n    return Match.cidr(range);\n  }\n\n  /**\n   * Matches anything except what's provided in the rule. The list of provided values must contain\n   * only strings or only numbers.\n   */\n  public static anythingBut(...values: any[]): string[] {\n    if (values.length === 0) {\n      throw new Error(\"anythingBut matchers must be non-empty lists\");\n    }\n\n    const allNumbers = values.every((v) => typeof v === \"number\");\n    const allStrings = values.every((v) => typeof v === \"string\");\n\n    if (!(allNumbers || allStrings)) {\n      throw new Error(\n        \"anythingBut matchers must be lists that contain only strings or only numbers.\",\n      );\n    }\n\n    return this.fromObjects([{ \"anything-but\": values }]);\n  }\n\n  /**\n   * Matches any string that doesn't start with the given prefix.\n   */\n  public static anythingButPrefix(prefix: string): string[] {\n    return this.fromObjects([{ \"anything-but\": { prefix: prefix } }]);\n  }\n\n  /**\n   * Matches numbers greater than the provided value\n   */\n  public static greaterThan(value: number): string[] {\n    return this.numeric(\">\", value);\n  }\n\n  /**\n   * Matches numbers greater than, or equal to, the provided value\n   */\n  public static greaterThanOrEqual(value: number): string[] {\n    return this.numeric(\">=\", value);\n  }\n\n  /**\n   * Matches numbers less than the provided value\n   */\n  public static lessThan(value: number): string[] {\n    return this.numeric(\"<\", value);\n  }\n\n  /**\n   * Matches numbers less than, or equal to, the provided value\n   */\n  public static lessThanOrEqual(value: number): string[] {\n    return this.numeric(\"<=\", value);\n  }\n\n  /**\n   * Matches numbers equal to the provided value\n   */\n  public static equal(value: number): string[] {\n    return this.numeric(\"=\", value);\n  }\n\n  /**\n   * Matches numbers inside a closed numeric interval. Equivalent to:\n   *\n   *    Match.allOf(Match.greaterThanOrEqual(lower), Match.lessThanOrEqual(upper))\n   *\n   * @param lower Lower bound (inclusive)\n   * @param upper Upper bound (inclusive)\n   */\n  public static interval(lower: number, upper: number): string[] {\n    if (lower > upper) {\n      throw new Error(`Invalid interval: [${lower}, ${upper}]`);\n    }\n\n    return Match.allOf(\n      Match.greaterThanOrEqual(lower),\n      Match.lessThanOrEqual(upper),\n    );\n  }\n\n  /**\n   * Matches an event if any of the provided matchers do. Only numeric matchers are accepted.\n   */\n  public static allOf(...matchers: any[]): string[] {\n    if (matchers.length === 0) {\n      throw new Error(\"A list of matchers must contain at least one element.\");\n    }\n\n    return this.fromMergedObjects(matchers);\n  }\n\n  /**\n   * Matches an event if any of the provided matchers does.\n   */\n  public static anyOf(...matchers: any[]): string[] {\n    if (matchers.length === 0) {\n      throw new Error(\"A list of matchers must contain at least one element.\");\n    }\n    return this.fromObjects(matchers);\n  }\n\n  private static numeric(\n    operator: ComparisonOperator,\n    value: number,\n  ): string[] {\n    return this.fromObjects([{ numeric: [operator, value] }]);\n  }\n\n  private static fromObjects(values: any[]): string[] {\n    return new Match(values, { mergeMatchers: false }).asList();\n  }\n\n  private static fromMergedObjects(values: any[]): string[] {\n    return new Match(values, { mergeMatchers: true }).asList();\n  }\n\n  public readonly creationStack: string[];\n\n  private constructor(\n    private readonly matchers: any[],\n    private readonly options: MatchOptions,\n  ) {\n    // TODO: Implement stack traces\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  resolve(context: IResolveContext): any {\n    const matchers = this.matchers.flatMap((matcher) =>\n      context.resolve(matcher),\n    );\n    return this.options.mergeMatchers ? this.merge(matchers) : matchers;\n  }\n\n  private merge(matchers: any[]): any {\n    // This is the only supported case for merging at the moment.\n    // We can generalize this logic if EventBridge starts supporting more cases in the future.\n    if (!matchers.every((matcher) => matcher?.numeric)) {\n      throw new Error(\n        \"Only numeric matchers can be merged into a single matcher.\",\n      );\n    }\n\n    return [{ numeric: matchers.flatMap((matcher) => matcher.numeric) }];\n  }\n\n  toString(): string {\n    return Token.asString(this);\n  }\n\n  /**\n   * A representation of this matcher as a list of strings\n   */\n  asList(): string[] {\n    return Token.asList(this);\n  }\n}\n\n/**\n * Events in Amazon CloudWatch Events are represented as JSON objects. For more\n * information about JSON objects, see RFC 7159.\n *\n * **Important**: this class can only be used with a `Rule` class. In particular,\n * do not use it with `CfnRule` class: your pattern will not be rendered\n * correctly. In a `CfnRule` class, write the pattern as you normally would when\n * directly writing CloudFormation.\n *\n * Rules use event patterns to select events and route them to targets. A\n * pattern either matches an event or it doesn't. Event patterns are represented\n * as JSON objects with a structure that is similar to that of events.\n *\n * It is important to remember the following about event pattern matching:\n *\n * - For a pattern to match an event, the event must contain all the field names\n *   listed in the pattern. The field names must appear in the event with the\n *   same nesting structure.\n *\n * - Other fields of the event not mentioned in the pattern are ignored;\n *   effectively, there is a ``\"*\": \"*\"`` wildcard for fields not mentioned.\n *\n * - The matching is exact (character-by-character), without case-folding or any\n *   other string normalization.\n *\n * - The values being matched follow JSON rules: Strings enclosed in quotes,\n *   numbers, and the unquoted keywords true, false, and null.\n *\n * - Number matching is at the string representation level. For example, 300,\n *   300.0, and 3.0e2 are not considered equal.\n *\n * For custom events, some optional properties are required. For more information, see\n * [Minimum information needed for a valid custom event](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-events-structure.html#eb-custom-event).\n *\n * @see https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/CloudWatchEventsandEventPatterns.html\n */\nexport interface EventPattern {\n  /**\n   * By default, this is set to 0 (zero) in all events.\n   *\n   * @default - No filtering on version\n   */\n  readonly version?: string[];\n\n  /**\n   * A unique value is generated for every event. This can be helpful in\n   * tracing events as they move through rules to targets, and are processed.\n   *\n   * @default - No filtering on id\n   */\n  readonly id?: string[];\n\n  /**\n   * Identifies, in combination with the source field, the fields and values\n   * that appear in the detail field.\n   *\n   * Represents the \"detail-type\" event field.\n   *\n   * @default - No filtering on detail type\n   */\n  readonly detailType?: string[];\n\n  /**\n   * Identifies the service that sourced the event. All events sourced from\n   * within AWS begin with \"aws.\" Customer-generated events can have any value\n   * here, as long as it doesn't begin with \"aws.\" We recommend the use of\n   * Java package-name style reverse domain-name strings.\n   *\n   * To find the correct value for source for an AWS service, see the table in\n   * AWS Service Namespaces. For example, the source value for Amazon\n   * CloudFront is aws.cloudfront.\n   *\n   * @see http://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html#genref-aws-service-namespaces\n   * @default - No filtering on source\n   */\n  readonly source?: string[];\n\n  /**\n   * The 12-digit number identifying an AWS account.\n   *\n   * @default - No filtering on account\n   */\n  readonly account?: string[];\n\n  /**\n   * The event timestamp, which can be specified by the service originating\n   * the event. If the event spans a time interval, the service might choose\n   * to report the start time, so this value can be noticeably before the time\n   * the event is actually received.\n   *\n   * @default - No filtering on time\n   */\n  readonly time?: string[];\n\n  /**\n   * Identifies the AWS region where the event originated.\n   *\n   * @default - No filtering on region\n   */\n  readonly region?: string[];\n\n  /**\n   * This JSON array contains ARNs that identify resources that are involved\n   * in the event. Inclusion of these ARNs is at the discretion of the\n   * service.\n   *\n   * For example, Amazon EC2 instance state-changes include Amazon EC2\n   * instance ARNs, Auto Scaling events include ARNs for both instances and\n   * Auto Scaling groups, but API calls with AWS CloudTrail do not include\n   * resource ARNs.\n   *\n   * @default - No filtering on resource\n   */\n  readonly resources?: string[];\n\n  /**\n   * A JSON object, whose content is at the discretion of the service\n   * originating the event.\n   *\n   * @default - No filtering on detail\n   */\n  readonly detail?: { [key: string]: any };\n}\n"]}

package/lib/aws/notify/index.d.ts

@@ -0,0 +1,15 @@
+export * from "./archive";
+export * from "./event-bus";
+export * from "./event-pattern";
+export * from "./connection";
+export * from "./input";
+export * from "./on-event-options";
+export * from "./queue-policy";
+export * from "./queue";
+export * from "./rule";
+export * from "./schedule";
+export * from "./target";
+export * from "./kinesis-stream";
+export * from "./resource-policy";
+export * as targets from "./targets";
+export * from "./queue-config.generated";

package/lib/aws/notify/index.js

@@ -0,0 +1,35 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.targets = void 0;
+__exportStar(require("./archive"), exports);
+__exportStar(require("./event-bus"), exports);
+__exportStar(require("./event-pattern"), exports);
+__exportStar(require("./connection"), exports);
+__exportStar(require("./input"), exports);
+__exportStar(require("./on-event-options"), exports);
+__exportStar(require("./queue-policy"), exports);
+__exportStar(require("./queue"), exports);
+__exportStar(require("./rule"), exports);
+__exportStar(require("./schedule"), exports);
+__exportStar(require("./target"), exports);
+// kinesis
+__exportStar(require("./kinesis-stream"), exports);
+__exportStar(require("./resource-policy"), exports);
+exports.targets = require("./targets");
+// generated by JSII Struct builder to please JSII pacman
+__exportStar(require("./queue-config.generated"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYXdzL25vdGlmeS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLDRDQUEwQjtBQUMxQiw4Q0FBNEI7QUFDNUIsa0RBQWdDO0FBQ2hDLCtDQUE2QjtBQUM3QiwwQ0FBd0I7QUFDeEIscURBQW1DO0FBQ25DLGlEQUErQjtBQUMvQiwwQ0FBd0I7QUFDeEIseUNBQXVCO0FBQ3ZCLDZDQUEyQjtBQUMzQiwyQ0FBeUI7QUFDekIsVUFBVTtBQUNWLG1EQUFpQztBQUNqQyxvREFBa0M7QUFFbEMsdUNBQXFDO0FBRXJDLHlEQUF5RDtBQUN6RCwyREFBeUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tIFwiLi9hcmNoaXZlXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9ldmVudC1idXNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2V2ZW50LXBhdHRlcm5cIjtcbmV4cG9ydCAqIGZyb20gXCIuL2Nvbm5lY3Rpb25cIjtcbmV4cG9ydCAqIGZyb20gXCIuL2lucHV0XCI7XG5leHBvcnQgKiBmcm9tIFwiLi9vbi1ldmVudC1vcHRpb25zXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9xdWV1ZS1wb2xpY3lcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3F1ZXVlXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9ydWxlXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9zY2hlZHVsZVwiO1xuZXhwb3J0ICogZnJvbSBcIi4vdGFyZ2V0XCI7XG4vLyBraW5lc2lzXG5leHBvcnQgKiBmcm9tIFwiLi9raW5lc2lzLXN0cmVhbVwiO1xuZXhwb3J0ICogZnJvbSBcIi4vcmVzb3VyY2UtcG9saWN5XCI7XG5cbmV4cG9ydCAqIGFzIHRhcmdldHMgZnJvbSBcIi4vdGFyZ2V0c1wiO1xuXG4vLyBnZW5lcmF0ZWQgYnkgSlNJSSBTdHJ1Y3QgYnVpbGRlciB0byBwbGVhc2UgSlNJSSBwYWNtYW5cbmV4cG9ydCAqIGZyb20gXCIuL3F1ZXVlLWNvbmZpZy5nZW5lcmF0ZWRcIjtcbiJdfQ==

package/lib/aws/notify/input.d.ts

@@ -0,0 +1,126 @@
+import { IResolvable, IResolveContext } from "cdktf";
+import { IRule } from "./rule";
+/**
+ * The input to send to the event target
+ */
+export declare abstract 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: string): RuleTargetInput;
+    /**
+     * 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: string): RuleTargetInput;
+    /**
+     * 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: any): RuleTargetInput;
+    /**
+     * Take the event target input from a path in the event JSON
+     */
+    static fromEventPath(path: string): RuleTargetInput;
+    protected constructor();
+    /**
+     * Return the input properties for this input object
+     */
+    abstract bind(rule: IRule): RuleTargetInputProperties;
+}
+/**
+ * The input properties for an event target
+ */
+export interface RuleTargetInputProperties {
+    /**
+     * Literal input to the target service (must be valid JSON)
+     *
+     * @default - input for the event target. If the input contains a paths map
+     *   values wil be extracted from event and inserted into the `inputTemplate`.
+     */
+    readonly input?: string;
+    /**
+     * JsonPath to take input from the input event
+     *
+     * @default - None. The entire matched event is passed as input
+     */
+    readonly inputPath?: string;
+    /**
+     * Input template to insert paths map into
+     *
+     * @default - None.
+     */
+    readonly inputTemplate?: string;
+    /**
+     * Paths map to extract values from event and insert into `inputTemplate`
+     *
+     * @default - No values extracted from event.
+     */
+    readonly inputPathsMap?: {
+        [key: string]: string;
+    };
+}
+/**
+ * Represents a field in the event pattern
+ */
+export declare class EventField implements IResolvable {
+    readonly path: string;
+    /**
+     * Extract the event ID from the event
+     */
+    static get eventId(): string;
+    /**
+     * Extract the detail type from the event
+     */
+    static get detailType(): string;
+    /**
+     * Extract the source from the event
+     */
+    static get source(): string;
+    /**
+     * Extract the account from the event
+     */
+    static get account(): string;
+    /**
+     * Extract the time from the event
+     */
+    static get time(): string;
+    /**
+     * Extract the region from the event
+     */
+    static get region(): string;
+    /**
+     * Extract a custom JSON path from the event
+     */
+    static fromPath(path: string): string;
+    /**
+     * Human readable display hint about the event pattern
+     */
+    readonly displayHint: string;
+    readonly creationStack: string[];
+    /**
+     *
+     * @param path the path to a field in the event pattern
+     */
+    private constructor();
+    resolve(_ctx: IResolveContext): any;
+    toString(): string;
+    /**
+     * Convert the path to the field in the event pattern to JSON
+     */
+    toJSON(): string;
+}