@remit/api-http-client 0.0.42 → 0.0.43

package/@tanstack/react-query.gen.ts

@@ -1466,6 +1466,10 @@ export const unifiedThreadOperationsListAllThreadsQueryKey = (options?: Options<
  * What a row is in search mode: one per message, not one per mailbox. This differs from the starred mode above, where the same mail filed in two folders is two rows sharing a `threadId`. Collapsing by `threadId` is still a client's job if it renders one row per CONVERSATION, since distinct messages in one thread remain distinct rows here.
  *
  * Callers that omit `query` are unaffected: the INBOX (and starred) listings behave exactly as before.
+ *
+ * Row filters: `category`, `unread` and `attachments` are columns on the ThreadMessage row, so each is a predicate inside the query rather than a pass over what a page returned. They compose with every mode above — INBOX, starred and search alike — and a page therefore comes back full of matches however rare the criterion is. This is what the cross-account collections need: filtering the pages a client happens to have loaded shows an empty list whenever the matching mail sits below the newest page (#308).
+ *
+ * Counting: `count=true` answers how many CONVERSATIONS match, over the whole scope and independent of `limit`. `results=false` omits the rows, which is how a header total is read without also paying for a page of mail. Conversations rather than rows because that is what this listing renders: a row is per mailbox, so the same mail filed in two folders is two rows sharing a `threadId`, and clients collapse by it. Counting rows would put a third number beside a list that shows a second one.
  */
 export const unifiedThreadOperationsListAllThreadsOptions = (options?: Options<UnifiedThreadOperationsListAllThreadsData>) => queryOptions<UnifiedThreadOperationsListAllThreadsResponse, DefaultError, UnifiedThreadOperationsListAllThreadsResponse, ReturnType<typeof unifiedThreadOperationsListAllThreadsQueryKey>>({
     queryFn: async ({ queryKey, signal }) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/api-http-client",
-  "version": "0.0.42",
+  "version": "0.0.43",
   "type": "module",
   "exports": {
     ".": "./index.ts",

package/sdk.gen.ts

@@ -891,6 +891,10 @@ export const systemOperationsApplySystemUpdate = <ThrowOnError extends boolean =
  * What a row is in search mode: one per message, not one per mailbox. This differs from the starred mode above, where the same mail filed in two folders is two rows sharing a `threadId`. Collapsing by `threadId` is still a client's job if it renders one row per CONVERSATION, since distinct messages in one thread remain distinct rows here.
  *
  * Callers that omit `query` are unaffected: the INBOX (and starred) listings behave exactly as before.
+ *
+ * Row filters: `category`, `unread` and `attachments` are columns on the ThreadMessage row, so each is a predicate inside the query rather than a pass over what a page returned. They compose with every mode above — INBOX, starred and search alike — and a page therefore comes back full of matches however rare the criterion is. This is what the cross-account collections need: filtering the pages a client happens to have loaded shows an empty list whenever the matching mail sits below the newest page (#308).
+ *
+ * Counting: `count=true` answers how many CONVERSATIONS match, over the whole scope and independent of `limit`. `results=false` omits the rows, which is how a header total is read without also paying for a page of mail. Conversations rather than rows because that is what this listing renders: a row is per mailbox, so the same mail filed in two folders is two rows sharing a `threadId`, and clients collapse by it. Counting rows would put a third number beside a list that shows a second one.
  */
 export const unifiedThreadOperationsListAllThreads = <ThrowOnError extends boolean = false>(options?: Options<UnifiedThreadOperationsListAllThreadsData, ThrowOnError>): RequestResult<UnifiedThreadOperationsListAllThreadsResponses, unknown, ThrowOnError> => (options?.client ?? client).get<UnifiedThreadOperationsListAllThreadsResponses, unknown, ThrowOnError>({
     security: [{ name: 'Authorization', type: 'apiKey' }],

package/types.gen.ts

@@ -3049,11 +3049,18 @@ export type RemitImapThreadMessageResponse = {
 };
 
 /**
- * Aggregate response for `searchThreads`. Carries the matching rows (`items`), a
- * pagination `continuationToken`, and an optional `count` of every message the
- * query matches. `items` is omitted when `results=false` (count-only); `count` is
- * present only when `count=true`. Thread-specific so the shared `ResultList<T>`
- * (7 endpoints) stays untouched.
+ * Aggregate response for the filterable thread listings — `searchThreads` and
+ * `listAllThreads`. Carries the matching rows (`items`), a pagination
+ * `continuationToken`, and an optional `count` of what the query matches.
+ * `items` is omitted when `results=false` (count-only); `count` is present only
+ * when `count=true`. Thread-specific so the shared `ResultList<T>` (7 endpoints)
+ * stays untouched.
+ *
+ * `listAllThreads` answers with this model rather than `ResultList<T>` for that
+ * same reason: it needs the count field and the shared model cannot carry one.
+ * One model over both operations rather than a second of the same shape, so a
+ * client reading a filtered thread listing reads one response type whether the
+ * listing is scoped to a mailbox or spans every account.
  */
 export type RemitImapThreadSearchResponse = {
     /**
@@ -3065,7 +3072,18 @@ export type RemitImapThreadSearchResponse = {
      */
     continuationToken?: String800;
     /**
-     * How many messages the query matches, over the whole mailbox and independent of `limit`. Present only when `count=true`. With `senderTrust` or `dkimMismatch` in the query the count is over the enriched window instead, since those are resolved off the row.
+     * How much the query matches, over the whole scope and independent of `limit`.
+     * Present only when `count=true`.
+     *
+     * Each operation counts what it lists. `searchThreads` lists messages of one
+     * mailbox and counts messages; with `senderTrust` or `dkimMismatch` in the
+     * query that count is over the enriched window instead, since those are
+     * resolved off the row. `listAllThreads` counts CONVERSATIONS across every
+     * non-muted mailbox of every account — a thread holding two matching messages
+     * counts once, and so does one message reachable through a real folder and a
+     * virtual copy of it — because that is what the cross-account listing renders
+     * after collapsing by `threadId`. A count that disagreed with the rows beneath
+     * it would be a third number for the same set.
      */
     count?: number;
 };
@@ -3769,11 +3787,18 @@ export type RemitImapThreadMessageResponseWritable = {
 };
 
 /**
- * Aggregate response for `searchThreads`. Carries the matching rows (`items`), a
- * pagination `continuationToken`, and an optional `count` of every message the
- * query matches. `items` is omitted when `results=false` (count-only); `count` is
- * present only when `count=true`. Thread-specific so the shared `ResultList<T>`
- * (7 endpoints) stays untouched.
+ * Aggregate response for the filterable thread listings — `searchThreads` and
+ * `listAllThreads`. Carries the matching rows (`items`), a pagination
+ * `continuationToken`, and an optional `count` of what the query matches.
+ * `items` is omitted when `results=false` (count-only); `count` is present only
+ * when `count=true`. Thread-specific so the shared `ResultList<T>` (7 endpoints)
+ * stays untouched.
+ *
+ * `listAllThreads` answers with this model rather than `ResultList<T>` for that
+ * same reason: it needs the count field and the shared model cannot carry one.
+ * One model over both operations rather than a second of the same shape, so a
+ * client reading a filtered thread listing reads one response type whether the
+ * listing is scoped to a mailbox or spans every account.
  */
 export type RemitImapThreadSearchResponseWritable = {
     /**
@@ -3785,7 +3810,18 @@ export type RemitImapThreadSearchResponseWritable = {
      */
     continuationToken?: String800;
     /**
-     * How many messages the query matches, over the whole mailbox and independent of `limit`. Present only when `count=true`. With `senderTrust` or `dkimMismatch` in the query the count is over the enriched window instead, since those are resolved off the row.
+     * How much the query matches, over the whole scope and independent of `limit`.
+     * Present only when `count=true`.
+     *
+     * Each operation counts what it lists. `searchThreads` lists messages of one
+     * mailbox and counts messages; with `senderTrust` or `dkimMismatch` in the
+     * query that count is over the enriched window instead, since those are
+     * resolved off the row. `listAllThreads` counts CONVERSATIONS across every
+     * non-muted mailbox of every account — a thread holding two matching messages
+     * counts once, and so does one message reachable through a real folder and a
+     * virtual copy of it — because that is what the cross-account listing renders
+     * after collapsing by `threadId`. A count that disagreed with the rows beneath
+     * it would be a third number for the same set.
      */
     count?: number;
 };
@@ -5775,6 +5811,26 @@ export type UnifiedThreadOperationsListAllThreadsData = {
          * Free text to match against subject and From address. Supplying it switches the listing into search mode, which widens the scope past INBOX to every non-muted mailbox — see the operation description. Omitting it leaves the listing unchanged.
          */
         query?: string;
+        /**
+         * Filter to messages with one of these header-derived categories, as a union over the values given. Applied as a SQL predicate over the whole scope, so a page comes back full of matches however rare the category is. `uncategorized` is one of them — the pending state's name, never the absence of one.
+         */
+        category?: Array<RemitImapMessageCategory>;
+        /**
+         * When true, return only unread messages. A column on the row, so it narrows the query rather than the page.
+         */
+        unread?: boolean;
+        /**
+         * When true, return only messages carrying an attachment. A column on the row, so it narrows the query rather than the page.
+         */
+        attachments?: boolean;
+        /**
+         * Include how many messages the listing matches. Counted over the whole scope, independent of `limit`.
+         */
+        count?: boolean;
+        /**
+         * Return matching rows. Default true; set false for a count-only response.
+         */
+        results?: boolean;
     };
     url: '/threads';
 };
@@ -5783,13 +5839,7 @@ export type UnifiedThreadOperationsListAllThreadsResponses = {
     /**
      * The request has succeeded.
      */
-    200: {
-        /**
-         * Opaque, server-minted cursor: absent means the first (or last) page, present means resume from here. Echo it back unchanged to fetch the next page. Every listing endpoint that accepts it rejects a token it cannot decode with 400 ValidationError rather than silently restarting from the first page (#136, #172).
-         */
-        continuationToken?: String800;
-        items: Array<RemitImapThreadMessageResponse>;
-    };
+    200: RemitImapThreadSearchResponse;
 };
 
 export type UnifiedThreadOperationsListAllThreadsResponse = UnifiedThreadOperationsListAllThreadsResponses[keyof UnifiedThreadOperationsListAllThreadsResponses];