@remit/web-client 0.0.324 → 0.0.326

package/dist/src/hooks/useFollowFocusOpen.js

@@ -0,0 +1,52 @@
+/**
+ * useFollowFocusOpen — the reading pane follows the keyboard cursor.
+ *
+ * Moving the cursor with j/k or the arrows loads the row it lands on, the way
+ * a desktop mail client does. Enter and a plain click keep opening exactly as
+ * they did; only a keyboard move drives this, so a click never opens twice and
+ * Tab walking into the list opens nothing.
+ *
+ * Two properties make it safe to run on every cursor move:
+ *
+ * - The load waits for the cursor to settle. Key repeat delivers a keydown
+ *   every few tens of milliseconds, so holding j down costs one request for the
+ *   row it stops on rather than one per row it passes.
+ * - Nothing here marks anything read. Read state is set by the dwell in
+ *   `useMarkAsRead` — three seconds on the open message — which a fly-past
+ *   never reaches and a deliberate open reaches unchanged.
+ */
+import { useEffect, useRef } from "react";
+/**
+ * How long the cursor must sit still before its row loads. Comfortably above
+ * the ~30ms of a repeating key, so a held key coalesces into a single load,
+ * and short enough that a single press reads as immediate.
+ */
+export const FOLLOW_FOCUS_DELAY_MS = 120;
+export const useFollowFocusOpen = ({ keyboardFocusedMessageId, openMessageId, enabled, open, delayMs = FOLLOW_FOCUS_DELAY_MS, }) => {
+    // Lists pass an inline opener, so its identity changes every render. Holding
+    // it in a ref keeps a re-render from re-arming — and therefore permanently
+    // deferring — the pending load.
+    const openRef = useRef(open);
+    openRef.current = open;
+    // The last cursor move made while following was off. Such a move is spent,
+    // not deferred: clearing a selection must not load whatever row the cursor
+    // happens to be sitting on, only the next move should.
+    const declinedRef = useRef(undefined);
+    useEffect(() => {
+        const messageId = keyboardFocusedMessageId;
+        if (!enabled) {
+            declinedRef.current = messageId;
+            return;
+        }
+        if (messageId === undefined)
+            return;
+        if (messageId === openMessageId)
+            return;
+        if (messageId === declinedRef.current) {
+            declinedRef.current = undefined;
+            return;
+        }
+        const timer = setTimeout(() => openRef.current(messageId), delayMs);
+        return () => clearTimeout(timer);
+    }, [enabled, keyboardFocusedMessageId, openMessageId, delayMs]);
+};

package/dist/src/hooks/useInitialSyncProgress.d.ts

@@ -0,0 +1,41 @@
+import type { RemitImapSyncPhase } from "@remit/api-http-client/types.gen.ts";
+/** Whether a phase reading means the server is mid-sync right now. */
+export declare function isSyncingPhase(phase: RemitImapSyncPhase | undefined): boolean;
+export declare const POLL_MS = 3000;
+/**
+ * How long an account may stay silent before the answer is given without it.
+ *
+ * An account that errors counts as answered; one that never responds does not,
+ * and without a bound a single hung account holds the brief on its skeleton for
+ * as long as the tab is open — it would never say "You're caught up". Two poll
+ * rounds is long enough that a slow-but-alive account still gets to speak.
+ */
+export declare const ANSWER_DEADLINE_MS: number;
+export interface InitialSyncProgress {
+    /** At least one account reports an in-progress sync phase. */
+    syncing: boolean;
+    /** Every enabled sync-status query has answered; until then nothing is known. */
+    resolved: boolean;
+    /** Messages downloaded so far, summed over the accounts still syncing. */
+    synced: number;
+    /** What those accounts hold in total; 0 while the server has not counted. */
+    total: number;
+}
+/**
+ * Whether any of these accounts is mid-sync, read from the account sync-status
+ * endpoint (`syncPhase`) — a real server-side state the IMAP worker writes, not
+ * a guess from message counts. The per-mailbox message numbers alongside it are
+ * approximate by the API's own definition (a UID-range estimate), so they are
+ * only ever shown as progress, never as a total the UI reasons about.
+ *
+ * `enabled` exists because the answer only matters when something is about to
+ * be claimed about an empty result; polling every account continuously to
+ * answer a question nobody asked is not worth the requests.
+ *
+ * The poll is a question with a last answer. Once every account has spoken and
+ * none is mid-sync, nothing further can change the reading, so the polling
+ * stops there rather than re-asking every three seconds for the rest of the
+ * session — the caught-up user was paying about 1,200 requests an hour per
+ * account for an answer that was already final. A new account set asks again.
+ */
+export declare function useInitialSyncProgress(accountIds: string[], enabled: boolean): InitialSyncProgress;

package/dist/src/hooks/useInitialSyncProgress.js

@@ -0,0 +1,111 @@
+import { syncOperationsGetSyncStatusOptions } from "@remit/api-http-client/@tanstack/react-query.gen.ts";
+import { useQueries } from "@tanstack/react-query";
+import { useEffect, useState } from "react";
+/**
+ * The phases the server writes while a sync round is actually running.
+ *
+ * A set of the in-progress values rather than "not complete": an account row
+ * written before the phase existed reads back `undefined`, and `idle` means no
+ * sync is running. Both would otherwise pin a list to "still syncing" forever,
+ * which is the same dishonesty as the bug in the other direction.
+ */
+const IN_PROGRESS = new Set([
+    "discovering_mailboxes",
+    "syncing_inbox",
+    "syncing_others",
+]);
+/** Whether a phase reading means the server is mid-sync right now. */
+export function isSyncingPhase(phase) {
+    return !!phase && IN_PROGRESS.has(phase);
+}
+export const POLL_MS = 3000;
+/**
+ * How long an account may stay silent before the answer is given without it.
+ *
+ * An account that errors counts as answered; one that never responds does not,
+ * and without a bound a single hung account holds the brief on its skeleton for
+ * as long as the tab is open — it would never say "You're caught up". Two poll
+ * rounds is long enough that a slow-but-alive account still gets to speak.
+ */
+export const ANSWER_DEADLINE_MS = POLL_MS * 2;
+const UNKNOWN = {
+    syncing: false,
+    resolved: false,
+    synced: 0,
+    total: 0,
+};
+/**
+ * Whether any of these accounts is mid-sync, read from the account sync-status
+ * endpoint (`syncPhase`) — a real server-side state the IMAP worker writes, not
+ * a guess from message counts. The per-mailbox message numbers alongside it are
+ * approximate by the API's own definition (a UID-range estimate), so they are
+ * only ever shown as progress, never as a total the UI reasons about.
+ *
+ * `enabled` exists because the answer only matters when something is about to
+ * be claimed about an empty result; polling every account continuously to
+ * answer a question nobody asked is not worth the requests.
+ *
+ * The poll is a question with a last answer. Once every account has spoken and
+ * none is mid-sync, nothing further can change the reading, so the polling
+ * stops there rather than re-asking every three seconds for the rest of the
+ * session — the caught-up user was paying about 1,200 requests an hour per
+ * account for an answer that was already final. A new account set asks again.
+ */
+export function useInitialSyncProgress(accountIds, enabled) {
+    const accountKey = accountIds.join(",");
+    const [settled, setSettled] = useState(false);
+    const [deadlinePassed, setDeadlinePassed] = useState(false);
+    // A different account set is a different question: it gets its own answer,
+    // its own deadline, and a poll that runs again until it has one.
+    // biome-ignore lint/correctness/useExhaustiveDependencies: accountKey/enabled are trigger-only — the reset is unconditional, not a value read from either.
+    useEffect(() => {
+        setSettled(false);
+        setDeadlinePassed(false);
+    }, [accountKey, enabled]);
+    // biome-ignore lint/correctness/useExhaustiveDependencies: accountKey restarts the deadline for a new question rather than being read inside it.
+    useEffect(() => {
+        if (!enabled)
+            return;
+        const timer = setTimeout(() => setDeadlinePassed(true), ANSWER_DEADLINE_MS);
+        return () => clearTimeout(timer);
+    }, [accountKey, enabled]);
+    const queries = useQueries({
+        queries: accountIds.map((accountId) => ({
+            ...syncOperationsGetSyncStatusOptions({ path: { accountId } }),
+            // Disabling keeps the cached answer and its success/error status; it
+            // only stops the interval.
+            enabled: enabled && !settled,
+            refetchInterval: POLL_MS,
+            // A failed sync-status read is not the account failing — it must not
+            // raise the global fatal overlay over a question about an empty list.
+            meta: { softError: true },
+        })),
+    });
+    // A query that errored still counts as answered: the caller's fallback is the
+    // same either way, and one unreachable account must not hold the whole list
+    // in limbo. One that never answers at all is covered by the deadline instead.
+    const answered = queries.every((q) => q.isSuccess || q.isError);
+    const resolved = queries.length === 0 || answered || deadlinePassed;
+    let syncing = false;
+    let synced = 0;
+    let total = 0;
+    for (const query of queries) {
+        if (!isSyncingPhase(query.data?.syncPhase))
+            continue;
+        syncing = true;
+        for (const mailbox of query.data?.mailboxes ?? []) {
+            synced += mailbox.messagesSynced;
+            total += mailbox.messagesTotal;
+        }
+    }
+    const final = enabled && resolved && !syncing;
+    useEffect(() => {
+        if (final)
+            setSettled(true);
+    }, [final]);
+    if (!enabled)
+        return UNKNOWN;
+    if (!resolved)
+        return UNKNOWN;
+    return { syncing, resolved: true, synced, total };
+}

package/dist/src/hooks/useInlineImages.d.ts

@@ -0,0 +1,16 @@
+import type { RemitImapOutboxAttachmentResponse } from "@remit/api-http-client/types.gen.ts";
+import type { InlineImagePlacement, InlineImages } from "@remit/ui/rich-text";
+import type { PushErrorInput } from "../components/ui/error-banners";
+import type { StoredContent } from "../lib/compose-attachment-controller";
+interface UseInlineImagesOptions {
+    attach: (files: File[], placement?: InlineImagePlacement) => Promise<void>;
+    owns: (contentId: string) => boolean;
+    isLoaded: () => boolean;
+    storedContent: (contentId: string) => StoredContent | null;
+    refreshLinks: () => Promise<void>;
+    onRemoved: (listener: (contentId: string) => void) => () => void;
+    draftAttachments: readonly RemitImapOutboxAttachmentResponse[];
+    pushError: (input: PushErrorInput) => string;
+}
+export declare const useInlineImages: (options: UseInlineImagesOptions) => InlineImages;
+export {};

package/dist/src/hooks/useInlineImages.js

@@ -0,0 +1,52 @@
+import { useMemo, useRef } from "react";
+import { useAuthProvider } from "../auth/provider";
+import { attachmentFailureContent, extractAttachmentFailureDetail, extractAttachmentFailureReason, fetchAttachment, } from "../lib/attachment-download";
+export const useInlineImages = (options) => {
+    const { getToken } = useAuthProvider();
+    const latest = useRef({ ...options, getToken });
+    latest.current = { ...options, getToken };
+    return useMemo(() => {
+        const beforeLoad = (contentId) => {
+            const current = latest.current;
+            if (current.isLoaded())
+                return null;
+            return (current.draftAttachments.find((attachment) => attachment.contentId === contentId) ?? null);
+        };
+        const stored = (contentId) => latest.current.storedContent(contentId) ?? beforeLoad(contentId);
+        const fetchStored = (content) => fetchAttachment(content.contentUrl, latest.current.getToken).then((blob) => URL.createObjectURL(new Blob([blob], { type: content.contentType })));
+        const fetchRenewed = (contentId) => latest.current.refreshLinks().then(() => {
+            const renewed = stored(contentId);
+            if (!renewed) {
+                throw new Error("the file is no longer on this draft");
+            }
+            return fetchStored(renewed);
+        });
+        return {
+            attach: (files, placement) => {
+                void latest.current.attach(files, placement);
+            },
+            owns: (contentId) => latest.current.owns(contentId) || beforeLoad(contentId) !== null,
+            onRemoved: (listener) => latest.current.onRemoved(listener),
+            resolve: (contentId) => {
+                const content = stored(contentId);
+                if (!content)
+                    return Promise.resolve(null);
+                return fetchStored(content)
+                    .catch((error) => {
+                    if (extractAttachmentFailureReason(error) !== "link-expired") {
+                        throw error;
+                    }
+                    return fetchRenewed(contentId);
+                })
+                    .catch((error) => {
+                    const reason = extractAttachmentFailureReason(error);
+                    latest.current.pushError({
+                        ...attachmentFailureContent(reason, content.filename, extractAttachmentFailureDetail(error)),
+                        error: reason === "generic" ? error : undefined,
+                    });
+                    return null;
+                });
+            },
+        };
+    }, []);
+};

package/dist/src/hooks/useIntelligenceCalendar.d.ts

@@ -0,0 +1,20 @@
+/**
+ * The calendar half of the intelligence panel for the open message.
+ *
+ * The invitation, the day it lands on and the answers all come from the server:
+ * the suggestions the message produced, the events already on that day, and the
+ * busy time merged across every calendar. What is held here is only what the
+ * reader is in the middle of — the half-hours ticked, whether the offer is open,
+ * which answer is on its way and why the last one was refused — and none of it
+ * outlives the message it is about.
+ */
+import type { RemitImapThreadMessageResponse } from "@remit/api-http-client/types.gen.ts";
+import type { IntelligenceCalendarSurface, IntelligenceTabId } from "@remit/ui";
+import type { ReplyWithText } from "../components/compose/reply-with-times";
+import { type OpenThreadTarget } from "../routing";
+export interface IntelligenceCalendar {
+    surface: IntelligenceCalendarSurface;
+    tab: IntelligenceTabId;
+    onTabChange: (tab: IntelligenceTabId) => void;
+}
+export declare function useIntelligenceCalendar(thread: RemitImapThreadMessageResponse, replyWithText?: ReplyWithText, openThread?: (target: OpenThreadTarget) => void): IntelligenceCalendar;

package/dist/src/hooks/useIntelligenceCalendar.js

@@ -0,0 +1,230 @@
+import { CalendarAnswerOvertaken } from "@remit/domain-enums";
+import { useEffect, useMemo, useRef, useState } from "react";
+import { calendarUnavailable, calendarWriteGate, } from "../components/calendar/CalendarUnavailable";
+import { formatDayLabel, formatInstantClock } from "../lib/calendar-format";
+import { calendarReportHref } from "../lib/calendar-report";
+import { clashesOver, inviteStanding, isFromInvitation, slotOffersOn, slotsAsText, suggestionDate, suggestionWhen, toCalendarInvite, toEventSuggestion, } from "../lib/calendar-suggestion";
+import { useChangeSuggestionOnCalendar, useOpenEventOnCalendar, } from "../routing";
+import { calendarWindowOfDays, deviceTimeZone, isDrawnInstance, readCalendarInstanceId, toCalendarEventData, useCalendarEventWindow, useCalendarFreeBusyWeeks, useCalendarSuggestionAnswers, useCalendars, useMessageCalendarSuggestions, } from "./calendar";
+const fresh = (messageId) => ({
+    messageId,
+    tab: undefined,
+    offering: false,
+    picked: [],
+    answering: "",
+    failure: { suggestionId: "", text: "" },
+});
+/** Pending cards first, then the latest revision, so the card answers the newest ask. */
+const byUrgency = (a, b) => {
+    const pending = Number(b.state === "Pending") - Number(a.state === "Pending");
+    return pending !== 0 ? pending : b.sequence - a.sequence;
+};
+const refusal = (what, answer) => answer.kind === "refused"
+    ? `Couldn't ${what}: ${answer.message} Try again, or answer from your calendar app.`
+    : "";
+export function useIntelligenceCalendar(thread, replyWithText, openThread) {
+    const messageId = thread.messageId;
+    const { suggestions, isLoading, error } = useMessageCalendarSuggestions(messageId);
+    const calendarsRead = useCalendars();
+    const { calendars, defaultCalendarId, colorByCalendarId, timeZoneByCalendarId, } = calendarsRead;
+    const gate = calendarWriteGate(calendarsRead);
+    const answers = useCalendarSuggestionAnswers();
+    const openEvent = useOpenEventOnCalendar();
+    const changeOnCalendar = useChangeSuggestionOnCalendar();
+    const [held, setHeld] = useState(() => fresh(messageId));
+    const working = held.messageId === messageId ? held : fresh(messageId);
+    const onScreen = useRef(messageId);
+    onScreen.current = messageId;
+    // An answer can come back after the reader has moved on, and what it says
+    // is about the message it was given for, not the one now open.
+    const update = (change) => {
+        if (onScreen.current !== messageId)
+            return;
+        setHeld((prev) => ({
+            ...(prev.messageId === messageId ? prev : fresh(messageId)),
+            ...change,
+        }));
+    };
+    const invitation = useMemo(() => suggestions
+        .filter(isFromInvitation)
+        .filter((suggestion) => inviteStanding(suggestion) !== undefined)
+        .sort(byUrgency)[0], [suggestions]);
+    const readings = suggestions.filter((suggestion) => suggestion !== invitation && suggestion.state === "Pending");
+    const anchor = invitation ?? readings[0];
+    const date = anchor ? suggestionDate(anchor) : "";
+    const dayWindow = calendarWindowOfDays(date === "" ? "1970-01-01" : date, 1);
+    const dayEvents = useCalendarEventWindow({
+        ...dayWindow,
+        calendarIds: [],
+        enabled: date !== "",
+    });
+    const freeBusy = useCalendarFreeBusyWeeks(date === "" ? [] : [dayWindow]);
+    const context = {
+        threadId: thread.threadId,
+        threadSubject: thread.subject ?? "",
+        calendarId: defaultCalendarId,
+    };
+    const senderName = thread.fromName ?? thread.fromEmail ?? "";
+    const reportHref = calendarReportHref(working.failure.text || "the invitations in a message could not be read");
+    const addBlocked = calendarUnavailable(gate, reportHref);
+    const answer = (suggestionId, what, request) => {
+        update({ answering: suggestionId, failure: { suggestionId, text: "" } });
+        void request().then((result) => update({
+            answering: "",
+            failure: { suggestionId, text: refusal(what, result) },
+        }));
+    };
+    const invitationId = invitation?.suggestionId ?? "";
+    const inviteFailure = working.failure.suggestionId === invitationId ? working.failure.text : "";
+    const otherFailure = working.failure.suggestionId === invitationId ? "" : working.failure.text;
+    const standing = invitation ? inviteStanding(invitation) : undefined;
+    const invite = invitation && standing
+        ? {
+            invite: toCalendarInvite(invitation, standing.state, {
+                ...context,
+                senderName,
+            }),
+            whenText: suggestionWhen(invitation),
+            calendarName: calendars.find((calendar) => calendar.id === defaultCalendarId)
+                ?.name ?? "Calendar",
+            color: colorByCalendarId[defaultCalendarId] ?? "cal-1",
+            clashes: standing.state === "pending"
+                ? clashesOver({ start: invitation.dtStart, end: invitation.dtEnd }, freeBusy.spans)
+                : [],
+            rsvp: standing.rsvp,
+            busy: working.answering === invitation.suggestionId,
+            failure: inviteFailure,
+            reportHref,
+            addBlocked,
+            sender: senderName,
+        }
+        : undefined;
+    const slots = date === "" ? [] : slotOffersOn(date, freeBusy.spans);
+    const day = dayEvents.instances
+        .filter(isDrawnInstance)
+        .filter((instance) => !instance.allDay)
+        .sort((a, b) => a.start.localeCompare(b.start))
+        .map((instance) => {
+        const event = toCalendarEventData(instance, timeZoneByCalendarId[instance.calendarId] ?? "", deviceTimeZone());
+        return {
+            event,
+            timeText: formatInstantClock(instance.start),
+            color: colorByCalendarId[instance.calendarId] ?? "cal-1",
+        };
+    });
+    const deck = readings.map((suggestion) => ({
+        suggestion: toEventSuggestion(suggestion, {
+            ...context,
+            sender: senderName,
+        }),
+        whenText: suggestionWhen(suggestion),
+    }));
+    const readFailure = error === null
+        ? ""
+        : "Couldn't read the invitations in this message. Reopen it to try again.";
+    const cancellation = invitation?.method === "Cancel";
+    const changeFirst = (suggestionId) => {
+        const suggestion = suggestions.find((candidate) => candidate.suggestionId === suggestionId);
+        if (suggestion)
+            changeOnCalendar(suggestionDate(suggestion), suggestionId);
+    };
+    const unplaced = (suggestionId) => {
+        const suggestion = suggestions.find((candidate) => candidate.suggestionId === suggestionId);
+        return (suggestion?.zoneCertainty === "Ambiguous" &&
+            suggestion.method !== "Cancel");
+    };
+    const pickedText = date === "" ? "" : slotsAsText(date, slots, working.picked);
+    const overtaken = invitation !== undefined &&
+        invitation.answerOvertakenBy !== CalendarAnswerOvertaken.None;
+    const actions = {
+        onAddInvite: () => {
+            if (unplaced(invitationId)) {
+                changeFirst(invitationId);
+                return;
+            }
+            answer(invitationId, "add this to your calendar", () => answers.accept(invitationId, defaultCalendarId));
+        },
+        onTentativeInvite: cancellation
+            ? undefined
+            : () => answer(invitationId, "add this as a maybe", () => answers.tentative(invitationId, defaultCalendarId)),
+        onDeclineInvite: () => answer(invitationId, "decline this", () => answers.decline(invitationId)),
+        onMuteInvite: () => answer(invitationId, "stop these invitations", () => answers.dismiss(invitationId, true)),
+        onRemoveInvite: cancellation
+            ? () => answer(invitationId, "take this off your calendar", () => answers.accept(invitationId, defaultCalendarId))
+            : undefined,
+        onReopenInvite: cancellation
+            ? () => answer(invitationId, "keep this on your calendar", () => answers.dismiss(invitationId, false))
+            : overtaken
+                ? undefined
+                : () => answer(invitationId, "take this answer back", () => answers.reopen(invitationId)),
+        onOpenNewerInvite: openThread && invitation && invitation.supersededByThreadId !== ""
+            ? () => openThread({
+                threadId: invitation.supersededByThreadId,
+                messageId: invitation.supersededByMessageId,
+            })
+            : undefined,
+        onOfferOtherTimes: () => update({ offering: true }),
+        onToggleSlot: (slot) => update({
+            picked: working.picked.includes(slot.startTime)
+                ? working.picked.filter((start) => start !== slot.startTime)
+                : [...working.picked, slot.startTime],
+        }),
+        onReplyWithSlots: replyWithText
+            ? () => replyWithText({ threadId: thread.threadId, messageId }, pickedText)
+            : undefined,
+        onAddSuggestion: (suggestionId) => {
+            if (unplaced(suggestionId)) {
+                changeFirst(suggestionId);
+                return;
+            }
+            answer(suggestionId, "add this to your calendar", () => answers.accept(suggestionId, defaultCalendarId));
+        },
+        onReviewSuggestion: readings[0]?.method === "Cancel" ? undefined : changeFirst,
+        onDismissSuggestion: (suggestionId) => answer(suggestionId, "dismiss this", () => answers.dismiss(suggestionId, false)),
+        onSelectEvent: (eventId) => {
+            const { calendarObjectId, recurrenceId } = readCalendarInstanceId(eventId);
+            openEvent(date, calendarObjectId, recurrenceId);
+        },
+    };
+    const aboutTime = invite !== undefined || deck.length > 0 || error !== null;
+    const latched = working.tab !== undefined;
+    // The tab is decided once, when the message's suggestions have been read,
+    // and then held: answering the last card must not pull the tab out from
+    // under the reader, and a read still in flight must not decide it.
+    useEffect(() => {
+        if (isLoading || latched)
+            return;
+        setHeld((prev) => prev.messageId === messageId && prev.tab !== undefined
+            ? prev
+            : {
+                ...(prev.messageId === messageId ? prev : fresh(messageId)),
+                tab: aboutTime ? "calendar" : "sender",
+            });
+    }, [isLoading, latched, aboutTime, messageId]);
+    return {
+        surface: {
+            data: {
+                invite,
+                prose: working.offering && date !== ""
+                    ? {
+                        dayLabel: formatDayLabel(date),
+                        proposals: [],
+                        slots,
+                        picked: working.picked,
+                    }
+                    : undefined,
+                suggestions: deck,
+                day,
+                dayLabel: date === "" ? "" : formatDayLabel(date),
+                suggestionsBusy: working.answering !== "" && !invite?.busy,
+                failure: readFailure,
+                suggestionsFailure: otherFailure,
+                reportHref,
+                addBlocked,
+            },
+            actions,
+        },
+        tab: working.tab ?? "sender",
+        onTabChange: (tab) => update({ tab }),
+    };
+}

package/dist/src/hooks/useIntelligenceData.d.ts

@@ -0,0 +1,58 @@
+import type { RemitImapAddressResponse, RemitImapThreadMessageResponse } from "@remit/api-http-client/types.gen.ts";
+import type { AuthenticityIntel, IntelligenceData, SenderIntel } from "@remit/ui";
+/**
+ * A sender address we cannot read: empty, missing the `@`, or whose domain
+ * part carries no dot (catches placeholders like `missing_domain` and other
+ * junk). Structural — never a hard-coded literal.
+ */
+export declare function isSenderAddressUnverifiable(fromEmail: string | undefined): boolean;
+/**
+ * Build category intel from the thread message and address lookup.
+ *
+ * The row's category is a string the API chose, so it is narrowed rather than
+ * asserted: a value this build has no entry for — a category a newer server
+ * classifies into — resolves to `uncategorized`, which is the taxonomy's own
+ * name for "no classification this client can act on" and renders a readable
+ * neutral chip. Asserting instead would leave the chip with no tone at all.
+ */
+export declare function buildCategoryIntel(thread: RemitImapThreadMessageResponse, address: RemitImapAddressResponse | undefined): IntelligenceData["category"];
+/**
+ * Build sender intel from the thread message and address lookup.
+ *
+ * Engagement counters (`inboundCount`/`replyCount`) are passed through
+ * as-is from the address response. When absent (`undefined`) they remain
+ * `undefined` so the `SenderCard` engagement clause is suppressed rather
+ * than rendering a misleading "0 received" next to an earned trust badge.
+ */
+export declare function buildSenderIntel(thread: RemitImapThreadMessageResponse, address: RemitImapAddressResponse | undefined): SenderIntel;
+/** Build authenticity intel from the thread message's authenticity field. */
+export declare function buildAuthenticityIntel(thread: RemitImapThreadMessageResponse): AuthenticityIntel;
+export interface UseIntelligenceDataResult {
+    data: IntelligenceData | null;
+    /**
+     * True when the address lookup failed with a fatal first-party 5xx. The panel
+     * must not silently render the sender's flags (VIP/muted/blocked) as absent —
+     * that misrepresents the sender's real state. Escalation covers it.
+     */
+    addressErrorIsFatal: boolean;
+    /**
+     * Address id for the sender — needed for PATCH /addresses/{id} mutations.
+     * `undefined` until the lookup resolves the row for exactly this address;
+     * quick actions that PATCH it must stay unwired until then.
+     */
+    addressId: string | undefined;
+    /**
+     * Raw address response for the sender — forwarded to the quick-action
+     * mutation hooks so they can optimistically patch the cache.
+     */
+    address: RemitImapAddressResponse | undefined;
+}
+/**
+ * Maps a `RemitImapThreadMessageResponse` into `IntelligenceData` for the
+ * `IntelligencePanel` component. Two data sources:
+ *
+ * 1. The thread row itself (already loaded) → sender basics, trust, authenticity, category.
+ * 2. `GET /addresses/search?q=<email>` → address flags (VIP/muted/blocked/etc.)
+ *    and first-seen timestamp. One round-trip per unique sender.
+ */
+export declare function useIntelligenceData(thread: RemitImapThreadMessageResponse | null | undefined): UseIntelligenceDataResult;