terraconstructs 0.0.17 → 0.0.19

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

@@ -237,5 +237,5 @@ class Match {
 }
 exports.Match = Match;
 _a = JSII_RTTI_SYMBOL_1;
-Match[_a] = { fqn: "terraconstructs.aws.notify.Match", version: "0.0.17" };
+Match[_a] = { fqn: "terraconstructs.aws.notify.Match", version: "0.0.19" };
 //# 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":["// https://github.com/aws/aws-cdk/blob/v2.156.0/packages/aws-cdk-lib/aws-events/lib/event-pattern.ts\n\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 strings with the given prefix in the JSON of the event regardless of the casing\n   */\n  public static prefixEqualsIgnoreCase(value: string): string[] {\n    return this.fromObjects([{ prefix: { \"equals-ignore-case\": value } }]);\n  }\n\n  /**\n   * Matches strings with the given suffix in the JSON of the event regardless of the casing\n   */\n  public static suffixEqualsIgnoreCase(value: string): string[] {\n    return this.fromObjects([{ suffix: { \"equals-ignore-case\": value } }]);\n  }\n\n  /**\n   * Matches strings with the given wildcard pattern in the JSON of the event\n   */\n  public static wildcard(value: string): string[] {\n    return this.fromObjects([{ wildcard: 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(...values: string[]): string[] {\n    return this.anythingButConjunction(\"prefix\", values);\n  }\n\n  /**\n   * Matches any string that doesn't end with the given suffix.\n   */\n  public static anythingButSuffix(...values: string[]): string[] {\n    return this.anythingButConjunction(\"suffix\", values);\n  }\n\n  /**\n   * Matches any string that doesn't match with the given wildcard pattern.\n   */\n  public static anythingButWildcard(...values: string[]): string[] {\n    return this.anythingButConjunction(\"wildcard\", values);\n  }\n\n  /**\n   * Matches any string that doesn't match with the given value regardless of character casing.\n   */\n  public static anythingButEqualsIgnoreCase(...values: string[]): string[] {\n    return this.anythingButConjunction(\"equals-ignore-case\", values);\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 anythingButConjunction(\n    filterKey: string,\n    values: string[],\n  ): string[] {\n    if (values.length === 0) {\n      throw new Error(\"anythingBut matchers must be non-empty lists\");\n    }\n\n    // When there is a single value return it, otherwise return the array\n    const filterValue = values.length === 1 ? values[0] : values;\n\n    return this.fromObjects([{ \"anything-but\": { [filterKey]: filterValue } }]);\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

@@ -11,5 +11,16 @@ export * from "./schedule";
 export * from "./target";
 export * from "./kinesis-stream";
 export * from "./resource-policy";
+export * from "./policy";
+export * from "./topic";
+export * from "./topic-base";
+export * from "./subscription";
+export * from "./subscriber";
+export * from "./subscription-filter";
+export * from "./delivery-policy";
+import "./sns-augmentations.generated";
+export * from "./notification-rule";
+export * from "./notification-rule-source";
+export * from "./notification-rule-target";
 export * as targets from "./targets";
 export * from "./queue-config.generated";

package/lib/aws/notify/index.js

@@ -29,9 +29,22 @@ __exportStar(require("./target"), exports);
 // kinesis
 __exportStar(require("./kinesis-stream"), exports);
 __exportStar(require("./resource-policy"), exports);
+// sns
+__exportStar(require("./policy"), exports);
+__exportStar(require("./topic"), exports);
+__exportStar(require("./topic-base"), exports);
+__exportStar(require("./subscription"), exports);
+__exportStar(require("./subscriber"), exports);
+__exportStar(require("./subscription-filter"), exports);
+__exportStar(require("./delivery-policy"), exports);
+require("./sns-augmentations.generated");
+// codestarnotifications
+__exportStar(require("./notification-rule"), exports);
+__exportStar(require("./notification-rule-source"), exports);
+__exportStar(require("./notification-rule-target"), exports);
 exports.targets = require("./targets");
 // generated by JSII Struct builder to please JSII pacman
 __exportStar(require("./queue-config.generated"), exports);
 // TODO: re-add QueueBase and Metrics support
 // import "./sqs-augmentations.generated";
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYXdzL25vdGlmeS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLDRDQUEwQjtBQUMxQiw4Q0FBNEI7QUFDNUIsa0RBQWdDO0FBQ2hDLCtDQUE2QjtBQUM3QiwwQ0FBd0I7QUFDeEIscURBQW1DO0FBQ25DLGlEQUErQjtBQUMvQiwwQ0FBd0I7QUFDeEIseUNBQXVCO0FBQ3ZCLDZDQUEyQjtBQUMzQiwyQ0FBeUI7QUFDekIsVUFBVTtBQUNWLG1EQUFpQztBQUNqQyxvREFBa0M7QUFFbEMsdUNBQXFDO0FBRXJDLHlEQUF5RDtBQUN6RCwyREFBeUM7QUFFekMsNkNBQTZDO0FBQzdDLDBDQUEwQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gXCIuL2FyY2hpdmVcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2V2ZW50LWJ1c1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vZXZlbnQtcGF0dGVyblwiO1xuZXhwb3J0ICogZnJvbSBcIi4vY29ubmVjdGlvblwiO1xuZXhwb3J0ICogZnJvbSBcIi4vaW5wdXRcIjtcbmV4cG9ydCAqIGZyb20gXCIuL29uLWV2ZW50LW9wdGlvbnNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3F1ZXVlLXBvbGljeVwiO1xuZXhwb3J0ICogZnJvbSBcIi4vcXVldWVcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3J1bGVcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3NjaGVkdWxlXCI7XG5leHBvcnQgKiBmcm9tIFwiLi90YXJnZXRcIjtcbi8vIGtpbmVzaXNcbmV4cG9ydCAqIGZyb20gXCIuL2tpbmVzaXMtc3RyZWFtXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9yZXNvdXJjZS1wb2xpY3lcIjtcblxuZXhwb3J0ICogYXMgdGFyZ2V0cyBmcm9tIFwiLi90YXJnZXRzXCI7XG5cbi8vIGdlbmVyYXRlZCBieSBKU0lJIFN0cnVjdCBidWlsZGVyIHRvIHBsZWFzZSBKU0lJIHBhY21hblxuZXhwb3J0ICogZnJvbSBcIi4vcXVldWUtY29uZmlnLmdlbmVyYXRlZFwiO1xuXG4vLyBUT0RPOiByZS1hZGQgUXVldWVCYXNlIGFuZCBNZXRyaWNzIHN1cHBvcnRcbi8vIGltcG9ydCBcIi4vc3FzLWF1Z21lbnRhdGlvbnMuZ2VuZXJhdGVkXCI7XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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

package/lib/aws/notify/input.js

@@ -54,7 +54,7 @@ class RuleTargetInput {
 }
 exports.RuleTargetInput = RuleTargetInput;
 _a = JSII_RTTI_SYMBOL_1;
-RuleTargetInput[_a] = { fqn: "terraconstructs.aws.notify.RuleTargetInput", version: "0.0.17" };
+RuleTargetInput[_a] = { fqn: "terraconstructs.aws.notify.RuleTargetInput", version: "0.0.19" };
 /**
  * Event Input that is directly derived from the construct
  */
@@ -269,7 +269,7 @@ class EventField {
 }
 exports.EventField = EventField;
 _b = JSII_RTTI_SYMBOL_1;
-EventField[_b] = { fqn: "terraconstructs.aws.notify.EventField", version: "0.0.17" };
+EventField[_b] = { fqn: "terraconstructs.aws.notify.EventField", version: "0.0.19" };
 var InputType;
 (function (InputType) {
     InputType[InputType["Object"] = 0] = "Object";

package/lib/aws/notify/kinesis-stream.js

@@ -494,7 +494,7 @@ class Stream extends StreamBase {
 }
 exports.Stream = Stream;
 _a = JSII_RTTI_SYMBOL_1;
-Stream[_a] = { fqn: "terraconstructs.aws.notify.Stream", version: "0.0.17" };
+Stream[_a] = { fqn: "terraconstructs.aws.notify.Stream", version: "0.0.19" };
 /**
  * What kind of server-side encryption to apply to this stream
  */

package/lib/aws/notify/notification-rule-source.d.ts

@@ -0,0 +1,20 @@
+import * as constructs from "constructs";
+/**
+ * Information about the Codebuild or CodePipeline associated with a notification source.
+ */
+export interface NotificationRuleSourceConfig {
+    /**
+     * The Amazon Resource Name (ARN) of the notification source.
+     */
+    readonly sourceArn: string;
+}
+/**
+ * Represents a notification source
+ * The source that allows CodeBuild and CodePipeline to associate with this rule.
+ */
+export interface INotificationRuleSource {
+    /**
+     * Returns a source configuration for notification rule.
+     */
+    bindAsNotificationRuleSource(scope: constructs.Construct): NotificationRuleSourceConfig;
+}

package/lib/aws/notify/notification-rule-source.js

@@ -0,0 +1,4 @@
+"use strict";
+// https://github.com/aws/aws-cdk/blob/a2c633f1e698249496f11338312ab42bd7b1e4f0/packages/aws-cdk-lib/aws-codestarnotifications/lib/notification-rule-source.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm90aWZpY2F0aW9uLXJ1bGUtc291cmNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2F3cy9ub3RpZnkvbm90aWZpY2F0aW9uLXJ1bGUtc291cmNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSw4SkFBOEoiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBodHRwczovL2dpdGh1Yi5jb20vYXdzL2F3cy1jZGsvYmxvYi9hMmM2MzNmMWU2OTgyNDk0OTZmMTEzMzgzMTJhYjQyYmQ3YjFlNGYwL3BhY2thZ2VzL2F3cy1jZGstbGliL2F3cy1jb2Rlc3Rhcm5vdGlmaWNhdGlvbnMvbGliL25vdGlmaWNhdGlvbi1ydWxlLXNvdXJjZS50c1xuXG5pbXBvcnQgKiBhcyBjb25zdHJ1Y3RzIGZyb20gXCJjb25zdHJ1Y3RzXCI7XG5cbi8qKlxuICogSW5mb3JtYXRpb24gYWJvdXQgdGhlIENvZGVidWlsZCBvciBDb2RlUGlwZWxpbmUgYXNzb2NpYXRlZCB3aXRoIGEgbm90aWZpY2F0aW9uIHNvdXJjZS5cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBOb3RpZmljYXRpb25SdWxlU291cmNlQ29uZmlnIHtcbiAgLyoqXG4gICAqIFRoZSBBbWF6b24gUmVzb3VyY2UgTmFtZSAoQVJOKSBvZiB0aGUgbm90aWZpY2F0aW9uIHNvdXJjZS5cbiAgICovXG4gIHJlYWRvbmx5IHNvdXJjZUFybjogc3RyaW5nO1xufVxuXG4vKipcbiAqIFJlcHJlc2VudHMgYSBub3RpZmljYXRpb24gc291cmNlXG4gKiBUaGUgc291cmNlIHRoYXQgYWxsb3dzIENvZGVCdWlsZCBhbmQgQ29kZVBpcGVsaW5lIHRvIGFzc29jaWF0ZSB3aXRoIHRoaXMgcnVsZS5cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBJTm90aWZpY2F0aW9uUnVsZVNvdXJjZSB7XG4gIC8qKlxuICAgKiBSZXR1cm5zIGEgc291cmNlIGNvbmZpZ3VyYXRpb24gZm9yIG5vdGlmaWNhdGlvbiBydWxlLlxuICAgKi9cbiAgYmluZEFzTm90aWZpY2F0aW9uUnVsZVNvdXJjZShcbiAgICBzY29wZTogY29uc3RydWN0cy5Db25zdHJ1Y3QsXG4gICk6IE5vdGlmaWNhdGlvblJ1bGVTb3VyY2VDb25maWc7XG59XG4iXX0=

package/lib/aws/notify/notification-rule-target.d.ts

@@ -0,0 +1,24 @@
+import * as constructs from "constructs";
+/**
+ * Information about the SNS topic or AWS Chatbot client associated with a notification target.
+ */
+export interface NotificationRuleTargetConfig {
+    /**
+     * The target type. Can be an Amazon SNS topic or AWS Chatbot client.
+     */
+    readonly targetType: string;
+    /**
+     * The Amazon Resource Name (ARN) of the Amazon SNS topic or AWS Chatbot client.
+     */
+    readonly targetAddress: string;
+}
+/**
+ * Represents a notification target
+ * That allows AWS Chatbot and SNS topic to associate with this rule target.
+ */
+export interface INotificationRuleTarget {
+    /**
+     * Returns a target configuration for notification rule.
+     */
+    bindAsNotificationRuleTarget(scope: constructs.Construct): NotificationRuleTargetConfig;
+}

package/lib/aws/notify/notification-rule-target.js

@@ -0,0 +1,4 @@
+"use strict";
+// https://github.com/aws/aws-cdk/blob/a2c633f1e698249496f11338312ab42bd7b1e4f0/packages/aws-cdk-lib/aws-codestarnotifications/lib/notification-rule-target.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm90aWZpY2F0aW9uLXJ1bGUtdGFyZ2V0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2F3cy9ub3RpZnkvbm90aWZpY2F0aW9uLXJ1bGUtdGFyZ2V0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSw4SkFBOEoiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBodHRwczovL2dpdGh1Yi5jb20vYXdzL2F3cy1jZGsvYmxvYi9hMmM2MzNmMWU2OTgyNDk0OTZmMTEzMzgzMTJhYjQyYmQ3YjFlNGYwL3BhY2thZ2VzL2F3cy1jZGstbGliL2F3cy1jb2Rlc3Rhcm5vdGlmaWNhdGlvbnMvbGliL25vdGlmaWNhdGlvbi1ydWxlLXRhcmdldC50c1xuXG5pbXBvcnQgKiBhcyBjb25zdHJ1Y3RzIGZyb20gXCJjb25zdHJ1Y3RzXCI7XG5cbi8qKlxuICogSW5mb3JtYXRpb24gYWJvdXQgdGhlIFNOUyB0b3BpYyBvciBBV1MgQ2hhdGJvdCBjbGllbnQgYXNzb2NpYXRlZCB3aXRoIGEgbm90aWZpY2F0aW9uIHRhcmdldC5cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBOb3RpZmljYXRpb25SdWxlVGFyZ2V0Q29uZmlnIHtcbiAgLyoqXG4gICAqIFRoZSB0YXJnZXQgdHlwZS4gQ2FuIGJlIGFuIEFtYXpvbiBTTlMgdG9waWMgb3IgQVdTIENoYXRib3QgY2xpZW50LlxuICAgKi9cbiAgcmVhZG9ubHkgdGFyZ2V0VHlwZTogc3RyaW5nO1xuXG4gIC8qKlxuICAgKiBUaGUgQW1hem9uIFJlc291cmNlIE5hbWUgKEFSTikgb2YgdGhlIEFtYXpvbiBTTlMgdG9waWMgb3IgQVdTIENoYXRib3QgY2xpZW50LlxuICAgKi9cbiAgcmVhZG9ubHkgdGFyZ2V0QWRkcmVzczogc3RyaW5nO1xufVxuXG4vKipcbiAqIFJlcHJlc2VudHMgYSBub3RpZmljYXRpb24gdGFyZ2V0XG4gKiBUaGF0IGFsbG93cyBBV1MgQ2hhdGJvdCBhbmQgU05TIHRvcGljIHRvIGFzc29jaWF0ZSB3aXRoIHRoaXMgcnVsZSB0YXJnZXQuXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgSU5vdGlmaWNhdGlvblJ1bGVUYXJnZXQge1xuICAvKipcbiAgICogUmV0dXJucyBhIHRhcmdldCBjb25maWd1cmF0aW9uIGZvciBub3RpZmljYXRpb24gcnVsZS5cbiAgICovXG4gIGJpbmRBc05vdGlmaWNhdGlvblJ1bGVUYXJnZXQoXG4gICAgc2NvcGU6IGNvbnN0cnVjdHMuQ29uc3RydWN0LFxuICApOiBOb3RpZmljYXRpb25SdWxlVGFyZ2V0Q29uZmlnO1xufVxuIl19

package/lib/aws/notify/notification-rule.d.ts

@@ -0,0 +1,123 @@
+import * as constructs from "constructs";
+import { AwsConstructBase, AwsConstructProps, IAwsConstruct } from "..";
+import { INotificationRuleSource } from "./notification-rule-source";
+import { INotificationRuleTarget } from "./notification-rule-target";
+/**
+ * The level of detail to include in the notifications for this resource.
+ */
+export declare enum DetailType {
+    /**
+     * BASIC will include only the contents of the event as it would appear in AWS CloudWatch
+     */
+    BASIC = "BASIC",
+    /**
+     * FULL will include any supplemental information provided by AWS CodeStar Notifications and/or the service for the resource for which the notification is created.
+     */
+    FULL = "FULL"
+}
+/**
+ * Standard set of options for `notifyOnXxx` codestar notification handler on construct
+ */
+export interface NotificationRuleOptions {
+    /**
+     * The name for the notification rule.
+     * Notification rule names must be unique in your AWS account.
+     *
+     * @default - generated from the `id`
+     */
+    readonly notificationRuleName?: string;
+    /**
+     * The status of the notification rule.
+     * If the enabled is set to DISABLED, notifications aren't sent for the notification rule.
+     *
+     * @default true
+     */
+    readonly enabled?: boolean;
+    /**
+     * The level of detail to include in the notifications for this resource.
+     * BASIC will include only the contents of the event as it would appear in AWS CloudWatch.
+     * FULL will include any supplemental information provided by AWS CodeStar Notifications and/or the service for the resource for which the notification is created.
+     *
+     * @default DetailType.FULL
+     */
+    readonly detailType?: DetailType;
+}
+/**
+ * Properties for a new notification rule
+ */
+export interface NotificationRuleProps extends AwsConstructProps, NotificationRuleOptions {
+    /**
+     * A list of event types associated with this notification rule.
+     * For a complete list of event types and IDs, see Notification concepts in the Developer Tools Console User Guide.
+     * @see https://docs.aws.amazon.com/dtconsole/latest/userguide/concepts.html#concepts-api
+     */
+    readonly events: string[];
+    /**
+     * The Amazon Resource Name (ARN) of the resource to associate with the notification rule.
+     * Currently, Supported sources include pipelines in AWS CodePipeline, build projects in AWS CodeBuild, and repositories in AWS CodeCommit in this L2 constructor.
+     * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codestarnotifications-notificationrule.html#cfn-codestarnotifications-notificationrule-resource
+     */
+    readonly source: INotificationRuleSource;
+    /**
+     * The targets to register for the notification destination.
+     *
+     * @default - No targets are added to the rule. Use `addTarget()` to add a target.
+     */
+    readonly targets?: INotificationRuleTarget[];
+    /**
+     * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.88.0/docs/resources/codestarnotifications_notification_rule#tags CodestarnotificationsNotificationRule#tags}
+     */
+    readonly tags?: {
+        [key: string]: string;
+    };
+}
+/**
+ * Represents a notification rule
+ */
+export interface INotificationRule extends IAwsConstruct {
+    /**
+     * The ARN of the notification rule (i.e. arn:aws:codestar-notifications:::notificationrule/01234abcde)
+     *
+     * @attribute
+     */
+    readonly notificationRuleArn: string;
+    /**
+     * Adds target to notification rule
+     *
+     * @param target The SNS topic or AWS Chatbot Slack target
+     * @returns boolean - return true if it had any effect
+     */
+    addTarget(target: INotificationRuleTarget): boolean;
+}
+/**
+ * A new notification rule
+ *
+ * @resource AWS::CodeStarNotifications::NotificationRule
+ */
+export declare class NotificationRule extends AwsConstructBase implements INotificationRule {
+    /**
+     * Import an existing notification rule provided an ARN
+     * @param scope The parent creating construct
+     * @param id The construct's name
+     * @param notificationRuleArn Notification rule ARN (i.e. arn:aws:codestar-notifications:::notificationrule/01234abcde)
+     */
+    static fromNotificationRuleArn(scope: constructs.Construct, id: string, notificationRuleArn: string): INotificationRule;
+    /**
+     * @attribute
+     */
+    readonly notificationRuleArn: string;
+    private readonly targetList;
+    private readonly events;
+    private readonly resource;
+    get outputs(): Record<string, any>;
+    constructor(scope: constructs.Construct, id: string, props: NotificationRuleProps);
+    addTarget(target: INotificationRuleTarget): boolean;
+    /**
+     * Adds events to notification rule
+     *
+     * @see https://docs.aws.amazon.com/dtconsole/latest/userguide/concepts.html#events-ref-pipeline
+     * @see https://docs.aws.amazon.com/dtconsole/latest/userguide/concepts.html#events-ref-buildproject
+     * @param events The list of event types for AWS Codebuild and AWS CodePipeline
+     */
+    private addEvents;
+}

package/lib/aws/notify/notification-rule.js

@@ -0,0 +1,129 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotificationRule = exports.DetailType = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+// https://github.com/aws/aws-cdk/blob/bc96ee17a18c19b98e4ad052bed7c24da2371050/packages/aws-cdk-lib/aws-codestarnotifications/lib/notification-rule.ts
+const provider_aws_1 = require("@cdktf/provider-aws");
+const cdktf_1 = require("cdktf");
+const __1 = require("..");
+/**
+ * The level of detail to include in the notifications for this resource.
+ */
+var DetailType;
+(function (DetailType) {
+    /**
+     * BASIC will include only the contents of the event as it would appear in AWS CloudWatch
+     */
+    DetailType["BASIC"] = "BASIC";
+    /**
+     * FULL will include any supplemental information provided by AWS CodeStar Notifications and/or the service for the resource for which the notification is created.
+     */
+    DetailType["FULL"] = "FULL";
+})(DetailType || (exports.DetailType = DetailType = {}));
+/**
+ * A new notification rule
+ *
+ * @resource AWS::CodeStarNotifications::NotificationRule
+ */
+class NotificationRule extends __1.AwsConstructBase {
+    /**
+     * Import an existing notification rule provided an ARN
+     * @param scope The parent creating construct
+     * @param id The construct's name
+     * @param notificationRuleArn Notification rule ARN (i.e. arn:aws:codestar-notifications:::notificationrule/01234abcde)
+     */
+    static fromNotificationRuleArn(scope, id, notificationRuleArn) {
+        class Import extends __1.AwsConstructBase {
+            constructor() {
+                super(...arguments);
+                this.notificationRuleArn = notificationRuleArn;
+            }
+            get outputs() {
+                return { notificationRuleArn: this.notificationRuleArn };
+            }
+            addTarget(_target) {
+                cdktf_1.Annotations.of(this).addWarning(`Cannot add targets to imported NotificationRule '${this.node.id}'. Define targets directly on the source or manage permissions separately.`);
+                return false;
+            }
+        }
+        return new Import(scope, id, {
+            environmentFromArn: notificationRuleArn,
+        });
+    }
+    get outputs() {
+        return { notificationRuleArn: this.notificationRuleArn };
+    }
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        this.targetList = [];
+        this.events = [];
+        const source = props.source.bindAsNotificationRuleSource(this);
+        this.addEvents(props.events);
+        // Process initial targets from props
+        props.targets?.forEach((target) => {
+            this.addTarget(target);
+        });
+        const ruleName = props.notificationRuleName
+            ? props.notificationRuleName.slice(-64) // Ensure 64 char limit
+            : this.stack.uniqueResourceName(this, { maxLength: 64 });
+        this.resource =
+            new provider_aws_1.codestarnotificationsNotificationRule.CodestarnotificationsNotificationRule(this, "Resource", {
+                name: ruleName,
+                detailType: props.detailType ?? DetailType.FULL,
+                eventTypeIds: cdktf_1.Lazy.listValue({
+                    produce: () => {
+                        if (cdktf_1.Token.isUnresolved(props.events)) {
+                            return props.events;
+                        }
+                        return this.events;
+                    },
+                }),
+                resource: source.sourceArn,
+                status: props.enabled === false
+                    ? "DISABLED"
+                    : props.enabled === true || props.enabled === undefined
+                        ? "ENABLED"
+                        : undefined, // Let Terraform handle default if undefined
+                // Use Lazy producer to handle the potentially dynamic list of targets
+                target: cdktf_1.Lazy.anyValue({
+                    produce: () => this.targetList.map((t) => provider_aws_1.codestarnotificationsNotificationRule.codestarnotificationsNotificationRuleTargetToTerraform({
+                        address: t.targetAddress,
+                        type: t.targetType,
+                    })),
+                }),
+                tags: props.tags,
+            });
+        this.notificationRuleArn = this.resource.arn;
+    }
+    addTarget(target) {
+        const boundTarget = target.bindAsNotificationRuleTarget(this);
+        // Check if target already exists to avoid duplicates if this method were to update the resource
+        const exists = this.targetList.some((t) => t.targetAddress === boundTarget.targetAddress &&
+            t.targetType === boundTarget.targetType);
+        if (!exists) {
+            this.targetList.push(boundTarget);
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Adds events to notification rule
+     *
+     * @see https://docs.aws.amazon.com/dtconsole/latest/userguide/concepts.html#events-ref-pipeline
+     * @see https://docs.aws.amazon.com/dtconsole/latest/userguide/concepts.html#events-ref-buildproject
+     * @param events The list of event types for AWS Codebuild and AWS CodePipeline
+     */
+    addEvents(events) {
+        events.forEach((event) => {
+            if (this.events.includes(event)) {
+                return;
+            }
+            this.events.push(event);
+        });
+    }
+}
+exports.NotificationRule = NotificationRule;
+_a = JSII_RTTI_SYMBOL_1;
+NotificationRule[_a] = { fqn: "terraconstructs.aws.notify.NotificationRule", version: "0.0.19" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"notification-rule.js","sourceRoot":"","sources":["../../../src/aws/notify/notification-rule.ts"],"names":[],"mappings":"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","sourcesContent":["// https://github.com/aws/aws-cdk/blob/bc96ee17a18c19b98e4ad052bed7c24da2371050/packages/aws-cdk-lib/aws-codestarnotifications/lib/notification-rule.ts\n\nimport { codestarnotificationsNotificationRule } from \"@cdktf/provider-aws\";\nimport { Annotations, Lazy, Token } from \"cdktf\";\nimport * as constructs from \"constructs\";\nimport { AwsConstructBase, AwsConstructProps, IAwsConstruct } from \"..\";\nimport { INotificationRuleSource } from \"./notification-rule-source\";\nimport {\n  INotificationRuleTarget,\n  NotificationRuleTargetConfig,\n} from \"./notification-rule-target\";\n\n/**\n * The level of detail to include in the notifications for this resource.\n */\nexport enum DetailType {\n  /**\n   * BASIC will include only the contents of the event as it would appear in AWS CloudWatch\n   */\n  BASIC = \"BASIC\",\n\n  /**\n   * FULL will include any supplemental information provided by AWS CodeStar Notifications and/or the service for the resource for which the notification is created.\n   */\n  FULL = \"FULL\",\n}\n\n/**\n * Standard set of options for `notifyOnXxx` codestar notification handler on construct\n */\nexport interface NotificationRuleOptions {\n  /**\n   * The name for the notification rule.\n   * Notification rule names must be unique in your AWS account.\n   *\n   * @default - generated from the `id`\n   */\n  readonly notificationRuleName?: string;\n\n  /**\n   * The status of the notification rule.\n   * If the enabled is set to DISABLED, notifications aren't sent for the notification rule.\n   *\n   * @default true\n   */\n  readonly enabled?: boolean;\n\n  /**\n   * The level of detail to include in the notifications for this resource.\n   * BASIC will include only the contents of the event as it would appear in AWS CloudWatch.\n   * FULL will include any supplemental information provided by AWS CodeStar Notifications and/or the service for the resource for which the notification is created.\n   *\n   * @default DetailType.FULL\n   */\n  readonly detailType?: DetailType;\n\n  // createdBy is not supported by the Terraform resource\n  // /**\n  //  * The name or email alias of the person who created the notification rule.\n  //  * If not specified, it means that the creator's alias is not provided.\n  //  *\n  //  * @default - No alias provided\n  //  */\n  // readonly createdBy?: string;\n}\n\n/**\n * Properties for a new notification rule\n */\nexport interface NotificationRuleProps\n  extends AwsConstructProps,\n    NotificationRuleOptions {\n  /**\n   * A list of event types associated with this notification rule.\n   * For a complete list of event types and IDs, see Notification concepts in the Developer Tools Console User Guide.\n   * @see https://docs.aws.amazon.com/dtconsole/latest/userguide/concepts.html#concepts-api\n   */\n  readonly events: string[];\n\n  /**\n   * The Amazon Resource Name (ARN) of the resource to associate with the notification rule.\n   * Currently, Supported sources include pipelines in AWS CodePipeline, build projects in AWS CodeBuild, and repositories in AWS CodeCommit in this L2 constructor.\n   * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codestarnotifications-notificationrule.html#cfn-codestarnotifications-notificationrule-resource\n   */\n  readonly source: INotificationRuleSource;\n\n  /**\n   * The targets to register for the notification destination.\n   *\n   * @default - No targets are added to the rule. Use `addTarget()` to add a target.\n   */\n  readonly targets?: INotificationRuleTarget[];\n  /**\n   * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.88.0/docs/resources/codestarnotifications_notification_rule#tags CodestarnotificationsNotificationRule#tags}\n   */\n  readonly tags?: {\n    [key: string]: string;\n  };\n}\n\n/**\n * Represents a notification rule\n */\nexport interface INotificationRule extends IAwsConstruct {\n  /**\n   * The ARN of the notification rule (i.e. arn:aws:codestar-notifications:::notificationrule/01234abcde)\n   *\n   * @attribute\n   */\n  readonly notificationRuleArn: string;\n\n  /**\n   * Adds target to notification rule\n   *\n   * @param target The SNS topic or AWS Chatbot Slack target\n   * @returns boolean - return true if it had any effect\n   */\n  addTarget(target: INotificationRuleTarget): boolean;\n}\n\n/**\n * A new notification rule\n *\n * @resource AWS::CodeStarNotifications::NotificationRule\n */\nexport class NotificationRule\n  extends AwsConstructBase\n  implements INotificationRule\n{\n  /**\n   * Import an existing notification rule provided an ARN\n   * @param scope The parent creating construct\n   * @param id The construct's name\n   * @param notificationRuleArn Notification rule ARN (i.e. arn:aws:codestar-notifications:::notificationrule/01234abcde)\n   */\n  public static fromNotificationRuleArn(\n    scope: constructs.Construct,\n    id: string,\n    notificationRuleArn: string,\n  ): INotificationRule {\n    class Import extends AwsConstructBase implements INotificationRule {\n      readonly notificationRuleArn = notificationRuleArn;\n      public get outputs(): Record<string, any> {\n        return { notificationRuleArn: this.notificationRuleArn };\n      }\n\n      public addTarget(_target: INotificationRuleTarget): boolean {\n        Annotations.of(this).addWarning(\n          `Cannot add targets to imported NotificationRule '${this.node.id}'. Define targets directly on the source or manage permissions separately.`,\n        );\n        return false;\n      }\n    }\n\n    return new Import(scope, id, {\n      environmentFromArn: notificationRuleArn,\n    });\n  }\n\n  /**\n   * @attribute\n   */\n  public readonly notificationRuleArn: string;\n\n  private readonly targetList: NotificationRuleTargetConfig[] = [];\n  private readonly events: string[] = [];\n  private readonly resource: codestarnotificationsNotificationRule.CodestarnotificationsNotificationRule;\n\n  public get outputs(): Record<string, any> {\n    return { notificationRuleArn: this.notificationRuleArn };\n  }\n\n  constructor(\n    scope: constructs.Construct,\n    id: string,\n    props: NotificationRuleProps,\n  ) {\n    super(scope, id, props);\n\n    const source = props.source.bindAsNotificationRuleSource(this);\n\n    this.addEvents(props.events);\n\n    // Process initial targets from props\n    props.targets?.forEach((target) => {\n      this.addTarget(target);\n    });\n\n    const ruleName = props.notificationRuleName\n      ? props.notificationRuleName.slice(-64) // Ensure 64 char limit\n      : this.stack.uniqueResourceName(this, { maxLength: 64 });\n\n    this.resource =\n      new codestarnotificationsNotificationRule.CodestarnotificationsNotificationRule(\n        this,\n        \"Resource\",\n        {\n          name: ruleName,\n          detailType: props.detailType ?? DetailType.FULL,\n          eventTypeIds: Lazy.listValue({\n            produce: () => {\n              if (Token.isUnresolved(props.events)) {\n                return props.events;\n              }\n              return this.events;\n            },\n          }),\n          resource: source.sourceArn,\n          status:\n            props.enabled === false\n              ? \"DISABLED\"\n              : props.enabled === true || props.enabled === undefined\n                ? \"ENABLED\"\n                : undefined, // Let Terraform handle default if undefined\n          // Use Lazy producer to handle the potentially dynamic list of targets\n          target: Lazy.anyValue({\n            produce: () =>\n              this.targetList.map((t) =>\n                codestarnotificationsNotificationRule.codestarnotificationsNotificationRuleTargetToTerraform(\n                  {\n                    address: t.targetAddress,\n                    type: t.targetType,\n                  },\n                ),\n              ),\n          }),\n          tags: props.tags,\n        },\n      );\n\n    this.notificationRuleArn = this.resource.arn;\n  }\n\n  public addTarget(target: INotificationRuleTarget): boolean {\n    const boundTarget = target.bindAsNotificationRuleTarget(this);\n    // Check if target already exists to avoid duplicates if this method were to update the resource\n    const exists = this.targetList.some(\n      (t) =>\n        t.targetAddress === boundTarget.targetAddress &&\n        t.targetType === boundTarget.targetType,\n    );\n    if (!exists) {\n      this.targetList.push(boundTarget);\n      return true;\n    }\n    return false;\n  }\n  /**\n   * Adds events to notification rule\n   *\n   * @see https://docs.aws.amazon.com/dtconsole/latest/userguide/concepts.html#events-ref-pipeline\n   * @see https://docs.aws.amazon.com/dtconsole/latest/userguide/concepts.html#events-ref-buildproject\n   * @param events The list of event types for AWS Codebuild and AWS CodePipeline\n   */\n  private addEvents(events: string[]): void {\n    events.forEach((event) => {\n      if (this.events.includes(event)) {\n        return;\n      }\n\n      this.events.push(event);\n    });\n  }\n}\n"]}

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

@@ -0,0 +1,56 @@
+import { Construct } from "constructs";
+import { ITopic } from "./topic-base";
+import { AwsConstructBase, AwsConstructProps } from "../aws-construct";
+import { PolicyDocument, PolicyStatement } from "../iam";
+/**
+ * Properties to associate SNS topics with a policy
+ */
+export interface TopicPolicyProps extends AwsConstructProps {
+    /**
+     * The set of topics this policy applies to.
+     */
+    readonly topics: ITopic[];
+    /**
+     * IAM policy document to apply to topic(s).
+     * @default empty policy document
+     */
+    readonly policyDocument?: PolicyDocument;
+    /**
+     * Adds a statement to enforce encryption of data in transit when publishing to the topic.
+     *
+     * For more information, see https://docs.aws.amazon.com/sns/latest/dg/sns-security-best-practices.html#enforce-encryption-data-in-transit.
+     *
+     * @default false
+     */
+    readonly enforceSSL?: boolean;
+}
+/**
+ * The policy for an SNS Topic
+ *
+ * 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.
+ *
+ * @resource aws_sns_topic_policy
+ */
+export declare class TopicPolicy extends AwsConstructBase {
+    /**
+     * The IAM policy document associated with this policy.
+     */
+    readonly document: PolicyDocument;
+    get outputs(): Record<string, any>;
+    constructor(scope: Construct, id: string, props: TopicPolicyProps);
+    /**
+     * Creates a statement to enforce encryption of data in transit when publishing to the topic.
+     *
+     * For more information, see https://docs.aws.amazon.com/sns/latest/dg/sns-security-best-practices.html#enforce-encryption-data-in-transit.
+     */
+    protected createSSLPolicyStatement(topicArns: string[]): PolicyStatement;
+}