@cosmicdrift/kumiko-bundled-features 0.392.2 → 0.394.0

package/dist/inbound-mail-foundation/quarantine-header-import.js

@@ -0,0 +1,53 @@
+// A quarantined mail stays visible: its headers (and the original, when file storage is there) are
+// imported as a message without content, marked "unavailable / quarantined". The import is best
+// effort: the quarantine row already moves the cursor on, and a retry can still load the content.
+import { InboundMailFoundationHandlers } from "./constants.js";
+import { ingestPayloadOf } from "./ingest-payload.js";
+import { INBOUND_MISSING_SENDER, normalizeRawInboundMessage } from "./normalize-inbound-message.js";
+const EPOCH_ISO = "1970-01-01T00:00:00Z";
+export function headerOnlyOf(msg) {
+    const { text: _text, html: _html, attachments: _a, skippedAttachments: _s, ...envelope } = msg;
+    return { ...envelope, text: "", html: null, attachments: [], skippedAttachments: [] };
+}
+/** Null when the provider reported no headers for the mail: nothing meaningful to show. */
+export function headerOnlyOfRejected(entry) {
+    const { headers } = entry;
+    if (!headers)
+        return null;
+    return {
+        providerMessageId: entry.providerMessageId,
+        messageIdHeader: headers.messageIdHeader,
+        providerThreadId: null,
+        references: [],
+        from: headers.from === "" ? INBOUND_MISSING_SENDER : headers.from,
+        to: headers.to,
+        cc: headers.cc,
+        subject: headers.subject,
+        snippet: "",
+        receivedAtIso: headers.receivedAtIso === "" ? EPOCH_ISO : headers.receivedAtIso,
+        rawMime: entry.rawMime ?? null,
+        scope: "inbox",
+    };
+}
+export async function importQuarantinedHeaders(deps, account, headerOnly) {
+    // skip: no header data to import for this mail
+    if (!headerOnly)
+        return;
+    try {
+        const result = await deps.dispatchWrite({
+            handlerQn: InboundMailFoundationHandlers.ingestMessage,
+            tenantId: account.tenantId,
+            payload: ingestPayloadOf(account, normalizeRawInboundMessage(headerOnly), {
+                providerCursor: "quarantine",
+                bodyRef: "",
+                contentUnavailableReason: "quarantined",
+            }),
+        });
+        if (!result.isSuccess) {
+            deps.log(`inbound-mail: account ${account.id} header import of a quarantined mail was rejected`);
+        }
+    }
+    catch {
+        deps.log(`inbound-mail: account ${account.id} header import of a quarantined mail failed`);
+    }
+}

package/dist/inbound-mail-foundation/quarantine-retry.d.ts

@@ -0,0 +1,13 @@
+import type { DbConnection } from "@cosmicdrift/kumiko-framework/db";
+import type { DispatchWrite } from "./supervisor-ingest.ts";
+import type { InboundMailContext, InboundMailProviderPlugin, MailAccountRecord } from "./types.ts";
+export declare function retryQuarantinedMessages(args: {
+    readonly db: DbConnection;
+    readonly dispatchWrite: DispatchWrite;
+    readonly providerCtx: InboundMailContext;
+    readonly account: MailAccountRecord;
+    readonly plugin: InboundMailProviderPlugin;
+    readonly accessToken?: string | undefined;
+    readonly signal?: AbortSignal | undefined;
+    readonly log: (line: string) => void;
+}): Promise<void>;

package/dist/inbound-mail-foundation/quarantine-retry.js

@@ -0,0 +1,97 @@
+// Quarantine retry: mails flagged by retry-quarantined-message are loaded from the provider again
+// after a successful sync. A mail that now goes through leaves the quarantine; one that fails again
+// stays in it (flag reset, so it is not retried on every tick). An outage (provider, KMS, file
+// storage) is not the mail's failure: the flag stays and the retry runs after the recovery.
+import { ENCRYPTION_UNAVAILABLE_CODE } from "@cosmicdrift/kumiko-framework/crypto";
+import { deleteMany, selectMany, updateMany } from "@cosmicdrift/kumiko-framework/db";
+import { errorCodeOf } from "@cosmicdrift/kumiko-types/type-guards";
+import { inboundMessageAggregateId } from "./aggregate-id.js";
+import { InboundMailFoundationHandlers } from "./constants.js";
+import { describeError } from "./describe-error.js";
+import { isFileStorageWriteFailure } from "./file-storage-failure.js";
+import { clearIngestFailures } from "./ingest-failures.js";
+import { ingestPayloadOf } from "./ingest-payload.js";
+import { normalizeRawInboundMessage, } from "./normalize-inbound-message.js";
+import { inboundMessagesProjectionTable } from "./projection.js";
+import { quarantineTable } from "./quarantine-entities.js";
+const RETRY_BUDGET_PER_TICK = 20;
+function isOutageFailure(error) {
+    return isFileStorageWriteFailure(error) || errorCodeOf(error) === ENCRYPTION_UNAVAILABLE_CODE;
+}
+// A mail with a header-only entry gets its content attached, one without any entry is ingested in full.
+function reloadMessage(dispatchWrite, account, msg, hasHeaderRow) {
+    return hasHeaderRow
+        ? dispatchWrite({
+            handlerQn: InboundMailFoundationHandlers.attachMessageContent,
+            tenantId: account.tenantId,
+            payload: {
+                accountId: account.id,
+                providerMessageId: msg.providerMessageId,
+                outcome: "fetched",
+                bodyText: msg.bodyText,
+                bodyTextTruncated: msg.bodyTextTruncated,
+                ...(msg.rawMime != null && { rawMime: msg.rawMime }),
+                ...(msg.bodyHtml !== null && { bodyHtml: msg.bodyHtml }),
+                attachments: msg.attachments,
+                skippedAttachments: msg.skippedAttachments,
+            },
+        })
+        : dispatchWrite({
+            handlerQn: InboundMailFoundationHandlers.ingestMessage,
+            tenantId: account.tenantId,
+            payload: ingestPayloadOf(account, msg, {
+                providerCursor: "quarantine-retry",
+                bodyRef: "",
+            }),
+        });
+}
+export async function retryQuarantinedMessages(args) {
+    const { db, account, plugin, dispatchWrite, log } = args;
+    // skip: the provider cannot reload single mails.
+    if (!plugin.fetchContent)
+        return;
+    const requested = await selectMany(db, quarantineTable, { accountId: account.id, retryRequestedAt: { ne: null } }, { fields: ["providerMessageId"], limit: RETRY_BUDGET_PER_TICK });
+    // skip: nothing was asked for.
+    if (requested.length === 0)
+        return;
+    const ids = requested.map((row) => row.providerMessageId);
+    const done = new Set();
+    const held = new Set();
+    try {
+        const result = await plugin.fetchContent(args.providerCtx, account, ids, {
+            ...(args.accessToken !== undefined && { accessToken: args.accessToken }),
+            ...(args.signal !== undefined && { signal: args.signal }),
+        });
+        const existing = new Set((await selectMany(db, inboundMessagesProjectionTable, {
+            tenantId: account.tenantId,
+            id: { in: ids.map((id) => inboundMessageAggregateId(account.id, id)) },
+        }, { fields: ["id"] })).map((row) => row.id));
+        for (const raw of result.messages) {
+            const msg = normalizeRawInboundMessage(raw);
+            const hasHeaderRow = existing.has(inboundMessageAggregateId(account.id, msg.providerMessageId));
+            const outcome = await reloadMessage(dispatchWrite, account, msg, hasHeaderRow);
+            if (outcome.isSuccess)
+                done.add(msg.providerMessageId);
+            else if (isOutageFailure(outcome.error))
+                held.add(msg.providerMessageId);
+        }
+    }
+    catch (err) {
+        log(`inbound-mail: account ${account.id} quarantine retry failed: ${describeError(err)}`);
+        for (const id of ids)
+            held.add(id);
+    }
+    const doneIds = [...done];
+    if (doneIds.length > 0) {
+        await deleteMany(db, quarantineTable, {
+            accountId: account.id,
+            providerMessageId: { in: doneIds },
+        });
+        await clearIngestFailures(db, account.id, doneIds);
+    }
+    const failed = ids.filter((id) => !done.has(id) && !held.has(id));
+    if (failed.length > 0) {
+        await updateMany(db, quarantineTable, { retryRequestedAt: null }, { accountId: account.id, providerMessageId: { in: failed } });
+        log(`inbound-mail: account ${account.id} ${failed.length} quarantined mail(s) still failing`);
+    }
+}

package/dist/inbound-mail-foundation/quarantine-screens.d.ts

@@ -0,0 +1,4 @@
+import { type ProjectionListScreenDefinition } from "@cosmicdrift/kumiko-framework/engine";
+import type { InboundMailRoles } from "./mail-roles.ts";
+export declare const QUARANTINE_REASON_OPTION_KEY_PREFIX = "inboundMail.quarantine.reason.";
+export declare function createMailQuarantineScreen({ memberRoles, }: InboundMailRoles): ProjectionListScreenDefinition;

package/dist/inbound-mail-foundation/quarantine-screens.js

@@ -0,0 +1,57 @@
+import { i18nKey, MAX_LIST_LIMIT, } from "@cosmicdrift/kumiko-framework/engine";
+import { InboundMailFoundationHandlers, InboundMailFoundationQueries } from "./constants.js";
+import { MAIL_QUARANTINE_SCREEN_ID } from "./screens.js";
+export const QUARANTINE_REASON_OPTION_KEY_PREFIX = "inboundMail.quarantine.reason.";
+// Same roles as the handlers; the bound query shows each caller only the mailboxes they may manage.
+// dormant: reached through the row action "Quarantine" of the mailbox list.
+export function createMailQuarantineScreen({ memberRoles, }) {
+    return {
+        id: MAIL_QUARANTINE_SCREEN_ID,
+        type: "projectionList",
+        agent: { expose: false },
+        query: InboundMailFoundationQueries.listQuarantine,
+        pagination: false,
+        pageSize: MAX_LIST_LIMIT,
+        columns: [
+            { field: "sender", label: i18nKey("inboundMail.quarantine.col.sender"), sortable: false },
+            { field: "subject", label: i18nKey("inboundMail.quarantine.col.subject"), sortable: false },
+            {
+                field: "reason",
+                label: i18nKey("inboundMail.quarantine.col.reason"),
+                sortable: false,
+                renderer: { format: "enumOption", keyPrefix: QUARANTINE_REASON_OPTION_KEY_PREFIX },
+            },
+            {
+                field: "accountName",
+                label: i18nKey("inboundMail.quarantine.col.mailbox"),
+                sortable: false,
+                hideOnNarrow: true,
+            },
+            {
+                field: "quarantinedAt",
+                label: i18nKey("inboundMail.quarantine.col.date"),
+                sortable: false,
+                renderer: { format: "timestamp" },
+            },
+        ],
+        rowActions: [
+            {
+                kind: "writeHandler",
+                id: "retry",
+                label: i18nKey("inboundMail.quarantine.retry"),
+                handler: InboundMailFoundationHandlers.retryQuarantinedMessage,
+                payload: { map: { accountId: "accountId", providerMessageId: "providerMessageId" } },
+                visible: { field: "retryRequestedAt", eq: null },
+            },
+            {
+                kind: "writeHandler",
+                id: "acknowledge",
+                label: i18nKey("inboundMail.quarantine.acknowledge"),
+                handler: InboundMailFoundationHandlers.acknowledgeQuarantine,
+                payload: { map: { accountId: "accountId", providerMessageId: "providerMessageId" } },
+            },
+        ],
+        access: { roles: [...memberRoles] },
+        dormant: true,
+    };
+}

package/dist/inbound-mail-foundation/quarantine.d.ts

@@ -0,0 +1,13 @@
+import type { DbConnection } from "@cosmicdrift/kumiko-framework/db";
+import { type QuarantineReasonCode } from "./quarantine-entities.ts";
+export declare const QUARANTINE_ACKNOWLEDGED_RETENTION_DAYS = 90;
+type QuarantineTarget = {
+    readonly tenantId: string;
+    readonly accountId: string;
+    readonly providerMessageId: string;
+};
+/** Returns true when a new row was written, false when the message was already quarantined. */
+export declare function quarantineMessage(db: DbConnection, target: QuarantineTarget, reasonCode: QuarantineReasonCode): Promise<boolean>;
+export declare function quarantinedMessageIds(db: DbConnection, accountId: string, providerMessageIds: readonly string[]): Promise<ReadonlySet<string>>;
+export declare function hasOpenQuarantine(db: DbConnection, accountId: string): Promise<boolean>;
+export {};

package/dist/inbound-mail-foundation/quarantine.js

@@ -0,0 +1,46 @@
+// Quarantine of poison mails: messages the supervisor cannot ingest (unparseable MIME, payload the
+// ingest handler rejects for good, or repeated hard failures). A quarantined id counts as seen, so the
+// cursor moves on instead of retrying the same mail forever. Rows carry ids only, no mail content.
+import { fetchOne, insertOne, selectMany } from "@cosmicdrift/kumiko-framework/db";
+import { Temporal } from "@cosmicdrift/kumiko-types/temporal";
+import { quarantineTable } from "./quarantine-entities.js";
+const LOOKUP_CHUNK_SIZE = 1000;
+export const QUARANTINE_ACKNOWLEDGED_RETENTION_DAYS = 90;
+/** Returns true when a new row was written, false when the message was already quarantined. */
+export async function quarantineMessage(db, target, reasonCode) {
+    const key = { accountId: target.accountId, providerMessageId: target.providerMessageId };
+    if (await fetchOne(db, quarantineTable, key))
+        return false;
+    try {
+        await insertOne(db, quarantineTable, {
+            id: crypto.randomUUID(),
+            tenantId: target.tenantId,
+            ...key,
+            reasonCode,
+            quarantinedAt: Temporal.Now.instant().toString(),
+        });
+        return true;
+    }
+    catch (err) {
+        // A concurrent worker quarantined the same message between the check and the insert.
+        if (await fetchOne(db, quarantineTable, key))
+            return false;
+        throw err;
+    }
+}
+export async function quarantinedMessageIds(db, accountId, providerMessageIds) {
+    const ids = new Set();
+    for (let start = 0; start < providerMessageIds.length; start += LOOKUP_CHUNK_SIZE) {
+        const rows = await selectMany(db, quarantineTable, {
+            accountId,
+            providerMessageId: { in: providerMessageIds.slice(start, start + LOOKUP_CHUNK_SIZE) },
+        }, { fields: ["providerMessageId"] });
+        for (const row of rows)
+            ids.add(row.providerMessageId);
+    }
+    return ids;
+}
+export async function hasOpenQuarantine(db, accountId) {
+    const rows = await selectMany(db, quarantineTable, { accountId, acknowledgedAt: null }, { fields: ["id"], limit: 1 });
+    return rows.length > 0;
+}

package/dist/inbound-mail-foundation/retention-job.d.ts

@@ -0,0 +1,2 @@
+import type { FeatureRegistrar } from "@cosmicdrift/kumiko-framework/engine";
+export declare function registerInboundMailRetentionJob(r: FeatureRegistrar<"inbound-mail-foundation">): void;

package/dist/inbound-mail-foundation/retention-job.js

@@ -0,0 +1,62 @@
+import { createFileProviderForTenant, deleteFileRefsBoundToRecord, } from "@cosmicdrift/kumiko-framework/files";
+import { INBOUND_MESSAGE_AGGREGATE_TYPE } from "./events.js";
+import { runInboundMailRetention } from "./retention-sweep.js";
+export function registerInboundMailRetentionJob(r) {
+    // Data-Retention — perTenant fan-out (one run per tenant, like
+    // data-retention:retention-cleanup): runInboundMailRetention's raw query
+    // helpers need the unfiltered runner, so the handler declares escapeHatch
+    // and reaches for ctx.db.unsafeRaw(). Without this cron, read_inbound_messages
+    // + the bodies grow unbounded (GDPR Art. 5).
+    const INBOUND_MAIL_RETENTION_REASON = "inbound-mail retention runs raw deletes; every statement filters by this run's tenantId";
+    r.job({
+        name: "inbound-mail-retention",
+        trigger: { cron: "0 3 * * *" },
+        perTenant: true,
+        concurrency: "skip",
+        escapeHatch: { reason: INBOUND_MAIL_RETENTION_REASON },
+        handler: async (_payload, ctx) => {
+            if (!ctx.registry) {
+                throw new Error("inbound-mail-retention: ctx.registry required (JobContext incomplete)");
+            }
+            const tenantId = ctx.systemUser?.tenantId ?? ctx._tenantId;
+            if (tenantId === undefined) {
+                // skip: cron fired without a perTenant fan-out tenant — nothing scoped
+                return;
+            }
+            const T = (await import("@cosmicdrift/kumiko-framework/time")).getTemporal();
+            const retentionDb = ctx.db.unsafeRaw(); // @cast-boundary db-operator — jobs never run inside a DbTx
+            // Original (.eml/.html) objects live in file-foundation; the provider is lazy and
+            // memoized so a tenant without purgeable mails never builds it.
+            let providerPromise = null;
+            const deleteBodyObject = async (bodyRef) => {
+                if (!providerPromise) {
+                    providerPromise = createFileProviderForTenant({ config: ctx.config, registry: ctx.registry, secrets: ctx.services.secrets }, tenantId);
+                }
+                const provider = await providerPromise;
+                await provider.delete(bodyRef);
+            };
+            const { systemUser } = ctx;
+            const deleteAttachments = systemUser
+                ? async (messageId) => {
+                    await deleteFileRefsBoundToRecord({
+                        db: ctx.db,
+                        user: systemUser,
+                        entityType: INBOUND_MESSAGE_AGGREGATE_TYPE,
+                        entityId: messageId,
+                    });
+                }
+                : undefined;
+            const report = await runInboundMailRetention({
+                db: retentionDb,
+                tenantId,
+                now: T.Now.instant(),
+                deleteBodyObject,
+                ...(deleteAttachments ? { deleteAttachments } : {}),
+            });
+            if (report.bodyObjectErrors > 0) {
+                // biome-ignore lint/suspicious/noConsole: operator-visibility for failed body deletes
+                console.warn(`[inbound-mail-foundation:inbound-mail-retention] tenant=${tenantId} bodyObjectErrors=${report.bodyObjectErrors}`);
+            }
+        },
+    });
+}

package/dist/inbound-mail-foundation/retention-sweep.d.ts

@@ -16,12 +16,16 @@ export interface InboundRetentionArgs {
     /** Deletes a file-storage body object by bodyRef key. Wired lazily by the job
      * (createFileProviderForTenant); if absent, no body is deleted. */
     readonly deleteBodyObject?: (bodyRef: string) => Promise<void>;
+    /** Removes the fileRefs bound to an expired mail (its attachments); wired by the job. */
+    readonly deleteAttachments?: (messageId: string) => Promise<void>;
 }
 export interface InboundRetentionReport {
     readonly messagesPurged: number;
     readonly bodyObjectsDeleted: number;
     readonly bodyObjectErrors: number;
     readonly seenPurged: number;
+    readonly quarantinePurged: number;
+    readonly ingestFailuresPurged: number;
 }
 export declare function runInboundMailRetention(args: InboundRetentionArgs): Promise<InboundRetentionReport>;
 export {};

package/dist/inbound-mail-foundation/retention-sweep.js

@@ -20,6 +20,18 @@
 //     directly through the table's tenant_id column (table-builder convention),
 //     without an Account join.
 //
+//   store_mail_ingest_failures (unmanaged): counters of mails the ingest could not take. A counter
+//     whose mail never failed again (it went through or was quarantined, which clear it) is stale
+//     after the seen retention.
+//
+//   store_mail_quarantine (unmanaged): acknowledged entries are purged after
+//     QUARANTINE_ACKNOWLEDGED_RETENTION_DAYS; unacknowledged ones stay, they
+//     keep the mailbox flagged until someone looked at them.
+//
+// Attachments are fileRefs bound to the mail row: they go with it (soft delete through the
+// fileRef executor; the generic soft-delete cleanup removes the bytes). A failure keeps the Row
+// for the next sweep, like a failed body delete.
+//
 // LIMITATION: the PII in the message events remains decryptable under the
 // TENANT subject key—per-Row retention does not shred a key. Actual Art.-17
 // erasure of event payloads happens only during tenant-destroy (key erasure).
@@ -29,7 +41,10 @@ import { deleteMany, selectMany } from "@cosmicdrift/kumiko-framework/db";
 import { archiveStream, deleteRowsWithoutReplayableStream, } from "@cosmicdrift/kumiko-framework/event-store";
 import { seenMessageTable } from "./entities.js";
 import { INBOUND_MESSAGE_AGGREGATE_TYPE } from "./events.js";
+import { ingestFailureTable } from "./ingest-failures.js";
 import { inboundMessagesProjectionTable } from "./projection.js";
+import { QUARANTINE_ACKNOWLEDGED_RETENTION_DAYS } from "./quarantine.js";
+import { quarantineTable } from "./quarantine-entities.js";
 export const MESSAGE_RETENTION_DAYS = 365;
 export const SEEN_RETENTION_DAYS = 90;
 const BATCH_LIMIT = 1000;
@@ -42,7 +57,18 @@ export async function runInboundMailRetention(args) {
     const seenCutoff = args.now.subtract({ hours: seenDays * 24 });
     const messages = await purgeExpiredMessages(args, messageCutoff);
     const seenPurged = await purgeExpiredSeenAnchors(args.db, args.tenantId, seenCutoff);
-    return { ...messages, seenPurged };
+    const quarantineCutoff = args.now.subtract({
+        hours: QUARANTINE_ACKNOWLEDGED_RETENTION_DAYS * 24,
+    });
+    const quarantinePurged = await deleteMany(args.db, quarantineTable, {
+        tenantId: args.tenantId,
+        acknowledgedAt: { lt: quarantineCutoff },
+    });
+    const ingestFailuresPurged = await deleteMany(args.db, ingestFailureTable, {
+        tenantId: args.tenantId,
+        lastFailedAt: { lt: seenCutoff },
+    });
+    return { ...messages, seenPurged, quarantinePurged, ingestFailuresPurged };
 }
 async function purgeExpiredMessages(args, cutoff) {
     let messagesPurged = 0;
@@ -74,16 +100,17 @@ async function purgeExpiredMessages(args, cutoff) {
                 archivedBy: ARCHIVED_BY,
                 reason: REASON,
             });
-            if (row.bodyRef && args.deleteBodyObject) {
-                try {
+            try {
+                if (row.bodyRef && args.deleteBodyObject) {
                     await args.deleteBodyObject(row.bodyRef);
                     bodyObjectsDeleted++;
                 }
-                catch {
-                    bodyObjectErrors++;
-                    failedIds.add(row.id);
-                    continue;
-                }
+                await args.deleteAttachments?.(row.id);
+            }
+            catch {
+                bodyObjectErrors++;
+                failedIds.add(row.id);
+                continue;
             }
             ids.push(row.id);
         }

package/dist/inbound-mail-foundation/screens.d.ts

@@ -1,9 +1,21 @@
 import { type ProjectionListScreenDefinition } from "@cosmicdrift/kumiko-framework/engine";
 import type { ActionFormScreenDefinition } from "@cosmicdrift/kumiko-framework/ui-types";
+import type { InboundMailRoles } from "./mail-roles.ts";
 export declare const MAIL_ACCOUNT_LIST_SCREEN_ID = "mail-accounts";
 export declare const MAIL_ACCOUNT_EDIT_SCREEN_ID = "mail-account-edit";
 export declare const MAIL_ACCOUNT_LIST_SCREEN_QN = "inbound-mail-foundation:screen:mail-accounts";
+export declare const MY_MAIL_ACCOUNT_LIST_SCREEN_ID = "my-mail-accounts";
+export declare const MY_MAIL_ACCOUNT_LIST_SCREEN_QN = "inbound-mail-foundation:screen:my-mail-accounts";
+export declare const MAIL_ACCOUNT_SENDER_CHECK_SCREEN_ID = "mail-account-sender-check";
 export declare const IMAP_CONNECT_SCREEN_ID = "mail-account-connect-imap";
+export declare const IMAP_RECONNECT_SCREEN_ID = "mail-account-reconnect-imap";
+export declare const MY_IMAP_RECONNECT_SCREEN_ID = "my-mail-account-reconnect-imap";
+export declare const MY_IMAP_CONNECT_SCREEN_ID = "my-mail-account-connect-imap";
+export declare const MAIL_QUARANTINE_SCREEN_ID = "mail-quarantine";
 export declare const MAIL_ACCOUNT_STATUS_OPTION_KEY_PREFIX = "inboundMail.accounts.status.";
-export declare const mailAccountListScreen: ProjectionListScreenDefinition;
-export declare const mailAccountEditScreen: ActionFormScreenDefinition;
+export declare const MAIL_ACCOUNT_LAST_ERROR_OPTION_KEY_PREFIX = "inboundMail.accounts.lastError.";
+export declare function createMailAccountListScreen({ adminRoles, }: InboundMailRoles): ProjectionListScreenDefinition;
+export declare function createMyMailAccountListScreen({ memberRoles, }: InboundMailRoles): ProjectionListScreenDefinition;
+export declare function createMailAccountEditScreen({ adminRoles, }: InboundMailRoles): ActionFormScreenDefinition;
+export declare function createMailAccountSenderCheckScreen({ adminRoles, }: InboundMailRoles): ActionFormScreenDefinition;
+export declare function createMailAccountScreens(roles: InboundMailRoles): readonly [ProjectionListScreenDefinition, ProjectionListScreenDefinition, ActionFormScreenDefinition, ActionFormScreenDefinition];