@remit/web-client 0.0.325 → 0.0.327

package/dist/src/lib/escalation-label.d.ts

@@ -0,0 +1,18 @@
+/** The subset of the search predicate that names the scope in escalation copy. */
+export interface EscalationScopeQuery {
+    query?: string;
+    from?: string;
+}
+/**
+ * Names what an escalated selection covers, for the notice text and the
+ * confirm dialog — never a bare "Select all" (issue #92 requirement 4). Free
+ * text wins when present since it's what the user actually typed; `from:`
+ * alone still names a scope. Neither present is unreachable in practice (the
+ * escalation control only ever renders for an active search), but the
+ * fallback keeps the label honest instead of throwing.
+ */
+export declare const describeSearchScope: (query: EscalationScopeQuery) => string;
+/** "Select all matching "npm"" — the escalation notice's action label. */
+export declare const escalationActionLabel: (query: EscalationScopeQuery) => string;
+/** "All 3,412 matching "npm" selected" — the bar's status label once escalated. */
+export declare const escalatedStatusLabel: (query: EscalationScopeQuery, total: number) => string;

package/dist/src/lib/escalation-label.js

@@ -0,0 +1,20 @@
+import { formatNumber } from "./format";
+/**
+ * Names what an escalated selection covers, for the notice text and the
+ * confirm dialog — never a bare "Select all" (issue #92 requirement 4). Free
+ * text wins when present since it's what the user actually typed; `from:`
+ * alone still names a scope. Neither present is unreachable in practice (the
+ * escalation control only ever renders for an active search), but the
+ * fallback keeps the label honest instead of throwing.
+ */
+export const describeSearchScope = (query) => {
+    if (query.query)
+        return `matching "${query.query}"`;
+    if (query.from)
+        return `from "${query.from}"`;
+    return "matching your search";
+};
+/** "Select all matching "npm"" — the escalation notice's action label. */
+export const escalationActionLabel = (query) => `Select all ${describeSearchScope(query)}`;
+/** "All 3,412 matching "npm" selected" — the bar's status label once escalated. */
+export const escalatedStatusLabel = (query, total) => `All ${formatNumber(total)} ${describeSearchScope(query)} selected`;

package/dist/src/lib/fatal-error.d.ts

@@ -0,0 +1,68 @@
+import type { Telemetry } from "./telemetry";
+/**
+ * The single escalation seam for first-party fatal errors.
+ *
+ * Calling `reportFatalError(error)` does three things, unconditionally:
+ *  1. records the error into the recent-errors ring (so the bug-report flow
+ *     picks it up),
+ *  2. emits a telemetry fatal-error event (when a telemetry sink is registered
+ *     via `setFatalErrorTelemetry` — `main.tsx` plugs the live RUM adapter in
+ *     here), and
+ *  3. notifies every subscriber — the `FatalErrorOverlay` subscribes here and
+ *     takes over the whole screen with the red escalation page.
+ *
+ * This is the one place telemetry plugs in: RUM wires in once, not per call
+ * site.
+ */
+export interface FatalError {
+    error: unknown;
+    /** Human-readable message extracted from the error. */
+    message: string;
+    /** Correlation id for support — distinguishes one fatal from the next. */
+    correlationId: string;
+    /** When the fatal was reported. */
+    at: number;
+    /**
+     * Whether retrying the same action might succeed. A transient class — a 5xx,
+     * an offline/network blip, an aborted request — is recoverable; the overlay
+     * offers Retry. A deterministic render/exception (caught by the route error
+     * boundary) is NOT recoverable — retry re-crashes, so the overlay offers a
+     * way out (a safe route) instead.
+     */
+    recoverable: boolean;
+    /** The error's stack, when it is an `Error`. Seeds the bug report. */
+    stack?: string;
+    /** React component stack from the error boundary, when available. */
+    componentStack?: string;
+}
+/** Options for `reportFatalError`. */
+export interface ReportFatalOptions {
+    /**
+     * Force the recoverable classification. Omit to derive it from the error
+     * (transient network/5xx/abort ⇒ recoverable). The route error boundary
+     * passes `false` for a caught render exception — it is deterministic.
+     */
+    recoverable?: boolean;
+    /** React component stack captured by the error boundary. */
+    componentStack?: string;
+}
+type FatalErrorListener = (fatal: FatalError) => void;
+/**
+ * Register the telemetry sink the fatal seam emits to. Called once from
+ * `main.tsx` with the live RUM adapter (no-op telemetry when RUM is disabled).
+ */
+export declare const setFatalErrorTelemetry: (sink: Telemetry) => void;
+/**
+ * Report a fatal, first-party error. Idempotent in spirit: the overlay shows
+ * the first fatal and stays until the user reloads, so repeated calls only
+ * refresh the recorded entry and re-notify (a no-op for an already-mounted
+ * overlay).
+ */
+export declare const reportFatalError: (error: unknown, options?: ReportFatalOptions) => FatalError;
+/** Subscribe to fatal errors. Returns an unsubscribe function. */
+export declare const subscribeFatalError: (listener: FatalErrorListener) => (() => void);
+/** The most recent fatal error, if any — lets a late subscriber catch up. */
+export declare const getCurrentFatalError: () => FatalError | null;
+/** Test-only: clear the in-memory fatal state, listeners, and telemetry sink. */
+export declare const __resetFatalError: () => void;
+export {};

package/dist/src/lib/fatal-error.js

@@ -0,0 +1,88 @@
+import { recordError } from "./console-errors";
+import { isServerError } from "./error-classifier";
+/**
+ * Default recoverable classification for an error with no explicit override.
+ * Only a 5xx is treated as recoverable — the one clearly transient class, where
+ * retrying the same action may succeed. Everything that reaches the fatal seam
+ * is otherwise deterministic: aborts and offline/network blips never escalate
+ * here (they are filtered upstream by `shouldEscalate`), so a statusless error
+ * arriving here is an uncaught/unhandled crash, not a benign network blip.
+ * A caught render exception is deterministic too — the error boundary reports
+ * it with an explicit `recoverable: false` for good measure.
+ */
+const defaultRecoverable = (error) => isServerError(error);
+const listeners = new Set();
+let current = null;
+let telemetry = null;
+/**
+ * Register the telemetry sink the fatal seam emits to. Called once from
+ * `main.tsx` with the live RUM adapter (no-op telemetry when RUM is disabled).
+ */
+export const setFatalErrorTelemetry = (sink) => {
+    telemetry = sink;
+};
+const toError = (error) => error instanceof Error ? error : new Error(messageOf(error));
+const messageOf = (error) => {
+    if (error instanceof Error)
+        return error.message || error.name;
+    if (typeof error === "string")
+        return error;
+    if (error &&
+        typeof error === "object" &&
+        "message" in error &&
+        typeof error.message === "string") {
+        return error.message;
+    }
+    return "An unexpected server error occurred.";
+};
+const newCorrelationId = () => {
+    if (typeof globalThis.crypto !== "undefined" &&
+        typeof globalThis.crypto.randomUUID === "function") {
+        return globalThis.crypto.randomUUID();
+    }
+    return `fatal-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+};
+/**
+ * Report a fatal, first-party error. Idempotent in spirit: the overlay shows
+ * the first fatal and stays until the user reloads, so repeated calls only
+ * refresh the recorded entry and re-notify (a no-op for an already-mounted
+ * overlay).
+ */
+export const reportFatalError = (error, options) => {
+    const fatal = {
+        error,
+        message: messageOf(error),
+        correlationId: newCorrelationId(),
+        at: Date.now(),
+        recoverable: options?.recoverable ?? defaultRecoverable(error),
+        stack: error instanceof Error ? error.stack : undefined,
+        componentStack: options?.componentStack,
+    };
+    current = fatal;
+    recordError(`Fatal: ${fatal.message} [${fatal.correlationId}]`);
+    // Single telemetry seam: emit the fatal through RUM (epic #658). Scrubbing
+    // of ids/tokens happens inside the RUM adapter.
+    telemetry?.recordError(toError(error), {
+        fatal: "true",
+        correlationId: fatal.correlationId,
+    });
+    for (const listener of listeners) {
+        listener(fatal);
+    }
+    return fatal;
+};
+/** Subscribe to fatal errors. Returns an unsubscribe function. */
+export const subscribeFatalError = (listener) => {
+    listeners.add(listener);
+    return () => {
+        listeners.delete(listener);
+    };
+};
+/** The most recent fatal error, if any — lets a late subscriber catch up. */
+export const getCurrentFatalError = () => current;
+/** Test-only: clear the in-memory fatal state, listeners, and telemetry sink. */
+export const __resetFatalError = () => {
+    current = null;
+    listeners.clear();
+    telemetry = null;
+};

package/dist/src/lib/filter-report.d.ts

@@ -0,0 +1,2 @@
+export declare function filterToggleReportHref(message: string): string;
+export declare function filterRunReportHref(message: string): string;

package/dist/src/lib/filter-report.js

@@ -0,0 +1,13 @@
+import { buildBugReportContext, buildGitHubIssueUrl } from "./bug-report";
+export function filterToggleReportHref(message) {
+    return buildGitHubIssueUrl(buildBugReportContext({
+        title: `Filter toggle: ${message}`,
+        errorMessage: message,
+    }));
+}
+export function filterRunReportHref(message) {
+    return buildGitHubIssueUrl(buildBugReportContext({
+        title: `Filter run now: ${message}`,
+        errorMessage: message,
+    }));
+}

package/dist/src/lib/flagged-criteria.d.ts

@@ -0,0 +1,36 @@
+/**
+ * What the Flagged view asks `listAllThreads` for, and what is left over.
+ *
+ * Every criterion the view offers — the category chip, the Unread and Has
+ * attachment chips, and the `from:` / `subject:` / `category:` / `is:unread` /
+ * `is:read` / `has:attachment` / `is:starred` tokens typed in the field — is a
+ * field on the ThreadMessage row, so all of them travel as query parameters. A
+ * criterion applied over the pages loaded so far is the defect this replaces: a
+ * starred collection is paged, so anything below the newest page was invisible
+ * to it (#308, #1128).
+ *
+ * `starred` is the view rather than a criterion: the request always carries it,
+ * which is what makes `is:starred` a carried token instead of residue.
+ *
+ * A chip beats a token where both set the same parameter — a control on screen
+ * beats text in a field — and the overruled token drops to the residue, where
+ * it matches nothing, which is the honest answer to a contradiction.
+ */
+import type { InboxFilterCriteria } from "./inbox-filters.js";
+import type { SearchToken } from "./search-tokens.js";
+import { type ThreadSearchTokenParamName, type ThreadSearchTokenParams } from "./thread-search-tokens.js";
+/**
+ * The token parameters `listAllThreads` carries, which is every parameter it
+ * takes. `from` and `subject` joined them once the operation grew a parameter
+ * for each field: its one free-text parameter matches both at once, so neither
+ * token could be asked for on its own and both were applied over the pages
+ * already fetched — a match below them never appeared (#1128).
+ */
+export declare const FLAGGED_TOKEN_PARAMS: readonly ThreadSearchTokenParamName[];
+export interface FlaggedCriteria {
+    /** What the request narrows by, chips and carried tokens together. */
+    criteria: ThreadSearchTokenParams;
+    /** The tokens no parameter carries; apply these over the returned rows. */
+    residual: SearchToken[];
+}
+export declare const flaggedCriteria: (chips: InboxFilterCriteria, tokens: readonly SearchToken[]) => FlaggedCriteria;

package/dist/src/lib/flagged-criteria.js

@@ -0,0 +1,22 @@
+import { inboxFilterParams } from "./inbox-filters.js";
+import { threadSearchTokens, } from "./thread-search-tokens.js";
+/**
+ * The token parameters `listAllThreads` carries, which is every parameter it
+ * takes. `from` and `subject` joined them once the operation grew a parameter
+ * for each field: its one free-text parameter matches both at once, so neither
+ * token could be asked for on its own and both were applied over the pages
+ * already fetched — a match below them never appeared (#1128).
+ */
+export const FLAGGED_TOKEN_PARAMS = [
+    "from",
+    "subject",
+    "category",
+    "unread",
+    "starred",
+    "attachments",
+];
+export const flaggedCriteria = (chips, tokens) => {
+    const chipParams = inboxFilterParams(chips);
+    const { params, residual } = threadSearchTokens(tokens, { ...chipParams, starred: true }, FLAGGED_TOKEN_PARAMS);
+    return { criteria: { ...params, ...chipParams }, residual };
+};

package/dist/src/lib/folder-failure.d.ts

@@ -0,0 +1,2 @@
+import type { RemitImapMailboxResponse } from "@remit/api-http-client/types.gen.ts";
+export declare const folderFailure: (mailbox: Pick<RemitImapMailboxResponse, "syncStatus" | "syncFailureReason">) => string | undefined;

package/dist/src/lib/folder-failure.js

@@ -0,0 +1,8 @@
+export const folderFailure = (mailbox) => {
+    if (mailbox.syncStatus !== "failed")
+        return undefined;
+    const reason = mailbox.syncFailureReason.trim();
+    if (reason.length === 0)
+        return "The last change to this folder failed.";
+    return `The mail server refused the last change: ${reason}`;
+};

package/dist/src/lib/folder-roles.d.ts

@@ -0,0 +1,33 @@
+import type { RemitImapCanonicalMailboxRole, RemitImapFolderAppointment } from "@remit/api-http-client/types.gen.ts";
+import { type MailboxPath } from "@remit/data-ports/mailbox-name";
+import type { NavMailboxRole } from "@remit/ui";
+/**
+ * RFC 032 exclusive-folder-appointment (#976): the sidebar, the move-to
+ * picker, and the per-role hooks all resolve a mailbox's role from the
+ * account's `folderAppointments` map — never by re-detecting it from the
+ * folder's name or IMAP flags. The map is server-computed (persisted choice,
+ * or a proposal for anything unfilled) and exclusive by construction: a role
+ * points at exactly one mailbox, so there is nothing left to dedupe or guess
+ * at client-side.
+ */
+/** `CanonicalMailboxRole` (PascalCase, wire) → kit `NavMailboxRole` (lowercase). */
+export declare const CANONICAL_TO_NAV_ROLE: Record<string, NavMailboxRole>;
+/** Kit `NavMailboxRole`/`FolderRole` (lowercase) → wire `CanonicalMailboxRole`. */
+export declare const NAV_ROLE_TO_CANONICAL: Record<NavMailboxRole, RemitImapCanonicalMailboxRole>;
+export declare const ROLE_PRIORITY: readonly NavMailboxRole[];
+/**
+ * Reverse the role→mailboxId appointment map into mailboxId→role, so a
+ * mailbox row can look up its own role in O(1). When a mailbox is appointed to
+ * more than one role, the highest-priority role wins for display purposes.
+ */
+export declare function buildMailboxRoleMap(appointments: readonly RemitImapFolderAppointment[]): Map<string, NavMailboxRole>;
+type Translator = (key: string, fallback: string) => string;
+/**
+ * Render-ready label: a trimmed `displayNameOverride` wins, else the
+ * canonical localized label for the appointed role, else the provider leaf.
+ */
+export declare function labelForMailbox(mailbox: MailboxPath & {
+    displayNameOverride?: string;
+}, role: NavMailboxRole | undefined, t?: Translator): string;
+export declare const shouldShowUnreadBadgeForRole: (role: NavMailboxRole | undefined) => boolean;
+export {};

package/dist/src/lib/folder-roles.js

@@ -0,0 +1,83 @@
+import { mailboxLeafName, } from "@remit/data-ports/mailbox-name";
+/**
+ * RFC 032 exclusive-folder-appointment (#976): the sidebar, the move-to
+ * picker, and the per-role hooks all resolve a mailbox's role from the
+ * account's `folderAppointments` map — never by re-detecting it from the
+ * folder's name or IMAP flags. The map is server-computed (persisted choice,
+ * or a proposal for anything unfilled) and exclusive by construction: a role
+ * points at exactly one mailbox, so there is nothing left to dedupe or guess
+ * at client-side.
+ */
+/** `CanonicalMailboxRole` (PascalCase, wire) → kit `NavMailboxRole` (lowercase). */
+export const CANONICAL_TO_NAV_ROLE = {
+    Inbox: "inbox",
+    Drafts: "drafts",
+    Sent: "sent",
+    Archive: "archive",
+    Junk: "junk",
+    Trash: "trash",
+    All: "all",
+    Flagged: "flagged",
+};
+/** Kit `NavMailboxRole`/`FolderRole` (lowercase) → wire `CanonicalMailboxRole`. */
+export const NAV_ROLE_TO_CANONICAL = {
+    inbox: "Inbox",
+    drafts: "Drafts",
+    sent: "Sent",
+    archive: "Archive",
+    junk: "Junk",
+    trash: "Trash",
+    all: "All",
+    flagged: "Flagged",
+};
+// Display/pin priority, matching the kit's own ROLE_ORDER (nav-sidebar.tsx).
+// Used to pick a single role when one mailbox is (unusually) appointed to more
+// than one — the RFC allows this, but a sidebar row shows one role — and to
+// order the move-to picker's system-folder rows.
+export const ROLE_PRIORITY = [
+    "inbox",
+    "flagged",
+    "drafts",
+    "sent",
+    "archive",
+    "all",
+    "junk",
+    "trash",
+];
+/**
+ * Reverse the role→mailboxId appointment map into mailboxId→role, so a
+ * mailbox row can look up its own role in O(1). When a mailbox is appointed to
+ * more than one role, the highest-priority role wins for display purposes.
+ */
+export function buildMailboxRoleMap(appointments) {
+    const byMailbox = new Map();
+    const sorted = [...appointments].sort((a, b) => ROLE_PRIORITY.indexOf(CANONICAL_TO_NAV_ROLE[a.role]) -
+        ROLE_PRIORITY.indexOf(CANONICAL_TO_NAV_ROLE[b.role]));
+    for (const appointment of sorted) {
+        if (!appointment.mailboxId)
+            continue;
+        if (byMailbox.has(appointment.mailboxId))
+            continue;
+        const role = CANONICAL_TO_NAV_ROLE[appointment.role];
+        if (role)
+            byMailbox.set(appointment.mailboxId, role);
+    }
+    return byMailbox;
+}
+/**
+ * Render-ready label: a trimmed `displayNameOverride` wins, else the
+ * canonical localized label for the appointed role, else the provider leaf.
+ */
+export function labelForMailbox(mailbox, role, t) {
+    const override = mailbox.displayNameOverride?.trim();
+    if (override)
+        return override;
+    const leaf = mailboxLeafName(mailbox);
+    if (!role || !t)
+        return leaf;
+    return t(`sidebar.${role}`, leaf);
+}
+// Roles where a user-action-oriented unread badge isn't useful: Sent/Drafts
+// weren't sent TO the user, and Trash is deleted mail (issue #195).
+const COUNTLESS_ROLES = new Set(["sent", "drafts", "trash"]);
+export const shouldShowUnreadBadgeForRole = (role) => role === undefined || !COUNTLESS_ROLES.has(role);

package/dist/src/lib/format.d.ts

@@ -0,0 +1,156 @@
+import { type FolderAppointmentSourceValue } from "@remit/data-ports/folder-role";
+/**
+ * Format a number according to user's locale.
+ */
+export declare const formatNumber: (value: number, options?: Intl.NumberFormatOptions) => string;
+/**
+ * Coerce any accepted date input into a Date. An all-digit string is treated as
+ * an epoch (the Postgres read path serializes int64 columns as numeric strings);
+ * any other string goes through the normal Date parser.
+ */
+export declare const toDate: (value: Date | string | number) => Date;
+/**
+ * Format a date according to user's locale. A missing or unparseable date
+ * renders as an empty string instead of throwing — display must never crash the
+ * view over one bad row.
+ */
+export declare const formatDate: (date: Date | string | number, options?: Intl.DateTimeFormatOptions) => string;
+/**
+ * Format date with common presets.
+ */
+export declare const formatDatePreset: (date: Date | string | number, preset: "short" | "medium" | "long" | "full" | "time" | "datetime") => string;
+/**
+ * Format relative time (e.g., "2 hours ago", "in 3 days").
+ */
+export declare const formatRelativeTime: (date: Date | string | number) => string;
+/**
+ * Format email date intelligently based on age.
+ * - Today: "10:42" (time only)
+ * - Yesterday: "Yesterday"
+ * - This week: "Tuesday" (day name)
+ * - Older: "Jan 17" (or "Jan 17, 2023" if different year)
+ */
+export declare const formatEmailDate: (date: Date | string | number) => string;
+/**
+ * Confirmation title for the move-to-Trash delete flow. Reflects that delete
+ * moves messages to Trash (not a permanent delete) and pluralizes on count.
+ * The count is always a concrete list of ids — every predicate delete ends on
+ * the wizard's review screen instead, which states what the predicate covers.
+ */
+export declare const formatDeleteToTrashTitle: (count: number) => string;
+export interface DeleteConfirmationCopy {
+    title: string;
+    description: string;
+    confirmLabel: string;
+}
+/**
+ * What the caller knows about the account's Trash. Two folder names, never one:
+ * the folder reader guessed and the folder that vanished are different facts.
+ * Both optional — a caller holding no open mailbox passes neither, and the copy
+ * drops the name clause rather than inventing one.
+ */
+export interface DeleteConfirmationContext {
+    /** The folder reader files this account's deletes in. */
+    trashFolderLabel?: string;
+    /** The folder the user appointed, now gone from the mail server. */
+    staleFolderLabel?: string;
+}
+/**
+ * What a delete will actually do to the selected mail.
+ *
+ * `unknown` is the state before the account's Trash appointment has resolved — a
+ * real state on a cold open, and the one the copy must not guess at, because
+ * guessing "move to Trash" over an expunge is the dishonesty this whole flow
+ * exists to remove.
+ *
+ * `noTrash` is a resolved answer of "none": the account appoints no Trash, so
+ * the server refuses the delete outright (#846) rather than moving anything.
+ * It is a different fact from "this row is not in Trash" and must never share
+ * an outcome with it — one promises a restore that can happen, the other a
+ * delete that will not.
+ *
+ * `unavailable` is the appointment failing to resolve at all. A read that
+ * cannot answer is not an answer: treating an errored `/config` as "no Trash
+ * here" reinstates the same lie on the failure path, where an expired session
+ * would collect "Move to Trash?" over an expunge. The delete is refused and the
+ * failure is stated instead.
+ *
+ * `staleTrash` is a resolved answer of "the folder you chose is gone" (#887).
+ * It is a repair rather than a first choice, and the copy says so, which a
+ * single `noTrash` member cannot — this function only ever sees the member.
+ *
+ * `unconfirmed` is a folder reader matched by name that nobody ever confirmed.
+ * Empty Trash refuses on it for the whole folder (D4); `deleteOutcomeFor`
+ * produces it too, for the narrower case of a row that is already inside that
+ * folder — deleting it expunges on the same name guess, and the guess is never
+ * enough to destroy mail (#876). Both surfaces derive it from the server's own
+ * 409, and the branch lives here so they word it identically.
+ */
+export type DeleteOutcome = "trash" | "permanent" | "noTrash" | "staleTrash" | "unconfirmed" | "unknown" | "unavailable";
+/** Where an account's Trash answer came from (`FolderAppointmentSource`). */
+export type TrashSource = FolderAppointmentSourceValue;
+/** One account's Trash, as `/config` resolved it. */
+export interface TrashResolution {
+    mailboxId: string | undefined;
+    source: TrashSource;
+    /** `Stale` only: the path the folder the user chose last had. */
+    staleFolderPath?: string;
+}
+/** A row about to be deleted, and the account whose Trash decides its fate. */
+export interface DeleteTarget {
+    accountId: string | undefined;
+    mailboxId: string;
+}
+export interface DeleteOutcomeInput {
+    targets: readonly DeleteTarget[];
+    /**
+     * Each account's Trash and where that answer came from. A key present is an
+     * answer, `source` and all — a key absent is an account nothing is known
+     * about yet.
+     */
+    trashByAccount: ReadonlyMap<string, TrashResolution>;
+    /**
+     * The appointments have actually arrived. Never `!isLoading`: React Query
+     * v5 leaves a paused offline query pending-but-not-fetching, which reads as
+     * loaded while `data` is still undefined.
+     */
+    hasAppointments: boolean;
+    /** The read for them failed. */
+    isError: boolean;
+}
+/**
+ * The outcome of deleting `targets`.
+ *
+ * One row bound for an expunge makes the whole delete unrecoverable, so a mixed
+ * set is permanent: the wording may overstate what is destroyed, never what is
+ * kept. One row on an account with no Trash refuses the whole call, so that
+ * outranks both. An expunge on a Trash nobody confirmed outranks a plain
+ * expunge in turn — the server refuses it (#876), so the dialog asks for the
+ * same confirmation up front rather than offering a confirm that 409s. Pure,
+ * so every branch — the failure ones above all — is testable without a DOM.
+ */
+export declare const deleteOutcomeFor: ({ targets, trashByAccount, hasAppointments, isError, }: DeleteOutcomeInput) => DeleteOutcome;
+/**
+ * The delete erases mail rather than filing it. Both outcomes a row already
+ * inside Trash produces say so — `unconfirmed` is only ever reached that way
+ * (#876) — and anything that reports what a delete did reads this rather than
+ * testing for `permanent`, which is how a run of expunged mail came to be
+ * announced as "moved to Trash".
+ */
+export declare const deleteExpunges: (outcome: DeleteOutcome) => boolean;
+/**
+ * The confirmation for a delete, worded for what the delete actually does.
+ * Deleting mail that already sits in Trash expunges it on the server and
+ * nothing survives that, so it is asked as a permanent delete — a dialog that
+ * says "Move to Trash" over an expunge collects an answer to a question the
+ * user was never asked.
+ *
+ * `noTrash`, `staleTrash`, `unconfirmed` and `unavailable` are not
+ * confirmations at all but refusals: nothing is deleted, and the label names
+ * the way out rather than the delete. The first three are answered in place by
+ * the appointment prompt — a link to Settings as the only remedy leaves the
+ * user to reassemble what they were doing. `unavailable` still routes to
+ * re-authentication, because an account read that fails is a session that ended
+ * under the reader far more often than it is anything else.
+ */
+export declare const deleteConfirmationCopy: (count: number, outcome: DeleteOutcome, context?: DeleteConfirmationContext) => DeleteConfirmationCopy;