@terreno/announcements 57.4.0

package/dist/models/announcementClickEvent.js

@@ -0,0 +1,56 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidClickAction = exports.AnnouncementClickEvent = void 0;
+var api_1 = require("@terreno/api");
+var mongoose_1 = __importDefault(require("mongoose"));
+var announcementClickEventSchema = new mongoose_1.default.Schema({
+    action: {
+        description: "Which announcement action the user clicked",
+        enum: ["primaryAction"],
+        required: true,
+        type: String,
+    },
+    announcementId: {
+        description: "Announcement whose primary action was clicked",
+        index: true,
+        ref: "Announcement",
+        required: true,
+        type: mongoose_1.default.Schema.Types.ObjectId,
+    },
+    clickedAt: {
+        description: "When the primary action was clicked",
+        required: true,
+        type: Date,
+    },
+    platform: {
+        description: "Client platform where the click occurred",
+        enum: ["ios", "android", "web"],
+        type: String,
+    },
+    userId: {
+        description: "User who clicked the announcement action",
+        index: true,
+        ref: "User",
+        required: true,
+        type: mongoose_1.default.Schema.Types.ObjectId,
+    },
+    version: {
+        description: "Announcement version at click time",
+        required: true,
+        type: Number,
+    },
+}, { strict: "throw", toJSON: { virtuals: true }, toObject: { virtuals: true } });
+announcementClickEventSchema.plugin(api_1.createdUpdatedPlugin);
+announcementClickEventSchema.plugin(api_1.isDeletedPlugin);
+announcementClickEventSchema.plugin(api_1.findExactlyOne);
+announcementClickEventSchema.plugin(api_1.findOneOrNone);
+announcementClickEventSchema.index({ announcementId: 1, clickedAt: -1 });
+exports.AnnouncementClickEvent = (_a = mongoose_1.default.models.AnnouncementClickEvent) !== null && _a !== void 0 ? _a : mongoose_1.default.model("AnnouncementClickEvent", announcementClickEventSchema);
+var isValidClickAction = function (value) {
+    return value === "primaryAction";
+};
+exports.isValidClickAction = isValidClickAction;

package/dist/models/announcementImpression.d.ts

@@ -0,0 +1,3 @@
+import type { AnnouncementImpressionModel, AnnouncementPlatform } from "../types";
+export declare const AnnouncementImpression: AnnouncementImpressionModel;
+export declare const isValidPlatform: (value: unknown) => value is AnnouncementPlatform;

package/dist/models/announcementImpression.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidPlatform = exports.AnnouncementImpression = void 0;
+var api_1 = require("@terreno/api");
+var mongoose_1 = __importDefault(require("mongoose"));
+var announcementImpressionSchema = new mongoose_1.default.Schema({
+    announcementId: {
+        description: "Announcement that was viewed",
+        index: true,
+        ref: "Announcement",
+        required: true,
+        type: mongoose_1.default.Schema.Types.ObjectId,
+    },
+    platform: {
+        description: "Client platform where the impression occurred",
+        enum: ["ios", "android", "web"],
+        type: String,
+    },
+    userId: {
+        description: "User who viewed the announcement",
+        index: true,
+        ref: "User",
+        required: true,
+        type: mongoose_1.default.Schema.Types.ObjectId,
+    },
+    version: {
+        description: "Announcement version viewed by the user",
+        required: true,
+        type: Number,
+    },
+    viewedAt: {
+        description: "When the announcement was viewed",
+        required: true,
+        type: Date,
+    },
+}, { strict: "throw", toJSON: { virtuals: true }, toObject: { virtuals: true } });
+announcementImpressionSchema.plugin(api_1.createdUpdatedPlugin);
+announcementImpressionSchema.plugin(api_1.isDeletedPlugin);
+announcementImpressionSchema.plugin(api_1.findExactlyOne);
+announcementImpressionSchema.plugin(api_1.findOneOrNone);
+announcementImpressionSchema.index({ announcementId: 1, viewedAt: -1 });
+exports.AnnouncementImpression = (_a = mongoose_1.default.models.AnnouncementImpression) !== null && _a !== void 0 ? _a : mongoose_1.default.model("AnnouncementImpression", announcementImpressionSchema);
+var isValidPlatform = function (value) {
+    return value === "ios" || value === "android" || value === "web";
+};
+exports.isValidPlatform = isValidPlatform;

package/dist/overview.d.ts

@@ -0,0 +1,14 @@
+import type { AcknowledgementPolicy, AnnouncementOverviewResponse } from "./types";
+export interface OverviewPagination {
+    limit: number;
+    page: number;
+}
+export declare const parseOverviewPagination: (query: {
+    limit?: unknown;
+    page?: unknown;
+}) => OverviewPagination;
+export declare const fetchAnnouncementOverview: ({ defaultAcknowledgementPolicy, limit, page, }: {
+    defaultAcknowledgementPolicy: AcknowledgementPolicy;
+    limit: number;
+    page: number;
+}) => Promise<AnnouncementOverviewResponse>;

package/dist/overview.js

@@ -0,0 +1,310 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchAnnouncementOverview = exports.parseOverviewPagination = void 0;
+var announcement_1 = require("./models/announcement");
+var announcementAcknowledgement_1 = require("./models/announcementAcknowledgement");
+var announcementClickEvent_1 = require("./models/announcementClickEvent");
+var announcementImpression_1 = require("./models/announcementImpression");
+var pending_1 = require("./pending");
+var NOT_DELETED = { deleted: { $ne: true } };
+var parseOverviewPagination = function (query) {
+    var _a, _b;
+    var parsedLimit = Number((_a = query.limit) !== null && _a !== void 0 ? _a : 20);
+    var parsedPage = Number((_b = query.page) !== null && _b !== void 0 ? _b : 1);
+    var limit = Number.isFinite(parsedLimit)
+        ? Math.min(Math.max(Math.trunc(parsedLimit), 1), 100)
+        : 20;
+    var page = Number.isFinite(parsedPage) ? Math.max(Math.trunc(parsedPage), 1) : 1;
+    return { limit: limit, page: page };
+};
+exports.parseOverviewPagination = parseOverviewPagination;
+var countEventTotals = function () { return __awaiter(void 0, void 0, void 0, function () {
+    var _a, impressionRows, acknowledgementRows, clickRows;
+    var _b, _c, _d, _e, _f, _g;
+    return __generator(this, function (_h) {
+        switch (_h.label) {
+            case 0: return [4 /*yield*/, Promise.all([
+                    announcementImpression_1.AnnouncementImpression.aggregate([{ $match: NOT_DELETED }, { $count: "count" }]),
+                    announcementAcknowledgement_1.AnnouncementAcknowledgement.aggregate([
+                        { $match: NOT_DELETED },
+                        { $count: "count" },
+                    ]),
+                    announcementClickEvent_1.AnnouncementClickEvent.aggregate([{ $match: NOT_DELETED }, { $count: "count" }]),
+                ])];
+            case 1:
+                _a = __read.apply(void 0, [_h.sent(), 3]), impressionRows = _a[0], acknowledgementRows = _a[1], clickRows = _a[2];
+                return [2 /*return*/, {
+                        acknowledgements: (_c = (_b = acknowledgementRows[0]) === null || _b === void 0 ? void 0 : _b.count) !== null && _c !== void 0 ? _c : 0,
+                        clicks: (_e = (_d = clickRows[0]) === null || _d === void 0 ? void 0 : _d.count) !== null && _e !== void 0 ? _e : 0,
+                        impressions: (_g = (_f = impressionRows[0]) === null || _f === void 0 ? void 0 : _f.count) !== null && _g !== void 0 ? _g : 0,
+                    }];
+        }
+    });
+}); };
+var countMetricsByAnnouncement = function (announcementIds) { return __awaiter(void 0, void 0, void 0, function () {
+    var metrics, announcementIds_1, announcementIds_1_1, id, matchByAnnouncement, _a, impressionCounts, acknowledgementCounts, clickCounts, impressionCounts_1, impressionCounts_1_1, row, existing, acknowledgementCounts_1, acknowledgementCounts_1_1, row, existing, clickCounts_1, clickCounts_1_1, row, existing;
+    var e_1, _b, e_2, _c, e_3, _d, e_4, _e;
+    var _f, _g, _h;
+    return __generator(this, function (_j) {
+        switch (_j.label) {
+            case 0:
+                metrics = new Map();
+                try {
+                    for (announcementIds_1 = __values(announcementIds), announcementIds_1_1 = announcementIds_1.next(); !announcementIds_1_1.done; announcementIds_1_1 = announcementIds_1.next()) {
+                        id = announcementIds_1_1.value;
+                        metrics.set(id.toString(), { acknowledgements: 0, clicks: 0, impressions: 0 });
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (announcementIds_1_1 && !announcementIds_1_1.done && (_b = announcementIds_1.return)) _b.call(announcementIds_1);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+                if (announcementIds.length === 0) {
+                    return [2 /*return*/, metrics];
+                }
+                matchByAnnouncement = {
+                    $match: __assign(__assign({}, NOT_DELETED), { announcementId: { $in: announcementIds } }),
+                };
+                return [4 /*yield*/, Promise.all([
+                        announcementImpression_1.AnnouncementImpression.aggregate([
+                            matchByAnnouncement,
+                            { $group: { _id: "$announcementId", count: { $sum: 1 } } },
+                        ]),
+                        announcementAcknowledgement_1.AnnouncementAcknowledgement.aggregate([
+                            matchByAnnouncement,
+                            { $group: { _id: "$announcementId", count: { $sum: 1 } } },
+                        ]),
+                        announcementClickEvent_1.AnnouncementClickEvent.aggregate([
+                            matchByAnnouncement,
+                            { $group: { _id: "$announcementId", count: { $sum: 1 } } },
+                        ]),
+                    ])];
+            case 1:
+                _a = __read.apply(void 0, [_j.sent(), 3]), impressionCounts = _a[0], acknowledgementCounts = _a[1], clickCounts = _a[2];
+                try {
+                    for (impressionCounts_1 = __values(impressionCounts), impressionCounts_1_1 = impressionCounts_1.next(); !impressionCounts_1_1.done; impressionCounts_1_1 = impressionCounts_1.next()) {
+                        row = impressionCounts_1_1.value;
+                        existing = (_f = metrics.get(row._id.toString())) !== null && _f !== void 0 ? _f : {
+                            acknowledgements: 0,
+                            clicks: 0,
+                            impressions: 0,
+                        };
+                        existing.impressions = row.count;
+                        metrics.set(row._id.toString(), existing);
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (impressionCounts_1_1 && !impressionCounts_1_1.done && (_c = impressionCounts_1.return)) _c.call(impressionCounts_1);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+                try {
+                    for (acknowledgementCounts_1 = __values(acknowledgementCounts), acknowledgementCounts_1_1 = acknowledgementCounts_1.next(); !acknowledgementCounts_1_1.done; acknowledgementCounts_1_1 = acknowledgementCounts_1.next()) {
+                        row = acknowledgementCounts_1_1.value;
+                        existing = (_g = metrics.get(row._id.toString())) !== null && _g !== void 0 ? _g : {
+                            acknowledgements: 0,
+                            clicks: 0,
+                            impressions: 0,
+                        };
+                        existing.acknowledgements = row.count;
+                        metrics.set(row._id.toString(), existing);
+                    }
+                }
+                catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                finally {
+                    try {
+                        if (acknowledgementCounts_1_1 && !acknowledgementCounts_1_1.done && (_d = acknowledgementCounts_1.return)) _d.call(acknowledgementCounts_1);
+                    }
+                    finally { if (e_3) throw e_3.error; }
+                }
+                try {
+                    for (clickCounts_1 = __values(clickCounts), clickCounts_1_1 = clickCounts_1.next(); !clickCounts_1_1.done; clickCounts_1_1 = clickCounts_1.next()) {
+                        row = clickCounts_1_1.value;
+                        existing = (_h = metrics.get(row._id.toString())) !== null && _h !== void 0 ? _h : {
+                            acknowledgements: 0,
+                            clicks: 0,
+                            impressions: 0,
+                        };
+                        existing.clicks = row.count;
+                        metrics.set(row._id.toString(), existing);
+                    }
+                }
+                catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                finally {
+                    try {
+                        if (clickCounts_1_1 && !clickCounts_1_1.done && (_e = clickCounts_1.return)) _e.call(clickCounts_1);
+                    }
+                    finally { if (e_4) throw e_4.error; }
+                }
+                return [2 /*return*/, metrics];
+        }
+    });
+}); };
+var toOverviewRow = function (_a) {
+    var _b, _c;
+    var announcement = _a.announcement, defaultAcknowledgementPolicy = _a.defaultAcknowledgementPolicy, metrics = _a.metrics;
+    return ({
+        _id: announcement._id.toString(),
+        acknowledgementPolicy: (0, pending_1.resolveAcknowledgementPolicy)({
+            announcement: announcement,
+            defaultAcknowledgementPolicy: defaultAcknowledgementPolicy,
+        }),
+        audienceType: (0, pending_1.resolveAudienceType)(announcement),
+        displayMode: (0, pending_1.resolveDisplayMode)(announcement),
+        expiresAt: (_b = announcement.expiresAt) === null || _b === void 0 ? void 0 : _b.toISOString(),
+        metrics: metrics,
+        priority: announcement.priority,
+        publishedAt: (_c = announcement.publishedAt) === null || _c === void 0 ? void 0 : _c.toISOString(),
+        status: announcement.status,
+        title: announcement.title,
+        version: announcement.version,
+    });
+};
+var fetchAnnouncementOverview = function (_a) { return __awaiter(void 0, [_a], void 0, function (_b) {
+    var skip, _c, facetResult, eventTotals, facet, paginated, total, statusCounts, statusCountMap, totals, metricsByAnnouncement, data;
+    var _d, _e, _f, _g, _h, _j, _k;
+    var defaultAcknowledgementPolicy = _b.defaultAcknowledgementPolicy, limit = _b.limit, page = _b.page;
+    return __generator(this, function (_l) {
+        switch (_l.label) {
+            case 0:
+                skip = (page - 1) * limit;
+                return [4 /*yield*/, Promise.all([
+                        announcement_1.Announcement.aggregate([
+                            { $match: NOT_DELETED },
+                            {
+                                $facet: {
+                                    paginated: [
+                                        // biome-ignore assist/source/useSortedKeys: MongoDB applies sort keys in insertion order
+                                        { $sort: { priority: -1, publishedAt: -1, _id: -1 } },
+                                        { $skip: skip },
+                                        { $limit: limit },
+                                    ],
+                                    statusCounts: [{ $group: { _id: "$status", count: { $sum: 1 } } }],
+                                    totalCount: [{ $count: "count" }],
+                                },
+                            },
+                        ]),
+                        countEventTotals(),
+                    ])];
+            case 1:
+                _c = __read.apply(void 0, [_l.sent(), 2]), facetResult = _c[0], eventTotals = _c[1];
+                facet = facetResult[0];
+                paginated = (_d = facet === null || facet === void 0 ? void 0 : facet.paginated) !== null && _d !== void 0 ? _d : [];
+                total = (_f = (_e = facet === null || facet === void 0 ? void 0 : facet.totalCount[0]) === null || _e === void 0 ? void 0 : _e.count) !== null && _f !== void 0 ? _f : 0;
+                statusCounts = (_g = facet === null || facet === void 0 ? void 0 : facet.statusCounts) !== null && _g !== void 0 ? _g : [];
+                statusCountMap = new Map(statusCounts.map(function (row) { return [row._id, row.count]; }));
+                totals = {
+                    acknowledgements: eventTotals.acknowledgements,
+                    announcements: total,
+                    archived: (_h = statusCountMap.get("archived")) !== null && _h !== void 0 ? _h : 0,
+                    clicks: eventTotals.clicks,
+                    draft: (_j = statusCountMap.get("draft")) !== null && _j !== void 0 ? _j : 0,
+                    impressions: eventTotals.impressions,
+                    published: (_k = statusCountMap.get("published")) !== null && _k !== void 0 ? _k : 0,
+                };
+                return [4 /*yield*/, countMetricsByAnnouncement(paginated.map(function (announcement) { return announcement._id; }))];
+            case 2:
+                metricsByAnnouncement = _l.sent();
+                data = paginated.map(function (announcement) {
+                    var _a;
+                    return toOverviewRow({
+                        announcement: announcement,
+                        defaultAcknowledgementPolicy: defaultAcknowledgementPolicy,
+                        metrics: (_a = metricsByAnnouncement.get(announcement._id.toString())) !== null && _a !== void 0 ? _a : {
+                            acknowledgements: 0,
+                            clicks: 0,
+                            impressions: 0,
+                        },
+                    });
+                });
+                return [2 /*return*/, {
+                        data: data,
+                        limit: limit,
+                        more: skip + data.length < total,
+                        page: page,
+                        total: total,
+                        totals: totals,
+                    }];
+        }
+    });
+}); };
+exports.fetchAnnouncementOverview = fetchAnnouncementOverview;

package/dist/pending.d.ts

@@ -0,0 +1,64 @@
+import { DateTime } from "luxon";
+import type { AcknowledgementPolicy, AnnouncementAudienceType, AnnouncementDisplayMode, AnnouncementDocument, AnnouncementPlatform } from "./types";
+export interface AnnouncementAckState {
+    announcementId: string;
+    version: number;
+}
+export interface AnnouncementImpressionState {
+    announcementId: string;
+    version: number;
+}
+export declare const resolveAcknowledgementPolicy: ({ announcement, defaultAcknowledgementPolicy, }: {
+    announcement: AnnouncementDocument;
+    defaultAcknowledgementPolicy?: AcknowledgementPolicy;
+}) => AcknowledgementPolicy;
+export declare const requiresAcknowledgementForAnnouncement: ({ announcement, defaultAcknowledgementPolicy, }: {
+    announcement: AnnouncementDocument;
+    defaultAcknowledgementPolicy?: AcknowledgementPolicy;
+}) => boolean;
+export declare const resolveDisplayMode: (announcement: AnnouncementDocument) => AnnouncementDisplayMode;
+export declare const resolveAudienceType: (announcement: AnnouncementDocument) => AnnouncementAudienceType;
+export declare const matchAudienceByType: ({ announcement, isStaff, user, }: {
+    announcement: AnnouncementDocument;
+    isStaff: (user: unknown) => boolean;
+    user: unknown;
+}) => boolean;
+export declare const parseQueryVersion: (raw: unknown) => number | undefined;
+export declare const passesMinBuildNumber: ({ announcement, queryVersion, }: {
+    announcement: AnnouncementDocument;
+    queryVersion?: number;
+}) => boolean;
+export declare const isInterruptDisplayMode: (announcement: AnnouncementDocument) => boolean;
+export declare const isAnnouncementVisibleNow: ({ announcement, now, }: {
+    announcement: AnnouncementDocument;
+    now?: DateTime;
+}) => boolean;
+export declare const matchesPlatform: ({ announcement, platform, }: {
+    announcement: AnnouncementDocument;
+    platform: AnnouncementPlatform;
+}) => boolean;
+export declare const isAnnouncementPendingForUser: ({ acknowledgements, announcement, defaultAcknowledgementPolicy, impressions, }: {
+    acknowledgements: AnnouncementAckState[];
+    announcement: AnnouncementDocument;
+    defaultAcknowledgementPolicy?: AcknowledgementPolicy;
+    impressions: AnnouncementImpressionState[];
+}) => boolean;
+export declare const sortAnnouncementsForQueue: (announcements: AnnouncementDocument[]) => AnnouncementDocument[];
+export declare const selectPendingAnnouncements: ({ acknowledgements, announcements, defaultAcknowledgementPolicy, impressions, now, platform, queryVersion, }: {
+    acknowledgements: AnnouncementAckState[];
+    announcements: AnnouncementDocument[];
+    defaultAcknowledgementPolicy?: AcknowledgementPolicy;
+    impressions: AnnouncementImpressionState[];
+    now?: DateTime;
+    platform: AnnouncementPlatform;
+    queryVersion?: number;
+}) => AnnouncementDocument[];
+export declare const isAnnouncementVisibleToUser: ({ announcement, isStaff, matchAudience, now, platform, queryVersion, user, }: {
+    announcement: AnnouncementDocument;
+    isStaff: (user: unknown) => boolean;
+    matchAudience: (user: unknown, announcement: AnnouncementDocument) => boolean | Promise<boolean>;
+    now?: DateTime;
+    platform: AnnouncementPlatform;
+    queryVersion?: number;
+    user: unknown;
+}) => Promise<boolean>;