@object-ui/app-shell 6.2.3 → 7.0.0

package/dist/hooks/useHomeInbox.js

@@ -0,0 +1,142 @@
+/**
+ * useHomeInbox
+ *
+ * One-shot fetch of the inbox streams the Home work-dashboard surfaces:
+ *   - pendingApprovalsCount — items waiting on the user (REST endpoint)
+ *   - notifications         — latest in-app inbox messages (assignments/@mentions)
+ *   - activities            — recent human activity feed (sys_activity)
+ *
+ * Everything degrades silently to empty on 404 / error so deployments without
+ * the approvals plugin, the inbox pipeline, or a `sys_activity` object still
+ * render Home. Unlike the top-bar bell (AppHeader) this does NOT poll — Home is
+ * a landing surface, one fetch on mount is enough; the bell stays the live
+ * source of truth. Query shapes mirror AppHeader so the two never diverge.
+ *
+ * @module
+ */
+import { useEffect, useRef, useState } from 'react';
+import { useAdapter } from '../providers/AdapterProvider';
+import { useAuth } from '@object-ui/auth';
+export function useHomeInbox(limit = 5) {
+    const dataSource = useAdapter();
+    const { user } = useAuth();
+    const [pendingApprovalsCount, setPendingApprovalsCount] = useState(0);
+    const [notifications, setNotifications] = useState([]);
+    const [activities, setActivities] = useState([]);
+    const mountedRef = useRef(true);
+    useEffect(() => {
+        mountedRef.current = true;
+        return () => { mountedRef.current = false; };
+    }, []);
+    // Recent activity (sys_activity). Raw rows use plugin-audit's column names
+    // (actor_name / summary / object_name / timestamp); map onto ActivityItem and
+    // keep only real human actions — drop sys_*/ai_* system churn (UUID-titled,
+    // actor "System"). Degrades to [] if the object is absent.
+    useEffect(() => {
+        if (!dataSource)
+            return;
+        let cancelled = false;
+        Promise.resolve(dataSource.find('sys_activity', { $orderby: { timestamp: 'desc' }, $top: 20 }))
+            .then((res) => {
+            if (cancelled || !mountedRef.current)
+                return;
+            const rows = Array.isArray(res?.data) ? res.data : [];
+            const mapped = rows
+                .filter((r) => {
+                if (!r || typeof r.type !== 'string')
+                    return false;
+                if (!(r.summary ?? '').toString().trim())
+                    return false;
+                const actor = String(r.actor_name ?? '').trim();
+                return actor.length > 0 && actor.toLowerCase() !== 'system';
+            })
+                .map((r) => {
+                let when = r.timestamp;
+                if (!when || when === 'NOW()' || Number.isNaN(Date.parse(when)))
+                    when = r.created_at;
+                const raw = String(r.type);
+                const type = raw === 'commented' || raw === 'mentioned' ? 'comment'
+                    : raw === 'deleted' ? 'delete'
+                        : raw === 'created' ? 'create'
+                            : 'update';
+                return {
+                    id: String(r.id),
+                    type,
+                    objectName: r.object_name ?? '',
+                    recordId: r.record_id ?? undefined,
+                    user: r.actor_name ?? 'System',
+                    description: r.summary ?? '',
+                    timestamp: when ?? '',
+                };
+            })
+                .slice(0, limit);
+            setActivities(mapped);
+        })
+            .catch(() => { });
+        return () => { cancelled = true; };
+    }, [dataSource, limit]);
+    // Latest in-app inbox messages (assignments / @mentions / alerts).
+    useEffect(() => {
+        if (!dataSource || !user?.id)
+            return;
+        let cancelled = false;
+        Promise.resolve(dataSource.find('sys_inbox_message', {
+            $filter: { user_id: user.id },
+            $orderby: { created_at: 'desc' },
+            $top: limit,
+        }))
+            .then((res) => {
+            if (cancelled || !mountedRef.current)
+                return;
+            const rows = Array.isArray(res?.data) ? res.data : [];
+            const seenTitles = new Set();
+            const deduped = rows
+                .filter((m) => m && (m.title ?? '').toString().trim())
+                .map((m) => ({
+                id: String(m.id),
+                title: String(m.title),
+                actionUrl: m.action_url ?? undefined,
+                createdAt: m.created_at ?? undefined,
+            }))
+                // Collapse repeated identical notifications (e.g. recurring digests)
+                // — keep the most recent of each title (rows are newest-first).
+                .filter((n) => (seenTitles.has(n.title) ? false : (seenTitles.add(n.title), true)));
+            setNotifications(deduped);
+        })
+            .catch(() => { });
+        return () => { cancelled = true; };
+    }, [dataSource, user?.id, limit]);
+    // Pending-approvals count (framework REST endpoint). 404 / error → 0.
+    useEffect(() => {
+        if (!user?.id)
+            return;
+        const serverUrl = (import.meta.env?.VITE_SERVER_URL || '').replace(/\/$/, '');
+        const identities = [];
+        if (user.id)
+            identities.push(user.id);
+        if (user.email)
+            identities.push(user.email);
+        for (const r of (user.roles || [])) {
+            if (r)
+                identities.push(`role:${r}`);
+        }
+        if (identities.length === 0)
+            return;
+        let cancelled = false;
+        const qs = new URLSearchParams({ status: 'pending', approverId: identities.join(',') });
+        fetch(`${serverUrl}/api/v1/approvals/requests?${qs}`, { credentials: 'include' })
+            .then(async (res) => {
+            if (!res.ok)
+                return;
+            const payload = await res.json().catch(() => null);
+            const seen = new Set();
+            for (const row of (payload?.data || []))
+                seen.add(row.id);
+            if (!cancelled && mountedRef.current)
+                setPendingApprovalsCount(seen.size);
+        })
+            .catch(() => { });
+        return () => { cancelled = true; };
+    }, [user?.id]);
+    return { pendingApprovalsCount, notifications, activities };
+}

package/dist/hooks/useNavPins.js

@@ -13,36 +13,30 @@
  * @module
  */
 import { useCallback, useMemo } from 'react';
+import { resolveHref } from '@object-ui/layout';
 import { useFavorites } from '../context/FavoritesProvider';
 const MAX_PINS = 20;
 /**
  * Synthesize the `href` for a NavigationItem in isolation from a sidebar.
  *
- * This duplicates a small portion of `NavigationRenderer.resolveHref` to keep
- * the favorite record self-describing — useful if a future iteration surfaces
- * nav-pins outside the sidebar (e.g. command palette / quick-jump). Returns
- * an empty string for non-routable item types; consumers should treat empty
- * href as "fall back to live nav tree".
+ * Delegates to `@object-ui/layout`'s `resolveHref` so all routing
+ * semantics (recordId templates, componentRef, viewName, …) stay
+ * consistent with what the sidebar renders.
+ *
+ * Returns an empty string for non-routable item types or unresolved
+ * `#` placeholders; consumers should treat empty href as "fall back
+ * to live nav tree". Template variables on `recordId` are NOT resolved
+ * here (no auth context at pin-storage time) — the pinned href will
+ * gracefully degrade to the list view in that case, matching what
+ * `resolveHref` does when its templateContext is missing.
  */
 function deriveHref(item, basePath = '') {
-    switch (item.type) {
-        case 'object':
-            if (!item.objectName)
-                return '';
-            return item.viewName
-                ? `${basePath}/${item.objectName}/view/${item.viewName}`
-                : `${basePath}/${item.objectName}`;
-        case 'dashboard':
-            return item.dashboardName ? `${basePath}/dashboard/${item.dashboardName}` : '';
-        case 'page':
-            return item.pageName ? `${basePath}/page/${item.pageName}` : '';
-        case 'report':
-            return item.reportName ? `${basePath}/report/${item.reportName}` : '';
-        case 'url':
-            return item.url ?? '';
-        default:
-            return '';
-    }
+    const { href, external } = resolveHref(item, basePath);
+    if (external)
+        return href;
+    if (!href || href === '#')
+        return '';
+    return href;
 }
 function favoriteIdFor(navId) {
     return `nav:${navId}`;

package/dist/hooks/useNavigationSync.d.ts

@@ -31,6 +31,39 @@ export declare function renameNavigationItems(navigation: NavigationItem[], type
  * whose key ordering is deterministic (we control object creation).
  */
 export declare function navigationEqual(a: NavigationItem[], b: NavigationItem[]): boolean;
+/**
+ * `sys_` is the platform-reserved metadata namespace (sys_organization_detail,
+ * sys_user_detail, …). Fallback signal only — see isPlatformArtifact.
+ */
+export declare function isSystemArtifactName(name: unknown): boolean;
+/**
+ * Package/platform-shipped pages and dashboards are never "something the user
+ * just created", so they must not trigger navigation sync no matter when they
+ * appear in (or vanish from) the metadata lists — package install/uninstall
+ * mid-session looks exactly like user CRUD to a name-set diff. A package that
+ * ships pages also ships (or contributes to) the navigation that exposes
+ * them; auto-syncing on top of that would duplicate entries at best and write
+ * into apps the package never intended at worst.
+ *
+ * Provenance is the primary signal: ADR-0010's applyProtection stamps
+ * `_packageId` + `_provenance: 'package'` on artifacts registered with
+ * package coords (the engine manifest path passes them). The `sys_` name
+ * prefix is only a fallback for registration paths that don't stamp
+ * provenance yet — third-party plugin pages are NOT guaranteed to carry it,
+ * which is why the field check comes first.
+ */
+export declare function isPlatformArtifact(item: unknown): boolean;
+/**
+ * Whether an app may be targeted by automatic navigation writes.
+ *
+ * ADR-0010 metadata protection: the loader stamps a `_lock` envelope on
+ * packaged artifacts (translated from the author-facing `protection` block,
+ * e.g. the `setup` app ships `protection.lock = 'full'`). Locks 'full' and
+ * 'no-overlay' reject PUT with 403 — a navigation write into such an app can
+ * never succeed, so don't attempt it (each attempt surfaced as a red
+ * "Failed to update navigation" toast).
+ */
+export declare function isNavigationSyncableApp(app: unknown): boolean;
 export interface UseNavigationSyncReturn {
     /** Call after a new page has been created / saved for the first time. */
     syncPageCreated: (appName: string, pageName: string, label?: string) => Promise<void>;

package/dist/hooks/useNavigationSync.js

@@ -13,6 +13,8 @@ import { toast } from 'sonner';
 import { useObjectTranslation } from '@object-ui/i18n';
 import { useAdapter } from '../providers/AdapterProvider';
 import { useMetadata } from '../providers/MetadataProvider';
+import { matchAppBySegment } from '../utils/appRoute';
+import { usePreviewDrafts } from '../preview/PreviewModeContext';
 // ============================================================================
 // Pure utility helpers (exported for testing)
 // ============================================================================
@@ -87,6 +89,54 @@ export function navigationEqual(a, b) {
         return true;
     return JSON.stringify(a) === JSON.stringify(b);
 }
+/**
+ * `sys_` is the platform-reserved metadata namespace (sys_organization_detail,
+ * sys_user_detail, …). Fallback signal only — see isPlatformArtifact.
+ */
+export function isSystemArtifactName(name) {
+    return typeof name === 'string' && name.startsWith('sys_');
+}
+/**
+ * Package/platform-shipped pages and dashboards are never "something the user
+ * just created", so they must not trigger navigation sync no matter when they
+ * appear in (or vanish from) the metadata lists — package install/uninstall
+ * mid-session looks exactly like user CRUD to a name-set diff. A package that
+ * ships pages also ships (or contributes to) the navigation that exposes
+ * them; auto-syncing on top of that would duplicate entries at best and write
+ * into apps the package never intended at worst.
+ *
+ * Provenance is the primary signal: ADR-0010's applyProtection stamps
+ * `_packageId` + `_provenance: 'package'` on artifacts registered with
+ * package coords (the engine manifest path passes them). The `sys_` name
+ * prefix is only a fallback for registration paths that don't stamp
+ * provenance yet — third-party plugin pages are NOT guaranteed to carry it,
+ * which is why the field check comes first.
+ */
+export function isPlatformArtifact(item) {
+    if (!item || typeof item !== 'object')
+        return false;
+    const a = item;
+    if (a._packageId != null || a._provenance === 'package')
+        return true;
+    return isSystemArtifactName(a.name);
+}
+/**
+ * Whether an app may be targeted by automatic navigation writes.
+ *
+ * ADR-0010 metadata protection: the loader stamps a `_lock` envelope on
+ * packaged artifacts (translated from the author-facing `protection` block,
+ * e.g. the `setup` app ships `protection.lock = 'full'`). Locks 'full' and
+ * 'no-overlay' reject PUT with 403 — a navigation write into such an app can
+ * never succeed, so don't attempt it (each attempt surfaced as a red
+ * "Failed to update navigation" toast).
+ */
+export function isNavigationSyncableApp(app) {
+    if (!app || typeof app !== 'object')
+        return false;
+    const a = app;
+    const lock = a._lock ?? a.protection?.lock;
+    return lock !== 'full' && lock !== 'no-overlay';
+}
 /**
  * Hook that provides methods to keep the App navigation tree in sync with
  * Page / Dashboard CRUD operations.  Each method:
@@ -115,7 +165,7 @@ export function useNavigationSync() {
         await refreshRef.current?.();
     }, []);
     /** Find the current app schema from metadata by name. */
-    const findApp = useCallback((appName) => apps.find((a) => a.name === appName), [apps]);
+    const findApp = useCallback((appName) => matchAppBySegment(apps, appName), [apps]);
     // ------------------------------------------------------------------
     // Created
     // ------------------------------------------------------------------
@@ -324,7 +374,7 @@ export function useNavigationSync() {
     const syncPageCreatedAllApps = useCallback(async (pageName, label) => {
         for (const app of apps) {
             const name = getAppName(app);
-            if (!name)
+            if (!name || !isNavigationSyncableApp(app))
                 continue;
             await syncPageCreated(name, pageName, label);
         }
@@ -333,7 +383,7 @@ export function useNavigationSync() {
     const syncDashboardCreatedAllApps = useCallback(async (dashboardName, label) => {
         for (const app of apps) {
             const name = getAppName(app);
-            if (!name)
+            if (!name || !isNavigationSyncableApp(app))
                 continue;
             await syncDashboardCreated(name, dashboardName, label);
         }
@@ -342,7 +392,7 @@ export function useNavigationSync() {
     const syncPageDeletedAllApps = useCallback(async (pageName) => {
         for (const app of apps) {
             const name = getAppName(app);
-            if (!name)
+            if (!name || !isNavigationSyncableApp(app))
                 continue;
             await syncPageDeleted(name, pageName);
         }
@@ -351,7 +401,7 @@ export function useNavigationSync() {
     const syncDashboardDeletedAllApps = useCallback(async (dashboardName) => {
         for (const app of apps) {
             const name = getAppName(app);
-            if (!name)
+            if (!name || !isNavigationSyncableApp(app))
                 continue;
             await syncDashboardDeleted(name, dashboardName);
         }
@@ -360,7 +410,7 @@ export function useNavigationSync() {
     const syncPageRenamedAllApps = useCallback(async (oldName, newName) => {
         for (const app of apps) {
             const name = getAppName(app);
-            if (!name)
+            if (!name || !isNavigationSyncableApp(app))
                 continue;
             await syncPageRenamed(name, oldName, newName);
         }
@@ -369,7 +419,7 @@ export function useNavigationSync() {
     const syncDashboardRenamedAllApps = useCallback(async (oldName, newName) => {
         for (const app of apps) {
             const name = getAppName(app);
-            if (!name)
+            if (!name || !isNavigationSyncableApp(app))
                 continue;
             await syncDashboardRenamed(name, oldName, newName);
         }
@@ -404,10 +454,17 @@ export function useNavigationSync() {
  * > should invoke `syncPageRenamed` / `syncDashboardRenamed` explicitly.
  */
 export function NavigationSyncEffect() {
-    const { pages, dashboards, apps } = useMetadata();
+    const { pages, dashboards, apps, getTypeStatus } = useMetadata();
     const adapter = useAdapter();
     const adapterRef = useRef(adapter);
     adapterRef.current = adapter;
+    // ADR-0037 — preview is read-only by design. Entering/leaving
+    // `?preview=draft` swaps the entire metadata source, so the page/dashboard
+    // sets legitimately DIFFER from the previous render; diffing across that
+    // swap would misread draft-only (or published-only) items as user
+    // creations/deletions and WRITE navigation changes back to the real app
+    // metadata from inside a preview. Disabled for the whole preview session.
+    const previewDrafts = usePreviewDrafts();
     const { syncPageCreated, syncDashboardCreated, syncPageDeleted, syncDashboardDeleted, } = useNavigationSync();
     // Track previous page/dashboard name sets
     const prevPageNamesRef = useRef(null);
@@ -422,8 +479,35 @@ export function NavigationSyncEffect() {
     useEffect(() => {
         if (syncingRef.current)
             return;
-        const currentPageNames = new Set((pages ?? []).map((p) => p.name).filter(Boolean));
-        const currentDashNames = new Set((dashboards ?? []).map((d) => d.name).filter(Boolean));
+        if (previewDrafts) {
+            // Drop the baseline so leaving preview re-seeds instead of diffing the
+            // published world against the draft world it just stopped rendering.
+            prevPageNamesRef.current = null;
+            prevDashNamesRef.current = null;
+            return;
+        }
+        // `page` and `dashboard` are lazily-loaded metadata types: their arrays
+        // are empty (or stale) until the fetch lands, and `invalidate()` empties
+        // them again mid-session (e.g. the New-record flow reloads meta). Diffing
+        // a not-ready snapshot misreads that dip as mass deletion / re-creation —
+        // notably flagging system pages as "user added" once the full list
+        // arrives. Only seed the baseline and diff while both types are 'ready'.
+        // (Contexts without getTypeStatus — hand-rolled test values — are
+        // treated as always ready.)
+        if (getTypeStatus &&
+            (getTypeStatus('page') !== 'ready' || getTypeStatus('dashboard') !== 'ready')) {
+            return;
+        }
+        // Platform/package artifacts never participate in the diff: they ship
+        // with the platform or arrive via package install, not from user CRUD,
+        // so their appearance must not write them into app navigation (nor
+        // their disappearance delete nav entries). See isPlatformArtifact.
+        const userArtifactNames = (items) => new Set(items
+            .filter((it) => !isPlatformArtifact(it))
+            .map((it) => it?.name)
+            .filter((n) => typeof n === 'string' && n.length > 0));
+        const currentPageNames = userArtifactNames(pages ?? []);
+        const currentDashNames = userArtifactNames(dashboards ?? []);
         const prevPages = prevPageNamesRef.current;
         const prevDash = prevDashNamesRef.current;
         // First render — seed refs and exit without syncing
@@ -456,7 +540,9 @@ export function NavigationSyncEffect() {
                     if (cancelled || syncVersionRef.current !== version)
                         break;
                     const appName = getAppName(app);
-                    if (!appName)
+                    // Write-protected apps (ADR-0010 `_lock`) would 403 every PUT —
+                    // skip them instead of spraying failure toasts.
+                    if (!appName || !isNavigationSyncableApp(app))
                         continue;
                     for (const pageName of addedPages) {
                         if (cancelled)
@@ -492,6 +578,6 @@ export function NavigationSyncEffect() {
         return () => {
             cancelled = true;
         };
-    }, [pages, dashboards, apps, syncPageCreated, syncDashboardCreated, syncPageDeleted, syncDashboardDeleted]);
+    }, [pages, dashboards, apps, previewDrafts, getTypeStatus, syncPageCreated, syncDashboardCreated, syncPageDeleted, syncDashboardDeleted]);
     return null;
 }

package/dist/hooks/useReconcileOnError.d.ts

@@ -0,0 +1,40 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/**
+ * ADR-0013 D2 — shared "reconcile a stream-transport failure instead of
+ * blindly retrying" wiring, used by every chat surface (AiChatPage and the
+ * console floating chatbot) so the behaviour is identical.
+ *
+ * The agent runtime persists the final assistant reply BEFORE it streams it
+ * (framework `service-ai`), so a network drop AFTER the turn completed leaves a
+ * complete reply server-side while the client only sees a stream error. On
+ * error we GET the conversation and, if the turn actually finished
+ * (`isReconcilableCompletedTurn`), re-hydrate the thread with the persisted
+ * messages and suppress the scary "Response failed / Retry" banner — the
+ * failure becomes a non-event. A genuinely-incomplete turn still surfaces
+ * Retry, whose re-send is idempotent under D1 (same `turnId`).
+ */
+export interface ReconcileOnError {
+    /** True when the last stream error was reconciled away (turn had completed). */
+    errorSuppressed: boolean;
+    /** Wire as `useObjectChat({ onError })`. */
+    handleChatError: (err: Error) => Promise<void>;
+    /**
+     * Assign `ref.current = setMessages` from `useObjectChat` (API mode) so the
+     * thread can be re-hydrated from the server on a reconcilable failure.
+     */
+    setMessagesRef: React.MutableRefObject<((m: unknown[]) => void) | undefined>;
+    /** Call when a fresh turn is sent, to clear any prior suppression. */
+    resetSuppression: () => void;
+}
+export declare function useReconcileOnError(opts: {
+    /** The agent chat endpoint, e.g. `${apiBase}/agents/:name/chat`. */
+    chatApi?: string;
+    /** Active conversation id (no reconciliation possible without one). */
+    conversationId?: string;
+}): ReconcileOnError;

package/dist/hooks/useReconcileOnError.js

@@ -0,0 +1,37 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import { useCallback, useRef, useState } from 'react';
+import { fetchConversation, toUIMessages } from './useChatConversation';
+import { isReconcilableCompletedTurn } from '../console/ai/reconcileTurn';
+export function useReconcileOnError(opts) {
+    const { chatApi, conversationId } = opts;
+    const [errorSuppressed, setErrorSuppressed] = useState(false);
+    const setMessagesRef = useRef(undefined);
+    const handleChatError = useCallback(async (_err) => {
+        const aiBase = chatApi?.replace(/\/agents\/[^/]+\/chat$/, '');
+        if (!conversationId || !aiBase) {
+            setErrorSuppressed(false);
+            return;
+        }
+        try {
+            const conv = await fetchConversation(aiBase, conversationId);
+            const ui = toUIMessages(conv?.messages);
+            if (isReconcilableCompletedTurn(ui) && setMessagesRef.current) {
+                setMessagesRef.current(ui);
+                setErrorSuppressed(true);
+                return;
+            }
+        }
+        catch {
+            /* fall through to the normal error banner */
+        }
+        setErrorSuppressed(false);
+    }, [conversationId, chatApi]);
+    const resetSuppression = useCallback(() => setErrorSuppressed(false), []);
+    return { errorSuppressed, handleChatError, setMessagesRef, resetSuppression };
+}

package/dist/hooks/useRecordApprovals.d.ts

@@ -2,20 +2,21 @@
  * useRecordApprovals
  *
  * Resolves the approval state for a single record so the detail-view header
- * can surface "Submit for Approval" / "Recall" actions and a status badge.
+ * can surface a status badge and — when the current user is a pending
+ * approver — "Approve" / "Reject" actions.
+ *
+ * Since ADR-0019 an approval is a **flow node** (`type: 'approval'`), not a
+ * standalone process: the flow opens the request when it reaches the node,
+ * and a decision resumes the run down its `approve` / `reject` edge. There is
+ * therefore no manual "submit" or "recall" from the record header — those
+ * endpoints were removed. This hook reads the record's requests and lets a
+ * pending approver record a decision.
  *
  * Talks directly to the framework REST endpoints under
- * `/api/v1/approvals/*`. Fails open: if the approvals plugin is not
- * installed (404) or the user has no identity, returns inert state so the
- * detail view continues to render normally.
+ * `/api/v1/approvals/*`. Fails open: if the approvals plugin is not installed
+ * (404 / 501) or the user has no identity, returns inert state so the detail
+ * view continues to render normally.
  */
-export interface ApprovalProcessLite {
-    id: string;
-    name: string;
-    label?: string;
-    object_name: string;
-    active?: boolean;
-}
 export interface ApprovalRequestLite {
     id: string;
     process_name: string;
@@ -31,18 +32,16 @@ export interface ApprovalRequestLite {
 interface UseRecordApprovalsResult {
     loading: boolean;
     available: boolean;
-    processes: ApprovalProcessLite[];
     pendingRequest: ApprovalRequestLite | null;
     latestRequest: ApprovalRequestLite | null;
-    canSubmit: boolean;
-    canRecall: boolean;
-    submit: (input?: {
-        processName?: string;
+    /** The current user is among the pending approvers and may record a decision. */
+    canDecide: boolean;
+    approve: (input?: {
         comment?: string;
-    }) => Promise<ApprovalRequestLite>;
-    recall: (input?: {
+    }) => Promise<ApprovalRequestLite | undefined>;
+    reject: (input?: {
         comment?: string;
-    }) => Promise<ApprovalRequestLite>;
+    }) => Promise<ApprovalRequestLite | undefined>;
     refresh: () => Promise<void>;
 }
 export declare function useRecordApprovals(objectName: string | undefined, recordId: string | undefined, currentUserId?: string | null): UseRecordApprovalsResult;