terraconstructs 0.0.17 → 0.0.18

package/lib/aws/notify/sns-augmentations.generated.d.ts

@@ -0,0 +1,125 @@
+import * as cw from "../cloudwatch";
+declare module "./topic-base" {
+    interface ITopic {
+        /**
+         * Return the given named metric for this Topic
+         */
+        metric(metricName: string, props?: cw.MetricOptions): cw.Metric;
+        /**
+         * Metric for the size of messages published through this topic
+         *
+         * Average over 5 minutes
+         */
+        metricPublishSize(props?: cw.MetricOptions): cw.Metric;
+        /**
+         * The number of messages published to your Amazon SNS topics.
+         *
+         * Sum over 5 minutes
+         */
+        metricNumberOfMessagesPublished(props?: cw.MetricOptions): cw.Metric;
+        /**
+         * The number of messages successfully delivered from your Amazon SNS topics to subscribing endpoints.
+         *
+         * Sum over 5 minutes
+         */
+        metricNumberOfNotificationsDelivered(props?: cw.MetricOptions): cw.Metric;
+        /**
+         * The number of messages that Amazon SNS failed to deliver.
+         *
+         * Sum over 5 minutes
+         */
+        metricNumberOfNotificationsFailed(props?: cw.MetricOptions): cw.Metric;
+        /**
+         * The number of messages that were rejected by subscription filter policies.
+         *
+         * Sum over 5 minutes
+         */
+        metricNumberOfNotificationsFilteredOut(props?: cw.MetricOptions): cw.Metric;
+        /**
+         * The number of messages that were rejected by subscription filter policies because the messages have no attributes.
+         *
+         * Sum over 5 minutes
+         */
+        metricNumberOfNotificationsFilteredOutNoMessageAttributes(props?: cw.MetricOptions): cw.Metric;
+        /**
+         * The number of messages that were rejected by subscription filter policies because the messages' attributes are invalid
+         *
+         * Sum over 5 minutes
+         */
+        metricNumberOfNotificationsFilteredOutInvalidAttributes(props?: cw.MetricOptions): cw.Metric;
+        /**
+         * The charges you have accrued since the start of the current calendar month for sending SMS messages.
+         *
+         * Maximum over 5 minutes
+         */
+        metricSMSMonthToDateSpentUSD(props?: cw.MetricOptions): cw.Metric;
+        /**
+         * The rate of successful SMS message deliveries.
+         *
+         * Sum over 5 minutes
+         */
+        metricSMSSuccessRate(props?: cw.MetricOptions): cw.Metric;
+    }
+}
+declare module "./topic-base" {
+    interface TopicBase {
+        /**
+         * Return the given named metric for this Topic
+         */
+        metric(metricName: string, props?: cw.MetricOptions): cw.Metric;
+        /**
+         * Metric for the size of messages published through this topic
+         *
+         * Average over 5 minutes
+         */
+        metricPublishSize(props?: cw.MetricOptions): cw.Metric;
+        /**
+         * The number of messages published to your Amazon SNS topics.
+         *
+         * Sum over 5 minutes
+         */
+        metricNumberOfMessagesPublished(props?: cw.MetricOptions): cw.Metric;
+        /**
+         * The number of messages successfully delivered from your Amazon SNS topics to subscribing endpoints.
+         *
+         * Sum over 5 minutes
+         */
+        metricNumberOfNotificationsDelivered(props?: cw.MetricOptions): cw.Metric;
+        /**
+         * The number of messages that Amazon SNS failed to deliver.
+         *
+         * Sum over 5 minutes
+         */
+        metricNumberOfNotificationsFailed(props?: cw.MetricOptions): cw.Metric;
+        /**
+         * The number of messages that were rejected by subscription filter policies.
+         *
+         * Sum over 5 minutes
+         */
+        metricNumberOfNotificationsFilteredOut(props?: cw.MetricOptions): cw.Metric;
+        /**
+         * The number of messages that were rejected by subscription filter policies because the messages have no attributes.
+         *
+         * Sum over 5 minutes
+         */
+        metricNumberOfNotificationsFilteredOutNoMessageAttributes(props?: cw.MetricOptions): cw.Metric;
+        /**
+         * The number of messages that were rejected by subscription filter policies because the messages' attributes are invalid
+         *
+         * Sum over 5 minutes
+         */
+        metricNumberOfNotificationsFilteredOutInvalidAttributes(props?: cw.MetricOptions): cw.Metric;
+        /**
+         * The charges you have accrued since the start of the current calendar month for sending SMS messages.
+         *
+         * Maximum over 5 minutes
+         */
+        metricSMSMonthToDateSpentUSD(props?: cw.MetricOptions): cw.Metric;
+        /**
+         * The rate of successful SMS message deliveries.
+         *
+         * Sum over 5 minutes
+         */
+        metricSMSSuccessRate(props?: cw.MetricOptions): cw.Metric;
+    }
+}

package/lib/aws/notify/sns-augmentations.generated.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// Copyright 2012-2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+/* eslint-disable prettier/prettier,max-len */
+const cw = require("../cloudwatch");
+const topic_base_1 = require("./topic-base");
+topic_base_1.TopicBase.prototype.metric = function (metricName, props) {
+    return new cw.Metric({
+        "namespace": "AWS/SNS",
+        "metricName": metricName,
+        "dimensionsMap": {
+            "TopicName": this.topicName
+        },
+        ...props
+    }).attachTo(this);
+};
+topic_base_1.TopicBase.prototype.metricPublishSize = function (props) {
+    return this.metric("PublishSize", {
+        "statistic": "Average",
+        ...props
+    });
+};
+topic_base_1.TopicBase.prototype.metricNumberOfMessagesPublished = function (props) {
+    return this.metric("NumberOfMessagesPublished", {
+        "statistic": "Sum",
+        ...props
+    });
+};
+topic_base_1.TopicBase.prototype.metricNumberOfNotificationsDelivered = function (props) {
+    return this.metric("NumberOfNotificationsDelivered", {
+        "statistic": "Sum",
+        ...props
+    });
+};
+topic_base_1.TopicBase.prototype.metricNumberOfNotificationsFailed = function (props) {
+    return this.metric("NumberOfNotificationsFailed", {
+        "statistic": "Sum",
+        ...props
+    });
+};
+topic_base_1.TopicBase.prototype.metricNumberOfNotificationsFilteredOut = function (props) {
+    return this.metric("NumberOfNotificationsFilteredOut", {
+        "statistic": "Sum",
+        ...props
+    });
+};
+topic_base_1.TopicBase.prototype.metricNumberOfNotificationsFilteredOutNoMessageAttributes = function (props) {
+    return this.metric("NumberOfNotificationsFilteredOut-NoMessageAttributes", {
+        "statistic": "Sum",
+        ...props
+    });
+};
+topic_base_1.TopicBase.prototype.metricNumberOfNotificationsFilteredOutInvalidAttributes = function (props) {
+    return this.metric("NumberOfNotificationsFilteredOut-InvalidAttributes", {
+        "statistic": "Sum",
+        ...props
+    });
+};
+topic_base_1.TopicBase.prototype.metricSMSMonthToDateSpentUSD = function (props) {
+    return this.metric("SMSMonthToDateSpentUSD", {
+        "statistic": "Maximum",
+        ...props
+    });
+};
+topic_base_1.TopicBase.prototype.metricSMSSuccessRate = function (props) {
+    return this.metric("SMSSuccessRate", {
+        "statistic": "Sum",
+        ...props
+    });
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sns-augmentations.generated.js","sourceRoot":"","sources":["../../../src/aws/notify/sns-augmentations.generated.ts"],"names":[],"mappings":";;AAAA,+EAA+E;AAC/E,8CAA8C;AAC9C,oCAAoC;AACpC,6CAAyC;AAoJzC,sBAAS,CAAC,SAAS,CAAC,MAAM,GAAG,UAAS,UAAkB,EAAE,KAAwB;IAChF,OAAO,IAAI,EAAE,CAAC,MAAM,CAAC;QACnB,WAAW,EAAE,SAAS;QACtB,YAAY,EAAE,UAAU;QACxB,eAAe,EAAE;YACf,WAAW,EAAE,IAAI,CAAC,SAAS;SAC5B;QACD,GAAG,KAAK;KACT,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;AACpB,CAAC,CAAC;AACF,sBAAS,CAAC,SAAS,CAAC,iBAAiB,GAAG,UAAS,KAAwB;IACvE,OAAO,IAAI,CAAC,MAAM,CAAC,aAAa,EAAE;QAChC,WAAW,EAAE,SAAS;QACtB,GAAG,KAAK;KACT,CAAC,CAAC;AACL,CAAC,CAAC;AACF,sBAAS,CAAC,SAAS,CAAC,+BAA+B,GAAG,UAAS,KAAwB;IACrF,OAAO,IAAI,CAAC,MAAM,CAAC,2BAA2B,EAAE;QAC9C,WAAW,EAAE,KAAK;QAClB,GAAG,KAAK;KACT,CAAC,CAAC;AACL,CAAC,CAAC;AACF,sBAAS,CAAC,SAAS,CAAC,oCAAoC,GAAG,UAAS,KAAwB;IAC1F,OAAO,IAAI,CAAC,MAAM,CAAC,gCAAgC,EAAE;QACnD,WAAW,EAAE,KAAK;QAClB,GAAG,KAAK;KACT,CAAC,CAAC;AACL,CAAC,CAAC;AACF,sBAAS,CAAC,SAAS,CAAC,iCAAiC,GAAG,UAAS,KAAwB;IACvF,OAAO,IAAI,CAAC,MAAM,CAAC,6BAA6B,EAAE;QAChD,WAAW,EAAE,KAAK;QAClB,GAAG,KAAK;KACT,CAAC,CAAC;AACL,CAAC,CAAC;AACF,sBAAS,CAAC,SAAS,CAAC,sCAAsC,GAAG,UAAS,KAAwB;IAC5F,OAAO,IAAI,CAAC,MAAM,CAAC,kCAAkC,EAAE;QACrD,WAAW,EAAE,KAAK;QAClB,GAAG,KAAK;KACT,CAAC,CAAC;AACL,CAAC,CAAC;AACF,sBAAS,CAAC,SAAS,CAAC,yDAAyD,GAAG,UAAS,KAAwB;IAC/G,OAAO,IAAI,CAAC,MAAM,CAAC,sDAAsD,EAAE;QACzE,WAAW,EAAE,KAAK;QAClB,GAAG,KAAK;KACT,CAAC,CAAC;AACL,CAAC,CAAC;AACF,sBAAS,CAAC,SAAS,CAAC,uDAAuD,GAAG,UAAS,KAAwB;IAC7G,OAAO,IAAI,CAAC,MAAM,CAAC,oDAAoD,EAAE;QACvE,WAAW,EAAE,KAAK;QAClB,GAAG,KAAK;KACT,CAAC,CAAC;AACL,CAAC,CAAC;AACF,sBAAS,CAAC,SAAS,CAAC,4BAA4B,GAAG,UAAS,KAAwB;IAClF,OAAO,IAAI,CAAC,MAAM,CAAC,wBAAwB,EAAE;QAC3C,WAAW,EAAE,SAAS;QACtB,GAAG,KAAK;KACT,CAAC,CAAC;AACL,CAAC,CAAC;AACF,sBAAS,CAAC,SAAS,CAAC,oBAAoB,GAAG,UAAS,KAAwB;IAC1E,OAAO,IAAI,CAAC,MAAM,CAAC,gBAAgB,EAAE;QACnC,WAAW,EAAE,KAAK;QAClB,GAAG,KAAK;KACT,CAAC,CAAC;AACL,CAAC,CAAC","sourcesContent":["// Copyright 2012-2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.\n/* eslint-disable prettier/prettier,max-len */\nimport * as cw from \"../cloudwatch\";\nimport { TopicBase } from \"./topic-base\";\n\ndeclare module \"./topic-base\" {\n  interface ITopic {\n    /**\n     * Return the given named metric for this Topic\n     */\n    metric(metricName: string, props?: cw.MetricOptions): cw.Metric;\n\n    /**\n     * Metric for the size of messages published through this topic\n     *\n     * Average over 5 minutes\n     */\n    metricPublishSize(props?: cw.MetricOptions): cw.Metric;\n\n    /**\n     * The number of messages published to your Amazon SNS topics.\n     *\n     * Sum over 5 minutes\n     */\n    metricNumberOfMessagesPublished(props?: cw.MetricOptions): cw.Metric;\n\n    /**\n     * The number of messages successfully delivered from your Amazon SNS topics to subscribing endpoints.\n     *\n     * Sum over 5 minutes\n     */\n    metricNumberOfNotificationsDelivered(props?: cw.MetricOptions): cw.Metric;\n\n    /**\n     * The number of messages that Amazon SNS failed to deliver.\n     *\n     * Sum over 5 minutes\n     */\n    metricNumberOfNotificationsFailed(props?: cw.MetricOptions): cw.Metric;\n\n    /**\n     * The number of messages that were rejected by subscription filter policies.\n     *\n     * Sum over 5 minutes\n     */\n    metricNumberOfNotificationsFilteredOut(props?: cw.MetricOptions): cw.Metric;\n\n    /**\n     * The number of messages that were rejected by subscription filter policies because the messages have no attributes.\n     *\n     * Sum over 5 minutes\n     */\n    metricNumberOfNotificationsFilteredOutNoMessageAttributes(props?: cw.MetricOptions): cw.Metric;\n\n    /**\n     * The number of messages that were rejected by subscription filter policies because the messages' attributes are invalid\n     *\n     * Sum over 5 minutes\n     */\n    metricNumberOfNotificationsFilteredOutInvalidAttributes(props?: cw.MetricOptions): cw.Metric;\n\n    /**\n     * The charges you have accrued since the start of the current calendar month for sending SMS messages.\n     *\n     * Maximum over 5 minutes\n     */\n    metricSMSMonthToDateSpentUSD(props?: cw.MetricOptions): cw.Metric;\n\n    /**\n     * The rate of successful SMS message deliveries.\n     *\n     * Sum over 5 minutes\n     */\n    metricSMSSuccessRate(props?: cw.MetricOptions): cw.Metric;\n  }\n}\n\n\n\ndeclare module \"./topic-base\" {\n  interface TopicBase {\n    /**\n     * Return the given named metric for this Topic\n     */\n    metric(metricName: string, props?: cw.MetricOptions): cw.Metric;\n\n    /**\n     * Metric for the size of messages published through this topic\n     *\n     * Average over 5 minutes\n     */\n    metricPublishSize(props?: cw.MetricOptions): cw.Metric;\n\n    /**\n     * The number of messages published to your Amazon SNS topics.\n     *\n     * Sum over 5 minutes\n     */\n    metricNumberOfMessagesPublished(props?: cw.MetricOptions): cw.Metric;\n\n    /**\n     * The number of messages successfully delivered from your Amazon SNS topics to subscribing endpoints.\n     *\n     * Sum over 5 minutes\n     */\n    metricNumberOfNotificationsDelivered(props?: cw.MetricOptions): cw.Metric;\n\n    /**\n     * The number of messages that Amazon SNS failed to deliver.\n     *\n     * Sum over 5 minutes\n     */\n    metricNumberOfNotificationsFailed(props?: cw.MetricOptions): cw.Metric;\n\n    /**\n     * The number of messages that were rejected by subscription filter policies.\n     *\n     * Sum over 5 minutes\n     */\n    metricNumberOfNotificationsFilteredOut(props?: cw.MetricOptions): cw.Metric;\n\n    /**\n     * The number of messages that were rejected by subscription filter policies because the messages have no attributes.\n     *\n     * Sum over 5 minutes\n     */\n    metricNumberOfNotificationsFilteredOutNoMessageAttributes(props?: cw.MetricOptions): cw.Metric;\n\n    /**\n     * The number of messages that were rejected by subscription filter policies because the messages' attributes are invalid\n     *\n     * Sum over 5 minutes\n     */\n    metricNumberOfNotificationsFilteredOutInvalidAttributes(props?: cw.MetricOptions): cw.Metric;\n\n    /**\n     * The charges you have accrued since the start of the current calendar month for sending SMS messages.\n     *\n     * Maximum over 5 minutes\n     */\n    metricSMSMonthToDateSpentUSD(props?: cw.MetricOptions): cw.Metric;\n\n    /**\n     * The rate of successful SMS message deliveries.\n     *\n     * Sum over 5 minutes\n     */\n    metricSMSSuccessRate(props?: cw.MetricOptions): cw.Metric;\n  }\n}\n\nTopicBase.prototype.metric = function(metricName: string, props?: cw.MetricOptions) {\n  return new cw.Metric({\n    \"namespace\": \"AWS/SNS\",\n    \"metricName\": metricName,\n    \"dimensionsMap\": {\n      \"TopicName\": this.topicName\n    },\n    ...props\n  }).attachTo(this);\n};\nTopicBase.prototype.metricPublishSize = function(props?: cw.MetricOptions) {\n  return this.metric(\"PublishSize\", {\n    \"statistic\": \"Average\",\n    ...props\n  });\n};\nTopicBase.prototype.metricNumberOfMessagesPublished = function(props?: cw.MetricOptions) {\n  return this.metric(\"NumberOfMessagesPublished\", {\n    \"statistic\": \"Sum\",\n    ...props\n  });\n};\nTopicBase.prototype.metricNumberOfNotificationsDelivered = function(props?: cw.MetricOptions) {\n  return this.metric(\"NumberOfNotificationsDelivered\", {\n    \"statistic\": \"Sum\",\n    ...props\n  });\n};\nTopicBase.prototype.metricNumberOfNotificationsFailed = function(props?: cw.MetricOptions) {\n  return this.metric(\"NumberOfNotificationsFailed\", {\n    \"statistic\": \"Sum\",\n    ...props\n  });\n};\nTopicBase.prototype.metricNumberOfNotificationsFilteredOut = function(props?: cw.MetricOptions) {\n  return this.metric(\"NumberOfNotificationsFilteredOut\", {\n    \"statistic\": \"Sum\",\n    ...props\n  });\n};\nTopicBase.prototype.metricNumberOfNotificationsFilteredOutNoMessageAttributes = function(props?: cw.MetricOptions) {\n  return this.metric(\"NumberOfNotificationsFilteredOut-NoMessageAttributes\", {\n    \"statistic\": \"Sum\",\n    ...props\n  });\n};\nTopicBase.prototype.metricNumberOfNotificationsFilteredOutInvalidAttributes = function(props?: cw.MetricOptions) {\n  return this.metric(\"NumberOfNotificationsFilteredOut-InvalidAttributes\", {\n    \"statistic\": \"Sum\",\n    ...props\n  });\n};\nTopicBase.prototype.metricSMSMonthToDateSpentUSD = function(props?: cw.MetricOptions) {\n  return this.metric(\"SMSMonthToDateSpentUSD\", {\n    \"statistic\": \"Maximum\",\n    ...props\n  });\n};\nTopicBase.prototype.metricSMSSuccessRate = function(props?: cw.MetricOptions) {\n  return this.metric(\"SMSSuccessRate\", {\n    \"statistic\": \"Sum\",\n    ...props\n  });\n};"]}

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

@@ -0,0 +1,33 @@
+export interface MetricWithDims<D> {
+    readonly namespace: string;
+    readonly metricName: string;
+    readonly statistic: string;
+    readonly dimensionsMap: D;
+}
+export declare class SNSMetrics {
+    static numberOfNotificationsDeliveredSum(dimensions: {
+        TopicName: string;
+    }): MetricWithDims<{
+        TopicName: string;
+    }>;
+    static numberOfNotificationsFailedSum(dimensions: {
+        TopicName: string;
+    }): MetricWithDims<{
+        TopicName: string;
+    }>;
+    static numberOfMessagesPublishedSum(dimensions: {
+        TopicName: string;
+    }): MetricWithDims<{
+        TopicName: string;
+    }>;
+    static publishSizeAverage(dimensions: {
+        TopicName: string;
+    }): MetricWithDims<{
+        TopicName: string;
+    }>;
+    static smsSuccessRateSum(dimensions: {
+        TopicName: string;
+    }): MetricWithDims<{
+        TopicName: string;
+    }>;
+}

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

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SNSMetrics = void 0;
+class SNSMetrics {
+    static numberOfNotificationsDeliveredSum(dimensions) {
+        return {
+            "namespace": "AWS/SNS",
+            "metricName": "NumberOfNotificationsDelivered",
+            "dimensionsMap": dimensions,
+            "statistic": "Sum"
+        };
+    }
+    static numberOfNotificationsFailedSum(dimensions) {
+        return {
+            "namespace": "AWS/SNS",
+            "metricName": "NumberOfNotificationsFailed",
+            "dimensionsMap": dimensions,
+            "statistic": "Sum"
+        };
+    }
+    static numberOfMessagesPublishedSum(dimensions) {
+        return {
+            "namespace": "AWS/SNS",
+            "metricName": "NumberOfMessagesPublished",
+            "dimensionsMap": dimensions,
+            "statistic": "Sum"
+        };
+    }
+    static publishSizeAverage(dimensions) {
+        return {
+            "namespace": "AWS/SNS",
+            "metricName": "PublishSize",
+            "dimensionsMap": dimensions,
+            "statistic": "Average"
+        };
+    }
+    static smsSuccessRateSum(dimensions) {
+        return {
+            "namespace": "AWS/SNS",
+            "metricName": "SMSSuccessRate",
+            "dimensionsMap": dimensions,
+            "statistic": "Sum"
+        };
+    }
+}
+exports.SNSMetrics = SNSMetrics;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,44 @@
+import { Construct, IDependable } from "constructs";
+import { SubscriptionOptions } from "./subscription";
+import { ITopic } from "./topic-base";
+/**
+ * Subscription configuration
+ */
+export interface TopicSubscriptionConfig extends SubscriptionOptions {
+    /**
+     * The scope in which to create the SNS subscription resource. Normally you'd
+     * want the subscription to be created on the consuming stack because the
+     * topic is usually referenced by the consumer's resource policy (e.g. SQS
+     * queue policy). Otherwise, it will cause a cyclic reference.
+     *
+     * If this is undefined, the subscription will be created on the topic's stack.
+     *
+     * @default - use the topic as the scope of the subscription, in which case `subscriberId` must be defined.
+     */
+    readonly subscriberScope?: Construct;
+    /**
+     * The id of the SNS subscription resource created under `scope`. In most
+     * cases, it is recommended to use the `uniqueId` of the topic you are
+     * subscribing to.
+     */
+    readonly subscriberId: string;
+    /**
+     * The resources that need to be created before the subscription can be safely created.
+     * For example for SQS subscription, the subscription needs to have a dependency on the SQS queue policy
+     * in order for the subscription to successfully deliver messages.
+     *
+     * @default - empty list
+     */
+    readonly subscriptionDependency?: IDependable;
+}
+/**
+ * Topic subscription
+ */
+export interface ITopicSubscription {
+    /**
+     * Returns a configuration used to subscribe to an SNS topic
+     *
+     * @param topic topic for which subscription will be configured
+     */
+    bind(topic: ITopic): TopicSubscriptionConfig;
+}

package/lib/aws/notify/subscriber.js

@@ -0,0 +1,4 @@
+"use strict";
+// https://github.com/aws/aws-cdk/blob/a2c633f1e698249496f11338312ab42bd7b1e4f0/packages/aws-cdk-lib/aws-sns/lib/subscriber.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,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

package/lib/aws/notify/subscription-filter.d.ts

@@ -0,0 +1,129 @@
+/**
+ * Conditions that can be applied to string attributes.
+ */
+export interface StringConditions {
+    /**
+     * Match one or more values.
+     *
+     * @deprecated use `allowlist`
+     * @default - None
+     */
+    readonly whitelist?: string[];
+    /**
+     * Match any value that doesn't include any of the specified values.
+     * @deprecated use `denylist`
+     * @default - None
+     */
+    readonly blacklist?: string[];
+    /**
+     * Match one or more values.
+     * @default - None
+     */
+    readonly allowlist?: string[];
+    /**
+     * Match any value that doesn't include any of the specified values.
+     * @default - None
+     */
+    readonly denylist?: string[];
+    /**
+     * Matches values that begins with the specified prefixes.
+     *
+     * @default - None
+     */
+    readonly matchPrefixes?: string[];
+    /**
+     * Matches values that end with the specified suffixes.
+     *
+     * @default - None
+     */
+    readonly matchSuffixes?: string[];
+}
+/**
+ * Between condition for a numeric attribute.
+ */
+export interface BetweenCondition {
+    /**
+     * The start value.
+     */
+    readonly start: number;
+    /**
+     * The stop value.
+     */
+    readonly stop: number;
+}
+/**
+ * Conditions that can be applied to numeric attributes.
+ */
+export interface NumericConditions {
+    /**
+     * Match one or more values.
+     * @deprecated use `allowlist`
+     * @default - None
+     */
+    readonly whitelist?: number[];
+    /**
+     * Match one or more values.
+     *
+     * @default - None
+     */
+    readonly allowlist?: number[];
+    /**
+     * Match values that are greater than the specified value.
+     *
+     * @default - None
+     */
+    readonly greaterThan?: number;
+    /**
+     * Match values that are greater than or equal to the specified value.
+     *
+     * @default - None
+     */
+    readonly greaterThanOrEqualTo?: number;
+    /**
+     * Match values that are less than the specified value.
+     *
+     * @default - None
+     */
+    readonly lessThan?: number;
+    /**
+     * Match values that are less than or equal to the specified value.
+     *
+     * @default - None
+     */
+    readonly lessThanOrEqualTo?: number;
+    /**
+     * Match values that are between the specified values.
+     *
+     * @default - None
+     */
+    readonly between?: BetweenCondition;
+    /**
+     * Match values that are strictly between the specified values.
+     *
+     * @default - None
+     */
+    readonly betweenStrict?: BetweenCondition;
+}
+/**
+ * A subscription filter for an attribute.
+ */
+export declare class SubscriptionFilter {
+    readonly conditions: any[];
+    /**
+     * Returns a subscription filter for a string attribute.
+     */
+    static stringFilter(stringConditions: StringConditions): SubscriptionFilter;
+    /**
+     * Returns a subscription filter for a numeric attribute.
+     */
+    static numericFilter(numericConditions: NumericConditions): SubscriptionFilter;
+    /**
+     * Returns a subscription filter for attribute key matching.
+     */
+    static existsFilter(): SubscriptionFilter;
+    /**
+     *
+     * @param conditions conditions that specify the message attributes that should be included, excluded, matched, etc.
+     */
+    constructor(conditions?: any[]);
+}

package/lib/aws/notify/subscription-filter.js

@@ -0,0 +1,105 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubscriptionFilter = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+/**
+ * A subscription filter for an attribute.
+ */
+class SubscriptionFilter {
+    /**
+     * Returns a subscription filter for a string attribute.
+     */
+    static stringFilter(stringConditions) {
+        const conditions = new Array();
+        if (stringConditions.whitelist && stringConditions.allowlist) {
+            // TODO: Adopt UnscopedValidationError
+            throw new Error("`whitelist` is deprecated; please use `allowlist` instead");
+        }
+        if (stringConditions.blacklist && stringConditions.denylist) {
+            // TODO: Adopt UnscopedValidationError
+            throw new Error("`blacklist` is deprecated; please use `denylist` instead");
+        }
+        const allowlist = stringConditions.allowlist ?? stringConditions.whitelist;
+        const denylist = stringConditions.denylist ?? stringConditions.blacklist;
+        if (allowlist) {
+            conditions.push(...allowlist);
+        }
+        if (denylist) {
+            conditions.push({ "anything-but": denylist });
+        }
+        if (stringConditions.matchPrefixes) {
+            conditions.push(...stringConditions.matchPrefixes.map((p) => ({ prefix: p })));
+        }
+        if (stringConditions.matchSuffixes) {
+            conditions.push(...stringConditions.matchSuffixes.map((s) => ({ suffix: s })));
+        }
+        return new SubscriptionFilter(conditions);
+    }
+    /**
+     * Returns a subscription filter for a numeric attribute.
+     */
+    static numericFilter(numericConditions) {
+        const conditions = new Array();
+        if (numericConditions.whitelist && numericConditions.allowlist) {
+            // TODO: Adopt UnscopedValidationError
+            throw new Error("`whitelist` is deprecated; please use `allowlist` instead");
+        }
+        const allowlist = numericConditions.allowlist ?? numericConditions.whitelist;
+        if (allowlist) {
+            conditions.push(...allowlist.map((v) => ({ numeric: ["=", v] })));
+        }
+        if (numericConditions.greaterThan !== undefined) {
+            conditions.push({ numeric: [">", numericConditions.greaterThan] });
+        }
+        if (numericConditions.greaterThanOrEqualTo !== undefined) {
+            conditions.push({
+                numeric: [">=", numericConditions.greaterThanOrEqualTo],
+            });
+        }
+        if (numericConditions.lessThan !== undefined) {
+            conditions.push({ numeric: ["<", numericConditions.lessThan] });
+        }
+        if (numericConditions.lessThanOrEqualTo !== undefined) {
+            conditions.push({ numeric: ["<=", numericConditions.lessThanOrEqualTo] });
+        }
+        if (numericConditions.between) {
+            conditions.push({
+                numeric: [
+                    ">=",
+                    numericConditions.between.start,
+                    "<=",
+                    numericConditions.between.stop,
+                ],
+            });
+        }
+        if (numericConditions.betweenStrict) {
+            conditions.push({
+                numeric: [
+                    ">",
+                    numericConditions.betweenStrict.start,
+                    "<",
+                    numericConditions.betweenStrict.stop,
+                ],
+            });
+        }
+        return new SubscriptionFilter(conditions);
+    }
+    /**
+     * Returns a subscription filter for attribute key matching.
+     */
+    static existsFilter() {
+        return new SubscriptionFilter([{ exists: true }]);
+    }
+    /**
+     *
+     * @param conditions conditions that specify the message attributes that should be included, excluded, matched, etc.
+     */
+    constructor(conditions = []) {
+        this.conditions = conditions;
+    }
+}
+exports.SubscriptionFilter = SubscriptionFilter;
+_a = JSII_RTTI_SYMBOL_1;
+SubscriptionFilter[_a] = { fqn: "terraconstructs.aws.notify.SubscriptionFilter", version: "0.0.18" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"subscription-filter.js","sourceRoot":"","sources":["../../../src/aws/notify/subscription-filter.ts"],"names":[],"mappings":"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","sourcesContent":["// https://github.com/aws/aws-cdk/blob/7452462550a100f5bd2dcab6f495c9f68bf0db4a/packages/aws-cdk-lib/aws-sns/lib/subscription-filter.ts\n\n// TODO: Adopt UnscopedValidationError\n// - https://github.com/aws/aws-cdk/pull/33382/\n// - https://github.com/aws/aws-cdk/pull/33045\n// import { UnscopedValidationError } from \"../../core/lib/errors\";\n\n/**\n * Conditions that can be applied to string attributes.\n */\nexport interface StringConditions {\n  /**\n   * Match one or more values.\n   *\n   * @deprecated use `allowlist`\n   * @default - None\n   */\n  readonly whitelist?: string[];\n\n  /**\n   * Match any value that doesn't include any of the specified values.\n   * @deprecated use `denylist`\n   * @default - None\n   */\n  readonly blacklist?: string[];\n\n  /**\n   * Match one or more values.\n   * @default - None\n   */\n  readonly allowlist?: string[];\n\n  /**\n   * Match any value that doesn't include any of the specified values.\n   * @default - None\n   */\n  readonly denylist?: string[];\n\n  /**\n   * Matches values that begins with the specified prefixes.\n   *\n   * @default - None\n   */\n  readonly matchPrefixes?: string[];\n\n  /**\n   * Matches values that end with the specified suffixes.\n   *\n   * @default - None\n   */\n  readonly matchSuffixes?: string[];\n}\n\n/**\n * Between condition for a numeric attribute.\n */\nexport interface BetweenCondition {\n  /**\n   * The start value.\n   */\n  readonly start: number;\n\n  /**\n   * The stop value.\n   */\n  readonly stop: number;\n}\n\n/**\n * Conditions that can be applied to numeric attributes.\n */\nexport interface NumericConditions {\n  /**\n   * Match one or more values.\n   * @deprecated use `allowlist`\n   * @default - None\n   */\n  readonly whitelist?: number[];\n\n  /**\n   * Match one or more values.\n   *\n   * @default - None\n   */\n  readonly allowlist?: number[];\n\n  /**\n   * Match values that are greater than the specified value.\n   *\n   * @default - None\n   */\n  readonly greaterThan?: number;\n\n  /**\n   * Match values that are greater than or equal to the specified value.\n   *\n   * @default - None\n   */\n  readonly greaterThanOrEqualTo?: number;\n\n  /**\n   * Match values that are less than the specified value.\n   *\n   * @default - None\n   */\n  readonly lessThan?: number;\n\n  /**\n   * Match values that are less than or equal to the specified value.\n   *\n   * @default - None\n   */\n  readonly lessThanOrEqualTo?: number;\n\n  /**\n   * Match values that are between the specified values.\n   *\n   * @default - None\n   */\n  readonly between?: BetweenCondition;\n\n  /**\n   * Match values that are strictly between the specified values.\n   *\n   * @default - None\n   */\n  readonly betweenStrict?: BetweenCondition;\n}\n\n/**\n * A subscription filter for an attribute.\n */\nexport class SubscriptionFilter {\n  /**\n   * Returns a subscription filter for a string attribute.\n   */\n  public static stringFilter(stringConditions: StringConditions) {\n    const conditions = new Array<any>();\n\n    if (stringConditions.whitelist && stringConditions.allowlist) {\n      // TODO: Adopt UnscopedValidationError\n      throw new Error(\n        \"`whitelist` is deprecated; please use `allowlist` instead\",\n      );\n    }\n    if (stringConditions.blacklist && stringConditions.denylist) {\n      // TODO: Adopt UnscopedValidationError\n      throw new Error(\n        \"`blacklist` is deprecated; please use `denylist` instead\",\n      );\n    }\n    const allowlist = stringConditions.allowlist ?? stringConditions.whitelist;\n    const denylist = stringConditions.denylist ?? stringConditions.blacklist;\n\n    if (allowlist) {\n      conditions.push(...allowlist);\n    }\n\n    if (denylist) {\n      conditions.push({ \"anything-but\": denylist });\n    }\n\n    if (stringConditions.matchPrefixes) {\n      conditions.push(\n        ...stringConditions.matchPrefixes.map((p) => ({ prefix: p })),\n      );\n    }\n\n    if (stringConditions.matchSuffixes) {\n      conditions.push(\n        ...stringConditions.matchSuffixes.map((s) => ({ suffix: s })),\n      );\n    }\n\n    return new SubscriptionFilter(conditions);\n  }\n\n  /**\n   * Returns a subscription filter for a numeric attribute.\n   */\n  public static numericFilter(numericConditions: NumericConditions) {\n    const conditions = new Array<any>();\n\n    if (numericConditions.whitelist && numericConditions.allowlist) {\n      // TODO: Adopt UnscopedValidationError\n      throw new Error(\n        \"`whitelist` is deprecated; please use `allowlist` instead\",\n      );\n    }\n    const allowlist =\n      numericConditions.allowlist ?? numericConditions.whitelist;\n\n    if (allowlist) {\n      conditions.push(...allowlist.map((v) => ({ numeric: [\"=\", v] })));\n    }\n\n    if (numericConditions.greaterThan !== undefined) {\n      conditions.push({ numeric: [\">\", numericConditions.greaterThan] });\n    }\n\n    if (numericConditions.greaterThanOrEqualTo !== undefined) {\n      conditions.push({\n        numeric: [\">=\", numericConditions.greaterThanOrEqualTo],\n      });\n    }\n\n    if (numericConditions.lessThan !== undefined) {\n      conditions.push({ numeric: [\"<\", numericConditions.lessThan] });\n    }\n\n    if (numericConditions.lessThanOrEqualTo !== undefined) {\n      conditions.push({ numeric: [\"<=\", numericConditions.lessThanOrEqualTo] });\n    }\n\n    if (numericConditions.between) {\n      conditions.push({\n        numeric: [\n          \">=\",\n          numericConditions.between.start,\n          \"<=\",\n          numericConditions.between.stop,\n        ],\n      });\n    }\n\n    if (numericConditions.betweenStrict) {\n      conditions.push({\n        numeric: [\n          \">\",\n          numericConditions.betweenStrict.start,\n          \"<\",\n          numericConditions.betweenStrict.stop,\n        ],\n      });\n    }\n\n    return new SubscriptionFilter(conditions);\n  }\n\n  /**\n   * Returns a subscription filter for attribute key matching.\n   */\n  public static existsFilter() {\n    return new SubscriptionFilter([{ exists: true }]);\n  }\n\n  /**\n   *\n   * @param conditions conditions that specify the message attributes that should be included, excluded, matched, etc.\n   */\n  constructor(public readonly conditions: any[] = []) {}\n}\n"]}