@remit/web-client 0.0.324 → 0.0.326

package/dist/src/lib/autodiscovery.js

@@ -0,0 +1,320 @@
+/**
+ * Client-side autodiscovery for IMAP/SMTP server settings.
+ *
+ * Strategy (stop at first hit):
+ * 1. Curated provider table (top ~30 providers)
+ * 2. Mozilla Autoconfig: GET https://autoconfig.thunderbird.net/v1.1/{domain}
+ * 3. Domain-hosted autoconfig: GET https://autoconfig.{domain}/mail/config-v1.1.xml
+ * 4. Fallback heuristics: imap.{domain}:993/tls, smtp.{domain}:587/starttls
+ *
+ * NOTE: A future backend endpoint `GET /autodiscovery?email=…` (TypeSpec-first)
+ * is planned to handle DNS SRV lookups and CORS-blocked domains server-side.
+ * Until it exists, this client-side implementation covers the majority of providers.
+ */
+/** Static curated provider table — top providers with known-good settings */
+const PROVIDER_TABLE = {
+    "gmail.com": {
+        imap: { host: "imap.gmail.com", port: 993, security: "tls" },
+        smtp: { host: "smtp.gmail.com", port: 587, security: "starttls" },
+        source: "provider-table",
+    },
+    "googlemail.com": {
+        imap: { host: "imap.gmail.com", port: 993, security: "tls" },
+        smtp: { host: "smtp.gmail.com", port: 587, security: "starttls" },
+        source: "provider-table",
+    },
+    "outlook.com": {
+        imap: { host: "outlook.office365.com", port: 993, security: "tls" },
+        smtp: { host: "smtp.office365.com", port: 587, security: "starttls" },
+        source: "provider-table",
+    },
+    "hotmail.com": {
+        imap: { host: "outlook.office365.com", port: 993, security: "tls" },
+        smtp: { host: "smtp.office365.com", port: 587, security: "starttls" },
+        source: "provider-table",
+    },
+    "live.com": {
+        imap: { host: "outlook.office365.com", port: 993, security: "tls" },
+        smtp: { host: "smtp.office365.com", port: 587, security: "starttls" },
+        source: "provider-table",
+    },
+    "msn.com": {
+        imap: { host: "outlook.office365.com", port: 993, security: "tls" },
+        smtp: { host: "smtp.office365.com", port: 587, security: "starttls" },
+        source: "provider-table",
+    },
+    "icloud.com": {
+        imap: { host: "imap.mail.me.com", port: 993, security: "tls" },
+        smtp: { host: "smtp.mail.me.com", port: 587, security: "starttls" },
+        source: "provider-table",
+    },
+    "me.com": {
+        imap: { host: "imap.mail.me.com", port: 993, security: "tls" },
+        smtp: { host: "smtp.mail.me.com", port: 587, security: "starttls" },
+        source: "provider-table",
+    },
+    "mac.com": {
+        imap: { host: "imap.mail.me.com", port: 993, security: "tls" },
+        smtp: { host: "smtp.mail.me.com", port: 587, security: "starttls" },
+        source: "provider-table",
+    },
+    "fastmail.com": {
+        imap: { host: "imap.fastmail.com", port: 993, security: "tls" },
+        smtp: { host: "smtp.fastmail.com", port: 465, security: "tls" },
+        source: "provider-table",
+    },
+    "fastmail.fm": {
+        imap: { host: "imap.fastmail.com", port: 993, security: "tls" },
+        smtp: { host: "smtp.fastmail.com", port: 465, security: "tls" },
+        source: "provider-table",
+    },
+    "yahoo.com": {
+        imap: { host: "imap.mail.yahoo.com", port: 993, security: "tls" },
+        smtp: { host: "smtp.mail.yahoo.com", port: 465, security: "tls" },
+        source: "provider-table",
+    },
+    "yahoo.co.uk": {
+        imap: { host: "imap.mail.yahoo.com", port: 993, security: "tls" },
+        smtp: { host: "smtp.mail.yahoo.com", port: 465, security: "tls" },
+        source: "provider-table",
+    },
+    "ymail.com": {
+        imap: { host: "imap.mail.yahoo.com", port: 993, security: "tls" },
+        smtp: { host: "smtp.mail.yahoo.com", port: 465, security: "tls" },
+        source: "provider-table",
+    },
+    // NOTE: ProtonMail is intentionally omitted from the provider table.
+    // Proton has no direct IMAP/SMTP for hosted clients — it requires the
+    // locally-run Proton Bridge (127.0.0.1). Remit syncs server-side, so a
+    // loopback host would resolve to the sync worker, never the user's
+    // machine. Proton accounts fall through to manual entry, where the user
+    // can point at their own Bridge/relay if they run one.
+    "aol.com": {
+        imap: { host: "imap.aol.com", port: 993, security: "tls" },
+        smtp: { host: "smtp.aol.com", port: 465, security: "tls" },
+        source: "provider-table",
+    },
+    "zoho.com": {
+        imap: { host: "imap.zoho.com", port: 993, security: "tls" },
+        smtp: { host: "smtp.zoho.com", port: 465, security: "tls" },
+        source: "provider-table",
+    },
+    "gmx.com": {
+        imap: { host: "imap.gmx.com", port: 993, security: "tls" },
+        smtp: { host: "smtp.gmx.com", port: 587, security: "starttls" },
+        source: "provider-table",
+    },
+    "gmx.net": {
+        imap: { host: "imap.gmx.net", port: 993, security: "tls" },
+        smtp: { host: "mail.gmx.net", port: 587, security: "starttls" },
+        source: "provider-table",
+    },
+    "gmx.de": {
+        imap: { host: "imap.gmx.net", port: 993, security: "tls" },
+        smtp: { host: "mail.gmx.net", port: 587, security: "starttls" },
+        source: "provider-table",
+    },
+    "web.de": {
+        imap: { host: "imap.web.de", port: 993, security: "tls" },
+        smtp: { host: "smtp.web.de", port: 587, security: "starttls" },
+        source: "provider-table",
+    },
+    "mail.com": {
+        imap: { host: "imap.mail.com", port: 993, security: "tls" },
+        smtp: { host: "smtp.mail.com", port: 465, security: "tls" },
+        source: "provider-table",
+    },
+    "hey.com": {
+        imap: { host: "imap.hey.com", port: 993, security: "tls" },
+        smtp: { host: "smtp.hey.com", port: 465, security: "tls" },
+        source: "provider-table",
+    },
+    "tutanota.com": {
+        imap: { host: "mail.tutanota.com", port: 993, security: "tls" },
+        smtp: { host: "mail.tutanota.com", port: 465, security: "tls" },
+        source: "provider-table",
+    },
+    "tuta.io": {
+        imap: { host: "mail.tutanota.com", port: 993, security: "tls" },
+        smtp: { host: "mail.tutanota.com", port: 465, security: "tls" },
+        source: "provider-table",
+    },
+    "posteo.de": {
+        imap: { host: "posteo.de", port: 993, security: "tls" },
+        smtp: { host: "posteo.de", port: 465, security: "tls" },
+        source: "provider-table",
+    },
+    "runbox.com": {
+        imap: { host: "imap.runbox.com", port: 993, security: "tls" },
+        smtp: { host: "smtp.runbox.com", port: 587, security: "starttls" },
+        source: "provider-table",
+    },
+    "mailbox.org": {
+        imap: { host: "imap.mailbox.org", port: 993, security: "tls" },
+        smtp: { host: "smtp.mailbox.org", port: 465, security: "tls" },
+        source: "provider-table",
+    },
+    "hushmail.com": {
+        imap: { host: "imap.hushmail.com", port: 993, security: "tls" },
+        smtp: { host: "smtp.hushmail.com", port: 465, security: "tls" },
+        source: "provider-table",
+    },
+};
+/** App-password doc links per domain (static lookup) */
+export const APP_PASSWORD_URLS = {
+    "gmail.com": "https://support.google.com/accounts/answer/185833",
+    "googlemail.com": "https://support.google.com/accounts/answer/185833",
+    "yahoo.com": "https://help.yahoo.com/kb/generate-manage-third-party-passwords-sln15241.html",
+    "icloud.com": "https://support.apple.com/en-us/102654",
+    "me.com": "https://support.apple.com/en-us/102654",
+    "mac.com": "https://support.apple.com/en-us/102654",
+    "fastmail.com": "https://www.fastmail.help/hc/en-us/articles/360058752854",
+    "fastmail.fm": "https://www.fastmail.help/hc/en-us/articles/360058752854",
+    "outlook.com": "https://support.microsoft.com/en-us/account-billing/manage-app-passwords-for-two-step-verification-d6dc8c6d-4bf7-4851-ad95-6d07799387e9",
+    "hotmail.com": "https://support.microsoft.com/en-us/account-billing/manage-app-passwords-for-two-step-verification-d6dc8c6d-4bf7-4851-ad95-6d07799387e9",
+    "zoho.com": "https://help.zoho.com/portal/en/kb/zoho-mail/client-configuration/imap-access/articles/zoho-mail-app-passwords",
+};
+function parseMozillaAutoconfigXml(xml) {
+    try {
+        const parser = new DOMParser();
+        const doc = parser.parseFromString(xml, "application/xml");
+        if (doc.querySelector("parsererror"))
+            return null;
+        const incomingServers = doc.querySelectorAll("incomingServer[type='imap']");
+        const outgoingServers = doc.querySelectorAll("outgoingServer[type='smtp']");
+        if (!incomingServers.length || !outgoingServers.length)
+            return null;
+        const imap = incomingServers[0];
+        const smtp = outgoingServers[0];
+        const imapHost = imap.querySelector("hostname")?.textContent?.trim();
+        const imapPortStr = imap.querySelector("port")?.textContent?.trim();
+        const imapSocketType = imap
+            .querySelector("socketType")
+            ?.textContent?.trim()
+            .toUpperCase();
+        const smtpHost = smtp.querySelector("hostname")?.textContent?.trim();
+        const smtpPortStr = smtp.querySelector("port")?.textContent?.trim();
+        const smtpSocketType = smtp
+            .querySelector("socketType")
+            ?.textContent?.trim()
+            .toUpperCase();
+        if (!imapHost || !imapPortStr || !smtpHost || !smtpPortStr)
+            return null;
+        const socketToSecurity = (socket) => {
+            if (socket === "SSL" || socket === "TLS" || socket === "SSL/TLS")
+                return "tls";
+            if (socket === "STARTTLS")
+                return "starttls";
+            return "none";
+        };
+        return {
+            imap: {
+                host: imapHost,
+                port: Number.parseInt(imapPortStr, 10),
+                security: socketToSecurity(imapSocketType),
+            },
+            smtp: {
+                host: smtpHost,
+                port: Number.parseInt(smtpPortStr, 10),
+                security: socketToSecurity(smtpSocketType),
+            },
+            source: "mozilla-autoconfig",
+        };
+    }
+    catch {
+        return null;
+    }
+}
+async function fetchMozillaAutoconfig(domain, signal) {
+    try {
+        const url = `https://autoconfig.thunderbird.net/v1.1/${domain}`;
+        const res = await fetch(url, { signal });
+        if (!res.ok)
+            return null;
+        const xml = await res.text();
+        const result = parseMozillaAutoconfigXml(xml);
+        if (result)
+            return result;
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+async function fetchDomainAutoconfig(domain, signal) {
+    try {
+        const url = `https://autoconfig.${domain}/mail/config-v1.1.xml`;
+        const res = await fetch(url, { signal });
+        if (!res.ok)
+            return null;
+        const xml = await res.text();
+        const result = parseMozillaAutoconfigXml(xml);
+        if (result)
+            return { ...result, source: "domain-autoconfig" };
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+function heuristicResult(domain) {
+    return {
+        imap: { host: `imap.${domain}`, port: 993, security: "tls" },
+        smtp: { host: `smtp.${domain}`, port: 587, security: "starttls" },
+        source: "heuristic",
+    };
+}
+/**
+ * Run autodiscovery for the given email address.
+ * Returns null if discovery fails after all strategies; caller should show manual-entry UI.
+ *
+ * Timeout defaults to 1.5s (not the spec's 5s): the browser autoconfig
+ * fetches (Mozilla ISPDB + autoconfig.{domain}) almost always reject on CORS,
+ * so for any non-table domain we'd otherwise burn ~5s on two doomed requests
+ * before the heuristic fallback. A short budget keeps the address step snappy.
+ * The real fix is the backend `/autodiscovery` endpoint (see module header).
+ */
+export async function discoverSettings(email, timeoutMs = 1500) {
+    const atIdx = email.indexOf("@");
+    if (atIdx === -1)
+        return null;
+    const domain = email.slice(atIdx + 1).toLowerCase();
+    if (!domain)
+        return null;
+    // 1. Curated table — instant, no network
+    const tableResult = PROVIDER_TABLE[domain];
+    if (tableResult)
+        return tableResult;
+    // 2+3. Network lookups with timeout
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const mozilla = await fetchMozillaAutoconfig(domain, controller.signal);
+        if (mozilla)
+            return mozilla;
+        const domainConfig = await fetchDomainAutoconfig(domain, controller.signal);
+        if (domainConfig)
+            return domainConfig;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+    // 4. Heuristic fallback — caller decides whether to prefill or show manual
+    return heuristicResult(domain);
+}
+/** Get a human-readable "looking up …" message shown during autodiscovery */
+export function getDiscoveryStatusMessage(email) {
+    const atIdx = email.indexOf("@");
+    if (atIdx === -1)
+        return "Looking up server settings…";
+    const domain = email.slice(atIdx + 1);
+    return `Looking up settings for ${domain}…`;
+}
+/** Get app-password URL for the email's domain, if known */
+export function getAppPasswordUrl(email) {
+    const atIdx = email.indexOf("@");
+    if (atIdx === -1)
+        return undefined;
+    const domain = email.slice(atIdx + 1).toLowerCase();
+    return APP_PASSWORD_URLS[domain];
+}

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

@@ -0,0 +1,69 @@
+/**
+ * What each daily-brief section asks `listAllThreads` for, and what is left over.
+ *
+ * The brief's category scope is not a criterion here: every section is its own
+ * category-scoped request, so the category travels per section rather than in
+ * the shared criteria. What is shared is the attribute chips and the tokens
+ * typed in the field — `from:`, `subject:`, `is:unread`, `has:attachment`,
+ * `is:starred` — all of them fields on the ThreadMessage row, so all of them
+ * travel as query parameters over the whole scope instead of as a pass over the
+ * rows already fetched (#312, #1128).
+ *
+ * The account pill and mute travel with them. Both used to narrow the rows after
+ * they arrived, which is what took the number off every section header: a count
+ * over every account, muted senders included, is not the size of a list showing
+ * one account without them (#1136, #1137).
+ *
+ * Two chips have no parameter anywhere — "From contacts" reads `senderTrust`,
+ * which is off-row (design D7), and "Today" is a date, which no listing
+ * endpoint takes. They narrow the rows the kit renders, so while either is on
+ * the request is wider than the list and the section totals are not the list's
+ * size. `briefCountsMatchRows` is how a caller knows to show no number instead.
+ */
+import type { BriefFilterId } from "@remit/ui";
+import type { SearchToken } from "./search-tokens.js";
+import { type ThreadSearchTokenParamName, type ThreadSearchTokenParams } from "./thread-search-tokens.js";
+/** The token parameters `listAllThreads` carries. */
+export declare const BRIEF_TOKEN_PARAMS: readonly ThreadSearchTokenParamName[];
+/** Chips the request cannot express, so the caller applies them over the rows. */
+export declare const BRIEF_CLIENT_ONLY_FILTERS: readonly BriefFilterId[];
+/**
+ * The chips on screen that no request carries, as the set to apply over the rows
+ * that came back. Every other chip was answered by the server over the whole
+ * scope, and applying one of those again here would narrow one page by a
+ * criterion the request already applied to everything (#312).
+ */
+export declare const briefClientOnlyFilters: (attributes: ReadonlySet<string>) => ReadonlySet<BriefFilterId>;
+/** Everything a section request narrows by except its own category. */
+export type BriefSectionParams = Omit<ThreadSearchTokenParams, "category"> & {
+    /** The account the pills narrow to, or absent for the whole config. */
+    accountId?: string;
+    /** Always `false` here: the brief renders no muted sender's mail. */
+    muted?: boolean;
+};
+export interface BriefCriteria {
+    /** What every section request carries, chips and carried tokens together. */
+    criteria: BriefSectionParams;
+    /** The tokens no parameter carries; apply these over the returned rows. */
+    residual: SearchToken[];
+}
+export declare const briefCriteria: (category: string, attributes: ReadonlySet<string>, tokens: readonly SearchToken[], accountId?: string) => BriefCriteria;
+export interface BriefCountReach {
+    /** Tokens the request did not carry, applied over the rows afterwards. */
+    residual: readonly SearchToken[];
+    /** Attribute chips currently on. */
+    attributes: ReadonlySet<string>;
+}
+/**
+ * Whether a section's server count is a count of what the section shows.
+ *
+ * The count answers the request. Anything narrowing the rows after they arrive —
+ * a residual token, or a chip with no parameter — makes the count the size of a
+ * wider set than the list. A wider number rendered as the section's size is a
+ * worse reading than no number, so the caller asks for none.
+ *
+ * The account pills are not among them any more, and neither is mute: both are
+ * parameters the request carries, so the count narrows exactly as the list does
+ * (#1136, #1137).
+ */
+export declare const briefCountsMatchRows: ({ residual, attributes, }: BriefCountReach) => boolean;

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

@@ -0,0 +1,62 @@
+import { inboxFilterParams } from "./inbox-filters.js";
+import { threadSearchTokens, } from "./thread-search-tokens.js";
+/** The token parameters `listAllThreads` carries. */
+export const BRIEF_TOKEN_PARAMS = [
+    "from",
+    "subject",
+    "category",
+    "unread",
+    "starred",
+    "attachments",
+];
+/** Chips the request cannot express, so the caller applies them over the rows. */
+export const BRIEF_CLIENT_ONLY_FILTERS = [
+    "contacts",
+    "today",
+];
+/**
+ * The chips on screen that no request carries, as the set to apply over the rows
+ * that came back. Every other chip was answered by the server over the whole
+ * scope, and applying one of those again here would narrow one page by a
+ * criterion the request already applied to everything (#312).
+ */
+export const briefClientOnlyFilters = (attributes) => new Set(BRIEF_CLIENT_ONLY_FILTERS.filter((id) => attributes.has(id)));
+export const briefCriteria = (category, attributes, tokens, accountId) => {
+    const chipParams = inboxFilterParams({
+        category,
+        attributes,
+    });
+    const { params, residual } = threadSearchTokens(tokens, chipParams, BRIEF_TOKEN_PARAMS);
+    const request = { ...params, ...chipParams };
+    // Mute is not a control the reader sets: the brief is the view that hides
+    // muted senders, so every request it makes says so and every count it shows
+    // is a count of what it renders.
+    const criteria = { muted: false };
+    if (request.from !== undefined)
+        criteria.from = request.from;
+    if (request.subject !== undefined)
+        criteria.subject = request.subject;
+    if (request.unread !== undefined)
+        criteria.unread = request.unread;
+    if (request.starred !== undefined)
+        criteria.starred = request.starred;
+    if (request.attachments !== undefined)
+        criteria.attachments = request.attachments;
+    if (accountId !== undefined)
+        criteria.accountId = accountId;
+    return { criteria, residual };
+};
+/**
+ * Whether a section's server count is a count of what the section shows.
+ *
+ * The count answers the request. Anything narrowing the rows after they arrive —
+ * a residual token, or a chip with no parameter — makes the count the size of a
+ * wider set than the list. A wider number rendered as the section's size is a
+ * worse reading than no number, so the caller asks for none.
+ *
+ * The account pills are not among them any more, and neither is mute: both are
+ * parameters the request carries, so the count narrows exactly as the list does
+ * (#1136, #1137).
+ */
+export const briefCountsMatchRows = ({ residual, attributes, }) => residual.length === 0 &&
+    !BRIEF_CLIENT_ONLY_FILTERS.some((id) => attributes.has(id));

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

@@ -0,0 +1,98 @@
+/**
+ * Daily brief section assembly.
+ *
+ * Pure function: takes one complete per-category server response and returns one
+ * section per message category, in a fixed display order:
+ *
+ *  1. Personal
+ *  2. Transactional
+ *  3. Newsletter
+ *  4. Marketing
+ *  5. Social
+ *  6. Automated
+ *  7. Unclassified
+ *
+ * Each section is its own server query, scoped to its category and carrying
+ * every criterion on screen the request can express, plus one count for the
+ * whole category. Nothing here groups a page: a category whose mail is entirely
+ * older than the newest unified page still has a section, and the section's
+ * header states the category's real size rather than how many of a shared window
+ * happened to fall in it (#312). `uncategorized` is its own section rather than
+ * being folded into Personal — unclassified mail is missing work, not a decision
+ * (issue #45). Starred mail is not a section — the star is a per-row marker, so
+ * a starred message stays in its category.
+ *
+ * Sender trust (vip/wellknown) no longer sections the brief — the signal is
+ * still carried on each row (see `toThreadRowData`) for future use, but it does
+ * not decide where a row lands. Read state is likewise not a routing signal: in
+ * a high-volume mailbox read≠handled and unread≠important; unread is a
+ * user-selectable filter chip instead.
+ *
+ * Muted senders and categories the scope holds none of are excluded. Mute is
+ * `muted=false` on each section's request, so the rows and the count answer the
+ * same predicate — dropping muted rows here instead left a header stating a
+ * number larger than the list under it, and a "Show all" that opened mail the
+ * brief would not render (#1137).
+ */
+import type { RemitImapThreadMessageResponse } from "@remit/api-http-client/types.gen.ts";
+import { type ResultCount, type ThreadCategory, type ThreadRowData, type ThreadSection } from "@remit/ui";
+import type { SearchToken } from "./search-tokens.js";
+/**
+ * Map a `RemitImapThreadMessageResponse` to the `ThreadRowData` shape used by
+ * remit-ui row body components. Mirrors the logic in MessageListItem so the
+ * brief rows render identically to per-mailbox rows.
+ */
+export declare function toThreadRowData(thread: RemitImapThreadMessageResponse): ThreadRowData;
+/**
+ * The categories the brief asks for, in the order it renders them. A category
+ * is both the section's own scope and the query parameter its request carries;
+ * the order and the label come from the kit's category table.
+ */
+export declare const BRIEF_CATEGORIES: readonly ThreadCategory[];
+/** One category's own server answer: its newest rows and how many it holds. */
+export interface BriefCategoryResult {
+    category: ThreadCategory;
+    /** The newest rows the section's request returned, newest first. */
+    rows: ThreadRowData[];
+    /** The category's size over the whole scope, or no number at all. */
+    total: ResultCount;
+    /** The request came back full, so the category holds more than these rows. */
+    atCap: boolean;
+    /** The request has not answered yet. */
+    loading: boolean;
+    /** The request failed. This category alone; the others are unaffected. */
+    failed: boolean;
+}
+/**
+ * The per-category server answers as brief sections, in display order.
+ *
+ * A regrouping of complete responses, never of a page: each result already is
+ * its whole category as far as the request was concerned, so no further page can
+ * move a section's membership or its total.
+ *
+ * A category the scope holds none of has no section — a header stating zero is
+ * noise, not information. A category still being fetched, or whose own request
+ * failed, keeps its section so the loading and error treatments have somewhere
+ * to render, and a category with a real total keeps its section even with no
+ * rows left after the chips, so the reader sees which filter emptied it.
+ */
+export declare function briefSections(results: readonly BriefCategoryResult[]): ThreadSection[];
+/**
+ * Returns true when `t` satisfies every token handed to it.
+ *
+ * The residue applier: callers pass the tokens their request could not carry —
+ * `threadSearchTokens` decides which those are by reading the request back — and
+ * this narrows the rows that came back by them. A token the request did carry
+ * must not be passed here; the server already answered it over the whole scope,
+ * and re-answering it over one page is how a criterion ends up meaning "among
+ * the rows fetched so far" (#312).
+ *
+ * Every token is implemented so that a request carrying fewer parameters still
+ * has somewhere to put the rest: no endpoint has `before:`, `after:`, `in:` or
+ * `account:` in the set these tokens are split against, and each takes one
+ * `from` and one `subject`, so a second of either — or one a chip overruled —
+ * lands here. A row without the data a token needs (no `sentDate` for
+ * `before:`/`after:`) never matches it, so it drops out rather than showing
+ * under an unverifiable filter.
+ */
+export declare function matchesSearchTokens(t: ThreadRowData, tokens: SearchToken[]): boolean;