@remit/web-client 0.0.324 → 0.0.326

package/dist/src/hooks/calendar/window.js

@@ -0,0 +1,135 @@
+const pad = (value) => String(value).padStart(2, "0");
+const civil = (instant) => `${instant.getUTCFullYear()}-${pad(instant.getUTCMonth() + 1)}-${pad(instant.getUTCDate())}`;
+const formatOffset = (minutes) => {
+    const sign = minutes < 0 ? "-" : "+";
+    const size = Math.abs(minutes);
+    return `${sign}${pad(Math.floor(size / 60))}:${pad(size % 60)}`;
+};
+/** A clock time on a civil date, carrying the offset the device is on then. */
+export function isoAt(date, time) {
+    const local = new Date(`${date}T${time}:00`);
+    return `${date}T${time}:00${formatOffset(-local.getTimezoneOffset())}`;
+}
+const zoneReaders = new Map();
+/**
+ * A zone nothing can resolve is not worth throwing over: the device's own clock
+ * is the honest fallback, and the resource records how its start was zoned.
+ */
+function zoneReader(timeZone) {
+    if (zoneReaders.has(timeZone))
+        return zoneReaders.get(timeZone);
+    let reader;
+    try {
+        reader = new Intl.DateTimeFormat("en-US", {
+            timeZone,
+            hourCycle: "h23",
+            year: "numeric",
+            month: "2-digit",
+            day: "2-digit",
+            hour: "2-digit",
+            minute: "2-digit",
+            second: "2-digit",
+        });
+    }
+    catch {
+        reader = undefined;
+    }
+    zoneReaders.set(timeZone, reader);
+    return reader;
+}
+/** How far ahead of UTC a zone is at one instant, in minutes. */
+function zoneOffsetAt(timeZone, instant) {
+    const reader = zoneReader(timeZone);
+    if (!reader)
+        return Number.NaN;
+    const parts = reader.formatToParts(new Date(instant));
+    const read = (type) => Number(parts.find((part) => part.type === type)?.value);
+    const hour = read("hour") % 24;
+    const reading = Date.UTC(read("year"), read("month") - 1, read("day"), hour, read("minute"), read("second"));
+    return (reading - instant) / 60_000;
+}
+/**
+ * A clock time on a civil date, carrying the offset **that zone** is on then.
+ *
+ * The device's own offset is the wrong one for a calendar anchored elsewhere: a
+ * 10:00 Amsterdam meeting rewritten with a New York offset is a 16:00 Amsterdam
+ * meeting, and nothing on screen says it moved.
+ *
+ * The offset is read twice because reading it needs an instant and the instant
+ * needs the offset. The first pass is off only inside a DST transition, and the
+ * second pass — taken at the instant the first one implies — settles it.
+ */
+export function isoAtInZone(date, time, timeZone) {
+    // A collection naming no zone reads as UTC at both ends, and UTC is the one
+    // zone the canonical IANA list holds no name for — so it is handled here
+    // rather than asked about.
+    if (timeZone === "")
+        return `${date}T${time}:00+00:00`;
+    const asIfUtc = Date.parse(`${date}T${time}:00Z`);
+    const first = zoneOffsetAt(timeZone, asIfUtc);
+    if (Number.isNaN(first))
+        return isoAt(date, time);
+    const settled = zoneOffsetAt(timeZone, asIfUtc - first * 60_000);
+    return `${date}T${time}:00${formatOffset(Number.isNaN(settled) ? first : settled)}`;
+}
+/**
+ * An instant written again as the wall time it reads as on a zone's clock.
+ *
+ * The listing serves each occurrence on its collection's clock, and the grid,
+ * the strip and the form all read the digits. Drawing those digits as they came
+ * puts a Tokyo calendar's 08:00 at 08:00 in New York; re-reading the instant on
+ * the device's clock is what puts it at 18:00 the evening before.
+ */
+export function isoOnClock(iso, timeZone) {
+    const instant = Date.parse(iso);
+    const zoned = zoneOffsetAt(timeZone, instant);
+    const offset = Number.isNaN(zoned)
+        ? -new Date(instant).getTimezoneOffset()
+        : zoned;
+    const wall = new Date(instant + offset * 60_000);
+    return `${civil(wall)}T${pad(wall.getUTCHours())}:${pad(wall.getUTCMinutes())}:${pad(wall.getUTCSeconds())}${formatOffset(offset)}`;
+}
+/** Midnight on a civil date, carrying the offset the device is on that day. */
+export const startOfDay = (date) => isoAt(date, "00:00");
+export function addDays(date, days) {
+    const [year, month, day] = date.split("-").map(Number);
+    return civil(new Date(Date.UTC(year, month - 1, day + days)));
+}
+/** The Monday of the week a day falls in — the day the grid starts weeks on. */
+function weekStart(date) {
+    const [year, month, day] = date.split("-").map(Number);
+    const instant = new Date(Date.UTC(year, month - 1, day));
+    return addDays(date, -((instant.getUTCDay() + 6) % 7));
+}
+function bounds(view, date) {
+    const [year, month] = date.split("-").map(Number);
+    if (view === "year")
+        return [`${year}-01-01`, `${year + 1}-01-01`];
+    if (view === "month") {
+        const first = `${year}-${pad(month)}-01`;
+        const next = month === 12 ? `${year + 1}-01-01` : `${year}-${pad(month + 1)}-01`;
+        return [weekStart(first), addDays(weekStart(addDays(next, -1)), 7)];
+    }
+    if (view === "day")
+        return [date, addDays(date, 1)];
+    const start = weekStart(date);
+    return [start, addDays(start, 7)];
+}
+/**
+ * The window a view over a day covers.
+ *
+ * The week is the unit every surface reads in. A grid asks for the one week it
+ * draws; the strip holds many days and asks for each of their weeks
+ * (`weekWindowsOver`), because a single read may not cover more than a year and
+ * a range that grows as the reader scrolls would eventually become one. Both
+ * therefore key on the same entries, so dropping into the grid and coming back
+ * out to the strip fetches nothing either of them already holds.
+ */
+export function calendarWindow(view, date) {
+    const [from, to] = bounds(view, date);
+    return { from: startOfDay(from), to: startOfDay(to) };
+}
+/** A window of whole days from one civil date, for a surface rolling its own. */
+export function calendarWindowOfDays(date, days) {
+    return { from: startOfDay(date), to: startOfDay(addDays(date, days)) };
+}

package/dist/src/hooks/queries/keys.d.ts

@@ -0,0 +1,5 @@
+export declare const messageKeys: {
+    all: readonly ["messages"];
+    detail: (messageId: string) => readonly ["messages", "detail", string];
+    body: (messageId: string) => readonly ["messages", "detail", string, "body"];
+};

package/dist/src/hooks/queries/keys.js

@@ -0,0 +1,5 @@
+export const messageKeys = {
+    all: ["messages"],
+    detail: (messageId) => [...messageKeys.all, "detail", messageId],
+    body: (messageId) => [...messageKeys.detail(messageId), "body"],
+};

package/dist/src/hooks/use-system-update.d.ts

@@ -0,0 +1,40 @@
+import type { ReleaseInfo } from "@remit/ui";
+import { type ReactNode } from "react";
+import { type UpdateSurface } from "../lib/self-update-state";
+/**
+ * How long a pressed check waits for the updater before the pane calls it a
+ * failure. The backend only records the request; the updater picks it up on a
+ * five-second watch tick, so half a minute is several ticks — patient enough for
+ * a busy box, short enough that a press against a dead updater is answered
+ * rather than left spinning for good.
+ */
+export declare const CHECK_ANSWER_BUDGET_MS = 30000;
+/** The press was recorded and nothing came back. Names the process and the log. */
+export declare const UPDATER_SILENT_REASON = "The updater did not answer. Run `remit logs updater` to see why.";
+export interface SelfUpdateApi {
+    surface: UpdateSurface;
+    /** Whether the pending release runs a schema migration during the window. */
+    appliesSchemaMigration: boolean;
+    currentVersion: string | undefined;
+    /** The available release, for the consent dialog. */
+    release: ReleaseInfo | undefined;
+    /** Ask the updater for a fresh check, showing a `checking` pane until it answers. */
+    onCheck: () => void;
+    /** Request a specific release — consent has been given. */
+    install: (targetVersion: string) => void;
+    /** Clear a finished or given-up result from the pane. */
+    onDismissResult: () => void;
+    /** Re-poll from the "server never came back" screen. */
+    onRetryConnection: () => void;
+}
+export declare function useSystemUpdate(): SelfUpdateApi;
+export declare function SelfUpdateProvider({ children }: {
+    children: ReactNode;
+}): import("react").FunctionComponentElement<import("react").ProviderProps<SelfUpdateApi | null>>;
+export declare function useSelfUpdate(): SelfUpdateApi;
+/**
+ * The surface when a provider is present, or null when it is not. For the nav
+ * dot, which renders in settings trees that some tests mount without the
+ * provider — no provider means no update to hint at.
+ */
+export declare function useOptionalSelfUpdate(): SelfUpdateApi | null;

package/dist/src/hooks/use-system-update.js

@@ -0,0 +1,237 @@
+/**
+ * The self-update surface, wired to the generated client.
+ *
+ * A single instance owns the query, the mutation, and the run this page asked
+ * for, and hands the folded `SelfUpdateState` plus the blocking-overlay state to
+ * every consumer through context — so the Advanced pane, the root overlay, and
+ * the nav dot all read one source of truth. The state machine itself lives in
+ * `lib/self-update-state.ts`.
+ *
+ * The held run lives here and nowhere else. A restart does not reload the page,
+ * so this state spans the whole window; a page that loads afterwards holds
+ * nothing and takes the server's answer as it finds it.
+ *
+ * Polling follows the run: every 30 seconds while idle, every 5 seconds while a
+ * run is in flight, this page is waiting on one it started, or it is waiting on
+ * a check it pressed for.
+ */
+import { systemOperationsApplySystemUpdateMutation, systemOperationsGetSystemUpdateOptions, systemOperationsGetSystemUpdateQueryKey, } from "@remit/api-http-client/@tanstack/react-query.gen.ts";
+import { systemOperationsGetSystemUpdate } from "@remit/api-http-client/sdk.gen.ts";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import { createContext, createElement, useCallback, useContext, useEffect, useRef, useState, } from "react";
+import { restartExpectedMeta, shouldEscalate, softErrorMeta, } from "../lib/error-classifier";
+import { reportFatalError } from "../lib/fatal-error";
+import { appliesSchemaMigration, checkAnswered, checkRequestFailureReason, deriveUpdateSurface, isSurfaceAbsent, mapUpdatePhase, releaseFromCheck, runInFlight, } from "../lib/self-update-state";
+const IDLE_POLL_MS = 30_000;
+const RUN_POLL_MS = 5_000;
+/**
+ * The poll's own error UX, and — while a run is known to be in flight — the
+ * restart that run performs. Stopping and starting the backend is what the run
+ * is, so the gateway statuses answered while it is down belong to the surface
+ * below, which shows the phase and gives up loudly if the server never comes
+ * back (#468). Outside that window the poll carries no such claim.
+ *
+ * "Known" is either source: the run this page started and holds, or the run the
+ * server last reported as going. The overlay speaks for a run in any tab, so the
+ * window it rides has to open in any tab too — a second tab, or this one after a
+ * reload, holds nothing and would otherwise meet the restart with no claim on it.
+ */
+const POLL_META = softErrorMeta;
+const POLL_ACROSS_RESTART_META = { ...softErrorMeta, ...restartExpectedMeta };
+/**
+ * How long a pressed check waits for the updater before the pane calls it a
+ * failure. The backend only records the request; the updater picks it up on a
+ * five-second watch tick, so half a minute is several ticks — patient enough for
+ * a busy box, short enough that a press against a dead updater is answered
+ * rather than left spinning for good.
+ */
+export const CHECK_ANSWER_BUDGET_MS = 30_000;
+/** The press was recorded and nothing came back. Names the process and the log. */
+export const UPDATER_SILENT_REASON = "The updater did not answer. Run `remit logs updater` to see why.";
+function pollInterval(error, run, hasHeldRun, hasPress) {
+    if (isSurfaceAbsent(error) && !hasHeldRun)
+        return false;
+    const inFlight = run !== null && run.outcome === null;
+    // A press is waiting on the updater's next watch tick (#599), so it polls at
+    // the run cadence — and only until the wait ends, which drops the press.
+    if (hasHeldRun || inFlight || hasPress)
+        return RUN_POLL_MS;
+    return IDLE_POLL_MS;
+}
+export function useSystemUpdate() {
+    const queryClient = useQueryClient();
+    const [held, setHeld] = useState(null);
+    const [dismissedRunId, setDismissedRunId] = useState(null);
+    const [checkPress, setCheckPress] = useState(null);
+    const [checkFailure, setCheckFailure] = useState(null);
+    const [sighting, setSighting] = useState(null);
+    const heldRef = useRef(held);
+    heldRef.current = held;
+    const pressRef = useRef(checkPress);
+    pressRef.current = checkPress;
+    // The last answer, which outlives the failed requests after it: a tab that
+    // never pressed install learns from here that it is inside a restart.
+    const lastKnown = queryClient.getQueryData(systemOperationsGetSystemUpdateQueryKey());
+    const insideRestart = held !== null || runInFlight(lastKnown, dismissedRunId) !== null;
+    const query = useQuery({
+        ...systemOperationsGetSystemUpdateOptions(),
+        retry: false,
+        meta: insideRestart ? POLL_ACROSS_RESTART_META : POLL_META,
+        refetchInterval: (query) => pollInterval(query.state.error, query.state.data?.run ?? null, heldRef.current !== null, pressRef.current !== null),
+    });
+    const dataRef = useRef(query.data);
+    dataRef.current = query.data;
+    const derived = deriveUpdateSurface({
+        data: query.data,
+        isError: query.isError,
+        error: query.error,
+        held,
+        dismissedRunId,
+        checkPress,
+        checkFailure,
+        sighting,
+        now: Date.now(),
+    });
+    // Stamp the run the server reports, once, off this tab's clock. The stamp is
+    // what the give-up is measured against, so it must not move while the server
+    // is unreachable — and it must not carry over to the next run.
+    const reported = runInFlight(query.data, dismissedRunId);
+    useEffect(() => {
+        if (reported === null) {
+            setSighting((current) => (current === null ? current : null));
+            return;
+        }
+        setSighting((current) => current !== null && current.runId === reported.runId
+            ? current
+            : { runId: reported.runId, observedAt: Date.now() });
+    }, [reported]);
+    const shownRunIdRef = useRef(null);
+    shownRunIdRef.current =
+        derived.surface.status === "ready" && "runId" in derived.surface.section
+            ? derived.surface.section.runId
+            : null;
+    const { releaseHeld } = derived;
+    useEffect(() => {
+        if (releaseHeld)
+            setHeld((current) => (current === null ? current : null));
+    }, [releaseHeld]);
+    // The updater answered the press: let go of it, so the next poll renders the
+    // verdict rather than the spinner.
+    useEffect(() => {
+        if (checkPress !== null && checkAnswered(checkPress, query.data))
+            setCheckPress(null);
+    }, [checkPress, query.data]);
+    // The wait has to end itself. A poll that answers with the same bytes changes
+    // nothing this hook reads, so nothing would re-render to notice the budget had
+    // run out, and the spinner would sit there for good (#599).
+    useEffect(() => {
+        if (checkPress === null)
+            return;
+        const remaining = checkPress.pressedAt + CHECK_ANSWER_BUDGET_MS - Date.now();
+        const timer = setTimeout(() => {
+            setCheckPress(null);
+            setCheckFailure(UPDATER_SILENT_REASON);
+        }, Math.max(0, remaining));
+        return () => clearTimeout(timer);
+    }, [checkPress]);
+    const { refetch } = query;
+    const onCheck = useCallback(() => {
+        // A plain refetch only re-reads state.json, so the answer would be exactly
+        // as old as it was before the press. refresh=true has the backend record a
+        // check request for the updater; the wait is this page's to keep, against
+        // the `lastCheckedAt` the server had when the control was pressed (#599).
+        setCheckFailure(null);
+        setCheckPress({
+            pressedAt: Date.now(),
+            since: dataRef.current?.check.lastCheckedAt,
+        });
+        void systemOperationsGetSystemUpdate({
+            query: { refresh: true },
+            throwOnError: true,
+        })
+            .then(() => {
+            void refetch();
+        })
+            .catch((error) => {
+            // The request never reached the seam, so nothing is coming. Say so
+            // where the press was made instead of reverting to the old verdict.
+            // This is a raw SDK call, outside the query cache that feeds the
+            // global sink, so the 5xx the seam answers when the control volume
+            // is unwritable escalates from here or from nowhere.
+            if (shouldEscalate(error, softErrorMeta, "user")) {
+                reportFatalError(error);
+            }
+            setCheckPress(null);
+            setCheckFailure(checkRequestFailureReason(error));
+        });
+    }, [refetch]);
+    const onRetryConnection = useCallback(() => {
+        void refetch();
+    }, [refetch]);
+    const mutation = useMutation({
+        ...systemOperationsApplySystemUpdateMutation(),
+        meta: { softError: true },
+        onSuccess: (response) => {
+            const run = response.run;
+            if (run !== null) {
+                setHeld({
+                    runId: run.runId,
+                    attemptedVersion: run.targetVersion,
+                    previousVersion: run.fromVersion,
+                    phase: mapUpdatePhase(run.phase),
+                    startedAt: Date.now(),
+                });
+                setDismissedRunId(null);
+            }
+            queryClient.setQueryData(systemOperationsGetSystemUpdateQueryKey(), response);
+        },
+        onError: () => {
+            void refetch();
+        },
+    });
+    const { mutate } = mutation;
+    const install = useCallback((targetVersion) => {
+        mutate({ body: { targetVersion } });
+    }, [mutate]);
+    const onDismissResult = useCallback(() => {
+        if (shownRunIdRef.current !== null)
+            setDismissedRunId(shownRunIdRef.current);
+        setHeld(null);
+        // Retiring the outcome uncovers the check verdict beneath it. A failure
+        // recorded while the outcome held the pane describes a press the user can
+        // no longer see, and an update run of its own supersedes anything an
+        // earlier check concluded — either way it must not resurface here.
+        setCheckPress(null);
+        setCheckFailure(null);
+    }, []);
+    return {
+        surface: derived.surface,
+        appliesSchemaMigration: appliesSchemaMigration(query.data),
+        currentVersion: query.data?.currentVersion,
+        release: releaseFromCheck(query.data, Date.now()),
+        onCheck,
+        install,
+        onDismissResult,
+        onRetryConnection,
+    };
+}
+const SelfUpdateContext = createContext(null);
+export function SelfUpdateProvider({ children }) {
+    const value = useSystemUpdate();
+    return createElement(SelfUpdateContext.Provider, { value }, children);
+}
+export function useSelfUpdate() {
+    const value = useContext(SelfUpdateContext);
+    if (value === null) {
+        throw new Error("useSelfUpdate must be used within a SelfUpdateProvider");
+    }
+    return value;
+}
+/**
+ * The surface when a provider is present, or null when it is not. For the nav
+ * dot, which renders in settings trees that some tests mount without the
+ * provider — no provider means no update to hint at.
+ */
+export function useOptionalSelfUpdate() {
+    return useContext(SelfUpdateContext);
+}

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

@@ -0,0 +1,17 @@
+import type { RemitImapLabelAction, RemitImapThreadMessageResponse } from "@remit/api-http-client/types.gen.ts";
+/**
+ * Apply or remove a label on a "just these" selection (issue #26, RFC 034
+ * recap). No optimistic patch: a label is metadata on the row, not something
+ * that removes it from the current view, so settling on the server response
+ * and invalidating is enough — unlike a move or delete, which the row leaves
+ * immediately.
+ */
+export declare const useApplyLabel: (options: {
+    mailboxId: string;
+    accountId?: string;
+    /** The threads the selection may span, for resolving which mailbox lists to invalidate. */
+    messages?: RemitImapThreadMessageResponse[];
+}) => {
+    applyLabel: (messageIds: string[], labelId: string, action: RemitImapLabelAction) => void;
+    isPending: boolean;
+};

package/dist/src/hooks/useApplyLabel.js

@@ -0,0 +1,41 @@
+import { messageBulkOperationsUpdateMessageLabelsMutation } from "@remit/api-http-client/@tanstack/react-query.gen.ts";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { useCallback } from "react";
+import { useErrorBanners } from "../components/ui/ErrorBannerProvider";
+import { formatErrorDetail } from "../components/ui/error-banners";
+import { runChunkedMutation } from "../lib/bulk-actions";
+import { invalidateThreadListQueries, threadListCacheKeys, } from "../lib/thread-list-cache";
+import { resolveMailboxesForMessages } from "./useMarkAsRead";
+/**
+ * Apply or remove a label on a "just these" selection (issue #26, RFC 034
+ * recap). No optimistic patch: a label is metadata on the row, not something
+ * that removes it from the current view, so settling on the server response
+ * and invalidating is enough — unlike a move or delete, which the row leaves
+ * immediately.
+ */
+export const useApplyLabel = (options) => {
+    const { mailboxId, messages } = options;
+    const queryClient = useQueryClient();
+    const { pushError } = useErrorBanners();
+    const { mutateAsync, isPending } = useMutation({
+        ...messageBulkOperationsUpdateMessageLabelsMutation(),
+        onError: (error, variables) => {
+            pushError({
+                title: variables.body.action === "Remove"
+                    ? "Couldn't remove label"
+                    : "Couldn't apply label",
+                detail: formatErrorDetail(error),
+                error,
+            });
+        },
+        onSettled: (_data, _error, variables) => {
+            invalidateThreadListQueries(queryClient, threadListCacheKeys(resolveMailboxesForMessages(variables.body.messageIds ?? [], messages ?? [], mailboxId)));
+        },
+    });
+    const applyLabel = useCallback((messageIds, labelId, action) => {
+        if (messageIds.length === 0)
+            return;
+        void runChunkedMutation(messageIds, (chunk) => mutateAsync({ body: { messageIds: chunk, labelId, action } }));
+    }, [mutateAsync]);
+    return { applyLabel, isPending };
+};

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

@@ -0,0 +1,74 @@
+import type { RemitImapFolderAppointment } from "@remit/api-http-client/types.gen.ts";
+import type { TrashResolution } from "../lib/format";
+/**
+ * Returns the account's appointed Archive mailbox id. `undefined` while
+ * loading or when no folder is appointed to (or proposed for) the role.
+ */
+export declare const useArchiveMailbox: (accountId: string | undefined) => {
+    archiveMailboxId: string | undefined;
+    isLoading: boolean;
+};
+/**
+ * Returns the account's appointed Drafts mailbox id. Used by the mailbox
+ * route to decide whether to render the segmented Drafts view (Remit drafts +
+ * IMAP Drafts) in place of the flat message list (issue #505).
+ */
+export declare const useDraftsMailbox: (accountId: string | undefined) => {
+    draftsMailboxId: string | undefined;
+    isLoading: boolean;
+};
+/**
+ * Returns the account's Inbox mailbox id — the destination for "Not spam"
+ * (issue #594), which moves a message out of Junk back to the inbox.
+ */
+export declare const useInboxMailbox: (accountId: string | undefined) => {
+    inboxMailboxId: string | undefined;
+    isLoading: boolean;
+};
+/**
+ * Returns the account's appointed Junk/Spam mailbox id, used by the triage
+ * `!` (mark junk) key (#429). The message-flags API has no `$Junk` keyword
+ * field, so "mark junk" is realized as a move to the Junk mailbox.
+ */
+export declare const useJunkMailbox: (accountId: string | undefined) => {
+    junkMailboxId: string | undefined;
+    isLoading: boolean;
+};
+/**
+ * Returns the account's appointed Trash mailbox id, which is how the mailbox
+ * pane tells it is looking at Trash and may offer to empty it (#847).
+ */
+export declare const useTrashMailbox: (accountId: string | undefined) => {
+    trashMailboxId: string | undefined;
+    isLoading: boolean;
+};
+/**
+ * Each account's appointed Trash mailbox, keyed by account. The delete
+ * confirmation needs it to tell a move-to-Trash apart from a delete inside
+ * Trash, which is an unrecoverable expunge and has to be asked as one (#845),
+ * and apart from an account that appoints no Trash at all, where the server
+ * refuses the delete outright (#846).
+ *
+ * A map rather than a set of ids, because the brief and Flagged answer for
+ * selections that span accounts (#855): "is this row in Trash" is a question
+ * about the row's own account, and "does any Trash exist" has to be answerable
+ * as "no" rather than as silence.
+ *
+ * `hasAppointments` is data presence, never `!isLoading`. React Query v5
+ * computes `isLoading` as `isPending && isFetching`, so an offline query is
+ * paused and reports neither loading nor error while `data` is still
+ * undefined — which read as "no Trash anywhere", and promised a reversible
+ * move over an expunge that would replay on reconnect.
+ */
+export declare const useTrashByAccount: () => {
+    trashByAccount: ReadonlyMap<string, TrashResolution>;
+    hasAppointments: boolean;
+    isError: boolean;
+};
+/**
+ * Returns an account's full role→mailbox appointment map, for callers that
+ * need more than one role at once (e.g. the Move-to picker excluding both
+ * Drafts and Sent, and ordering system folders by role). Empty while loading
+ * or when `accountId` is undefined.
+ */
+export declare const useFolderAppointments: (accountId: string | undefined) => readonly RemitImapFolderAppointment[];