@remit/web-client 0.0.325 → 0.0.327

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

@@ -0,0 +1,83 @@
+import type { ThreadOperationsSearchThreadsData } from "@remit/api-http-client/types.gen.ts";
+import { type BulkRunRequest } from "../components/mail/BulkRunProvider";
+import type { BulkActionProgress, BulkActionTarget, BulkRunStart, EscalatedAction } from "../lib/bulk-actions";
+/** The predicate a search-scoped run re-issues on every page — the same
+ *  filters the visible list is searching with, minus pagination/count knobs. */
+export type EscalationSearchQuery = Pick<NonNullable<ThreadOperationsSearchThreadsData["query"]>, "order" | "query" | "subject" | "from" | "unread" | "starred" | "attachments" | "category">;
+export type EscalationPhase = {
+    kind: "idle";
+} | {
+    kind: "counting";
+} | {
+    kind: "escalated";
+    total: number;
+};
+interface UseEscalatedActionsOptions {
+    mailboxId: string;
+    /** The mailbox in the user's words, for a commit refused while this runs. */
+    mailboxLabel?: string;
+    /** Owning account, forwarded to the unseen-count invalidation on completion. */
+    accountId?: string;
+    /** Disables escalation entirely (e.g. not searching). Resets any in-flight
+     *  phase back to idle. */
+    enabled: boolean;
+    /** Identifies the active predicate; escalation resets to idle whenever this
+     *  changes (a different search is a different question). */
+    predicateKey: string;
+    searchQuery: EscalationSearchQuery;
+    /**
+     * States how a run ended, for a user who is no longer looking at any screen
+     * that could show it. Handed to the run's owner rather than called here, so
+     * an ending that lands after this hook unmounted is still said (#112).
+     */
+    reportEnding?: BulkRunRequest["reportEnding"];
+}
+export interface UseEscalatedActionsResult {
+    phase: EscalationPhase;
+    /** Ask the server how many messages the predicate matches, and switch the
+     *  selection to that predicate once it answers. */
+    escalate: () => void;
+    /**
+     * Stop whatever this mailbox has running — its count, and the run when the
+     * run is its own. The request in flight is aborted and nothing further leaves
+     * (#113); a delete the server has already accepted still applies, so the
+     * batch on the wire is what a stop is worth. A no-op when nothing is running.
+     * Cancelling a count here never reaches a run in another mailbox: that run is
+     * not what this screen is offering to stop, and ending it would be silent.
+     * The only thing that ends a run in flight: leaving the selection, the
+     * wizard, the search or the mailbox does not.
+     */
+    stop: () => void;
+    /**
+     * Drop an escalated selection back to bounded without confirming anything.
+     * A run in flight owns the phase and holds it until it ends, so this is a
+     * no-op then — the selection the user is leaving and the run they started
+     * from it are two different things.
+     */
+    clear: () => void;
+    /** True while a chunked run (bounded->100 ids, or the escalated predicate)
+     *  over this mailbox is in flight, whichever screen started it. */
+    isRunning: boolean;
+    /** The action currently in flight, for status and progress wording. */
+    runningAction: EscalatedAction | undefined;
+    progress: BulkActionProgress | undefined;
+    /**
+     * Runs `action` in chunks. Pass `targets` for a materialized (bounded)
+     * selection; omit them to run against the escalated predicate (`phase` must
+     * be "escalated"). Each target names the account that owns it, so a
+     * selection spanning accounts is sent as one batch per account rather than
+     * as one batch the endpoint refuses whole (#872). Resolves once the run ends
+     * for any reason — cancelled, errored, or complete — with a
+     * `done`/`failedIds` outcome the caller reads to decide what is still
+     * outstanding, or with the refusal of a run that never started because
+     * another one is still going.
+     *
+     * The run itself belongs to `BulkRunProvider`, which outlives every screen
+     * that can show it: the caches, the refusal replay, the failure banner and
+     * the ending are its, so none of them are lost when the surface that started
+     * the run goes (#112).
+     */
+    runAction: (action: EscalatedAction, targets?: readonly BulkActionTarget[], claimEnding?: BulkRunRequest["claimEnding"]) => Promise<BulkRunStart>;
+}
+export declare const useEscalatedActions: ({ mailboxId, mailboxLabel, accountId, enabled, predicateKey, searchQuery, reportEnding, }: UseEscalatedActionsOptions) => UseEscalatedActionsResult;
+export {};

package/dist/src/hooks/useEscalatedActions.js

@@ -0,0 +1,175 @@
+import { messageBulkOperationsDeleteMessages, messageBulkOperationsMoveMessages, messageBulkOperationsUpdateFlags, threadOperationsSearchThreads, } from "@remit/api-http-client/sdk.gen.ts";
+import { useCallback, useEffect, useRef, useState } from "react";
+import { useBulkRun, } from "../components/mail/BulkRunProvider";
+import { useErrorBanners } from "../components/ui/ErrorBannerProvider";
+import { buildMutationErrorBanner } from "../components/ui/error-banners";
+/** Page size for the execution loop. Set to the write side's own 100-id cap so
+ *  an execution page IS a write chunk — no in-memory accumulation step between
+ *  reading ids and sending them. */
+const PAGE_SIZE = 100;
+export const useEscalatedActions = ({ mailboxId, mailboxLabel, accountId, enabled, predicateKey, searchQuery, reportEnding, }) => {
+    const [phase, setPhase] = useState({ kind: "idle" });
+    // The count's own signal, which is not the run's: leaving the search ends a
+    // count, and never a run (#112).
+    const countAbortRef = useRef(undefined);
+    const { run, start, stop: stopRun } = useBulkRun();
+    const { pushError } = useErrorBanners();
+    // The live run, when it is this mailbox's. A run is mail leaving one mailbox,
+    // so it reports on that mailbox's list — not on whichever list is on screen.
+    const activeRun = run?.mailboxId === mailboxId ? run : undefined;
+    const isRunning = activeRun !== undefined;
+    // Read by callbacks that must not close over a stale render's answer.
+    const isRunningRef = useRef(false);
+    isRunningRef.current = isRunning;
+    // A different search (or leaving search/desktop) makes any in-flight
+    // escalation meaningless — it would otherwise keep counting or offering to
+    // act on a predicate the visible list no longer reflects. The selection goes;
+    // a run already going does not. It pages the predicate it was started
+    // against and reports what it reached, wherever the list moved on to.
+    // biome-ignore lint/correctness/useExhaustiveDependencies: enabled/predicateKey are trigger-only — the reset itself reads neither.
+    useEffect(() => {
+        countAbortRef.current?.abort();
+        setPhase({ kind: "idle" });
+    }, [enabled, predicateKey]);
+    const searchQueryRef = useRef(searchQuery);
+    searchQueryRef.current = searchQuery;
+    const fetchPagesOf = useCallback((query) => async (continuationToken, signal) => {
+        const { data } = await threadOperationsSearchThreads({
+            path: { mailboxId },
+            query: { ...query, continuationToken, limit: PAGE_SIZE },
+            signal,
+            throwOnError: true,
+        });
+        return {
+            ids: (data.items ?? []).map((item) => item.messageId),
+            continuationToken: data.continuationToken,
+        };
+    }, [mailboxId]);
+    /**
+     * How many messages the predicate matches, straight from the server that
+     * resolves it (#509). One count-only request: `limit` is a page size and has
+     * no bearing on the answer, so nothing is paged to arrive at it.
+     */
+    const fetchMatchCount = useCallback(async (signal) => {
+        const { data } = await threadOperationsSearchThreads({
+            path: { mailboxId },
+            query: { ...searchQueryRef.current, count: true, results: false },
+            signal,
+            throwOnError: true,
+        });
+        if (data.count === undefined) {
+            throw new Error("the search returned no count for the selection");
+        }
+        return data.count;
+    }, [mailboxId]);
+    const applyBatchFor = useCallback((action) => async (ids, signal) => {
+        if (action.kind === "move") {
+            const { data } = await messageBulkOperationsMoveMessages({
+                body: {
+                    messageIds: ids,
+                    destinationMailboxId: action.destinationMailboxId,
+                },
+                signal,
+                throwOnError: true,
+            });
+            return data;
+        }
+        if (action.kind === "markRead") {
+            const { data } = await messageBulkOperationsUpdateFlags({
+                body: { messageIds: ids, isRead: true },
+                signal,
+                throwOnError: true,
+            });
+            return data;
+        }
+        const { data } = await messageBulkOperationsDeleteMessages({
+            body: { messageIds: ids },
+            signal,
+            throwOnError: true,
+        });
+        return data;
+    }, []);
+    const escalate = useCallback(() => {
+        const controller = new AbortController();
+        countAbortRef.current = controller;
+        setPhase({ kind: "counting" });
+        fetchMatchCount(controller.signal).then((total) => {
+            if (controller.signal.aborted) {
+                setPhase({ kind: "idle" });
+                return;
+            }
+            setPhase({ kind: "escalated", total });
+        }, (error) => {
+            // A stopped count rejects with its own abort. That is the press the
+            // user made, not a failure to report back to them.
+            if (controller.signal.aborted) {
+                setPhase({ kind: "idle" });
+                return;
+            }
+            pushError(buildMutationErrorBanner("Couldn't count matching messages", "The count didn't finish.", error));
+            setPhase({ kind: "idle" });
+        });
+    }, [fetchMatchCount, pushError]);
+    const stop = useCallback(() => {
+        countAbortRef.current?.abort();
+        if (isRunningRef.current)
+            stopRun(mailboxId);
+    }, [stopRun, mailboxId]);
+    const clear = useCallback(() => {
+        if (isRunningRef.current)
+            return;
+        countAbortRef.current?.abort();
+        setPhase({ kind: "idle" });
+    }, []);
+    const runAction = useCallback(async (action, targets, claimEnding) => {
+        // Read before the run clears the phase below, so a refusal can say how
+        // many messages the appointment's replay is about.
+        const matched = targets?.length ?? (phase.kind === "escalated" ? phase.total : 0);
+        // The predicate as it read when the run was confirmed. The run outlives
+        // the screen that started it, so reading the live query on every page
+        // would let a search typed afterwards redirect what is being deleted.
+        const source = targets !== undefined
+            ? { kind: "targets", targets }
+            : {
+                kind: "predicate",
+                fetchPage: fetchPagesOf(searchQueryRef.current),
+            };
+        const started = await start({
+            action,
+            mailboxId,
+            mailboxLabel,
+            accountId,
+            matched,
+            source,
+            applyBatch: applyBatchFor(action),
+            reportEnding,
+            claimEnding,
+        });
+        // The escalated selection was what the run was confirmed from, and the
+        // run has now happened to it. A refused commit leaves it standing: the
+        // selection is still the question, and stopping the other run is what
+        // makes it answerable.
+        if (started.kind === "ran")
+            setPhase({ kind: "idle" });
+        return started;
+    }, [
+        applyBatchFor,
+        fetchPagesOf,
+        phase,
+        mailboxId,
+        mailboxLabel,
+        accountId,
+        reportEnding,
+        start,
+    ]);
+    return {
+        phase,
+        escalate,
+        stop,
+        clear,
+        isRunning,
+        runningAction: activeRun?.action,
+        progress: activeRun?.progress,
+        runAction,
+    };
+};

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

@@ -0,0 +1,57 @@
+import type { RemitImapCreateFilterResponse } from "@remit/api-http-client/types.gen.ts";
+import { type OrganizeDraft, type OrganizeScope } from "../lib/organize/organize-model";
+/**
+ * The query key the filter list reads and both mutations invalidate on success.
+ * Extracted so create/delete invalidate exactly the key `useFilterList`
+ * subscribes to — a drift here would leave the settings list stale after a
+ * filter is created or deleted (the same contract `buildMailboxListKey` pins
+ * for trigger-sync).
+ */
+export declare const buildFilterListKey: (accountId: string) => [Pick<import("@remit/api-http-client").Options<import("@remit/api-http-client").FilterOperationsListFiltersData>, "query" | "body" | "headers" | "path" | "baseUrl"> & {
+    _id: string;
+    _infinite?: boolean;
+    tags?: ReadonlyArray<string>;
+}];
+/**
+ * List the account's standing filters (Standing + Temporary). Expired
+ * Temporary filters stay in the list — they are shown distinctly, never hidden
+ * (RFC 034 Decision 1.2).
+ */
+export declare const useFilterList: (accountId: string | undefined) => {
+    filters: import("@remit/api-http-client").RemitImapFilterResponse[];
+    isPending: boolean;
+    isError: boolean;
+    error: import("@remit/api-http-client").FilterOperationsListFiltersError | null;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<NoInfer<{
+        continuationToken?: import("@remit/api-http-client").String800;
+        items: Array<import("@remit/api-http-client").RemitImapFilterResponse>;
+    }>, import("@remit/api-http-client").FilterOperationsListFiltersError>>;
+};
+/**
+ * Create the standing (`"these and new mail like this"`) or temporary
+ * (`"until <date>"`) filter for an organize draft. The two one-time scopes
+ * never create a filter (RFC 034 recap) and are not handled here.
+ */
+export declare const useCreateFilter: (accountId: string | undefined) => {
+    createFilter: (draft: OrganizeDraft, scope: Extract<OrganizeScope, "standing" | "temporary">, name: string) => void;
+    createFilterAsync: (draft: OrganizeDraft, scope: Extract<OrganizeScope, "standing" | "temporary">, name: string) => Promise<RemitImapCreateFilterResponse | undefined>;
+    data: RemitImapCreateFilterResponse | undefined;
+    isPending: boolean;
+    isSuccess: boolean;
+    isError: boolean;
+    error: import("@remit/api-http-client").ApiError | import("@remit/api-http-client").ValidationError | null;
+    reset: () => void;
+};
+export declare const useDeleteFilter: (accountId: string | undefined) => {
+    deleteFilter: (filterId: string) => void;
+    isPending: boolean;
+    deletingFilterId: string | undefined;
+};
+export declare const useToggleFilter: (accountId: string | undefined) => {
+    toggleFilter: (filterId: string, enabled: boolean) => void;
+    retry: () => void;
+    togglingFilterId: string | undefined;
+    isError: boolean;
+    error: import("@remit/api-http-client").ApiError | null;
+    enabling: boolean;
+};

package/dist/src/hooks/useFilters.js

@@ -0,0 +1,147 @@
+import { filterDetailOperationsDeleteFilterMutation, filterDetailOperationsUpdateFilterMutation, filterOperationsCreateFilterMutation, filterOperationsListFiltersOptions, filterOperationsListFiltersQueryKey, } from "@remit/api-http-client/@tanstack/react-query.gen.ts";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import { useCallback } from "react";
+import { buildCreateFilterInput, } from "../lib/organize/organize-model";
+/**
+ * The query key the filter list reads and both mutations invalidate on success.
+ * Extracted so create/delete invalidate exactly the key `useFilterList`
+ * subscribes to — a drift here would leave the settings list stale after a
+ * filter is created or deleted (the same contract `buildMailboxListKey` pins
+ * for trigger-sync).
+ */
+export const buildFilterListKey = (accountId) => filterOperationsListFiltersQueryKey({ path: { accountId } });
+/**
+ * List the account's standing filters (Standing + Temporary). Expired
+ * Temporary filters stay in the list — they are shown distinctly, never hidden
+ * (RFC 034 Decision 1.2).
+ */
+export const useFilterList = (accountId) => {
+    const query = useQuery({
+        ...filterOperationsListFiltersOptions({
+            path: { accountId: accountId ?? "" },
+        }),
+        enabled: !!accountId,
+    });
+    return {
+        filters: query.data?.items ?? [],
+        isPending: query.isPending,
+        isError: query.isError,
+        error: query.error,
+        refetch: query.refetch,
+    };
+};
+/**
+ * Create the standing (`"these and new mail like this"`) or temporary
+ * (`"until <date>"`) filter for an organize draft. The two one-time scopes
+ * never create a filter (RFC 034 recap) and are not handled here.
+ */
+export const useCreateFilter = (accountId) => {
+    const queryClient = useQueryClient();
+    const mutation = useMutation({
+        ...filterOperationsCreateFilterMutation(),
+        onSuccess: () => {
+            if (!accountId)
+                return;
+            queryClient.invalidateQueries({
+                queryKey: buildFilterListKey(accountId),
+            });
+        },
+    });
+    const { mutate, mutateAsync } = mutation;
+    const createFilter = useCallback((draft, scope, name) => {
+        if (!accountId)
+            return;
+        mutate({
+            path: { accountId },
+            body: buildCreateFilterInput(draft, scope, name),
+        });
+    }, [accountId, mutate]);
+    /**
+     * The same create, resolved once the server has the filter, for work that has
+     * to follow it — the pass over the mail already in the mailbox. Chaining that
+     * to the request rather than to the surface is what keeps it running when the
+     * surface is closed while the create is still in flight.
+     *
+     * `undefined` means the create did not land. The failure itself is on
+     * `isError`, which is what the surface reports and retries from, so it is not
+     * raised a second time here.
+     */
+    const createFilterAsync = useCallback(async (draft, scope, name) => {
+        if (!accountId)
+            return undefined;
+        return mutateAsync({
+            path: { accountId },
+            body: buildCreateFilterInput(draft, scope, name),
+        }).then((created) => created, () => undefined);
+    }, [accountId, mutateAsync]);
+    return {
+        createFilter,
+        createFilterAsync,
+        data: mutation.data,
+        isPending: mutation.isPending,
+        isSuccess: mutation.isSuccess,
+        isError: mutation.isError,
+        error: mutation.error,
+        reset: mutation.reset,
+    };
+};
+export const useDeleteFilter = (accountId) => {
+    const queryClient = useQueryClient();
+    const mutation = useMutation({
+        ...filterDetailOperationsDeleteFilterMutation(),
+        onSuccess: () => {
+            if (!accountId)
+                return;
+            queryClient.invalidateQueries({
+                queryKey: buildFilterListKey(accountId),
+            });
+        },
+    });
+    const { mutate } = mutation;
+    const deleteFilter = useCallback((filterId) => {
+        if (!accountId)
+            return;
+        mutate({ path: { accountId, filterId } });
+    }, [accountId, mutate]);
+    return {
+        deleteFilter,
+        isPending: mutation.isPending,
+        deletingFilterId: mutation.isPending
+            ? mutation.variables?.path.filterId
+            : undefined,
+    };
+};
+export const useToggleFilter = (accountId) => {
+    const queryClient = useQueryClient();
+    const mutation = useMutation({
+        ...filterDetailOperationsUpdateFilterMutation(),
+        onSuccess: () => {
+            if (!accountId)
+                return;
+            queryClient.invalidateQueries({
+                queryKey: buildFilterListKey(accountId),
+            });
+        },
+    });
+    const { mutate, variables } = mutation;
+    const toggleFilter = useCallback((filterId, enabled) => {
+        if (!accountId)
+            return;
+        mutate({
+            path: { accountId, filterId },
+            body: { state: enabled ? "Active" : "Disabled" },
+        });
+    }, [accountId, mutate]);
+    const retry = useCallback(() => {
+        if (variables)
+            mutate(variables);
+    }, [mutate, variables]);
+    return {
+        toggleFilter,
+        retry,
+        togglingFilterId: mutation.isPending ? variables?.path.filterId : undefined,
+        isError: mutation.isError,
+        error: mutation.error,
+        enabling: variables?.body?.state === "Active",
+    };
+};

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

@@ -0,0 +1,6 @@
+/**
+ * `labelForMailbox` expects a positional `(key, fallback)` translator; i18next's
+ * `t` reads its second argument as an options object, which drops the fallback.
+ * Memoized so callers can hold it as a `useMemo` dependency.
+ */
+export declare const useFolderLabelTranslator: () => ((key: string, fallback: string) => string);

package/dist/src/hooks/useFolderLabelTranslator.js

@@ -0,0 +1,11 @@
+import { useCallback } from "react";
+import { useTranslation } from "react-i18next";
+/**
+ * `labelForMailbox` expects a positional `(key, fallback)` translator; i18next's
+ * `t` reads its second argument as an options object, which drops the fallback.
+ * Memoized so callers can hold it as a `useMemo` dependency.
+ */
+export const useFolderLabelTranslator = () => {
+    const { t } = useTranslation("mail", { useSuspense: false });
+    return useCallback((key, fallback) => t(key, { defaultValue: fallback }), [t]);
+};

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

@@ -0,0 +1,28 @@
+/**
+ * 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 declare const FOLLOW_FOCUS_DELAY_MS = 120;
+interface UseFollowFocusOpenOptions {
+    /**
+     * The row a keyboard command last moved the cursor onto, and `undefined`
+     * whenever the cursor last moved some other way — a click, a row taking DOM
+     * focus, a thread opening, the list reshuffling under a refetch.
+     */
+    keyboardFocusedMessageId: string | undefined;
+    /** The row already in the reading pane, so an open row does not reload. */
+    openMessageId: string | undefined;
+    /**
+     * Whether the cursor may open rows at all. Desktop-only: on the single-pane
+     * tiers the reading pane replaces the list, so following the cursor would
+     * throw the user off the list they are scanning. Also off while rows are
+     * selected, where the cursor is building a selection rather than reading.
+     */
+    enabled: boolean;
+    /** Opens a row in the reading pane. */
+    open: (messageId: string) => void;
+    delayMs?: number;
+}
+export declare const useFollowFocusOpen: ({ keyboardFocusedMessageId, openMessageId, enabled, open, delayMs, }: UseFollowFocusOpenOptions) => void;
+export {};

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;