terraconstructs 0.0.16 → 0.0.18

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"]}

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

@@ -0,0 +1,219 @@
+import { Construct } from "constructs";
+import { DeliveryPolicy } from "./delivery-policy";
+import { SubscriptionFilter } from "./subscription-filter";
+import { ITopic } from "./topic-base";
+import { AwsConstructBase, AwsConstructProps } from "../aws-construct";
+import * as notify from "../notify";
+/**
+ * Outputs for the Subscription construct.
+ */
+export interface SubscriptionOutputs {
+    /**
+     * The ARN of the subscription.
+     */
+    readonly subscriptionArn: string;
+}
+/**
+ * Options for creating a new subscription
+ */
+export interface SubscriptionOptions extends AwsConstructProps {
+    /**
+     * What type of subscription to add.
+     */
+    readonly protocol: SubscriptionProtocol;
+    /**
+     * The subscription endpoint.
+     *
+     * The meaning of this value depends on the value for 'protocol'.
+     */
+    readonly endpoint: string;
+    /**
+     * true if raw message delivery is enabled for the subscription. Raw messages are free of JSON formatting and can be
+     * sent to HTTP/S and Amazon SQS endpoints. For more information, see GetSubscriptionAttributes in the Amazon Simple
+     * Notification Service API Reference.
+     *
+     * @default false
+     */
+    readonly rawMessageDelivery?: boolean;
+    /**
+     * The filter policy.
+     *
+     * @default - all messages are delivered
+     */
+    readonly filterPolicy?: {
+        [attribute: string]: SubscriptionFilter;
+    };
+    /**
+     * The filter policy that is applied on the message body.
+     * To apply a filter policy to the message attributes, use `filterPolicy`. A maximum of one of `filterPolicyWithMessageBody` and `filterPolicy` may be used.
+     *
+     * @default - all messages are delivered
+     */
+    readonly filterPolicyWithMessageBody?: {
+        [attribute: string]: FilterOrPolicy;
+    };
+    /**
+     * Queue to be used as dead letter queue.
+     * If not passed no dead letter queue is enabled.
+     *
+     * @default - No dead letter queue enabled.
+     */
+    readonly deadLetterQueue?: notify.IQueue;
+    /**
+     * Arn of role allowing access to firehose delivery stream.
+     * Required for a firehose subscription protocol.
+     * @default - No subscription role is provided
+     */
+    readonly subscriptionRoleArn?: string;
+    /**
+     * The delivery policy.
+     *
+     * @default - if the initial delivery of the message fails, three retries with a delay between failed attempts set at 20 seconds
+     */
+    readonly deliveryPolicy?: DeliveryPolicy;
+}
+/**
+ * Properties for creating a new subscription
+ */
+export interface SubscriptionProps extends SubscriptionOptions {
+    /**
+     * The topic to subscribe to.
+     */
+    readonly topic: ITopic;
+}
+/**
+ * A new subscription.
+ *
+ * Prefer to use the `ITopic.addSubscription()` methods to create instances of
+ * this class.
+ *
+ * @resource aws_sns_topic_subscription
+ */
+export declare class Subscription extends AwsConstructBase {
+    /**
+     * The DLQ associated with this subscription if present.
+     */
+    readonly deadLetterQueue?: notify.IQueue;
+    private readonly resource;
+    readonly subscriptionOutputs: SubscriptionOutputs;
+    get outputs(): Record<string, any>;
+    constructor(scope: Construct, id: string, props: SubscriptionProps);
+    private renderDeliveryPolicy;
+    private buildDeadLetterQueue;
+    private buildDeadLetterConfig;
+}
+/**
+ * The type of subscription, controlling the type of the endpoint parameter.
+ */
+export declare enum SubscriptionProtocol {
+    /**
+     * JSON-encoded message is POSTED to an HTTP url.
+     */
+    HTTP = "http",
+    /**
+     * JSON-encoded message is POSTed to an HTTPS url.
+     */
+    HTTPS = "https",
+    /**
+     * Notifications are sent via email.
+     */
+    EMAIL = "email",
+    /**
+     * Notifications are JSON-encoded and sent via mail.
+     */
+    EMAIL_JSON = "email-json",
+    /**
+     * Notification is delivered by SMS
+     */
+    SMS = "sms",
+    /**
+     * Notifications are enqueued into an SQS queue.
+     */
+    SQS = "sqs",
+    /**
+     * JSON-encoded notifications are sent to a mobile app endpoint.
+     */
+    APPLICATION = "application",
+    /**
+     * Notifications trigger a Lambda function.
+     */
+    LAMBDA = "lambda",
+    /**
+     * Notifications put records into a firehose delivery stream.
+     */
+    FIREHOSE = "firehose"
+}
+/**
+ * The type of the MessageBody at a given key value pair
+ */
+export declare enum FilterOrPolicyType {
+    /**
+     * The filter of the MessageBody
+     */
+    FILTER = 0,
+    /**
+     * A nested key of the MessageBody
+     */
+    POLICY = 1
+}
+/**
+ * Class for building the FilterPolicy by avoiding union types
+ */
+export declare abstract class FilterOrPolicy {
+    /**
+     * Filter of MessageBody
+     */
+    static filter(filter: SubscriptionFilter): notify.Filter;
+    /**
+     * Policy of MessageBody
+     */
+    static policy(policy: {
+        [attribute: string]: FilterOrPolicy;
+    }): notify.Policy;
+    /**
+     * Type switch for disambiguating between subclasses
+     */
+    abstract readonly type: FilterOrPolicyType;
+    /**
+     * Check if instance is `Policy` type
+     */
+    isPolicy(): this is Policy;
+    /**
+     * Check if instance is `Filter` type
+     */
+    isFilter(): this is Filter;
+}
+/**
+ * Filter implementation of FilterOrPolicy
+ */
+export declare class Filter extends FilterOrPolicy {
+    readonly filterDoc: SubscriptionFilter;
+    /**
+     * Type used in DFS buildFilterPolicyWithMessageBody to determine json value type
+     */
+    readonly type = notify.FilterOrPolicyType.FILTER;
+    /**
+     * Policy constructor
+     * @param filterDoc filter argument to construct
+     */
+    constructor(filterDoc: SubscriptionFilter);
+}
+/**
+ * Policy Implementation of FilterOrPolicy
+ */
+export declare class Policy extends FilterOrPolicy {
+    readonly policyDoc: {
+        [attribute: string]: FilterOrPolicy;
+    };
+    /**
+     * Type used in DFS buildFilterPolicyWithMessageBody to determine json value type
+     */
+    readonly type = notify.FilterOrPolicyType.POLICY;
+    /**
+     * Policy constructor
+     * @param policyDoc policy argument to construct
+     */
+    constructor(policyDoc: {
+        [attribute: string]: FilterOrPolicy;
+    });
+}