@belonguniverseai/react-sdk 0.6.33 → 0.6.35

package/dist/api/computer.d.ts

@@ -0,0 +1,60 @@
+import { z } from 'zod';
+import { ApiClient } from './client.ts';
+declare const computerDeviceSchema: z.ZodObject<{
+    deviceId: z.ZodUUID;
+    name: z.ZodString;
+    os: z.ZodEnum<{
+        macos: "macos";
+        windows: "windows";
+        linux: "linux";
+    }>;
+    appVersion: z.ZodString;
+    pairedAt: z.ZodISODateTime;
+    lastSeenAt: z.ZodNullable<z.ZodISODateTime>;
+    online: z.ZodBoolean;
+}, z.core.$strip>;
+declare const computerStatusSchema: z.ZodObject<{
+    device: z.ZodNullable<z.ZodObject<{
+        deviceId: z.ZodUUID;
+        name: z.ZodString;
+        os: z.ZodEnum<{
+            macos: "macos";
+            windows: "windows";
+            linux: "linux";
+        }>;
+        appVersion: z.ZodString;
+        pairedAt: z.ZodISODateTime;
+        lastSeenAt: z.ZodNullable<z.ZodISODateTime>;
+        online: z.ZodBoolean;
+    }, z.core.$strip>>;
+    downloadUrl: z.ZodNullable<z.ZodURL>;
+}, z.core.$strip>;
+export type ComputerDevice = z.infer<typeof computerDeviceSchema>;
+export type ComputerStatus = z.infer<typeof computerStatusSchema>;
+export declare const fetchComputerStatus: (client: ApiClient) => Promise<ComputerStatus>;
+/** A one-time code; single attempt, since a retried POST would mint a second one. */
+export declare const createComputerPairing: (client: ApiClient) => Promise<{
+    pairingCode: string;
+    expiresAt: string;
+}>;
+export declare const revokeComputer: (client: ApiClient) => Promise<void>;
+/**
+ * The deep link the desktop app registers for. It carries the API this dock
+ * talks to (an absolute URL, resolved against the host page), so the app
+ * pairs with the right regional cell without asking.
+ */
+export declare const computerPairingLink: (pairingCode: string, apiBaseUrl: string) => string;
+export declare const useComputerStatus: (ownerCacheKey: string) => import('@tanstack/react-query').UseQueryResult<NoInfer<{
+    device: {
+        deviceId: string;
+        name: string;
+        os: "macos" | "windows" | "linux";
+        appVersion: string;
+        pairedAt: string;
+        lastSeenAt: string | null;
+        online: boolean;
+    } | null;
+    downloadUrl: string | null;
+}>, Error>;
+export declare const useRevokeComputer: (ownerCacheKey: string) => () => Promise<void>;
+export {};

package/dist/api/goals.d.ts

@@ -1,9 +1,9 @@
 import { z } from 'zod';
 export declare const goalStatusSchema: z.ZodEnum<{
-    waiting_for_approval: "waiting_for_approval";
     active: "active";
     paused: "paused";
     blocked: "blocked";
+    waiting_for_approval: "waiting_for_approval";
     clarifying: "clarifying";
     completion_claimed: "completion_claimed";
     deferred: "deferred";
@@ -25,10 +25,10 @@ export declare const goalJournalEntrySchema: z.ZodObject<{
     kind: z.ZodString;
     actor: z.ZodString;
     toStatus: z.ZodNullable<z.ZodEnum<{
-        waiting_for_approval: "waiting_for_approval";
         active: "active";
         paused: "paused";
         blocked: "blocked";
+        waiting_for_approval: "waiting_for_approval";
         clarifying: "clarifying";
         completion_claimed: "completion_claimed";
         deferred: "deferred";
@@ -45,10 +45,10 @@ export type GoalJournalEntry = z.infer<typeof goalJournalEntrySchema>;
 export declare const goalViewSchema: z.ZodObject<{
     goalId: z.ZodString;
     status: z.ZodEnum<{
-        waiting_for_approval: "waiting_for_approval";
         active: "active";
         paused: "paused";
         blocked: "blocked";
+        waiting_for_approval: "waiting_for_approval";
         clarifying: "clarifying";
         completion_claimed: "completion_claimed";
         deferred: "deferred";
@@ -90,10 +90,10 @@ export declare const goalViewSchema: z.ZodObject<{
         kind: z.ZodString;
         actor: z.ZodString;
         toStatus: z.ZodNullable<z.ZodEnum<{
-            waiting_for_approval: "waiting_for_approval";
             active: "active";
             paused: "paused";
             blocked: "blocked";
+            waiting_for_approval: "waiting_for_approval";
             clarifying: "clarifying";
             completion_claimed: "completion_claimed";
             deferred: "deferred";

package/dist/api/guide.d.ts

@@ -7,9 +7,16 @@ export type GuideState = {
 } | {
     readonly status: "unavailable";
 };
-export declare const fetchGuide: (client: ApiClient, locale: Locale) => Promise<GuideState>;
 /**
- * Keyed by locale only: the guide is public and deployment-wide, so it has no
- * account key. A language switch is a new key, so the view refetches.
+ * `pinnedChat`: this dock shows the personal agent's pinned chat (BEL-348). It is
+ * turned on per user and the guide route has no actor, so the dock says so, and
+ * the cloud adds the section about Sima. `pinnedChatEmail`: it also offers this
+ * user that chat's messages by email, so the cloud adds the paragraph about that.
  */
-export declare const useGuide: (locale: Locale) => import('@tanstack/react-query').UseQueryResult<NoInfer<GuideState>, Error>;
+export declare const fetchGuide: (client: ApiClient, locale: Locale, pinnedChat?: boolean, pinnedChatEmail?: boolean) => Promise<GuideState>;
+/**
+ * Keyed by locale (and whether this dock shows the pinned chat): the guide is
+ * public and deployment-wide, so it has no account key. A language switch is a
+ * new key, so the view refetches.
+ */
+export declare const useGuide: (locale: Locale, pinnedChat?: boolean, pinnedChatEmail?: boolean) => import('@tanstack/react-query').UseQueryResult<NoInfer<GuideState>, Error>;

package/dist/api/proactive.d.ts

@@ -0,0 +1,47 @@
+import { z } from 'zod';
+import { ApiClient } from './client.ts';
+declare const proactiveSchema: z.ZodObject<{
+    enabled: z.ZodBoolean;
+    lastCheckAt: z.ZodNullable<z.ZodISODateTime>;
+    nextCheckAt: z.ZodNullable<z.ZodISODateTime>;
+    checkingCount: z.ZodNumber;
+    slackAvailable: z.ZodBoolean;
+    emailEnabled: z.ZodDefault<z.ZodBoolean>;
+    emailAddress: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    watchedApps: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    readsConnectedApps: z.ZodDefault<z.ZodBoolean>;
+    readsSimetrik: z.ZodDefault<z.ZodBoolean>;
+    chat: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        sessionId: z.ZodString;
+        unreadCount: z.ZodNumber;
+        lastMessageAt: z.ZodNullable<z.ZodISODateTime>;
+        lastMessage: z.ZodNullable<z.ZodString>;
+        activeRunId: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type Proactive = z.infer<typeof proactiveSchema>;
+export type ProactiveState = {
+    readonly status: "ready";
+    readonly proactive: Proactive;
+} | {
+    readonly status: "unavailable";
+};
+/** The pinned chat, created on first use, moved to the Workspace it's opened from. */
+export declare const openPinnedChat: (client: ApiClient, workspaceExternalId: string | null) => Promise<string>;
+export declare const fetchProactive: (client: ApiClient) => Promise<ProactiveState>;
+/** How often the dock re-reads it, and how often while a check is deciding. */
+export declare const PROACTIVE_POLL_MS = 30000;
+export declare const PROACTIVE_ACTIVE_POLL_MS = 4000;
+/** Keyed by the account speaking to the API, so it is purged on a switch. */
+export declare const useProactive: () => import('@tanstack/react-query').UseQueryResult<NoInfer<ProactiveState>, Error>;
+/**
+ * What the dock already read, without ever asking: for a surface that only needs
+ * to know whether the pinned chat is on (the Guide). The dock's own poll keeps it
+ * current; nothing here starts a request.
+ */
+export declare const usePeekProactive: () => import('@tanstack/react-query').UseQueryResult<NoInfer<ProactiveState>, Error>;
+export declare const useSetProactiveEnabled: () => import('@tanstack/react-query').UseMutationResult<void, Error, boolean, unknown>;
+export declare const useSetProactiveEmail: () => import('@tanstack/react-query').UseMutationResult<void, Error, boolean, unknown>;
+export declare const useCheckNow: () => import('@tanstack/react-query').UseMutationResult<number, Error, void, unknown>;
+export declare const useMarkProactiveRead: () => import('@tanstack/react-query').UseMutationResult<void, Error, void, unknown>;
+export {};

package/dist/api/query-keys.d.ts

@@ -1,6 +1,10 @@
 import { Locale } from '../embed/locale.ts';
 export declare const queryKeys: {
     sessions: readonly ["belong", "sessions"];
+    /** Proactive checks: ACCOUNT-scoped, like `myUsage` below (BEL-348). */
+    proactive: (accountKey: string) => readonly ["belong", "proactive", string];
+    /** A mint, per account and Workspace. `workspaceKey` is "" when unscoped. */
+    agentComputerLink: (accountKey: string, workspaceKey: string) => readonly ["belong", "agent-computer-link", string, string];
     session: (sessionId: string) => readonly ["belong", "sessions", string];
     sessionStats: (sessionId: string) => readonly ["belong", "session-stats", string];
     messages: (sessionId: string) => readonly ["belong", "sessions", string, "messages"];
@@ -42,7 +46,18 @@ export declare const queryKeys: {
     agentGrant: (provider: string, scopeExternalId: string) => readonly ["belong", "agent-grant", string, string];
     /** Invalidation prefix for every task-schedule read (list + detail + runs). */
     taskSchedules: readonly ["belong", "task-schedules"];
+    /**
+     * Shared tasks (#613), ACCOUNT-scoped like the schedule reads below, with the
+     * account right after the prefix. The list, one shared task and "Accepting as
+     * …" carry titles, instructions, recipient email addresses and the caller's
+     * own sharing account, so a host that swaps accounts in place must never
+     * paint the previous user's.
+     */
+    sharedScheduleList: (accountKey: string) => readonly ["belong", "task-schedules", "shared-list", string];
+    sharedScheduleDetail: (accountKey: string, definitionId: string | null) => readonly ["belong", "task-schedules", "shared-detail", string, string | null];
+    sharingAccount: (accountKey: string) => readonly ["belong", "task-schedules", "sharing-account", string];
     apiKeys: (ownerCacheKey: string) => readonly ["belong", "api-keys", string];
+    computer: (ownerCacheKey: string) => readonly ["belong", "computer", string];
     /**
      * Plan 018 — the signed-in user's own usage. ACCOUNT-scoped (`accountKey`
      * from `api/account-scope.ts`, right after the prefix like the schedule keys),
@@ -54,7 +69,7 @@ export declare const queryKeys: {
      * The Simetrik agent Guide in one dock language. Public and deployment-wide,
      * so it carries no account key; the locale is the whole identity.
      */
-    guide: (locale: Locale) => readonly ["belong", "guide", import('../component').BelongLocale];
+    guide: (locale: Locale, pinnedChat?: boolean, pinnedChatEmail?: boolean) => readonly ["belong", "guide", import('../component').BelongLocale, "plain" | "pinned-chat", "email" | "no-email"];
     /**
      * Schedule reads are ACCOUNT-scoped as well as workspace-scoped (`accountKey`
      * from `api/account-scope.ts`). `/v1/task-schedules` keys off the caller, and
@@ -76,6 +91,12 @@ export declare const queryKeys: {
     taskScheduleFolders: (accountKey: string, workspaceKey: string) => readonly ["belong", "task-schedules", "folders", string, string];
     /** Who has access to one Project (and its pending links and handover). */
     projectAccess: (accountKey: string, workspaceKey: string, projectId: string) => readonly ["belong", "task-schedules", "project-access", string, string, string];
+    /**
+     * Who has access to one shared task, and its open links. Keyed by account
+     * like `projectAccess`: the share dialog shows a link straight from this
+     * read, so the previous account's answer must never serve the next one.
+     */
+    scheduleAccess: (accountKey: string, definitionId: string | null) => readonly ["belong", "task-schedules", "schedule-access", string, string | null];
     projectFiles: (accountKey: string, workspaceKey: string, projectId: string) => readonly ["belong", "task-schedules", "project-files", string, string, string];
     taskSchedule: (accountKey: string, workspaceKey: string, taskScheduleId: string) => readonly ["belong", "task-schedules", "detail", string, string, string];
     taskScheduleRuns: (accountKey: string, workspaceKey: string, taskScheduleId: string) => readonly ["belong", "task-schedules", "detail", string, string, string, "runs"];

package/dist/api/quota-refusal.d.ts

@@ -26,8 +26,8 @@ import { QuotaNoticeData } from '../stream/belong-data-parts.ts';
 declare const quotaRefusalSchema: z.ZodObject<{
     type: z.ZodLiteral<"quota_exceeded">;
     reason: z.ZodEnum<{
-        exhausted: "exhausted";
         blocked: "blocked";
+        exhausted: "exhausted";
     }>;
     limitWeightedTokens: z.ZodNumber;
     usedWeightedTokens: z.ZodNumber;

package/dist/api/task-schedule-folders.d.ts

@@ -5,18 +5,18 @@ export declare const MAX_FOLDER_DEPTH = 5;
 export declare const MAX_NODE_NAME_CHARS = 120;
 /** The caller's role in a Project: its owner, Can edit or Can view. */
 export declare const projectRoleSchema: z.ZodEnum<{
+    view: "view";
     edit: "edit";
     owner: "owner";
-    view: "view";
 }>;
 export type ProjectRole = z.infer<typeof projectRoleSchema>;
 declare const projectSchema: z.ZodObject<{
     projectId: z.ZodUUID;
     name: z.ZodString;
     role: z.ZodDefault<z.ZodEnum<{
+        view: "view";
         edit: "edit";
         owner: "owner";
-        view: "view";
     }>>;
     scheduleCount: z.ZodNumber;
     createdAt: z.ZodISODateTime;
@@ -41,7 +41,7 @@ export type TaskSchedulePlacement = {
 export declare const useProjects: () => import('@tanstack/react-query').UseQueryResult<NoInfer<{
     projectId: string;
     name: string;
-    role: "edit" | "owner" | "view";
+    role: "view" | "edit" | "owner";
     scheduleCount: number;
     createdAt: string;
     updatedAt: string;
@@ -85,7 +85,7 @@ export declare const useDeleteTaskScheduleFolder: () => import('@tanstack/react-
 /** Move a schedule into a Project (and optional folder), or out of every Project. Changes nothing else. */
 export declare const usePlaceTaskSchedule: () => import('@tanstack/react-query').UseMutationResult<{
     taskScheduleId: string;
-    status: "completed" | "active" | "paused" | "deleted";
+    status: "active" | "completed" | "paused" | "deleted";
 }, Error, {
     readonly taskScheduleId: string;
     readonly placement: TaskSchedulePlacement;

package/dist/api/task-schedule-projects.d.ts

@@ -2,24 +2,24 @@ import { z } from 'zod';
 export type ProjectGrantRole = "view" | "edit";
 declare const projectAccessSchema: z.ZodObject<{
     role: z.ZodEnum<{
+        view: "view";
         edit: "edit";
         owner: "owner";
-        view: "view";
     }>;
     people: z.ZodArray<z.ZodObject<{
         userId: z.ZodString;
         label: z.ZodString;
         role: z.ZodEnum<{
+            view: "view";
             edit: "edit";
             owner: "owner";
-            view: "view";
         }>;
     }, z.core.$strip>>;
     invitations: z.ZodArray<z.ZodObject<{
         id: z.ZodUUID;
         role: z.ZodEnum<{
-            edit: "edit";
             view: "view";
+            edit: "edit";
         }>;
         expiresAt: z.ZodISODateTime;
         token: z.ZodNullable<z.ZodString>;
@@ -42,15 +42,15 @@ export type ProjectFile = z.infer<typeof projectFilesSchema>["files"][number];
 /** The Files tab's upload cap, mirrored from the cloud. */
 export declare const MAX_PROJECT_FILE_BYTES: number;
 export declare const useProjectAccess: (projectId: string) => import('@tanstack/react-query').UseQueryResult<NoInfer<{
-    role: "edit" | "owner" | "view";
+    role: "view" | "edit" | "owner";
     people: {
         userId: string;
         label: string;
-        role: "edit" | "owner" | "view";
+        role: "view" | "edit" | "owner";
     }[];
     invitations: {
         id: string;
-        role: "edit" | "view";
+        role: "view" | "edit";
         expiresAt: string;
         token: string | null;
     }[];
@@ -80,7 +80,7 @@ export declare const useChangeProjectAccess: () => import('@tanstack/react-query
 }, unknown>;
 export declare const useAcceptProjectInvitation: () => import('@tanstack/react-query').UseMutationResult<{
     projectId: string;
-    role: "edit" | "owner" | "view";
+    role: "view" | "edit" | "owner";
 }, Error, string, unknown>;
 export declare const useDeleteProject: () => import('@tanstack/react-query').UseMutationResult<void, Error, string, unknown>;
 /** Offer the Project to someone with access, or (`toUserId: null`) withdraw the offer. */

package/dist/api/task-schedules.d.ts

@@ -137,8 +137,8 @@ export declare const recurrenceSchema: z.ZodPipe<z.ZodObject<{
     intervalMinutes?: number | undefined;
 }>>;
 export declare const taskScheduleSeriesStatusSchema: z.ZodEnum<{
-    completed: "completed";
     active: "active";
+    completed: "completed";
     paused: "paused";
     deleted: "deleted";
 }>;
@@ -151,8 +151,8 @@ declare const taskScheduleListItemSchema: z.ZodObject<{
     folderId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
     title: z.ZodString;
     status: z.ZodEnum<{
-        completed: "completed";
         active: "active";
+        completed: "completed";
         paused: "paused";
         deleted: "deleted";
     }>;
@@ -193,9 +193,9 @@ declare const taskScheduleListItemSchema: z.ZodObject<{
     nextRunAt: z.ZodNullable<z.ZodISODateTime>;
     lastRun: z.ZodNullable<z.ZodObject<{
         status: z.ZodEnum<{
-            failed: "failed";
             running: "running";
             completed: "completed";
+            failed: "failed";
         }>;
         at: z.ZodNullable<z.ZodISODateTime>;
     }, z.core.$strip>>;
@@ -210,8 +210,8 @@ export declare const taskScheduleDetailSchema: z.ZodObject<{
     folderId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
     title: z.ZodString;
     status: z.ZodEnum<{
-        completed: "completed";
         active: "active";
+        completed: "completed";
         paused: "paused";
         deleted: "deleted";
     }>;
@@ -252,18 +252,18 @@ export declare const taskScheduleDetailSchema: z.ZodObject<{
     nextRunAt: z.ZodNullable<z.ZodISODateTime>;
     lastRun: z.ZodNullable<z.ZodObject<{
         status: z.ZodEnum<{
-            failed: "failed";
             running: "running";
             completed: "completed";
+            failed: "failed";
         }>;
         at: z.ZodNullable<z.ZodISODateTime>;
     }, z.core.$strip>>;
     messagePreview: z.ZodString;
     createdAt: z.ZodISODateTime;
     projectRole: z.ZodDefault<z.ZodNullable<z.ZodEnum<{
+        view: "view";
         edit: "edit";
         owner: "owner";
-        view: "view";
     }>>>;
     emailAddresses: z.ZodOptional<z.ZodEnum<{
         visible: "visible";
@@ -357,9 +357,9 @@ export declare const taskScheduleRunSchema: z.ZodObject<{
         paused: "paused";
     }>>>;
     displayStatus: z.ZodEnum<{
-        failed: "failed";
         running: "running";
         completed: "completed";
+        failed: "failed";
         needs_attention: "needs_attention";
         stopped_early: "stopped_early";
     }>;
@@ -372,6 +372,7 @@ export declare const taskScheduleRunSchema: z.ZodObject<{
     runId: z.ZodDefault<z.ZodNullable<z.ZodUUID>>;
     delivery: z.ZodCatch<z.ZodDefault<z.ZodNullable<z.ZodObject<{
         outcome: z.ZodEnum<{
+            unknown: "unknown";
             partial: "partial";
             sent: "sent";
             not_sent: "not_sent";
@@ -387,8 +388,9 @@ export declare const taskScheduleRunSchema: z.ZodObject<{
                 schedule_email: "schedule_email";
             }>;
             status: z.ZodEnum<{
-                failed: "failed";
+                unknown: "unknown";
                 pending: "pending";
+                failed: "failed";
                 skipped: "skipped";
                 sent: "sent";
             }>;
@@ -396,6 +398,22 @@ export declare const taskScheduleRunSchema: z.ZodObject<{
             subject: z.ZodNullable<z.ZodString>;
             providerMessageId: z.ZodNullable<z.ZodString>;
             sentAt: z.ZodNullable<z.ZodISODateTime>;
+            providerEvent: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                type: z.ZodEnum<{
+                    failed: "failed";
+                    accepted: "accepted";
+                    delivered: "delivered";
+                    delivery_delayed: "delivery_delayed";
+                    bounced: "bounced";
+                    complained: "complained";
+                    suppressed: "suppressed";
+                }>;
+                at: z.ZodISODateTime;
+                bounceType: z.ZodNullable<z.ZodEnum<{
+                    hard: "hard";
+                    soft: "soft";
+                }>>;
+            }, z.core.$strip>>>;
             to: z.ZodOptional<z.ZodArray<z.ZodString>>;
             cc: z.ZodOptional<z.ZodArray<z.ZodString>>;
         }, z.core.$strip>>;
@@ -435,7 +453,7 @@ export type TaskScheduleListPlace = {
 export declare const useTaskSchedules: (filter: TaskScheduleFilter, q: string, place?: TaskScheduleListPlace) => import('@tanstack/react-query').UseInfiniteQueryResult<{
     taskScheduleId: string;
     title: string;
-    status: "completed" | "active" | "paused" | "deleted";
+    status: "active" | "completed" | "paused" | "deleted";
     recurrence: {
         readonly kind: "none";
     } | {
@@ -456,7 +474,7 @@ export declare const useTaskSchedules: (filter: TaskScheduleFilter, q: string, p
     timezone: string;
     nextRunAt: string | null;
     lastRun: {
-        status: "failed" | "running" | "completed";
+        status: "running" | "completed" | "failed";
         at: string | null;
     } | null;
     messagePreview: string;
@@ -465,10 +483,49 @@ export declare const useTaskSchedules: (filter: TaskScheduleFilter, q: string, p
     projectId?: string | null | undefined;
     folderId?: string | null | undefined;
 }[], Error>;
+/**
+ * The first page of a list, kept fresh for a surface that shows only a few rows. Its
+ * own query: polling the list above would refetch every page Scheduled has loaded
+ * under its key. `active` is `upcoming` plus a one-shot running right now, which has
+ * no next run (task-schedule-series.repo.ts).
+ */
+export declare const useTaskSchedulesFirstPage: (filter: "active" | "completed") => import('@tanstack/react-query').UseQueryResult<NoInfer<{
+    taskScheduleId: string;
+    title: string;
+    status: "active" | "completed" | "paused" | "deleted";
+    recurrence: {
+        readonly kind: "none";
+    } | {
+        readonly kind: "daily";
+    } | {
+        readonly kind: "weekdays";
+    } | {
+        readonly kind: "weekly";
+    } | {
+        readonly kind: "custom_weekly";
+        readonly weekdays: number[];
+    } | {
+        readonly kind: "manual";
+    } | {
+        readonly kind: "interval";
+        readonly intervalMinutes: number;
+    };
+    timezone: string;
+    nextRunAt: string | null;
+    lastRun: {
+        status: "running" | "completed" | "failed";
+        at: string | null;
+    } | null;
+    messagePreview: string;
+    createdAt: string;
+    shared?: boolean | undefined;
+    projectId?: string | null | undefined;
+    folderId?: string | null | undefined;
+}[]>, Error>;
 export declare const useTaskSchedule: (taskScheduleId: string | null) => import('@tanstack/react-query').UseQueryResult<NoInfer<{
     taskScheduleId: string;
     title: string;
-    status: "completed" | "active" | "paused" | "deleted";
+    status: "active" | "completed" | "paused" | "deleted";
     recurrence: {
         readonly kind: "none";
     } | {
@@ -489,12 +546,12 @@ export declare const useTaskSchedule: (taskScheduleId: string | null) => import(
     timezone: string;
     nextRunAt: string | null;
     lastRun: {
-        status: "failed" | "running" | "completed";
+        status: "running" | "completed" | "failed";
         at: string | null;
     } | null;
     messagePreview: string;
     createdAt: string;
-    projectRole: "edit" | "owner" | "view" | null;
+    projectRole: "view" | "edit" | "owner" | null;
     explicitTitle: string | null;
     message: string;
     mode: "plan" | "approve" | "balanced" | "bypass";
@@ -563,7 +620,7 @@ export declare const useTaskScheduleRuns: (taskScheduleId: string | null) => imp
     taskScheduleRunId: string;
     occurrenceKind: "manual" | "scheduled";
     seriesStatusAtRequest: "active" | "paused" | null;
-    displayStatus: "failed" | "running" | "completed" | "needs_attention" | "stopped_early";
+    displayStatus: "running" | "completed" | "failed" | "needs_attention" | "stopped_early";
     scheduledFor: string;
     startedAt: string | null;
     finishedAt: string | null;
@@ -572,20 +629,31 @@ export declare const useTaskScheduleRuns: (taskScheduleId: string | null) => imp
     taskId: string | null;
     runId: string | null;
     delivery: {
-        outcome: "partial" | "sent" | "not_sent";
+        outcome: "unknown" | "partial" | "sent" | "not_sent";
         reason: "no_match" | "missing_outcome" | "provider_failed" | null;
         emails: {
             source: "send_email" | "schedule_email";
-            status: "failed" | "pending" | "skipped" | "sent";
+            status: "unknown" | "pending" | "failed" | "skipped" | "sent";
             recipientCount: number | null;
             subject: string | null;
             providerMessageId: string | null;
             sentAt: string | null;
+            providerEvent?: {
+                type: "failed" | "accepted" | "delivered" | "delivery_delayed" | "bounced" | "complained" | "suppressed";
+                at: string;
+                bounceType: "hard" | "soft" | null;
+            } | null | undefined;
             to?: string[] | undefined;
             cc?: string[] | undefined;
         }[];
     } | null;
 }[], Error>;
+/**
+ * The newest run of each schedule, while it's on screen. The list's `lastRun` says
+ * "running" for a run that stopped to wait on the user; only the runs endpoint can
+ * tell, and only by asking again.
+ */
+export declare const useLatestTaskScheduleRuns: (taskScheduleIds: readonly string[]) => ReadonlyMap<string, TaskScheduleRun>;
 export type CreateTaskScheduleSeriesInput = {
     readonly scheduledFor: string;
     readonly timeExpression: string;
@@ -633,16 +701,55 @@ export declare const useCreateTaskSchedule: () => import('@tanstack/react-query'
 }, Error, CreateTaskScheduleSeriesInput, unknown>;
 export declare const useUpdateTaskSchedule: () => import('@tanstack/react-query').UseMutationResult<{
     taskScheduleId: string;
-    status: "completed" | "active" | "paused" | "deleted";
+    status: "active" | "completed" | "paused" | "deleted";
     nextRunAt: string | null;
 }, Error, UpdateTaskScheduleSeriesInput, unknown>;
 export declare const usePauseTaskSchedule: () => import('@tanstack/react-query').UseMutationResult<{
     status: "paused";
 }, Error, string, unknown>;
 export declare const useResumeTaskSchedule: () => import('@tanstack/react-query').UseMutationResult<{
-    status: "completed" | "active" | "needs_attention";
+    status: "active" | "completed" | "needs_attention";
     nextRunAt: string | null;
 }, Error, string, unknown>;
+/** #851 — what a bulk pause answers: each task counted once, and the ids an Undo resumes. */
+declare const bulkPauseResultSchema: z.ZodObject<{
+    paused: z.ZodNumber;
+    alreadyPaused: z.ZodNumber;
+    completed: z.ZodNumber;
+    notFound: z.ZodNumber;
+    pausedTaskScheduleIds: z.ZodArray<z.ZodUUID>;
+}, z.core.$strip>;
+export type BulkPauseResult = z.infer<typeof bulkPauseResultSchema>;
+/** #851 — pause every task in a Project folder and in the folders under it, in one write. */
+export declare const usePauseTaskScheduleFolder: () => import('@tanstack/react-query').UseMutationResult<{
+    paused: number;
+    alreadyPaused: number;
+    completed: number;
+    notFound: number;
+    pausedTaskScheduleIds: string[];
+}, Error, string, unknown>;
+/**
+ * #851 — how a resume of many ids ended. `needsAttention` tasks stayed
+ * paused (their connection or shared original needs fixing). When a chunk
+ * fails, the chunks before it have already resumed, so `incomplete` keeps
+ * that count and `unconfirmedIds` (the failed chunk and every later one) to
+ * retry. Resume is idempotent: an id that did resume answers `notPaused`.
+ */
+export type BulkResumeOutcome = {
+    readonly status: "resumed";
+    readonly resumed: number;
+    readonly needsAttention: number;
+} | {
+    readonly status: "incomplete";
+    readonly resumed: number;
+    readonly needsAttention: number;
+    readonly unconfirmedIds: readonly string[];
+};
+/**
+ * #851 — resume exactly these tasks: the Undo of a bulk pause, which can
+ * return more ids than one resume takes, so they go 100 at a time.
+ */
+export declare const useResumeTaskSchedulesByIds: () => import('@tanstack/react-query').UseMutationResult<BulkResumeOutcome, Error, readonly string[], unknown>;
 /** The two statuses run-now accepts — what the UI showed when it asked (#837). */
 export type RunNowSeriesStatus = "active" | "paused";
 /** The 409 run-now answers when the task's status is no longer the expected one. */