@arbidocs/blocks 0.4.138 → 0.4.139

package/dist/connection/ConnectedAgentCreator.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Create or edit an agent, bound to the connection: describe what it is for (or start from a
+ * template), see what it can do, save. Saving creates the agent if it is new, then pins its config:
+ * the base config (the agent's own, else the library default) with its `Agents` section patched
+ * (persona with its name, model, tool switches, skills, connected tools). The workspaces ticked
+ * under Advanced are granted (standing access); an external agent then shows its one-time
+ * connection script. An avatar can be generated once it has a name.
+ */
+import { type AgentCapability, type AgentCreatorLabels, type AgentTemplate } from '../agents/definitions/AgentCreator';
+import { type AgentTypeOption } from '../agents/definitions/AgentEditorParts';
+/** The agent being edited: its id, name, picture and address. */
+export interface ConnectedAgentCreatorAgent {
+    external_id: string;
+    given_name: string;
+    picture?: string | null;
+    email?: string | null;
+}
+export interface ConnectedAgentCreatorProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    /** Present: edit it; absent: create one. */
+    agent?: ConnectedAgentCreatorAgent | null;
+    /** The name a new agent starts with (e.g. a connection that needs `SlackAssistant`). */
+    initialName?: string;
+    /** Saved: the new or updated agent's id. */
+    onSaved?: (agentExtId: string) => void;
+    capabilities?: AgentCapability[];
+    templates?: AgentTemplate[];
+    types?: AgentTypeOption<string>[];
+    /**
+     * Offer to take a granted workspace back. It re-opens workspaces on the session to do it, so a
+     * host whose session keeps one workspace open (the ARBI app) leaves it off.
+     */
+    canRevokeWorkspaces?: boolean;
+    labels?: Partial<AgentCreatorLabels>;
+}
+export declare function ConnectedAgentCreator({ open, onOpenChange, agent, initialName, onSaved, capabilities, templates, types, canRevokeWorkspaces, labels, }: ConnectedAgentCreatorProps): import("react").JSX.Element;

package/dist/connection/ConnectedWorkflowHistory.d.ts

@@ -0,0 +1,45 @@
+/**
+ * A saved workflow's history and a task's activity, bound to the connection.
+ *
+ * - `ConnectedWorkflowHistory`: every run of a workflow (re-read while shown), each with when, what
+ *   it was (a thread, an email, an AI review, a reminder) and how it went; a run's thread opens
+ *   through the environment's `openConversation`, a document action's result through the host.
+ * - `ConnectedTaskActivityDialog`: a task's timeline (re-read while it runs), with who did what.
+ */
+import { type ReactNode } from 'react';
+import { useWorkflowRuns } from '@arbidocs/react';
+import { type TaskRunView, type TaskRunsDialogLabels } from '../agents/tasks/TaskRunsDialog';
+import { type TaskPerson } from '../agents/tasks/PersonPill';
+type WorkflowRun = NonNullable<ReturnType<typeof useWorkflowRuns>['data']>[number];
+/** A run as the history lists it: when, what, on how many documents. */
+export declare function workflowRunView(run: WorkflowRun, formatDate: (iso: string) => string): TaskRunView;
+export interface ConnectedWorkflowHistoryProps {
+    /** The workflow (`null`: closed). */
+    workflow: {
+        external_id: string;
+        name: string;
+    } | null;
+    onOpenChange: (open: boolean) => void;
+    /** In the page rather than a dialog. */
+    inline?: boolean;
+    hideHeader?: boolean;
+    formatDate?: (iso: string) => string;
+    /** Open a document action's result (an AI review's fields): the host's. Absent: no Open. */
+    onOpenResult?: (run: WorkflowRun) => void;
+    /** Under a failed run: e.g. a way to report it. */
+    renderErrorReport?: (run: TaskRunView) => ReactNode;
+    labels?: Partial<TaskRunsDialogLabels>;
+}
+export declare function ConnectedWorkflowHistory({ workflow, onOpenChange, inline, hideHeader, formatDate, onOpenResult, renderErrorReport, labels, }: ConnectedWorkflowHistoryProps): import("react").JSX.Element;
+export interface ConnectedTaskActivityDialogProps {
+    conversationId: string;
+    taskName: string;
+    /** The run is generating right now: the timeline then re-reads itself every few seconds. */
+    live?: boolean;
+    onClose: () => void;
+    /** How a person shows (the host's own pill). Default: the shared pill with their name. */
+    renderPerson?: (person: TaskPerson) => ReactNode;
+    formatExact?: (iso: string) => string;
+}
+export declare function ConnectedTaskActivityDialog({ conversationId, taskName, live, onClose, renderPerson: renderTaskPerson, formatExact, }: ConnectedTaskActivityDialogProps): import("react").JSX.Element;
+export {};

package/dist/connection/ConnectionProvider.d.ts

@@ -61,10 +61,12 @@ export declare function useConnection(): ConnectionValue;
 export declare const isAuthenticated: (s: ConnectionStatus) => s is "demo" | "authenticated";
 /** The open workspace as the connected kits see it, whoever hosts them. */
 export interface ConnectedWorkspace {
-    /** The selected workspace (the session state's). */
+    /** The selected workspace (the session state's; with a connection, else its fallback). */
     workspaceId: string | null;
     /** Signed in to a live backend: workspace-scoped queries may run. */
     live: boolean;
+    /** The signed-in user (their name and email, e.g. to sign a document). */
+    user: ArbiUser | null;
     /** The signed-in user's external id. */
     userId: string | undefined;
     /** Re-assert the workspace on the server session before a workspace-scoped write. */

package/dist/connection/calendar/AddCalendarDialogs.d.ts

@@ -0,0 +1,9 @@
+export declare function SubscribeDialog({ open, timeZone, onClose, }: {
+    open: boolean;
+    timeZone: string;
+    onClose: () => void;
+}): import("react").JSX.Element;
+export declare function HolidaysDialog({ open, onClose }: {
+    open: boolean;
+    onClose: () => void;
+}): import("react").JSX.Element;

package/dist/connection/calendar/BookingPagesPanel.d.ts

@@ -0,0 +1,13 @@
+import { type BookingPage } from '@arbidocs/react';
+export interface BookingPageFormProps {
+    page?: BookingPage | null;
+    defaultTimeZone: string;
+    onDone: () => void;
+}
+export declare function BookingPageForm({ page, defaultTimeZone, onDone }: BookingPageFormProps): import("react").JSX.Element;
+export interface BookingPagesPanelProps {
+    /** Zone for new pages; defaults to the calendar settings zone, then the browser's. */
+    defaultTimeZone?: string;
+    className?: string;
+}
+export declare function BookingPagesPanel({ defaultTimeZone, className }: BookingPagesPanelProps): import("react").JSX.Element;

package/dist/connection/calendar/CalendarAccountsPanel.d.ts

@@ -0,0 +1,5 @@
+export declare const BACKGROUND_SYNC_EXPLANATION: string;
+export interface CalendarAccountsPanelProps {
+    className?: string;
+}
+export declare function CalendarAccountsPanel({ className }: CalendarAccountsPanelProps): import("react").JSX.Element;

package/dist/connection/calendar/CalendarSettingsDialog.d.ts

@@ -0,0 +1,12 @@
+import { type CalendarSettings } from '@arbidocs/react';
+import { type CalendarListItem } from '../../calendar';
+export type CalendarSettingsTab = 'general' | 'accounts' | 'access' | 'booking' | 'rooms';
+export interface CalendarSettingsDialogProps {
+    open: boolean;
+    settings: CalendarSettings;
+    calendars: CalendarListItem[];
+    /** Tab to show when the dialog opens (default General). */
+    initialTab?: CalendarSettingsTab;
+    onClose: () => void;
+}
+export declare function CalendarSettingsDialog({ open, settings, calendars, initialTab, onClose, }: CalendarSettingsDialogProps): import("react").JSX.Element;

package/dist/connection/calendar/ConnectedCalendar.d.ts

@@ -0,0 +1,13 @@
+import { type CalendarCallSupport, type CalendarOverlayLink } from './types';
+export interface ConnectedCalendarProps {
+    /** ARBI calls for events (the host's calls stack). Without it: no "Add ARBI call", Join opens links. */
+    calls?: CalendarCallSupport;
+    /**
+     * Open what an overlay item (a fact, workflow or task) points to. Default: a conversation opens
+     * through the blocks environment; the rest does nothing.
+     */
+    onOpenOverlay?: (link: CalendarOverlayLink) => void;
+    /** Turn the account sync on open off (a host that syncs elsewhere). Default on. */
+    syncAccountsOnOpen?: boolean;
+}
+export declare function ConnectedCalendar({ calls, onOpenOverlay, syncAccountsOnOpen, }?: ConnectedCalendarProps): import("react").JSX.Element;

package/dist/connection/calendar/ConnectedMailInviteCard.d.ts

@@ -0,0 +1,12 @@
+import { type MailAttachment } from '@arbidocs/react';
+export interface ConnectedMailInviteCardProps {
+    accountId: string;
+    messageId: string;
+    attachments: MailAttachment[];
+    isOnline: boolean;
+    /** Open the event in the host's calendar ("Open in calendar"); without it the button is hidden. */
+    onOpenEvent?: (event: {
+        id: string;
+    }) => void;
+}
+export declare function ConnectedMailInviteCard({ accountId, messageId, attachments, isOnline, onOpenEvent, }: ConnectedMailInviteCardProps): import("react").JSX.Element | null;

package/dist/connection/calendar/ConnectedPublicBooking.d.ts

@@ -0,0 +1,9 @@
+/** The cancel link a guest can keep: this page with `?cancel=<token>`. */
+export declare function bookingCancelLink(slug: string, token: string, origin?: string): string;
+export interface ConnectedPublicBookingProps {
+    /** The booking page's slug (`/book/<slug>`). */
+    slug: string;
+    /** A guest's cancel token (`?cancel=`): the page offers to cancel that booking instead. */
+    cancelToken?: string | null;
+}
+export declare function ConnectedPublicBooking({ slug, cancelToken }: ConnectedPublicBookingProps): import("react").JSX.Element;

package/dist/connection/calendar/ConnectedUpcomingEvents.d.ts

@@ -0,0 +1,12 @@
+import { type CalendarEvent } from '@arbidocs/react';
+export interface ConnectedUpcomingEventsProps {
+    timeZone: string;
+    days?: number;
+    limit?: number;
+    showDeclined?: boolean;
+    onOpen?: (event: CalendarEvent) => void;
+    /** Join an event's meeting (the host's calls). Default: the link opens in a new tab. */
+    onJoin?: (event: CalendarEvent) => void;
+    className?: string;
+}
+export declare function ConnectedUpcomingEvents({ timeZone, days, limit, showDeclined, onOpen, onJoin, className, }: ConnectedUpcomingEventsProps): import("react").JSX.Element;

package/dist/connection/calendar/CopyField.d.ts

@@ -0,0 +1,9 @@
+export interface CopyFieldProps {
+    label: string;
+    value: string;
+    /** Monospace + break anywhere (secrets, URLs). */
+    mono?: boolean;
+    testId?: string;
+    className?: string;
+}
+export declare function CopyField({ label, value, mono, testId, className }: CopyFieldProps): import("react").JSX.Element;

package/dist/connection/calendar/EventEditorDialog.d.ts

@@ -0,0 +1,29 @@
+import { type CalendarEvent, type CalendarSettings } from '@arbidocs/react';
+import { type AttendeeDraft, type CalendarListItem, type EventDraft } from '../../calendar';
+export interface EditorState {
+    mode: 'create' | 'edit';
+    event?: CalendarEvent;
+    original: EventDraft;
+    draft: EventDraft;
+    error: string | null;
+    /** "Add ARBI call" pre-ticked (scheduled from a thread / DM): the call is made when the event is saved. */
+    autoCall?: boolean;
+}
+export interface EventEditorDialogProps {
+    editor: EditorState | null;
+    onChange: (update: (editor: EditorState | null) => EditorState | null) => void;
+    onSave: () => void;
+    onDelete: (event: CalendarEvent) => void;
+    /** The calendars an event can be saved to. */
+    calendars: CalendarListItem[];
+    callsEnabled: boolean;
+    onAddCall: (draft: EventDraft) => Promise<{
+        call_id: string;
+        url: string;
+    }>;
+    isWebinarAttendee: (attendee: AttendeeDraft) => boolean;
+    timeZone: string;
+    workingHours: CalendarSettings['working_hours'];
+    saving: boolean;
+}
+export declare function EventEditorDialog({ editor, onChange, onSave, onDelete, calendars, callsEnabled, onAddCall, isWebinarAttendee, timeZone, workingHours, saving, }: EventEditorDialogProps): import("react").JSX.Element;

package/dist/connection/calendar/EventScheduling.d.ts

@@ -0,0 +1,8 @@
+import { type EventDraft } from '../../calendar';
+export interface EventSchedulingProps {
+    draft: EventDraft;
+    onChange: (draft: EventDraft) => void;
+    timeZone: string;
+    workingStartHour?: number;
+}
+export declare function EventScheduling({ draft, onChange, timeZone, workingStartHour, }: EventSchedulingProps): import("react").JSX.Element | null;

package/dist/connection/calendar/InvitationsPanel.d.ts

@@ -0,0 +1,5 @@
+export interface InvitationsPanelProps {
+    timeZone: string;
+    onOpenEvent?: (eventId: string) => void;
+}
+export declare function InvitationsPanel({ timeZone, onOpenEvent }: InvitationsPanelProps): import("react").JSX.Element;

package/dist/connection/calendar/OpenAccessPanel.d.ts

@@ -0,0 +1,7 @@
+import { type CalendarRead } from '@arbidocs/react';
+export interface OpenAccessPanelProps {
+    /** Calendars to offer; defaults to `useCalendars()`. */
+    calendars?: CalendarRead[];
+    className?: string;
+}
+export declare function OpenAccessPanel({ calendars: given, className }: OpenAccessPanelProps): import("react").JSX.Element;

package/dist/connection/calendar/PublishCalendarDialog.d.ts

@@ -0,0 +1,8 @@
+export interface PublishCalendarDialogProps {
+    calendarId: string | null;
+    calendarName?: string | null;
+    onClose: () => void;
+    /** Open the Accounts tab when there is no account yet. */
+    onConnectAccount?: () => void;
+}
+export declare function PublishCalendarDialog({ calendarId, calendarName, onClose, onConnectAccount, }: PublishCalendarDialogProps): import("react").JSX.Element;

package/dist/connection/calendar/RoomsDirectoryPanel.d.ts

@@ -0,0 +1,8 @@
+export interface RoomsDirectoryPanelProps {
+    /** Zone for the time-window inputs; defaults to the calendar settings zone. */
+    timeZone?: string;
+    /** Show "New room" (any user may create; workspace rooms need workspace access). Default true. */
+    canCreate?: boolean;
+    className?: string;
+}
+export declare function RoomsDirectoryPanel({ timeZone, canCreate, className, }: RoomsDirectoryPanelProps): import("react").JSX.Element;

package/dist/connection/calendar/ShareCalendarDialog.d.ts

@@ -0,0 +1,6 @@
+export interface ShareCalendarDialogProps {
+    calendarId: string | null;
+    calendarName?: string | null;
+    onClose: () => void;
+}
+export declare function ShareCalendarDialog({ calendarId, calendarName, onClose, }: ShareCalendarDialogProps): import("react").JSX.Element;

package/dist/connection/calendar/copy.d.ts

@@ -0,0 +1,2 @@
+/** Copy a calendar value (a password, a link, an address) and say "<what> copied to clipboard". */
+export declare function useCalendarCopy(): (value: string, what?: string) => Promise<boolean>;

package/dist/connection/calendar/index.d.ts

@@ -0,0 +1,6 @@
+export { ConnectedCalendar, type ConnectedCalendarProps } from './ConnectedCalendar';
+export { ConnectedUpcomingEvents, type ConnectedUpcomingEventsProps, } from './ConnectedUpcomingEvents';
+export { ConnectedMailInviteCard, type ConnectedMailInviteCardProps, } from './ConnectedMailInviteCard';
+export { ConnectedPublicBooking, bookingCancelLink, type ConnectedPublicBookingProps, } from './ConnectedPublicBooking';
+export { useCalendarViewStore, requestCalendarEvent, requestCalendarComposer, type CalendarComposerPrefill, type PendingCalendarEvent, } from './store';
+export { openMeetingLink, type CalendarCallSupport, type CalendarOverlayLink } from './types';

package/dist/connection/calendar/store.d.ts

@@ -0,0 +1,47 @@
+import type { CalendarViewKind } from '../../calendar/types';
+/** "Schedule a call" from elsewhere (a thread, a DM, a dashboard): the editor opens prefilled. */
+export interface CalendarComposerPrefill {
+    title?: string;
+    attendees?: {
+        email?: string | null;
+        user_id?: string | null;
+        name?: string | null;
+    }[];
+    conversationId?: string | null;
+    /** Add an ARBI call when the event is saved ("Add ARBI call" ticked). */
+    addCall?: boolean;
+}
+export interface PendingCalendarEvent {
+    id: string;
+    recurrenceId?: string | null;
+}
+interface CalendarViewState {
+    /** `null` until the user picks one: the settings' default view applies. */
+    view: CalendarViewKind | null;
+    /** YYYY-MM-DD anchor; `null` = today. */
+    date: string | null;
+    pendingEvent: PendingCalendarEvent | null;
+    pendingComposer: CalendarComposerPrefill | null;
+    setPendingComposer: (prefill: CalendarComposerPrefill | null) => void;
+    setView: (view: CalendarViewKind) => void;
+    setDate: (date: string | null) => void;
+    setPendingEvent: (pending: PendingCalendarEvent | null) => void;
+}
+export declare const useCalendarViewStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<CalendarViewState>, "setState" | "persist"> & {
+    setState(partial: CalendarViewState | Partial<CalendarViewState> | ((state: CalendarViewState) => CalendarViewState | Partial<CalendarViewState>), replace?: false | undefined): unknown;
+    setState(state: CalendarViewState | ((state: CalendarViewState) => CalendarViewState), replace: true): unknown;
+    persist: {
+        setOptions: (options: Partial<import("zustand/middleware").PersistOptions<CalendarViewState, unknown, unknown>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: CalendarViewState) => void) => () => void;
+        onFinishHydration: (fn: (state: CalendarViewState) => void) => () => void;
+        getOptions: () => Partial<import("zustand/middleware").PersistOptions<CalendarViewState, unknown, unknown>>;
+    };
+}>;
+/** Ask the calendar to open on an event (ignored unless it is an `evt-` id). */
+export declare function requestCalendarEvent(event: PendingCalendarEvent): void;
+/** Ask the calendar to open the event editor prefilled. */
+export declare function requestCalendarComposer(prefill: CalendarComposerPrefill): void;
+export {};

package/dist/connection/calendar/types.d.ts

@@ -0,0 +1,36 @@
+import type { AttendeeDraft, EventDraft, WebinarRole } from '../../calendar/types';
+/**
+ * ARBI calls for calendar events, from the host (the calls stack lives there). Without it the
+ * editor offers no "Add ARBI call" or webinar, and Join opens the meeting link in a new tab.
+ */
+export interface CalendarCallSupport {
+    /** Whether "Add ARBI call", webinars and "Schedule call" are offered (the user may host calls). */
+    canSchedule: boolean;
+    /**
+     * Make the call for a draft: its key sealed to me and to the draft's ARBI attendees (who share its
+     * meeting chat). A webinar gives each attendee its role (`attendeeKey` → role).
+     */
+    create(draft: EventDraft, webinarRoles?: Record<string, WebinarRole>): Promise<{
+        call_id: string;
+        url: string;
+    }>;
+    /** After a save: seal the call's key to ARBI attendees added since it was made. */
+    share(draft: EventDraft): Promise<void>;
+    /** A saved webinar's roles (they live on its call), keyed by `attendeeKey`; `null`: not a webinar. */
+    loadWebinarRoles(url: string, attendees: AttendeeDraft[]): Promise<Record<string, WebinarRole> | null>;
+    /** Save a webinar's changed roles on its call. */
+    saveWebinarRoles(url: string, roles: Record<string, WebinarRole> | undefined, attendees: AttendeeDraft[]): Promise<void>;
+    /** The attendees (`attendeeKey`) that are ARBI users: who gets a role in a new webinar. */
+    arbiAttendees(attendees: AttendeeDraft[]): Promise<Set<string>>;
+    /** Join a meeting link (an ARBI call opens in the app; anything else in a new tab). */
+    join(url: string): void;
+    /** Open an ARBI call's meeting chat. */
+    openChat(url: string): void;
+}
+/** Open a meeting link without call support: a new tab. */
+export declare function openMeetingLink(url: string): void;
+/** Where an overlay item on the calendar points (`fact:…`, `workflow:…`, `conversation:…`). */
+export interface CalendarOverlayLink {
+    kind: 'fact' | 'workflow' | 'conversation';
+    id: string;
+}

package/dist/connection/calendar/useWebinarAttendee.d.ts

@@ -0,0 +1,3 @@
+import { type AttendeeDraft, type EventDraft } from '../../calendar';
+import type { CalendarCallSupport } from './types';
+export declare function useWebinarAttendee(draft: EventDraft | null | undefined, calls: CalendarCallSupport | undefined): (attendee: AttendeeDraft) => boolean;

package/dist/connection/notification-center/ConnectedNotificationCenter.d.ts

@@ -0,0 +1,15 @@
+import { type NotificationTarget } from '@arbidocs/react';
+import { type NotificationCenterProps } from './NotificationCenter';
+import type { NotificationCenterRenderers } from './NotificationEvent';
+export interface ConnectedNotificationCenterProps extends Pick<NotificationCenterProps, 'focusId' | 'headerRight' | 'workspaceLabel' | 'gridState' | 'onGridStateChange'> {
+    /** Open where an entry leads (the host owns its routes). An external page (`url`) opens in a
+     *  new tab without it. */
+    onOpen: (target: NotificationTarget) => void;
+    /** The host's own people / workspace / document renderers (default: the shared entities). */
+    renderers?: Partial<NotificationCenterRenderers>;
+    /** "Today, 14:05"; default the local date and time. */
+    formatTime?: (timestamp: number) => string;
+    /** Persisted notifications per page (default 100). */
+    pageSize?: number;
+}
+export declare function ConnectedNotificationCenter({ onOpen, renderers, formatTime, pageSize, ...pageProps }: ConnectedNotificationCenterProps): import("react").JSX.Element;

package/dist/connection/notification-center/NotificationCenter.d.ts

@@ -0,0 +1,37 @@
+/**
+ * The notification centre page: one time-sorted list of what the user received, what they sent
+ * and this session's log, with category/type filters, bulk delete and paging. Presentational:
+ * {@link ConnectedNotificationCenter} supplies the data; the host draws people, workspaces and
+ * documents ({@link NotificationCenterRenderers}) and owns where an entry leads.
+ */
+import { type ReactNode } from 'react';
+import type { GridState } from 'ag-grid-community';
+import { type NotificationTarget } from '@arbidocs/react';
+import { type NotificationCenterItem } from './items';
+import { type NotificationCenterRenderers } from './NotificationEvent';
+export interface NotificationCenterProps {
+    /** Every entry, newest first (see `buildNotificationCenterItems`). */
+    items: NotificationCenterItem[];
+    isLoading?: boolean;
+    /** More persisted notifications exist beyond the loaded ones. */
+    hasMore?: boolean;
+    isLoadingMore?: boolean;
+    onLoadMore?: () => void;
+    /** Delete entries (persisted ones on the server, session ones from the log). */
+    onDelete: (items: NotificationCenterItem[]) => void;
+    /** Open where an entry leads. */
+    onOpen: (target: NotificationTarget) => void;
+    renderers: NotificationCenterRenderers;
+    /** "Today, 14:05" for an entry's time. */
+    formatTime: (timestamp: number) => string;
+    /** The entry to scroll to and highlight (e.g. the one picked in the bell). */
+    focusId?: string | null;
+    /** Header content on the right (e.g. a panel mode switcher). */
+    headerRight?: ReactNode;
+    /** Label of the Workspace type filter (a host's own word for a workspace). */
+    workspaceLabel?: string;
+    /** Persisted column state (order, width, sort), read once at mount, and its changes. */
+    gridState?: GridState;
+    onGridStateChange?: (state: GridState) => void;
+}
+export declare function NotificationCenter({ items, isLoading, hasMore, isLoadingMore, onLoadMore, onDelete, onOpen, renderers, formatTime, focusId, headerRight, workspaceLabel, gridState, onGridStateChange, }: NotificationCenterProps): import("react").JSX.Element;

package/dist/connection/notification-center/NotificationEvent.d.ts

@@ -0,0 +1,33 @@
+/**
+ * The Event cell of the notification centre: what happened, as a sentence around the people and
+ * documents involved, with the action that opens it. A received notification reads from the
+ * recipient's side ("[Priya] mentioned you in a conversation"), a sent one from the sender's
+ * ("You mentioned [Sam] in a conversation"), a session-log entry as it was toasted.
+ */
+import type { ComponentType, ReactElement, ReactNode } from 'react';
+import { type NotificationTarget } from '@arbidocs/react';
+import type { NotificationCenterItem, NotificationRow } from './items';
+export type NotificationUser = NotificationRow['sender'];
+export interface NotificationDocumentChipProps {
+    documentId: string;
+    workspaceId?: string | null;
+    /** Open the document. */
+    onOpen: () => void;
+    /** What to show when the document is not known here (its name is encrypted per workspace). */
+    fallback: ReactNode;
+}
+/** How the host draws people, workspaces and documents in the list. */
+export interface NotificationCenterRenderers {
+    /** A person's pill. */
+    renderUser: (user: NotificationUser) => ReactNode;
+    /** A workspace's badge (the Category of a workspace's notification), or null when the host
+     *  does not know the workspace (the type's own category shows instead). */
+    renderWorkspace: (workspaceId: string) => ReactNode | null;
+    /** A signature notification's document: its chip when known, else `fallback`. */
+    DocumentChip: ComponentType<NotificationDocumentChipProps>;
+}
+export declare function NotificationEvent({ item, open, renderers, }: {
+    item: NotificationCenterItem;
+    open: (target: NotificationTarget) => void;
+    renderers: NotificationCenterRenderers;
+}): ReactElement | null;

package/dist/connection/notification-center/index.d.ts

@@ -0,0 +1,4 @@
+export { ConnectedNotificationCenter, type ConnectedNotificationCenterProps, } from './ConnectedNotificationCenter';
+export { NotificationCenter, type NotificationCenterProps } from './NotificationCenter';
+export { NotificationEvent, type NotificationCenterRenderers, type NotificationDocumentChipProps, type NotificationUser, } from './NotificationEvent';
+export { buildNotificationCenterItems, countNotificationTypes, filterNotificationCenterItems, type NotificationCenterItem, type NotificationFilterState, type NotificationFilterType, type NotificationRow, } from './items';

package/dist/connection/notification-center/items.d.ts

@@ -0,0 +1,44 @@
+/**
+ * The notification centre's one list: the persisted notifications (both what the user received
+ * and what they sent, from `/v1/notifications`) and the session log (the shared notify store's own
+ * entries), merged newest first, with the category and type filters over it.
+ */
+import type { components } from '@arbidocs/client';
+import type { AppNotification } from '@arbidocs/react/shell';
+export type NotificationRow = components['schemas']['NotificationResponse'];
+/**
+ * One entry of the list.
+ *
+ * - `kind: 'incoming'` — a persisted notification the user received; read from their side
+ *   (shows the sender).
+ * - `kind: 'activity'` — the user's own: a notification they sent (`persisted: true`) or a
+ *   session-log entry (`persisted: false`); read from the sender's side.
+ *
+ * `persisted` is what the user sees as the category: persisted entries survive in the
+ * notifications table ("Notifications"); session entries are this browser's log ("Session log").
+ */
+export interface NotificationCenterItem {
+    id: string;
+    timestamp: number;
+    kind: 'incoming' | 'activity';
+    persisted: boolean;
+    /** Every persisted entry. */
+    row?: NotificationRow;
+    /** Every session-log entry. */
+    entry?: AppNotification;
+}
+export type NotificationFilterType = 'notifications' | 'session' | 'workspace' | 'contact_accepted';
+export type NotificationFilterState = Map<NotificationFilterType, 'include' | 'exclude' | null>;
+/** The merged list, newest first. */
+export declare function buildNotificationCenterItems(rows: readonly NotificationRow[], session: readonly AppNotification[], userId: string): NotificationCenterItem[];
+/** Per-type counts of the received notifications, for the filter badges. */
+export declare function countNotificationTypes(items: readonly NotificationCenterItem[]): {
+    workspace: number;
+    contact_accepted: number;
+};
+/**
+ * The items the active "include" filters select, OR-combined: an item shows when it matches any.
+ * With no active filter everything shows. The category filters track `persisted`, the same
+ * differentiator as the Category column.
+ */
+export declare function filterNotificationCenterItems(items: NotificationCenterItem[], filters: NotificationFilterState): NotificationCenterItem[];

package/dist/facts/index.cjs

@@ -8,15 +8,15 @@ var chunkVPPX5XUF_cjs = require('../chunk-VPPX5XUF.cjs');
 var chunkRC25WMVB_cjs = require('../chunk-RC25WMVB.cjs');
 var chunkV4ISCZJ7_cjs = require('../chunk-V4ISCZJ7.cjs');
 var chunk2EI7NCUA_cjs = require('../chunk-2EI7NCUA.cjs');
-var chunkC2CWWEHO_cjs = require('../chunk-C2CWWEHO.cjs');
-var chunk7RGLTF76_cjs = require('../chunk-7RGLTF76.cjs');
+require('../chunk-C4WSHRR6.cjs');
 var chunkBIXHB4LV_cjs = require('../chunk-BIXHB4LV.cjs');
-require('../chunk-FX3K6LNZ.cjs');
+var chunk7RGLTF76_cjs = require('../chunk-7RGLTF76.cjs');
 var chunkPPCATBOY_cjs = require('../chunk-PPCATBOY.cjs');
-var chunkMHVNT4J3_cjs = require('../chunk-MHVNT4J3.cjs');
-require('../chunk-C4WSHRR6.cjs');
-require('../chunk-ULWRNGGE.cjs');
 var chunkKDG6FER6_cjs = require('../chunk-KDG6FER6.cjs');
+var chunkC2CWWEHO_cjs = require('../chunk-C2CWWEHO.cjs');
+require('../chunk-ULWRNGGE.cjs');
+require('../chunk-FX3K6LNZ.cjs');
+var chunkMHVNT4J3_cjs = require('../chunk-MHVNT4J3.cjs');
 require('../chunk-DES3K4SD.cjs');
 var lucideReact = require('lucide-react');
 var ui = require('@arbidocs/react/ui');

package/dist/facts/index.js

@@ -8,15 +8,15 @@ export { decodeWhitespaceEntities } from '../chunk-AF6RDAJF.js';
 import { SelectionBar, SelectionBarAction } from '../chunk-NUNKSZKU.js';
 import { FilterInput } from '../chunk-YU2KUMGE.js';
 export { DEFAULT_FILTER_INPUT_LABELS as DEFAULT_FACTS_FILTER_INPUT_LABELS, DEFAULT_FILTER_FIELDS as FACTS_SEARCH_FIELD_OPTIONS, FilterInput as FactsFilterInput } from '../chunk-YU2KUMGE.js';
-import { GridView } from '../chunk-N5YEF3LC.js';
-import { TabHeader } from '../chunk-4WWM3GQ5.js';
+import '../chunk-YNIBUKV5.js';
 import { detectTimeZone, listTimeZones } from '../chunk-GTCC2VAR.js';
-import '../chunk-SLSBJRWW.js';
+import { TabHeader } from '../chunk-4WWM3GQ5.js';
 import { observeResize } from '../chunk-NPLYHR2E.js';
-import { testIdOr } from '../chunk-7F6CBP3Z.js';
-import '../chunk-YNIBUKV5.js';
-import '../chunk-TX2ZICS7.js';
 import { initials } from '../chunk-OXF2IFXG.js';
+import { GridView } from '../chunk-N5YEF3LC.js';
+import '../chunk-TX2ZICS7.js';
+import '../chunk-SLSBJRWW.js';
+import { testIdOr } from '../chunk-7F6CBP3Z.js';
 import '../chunk-VUNV25KB.js';
 import { PencilLine, Check, MoreVertical, Pencil, Trash2, CalendarDays, X, Columns3, ChevronDown, RotateCcw, Milestone, CalendarClock, Scale, Lightbulb, ArrowRight, Loader2, Info, Paperclip, Tags, MoreHorizontal, FolderUp, BookMarked, Plus, Search, CheckCircle2, CornerDownLeft, Quote, ChevronLeft, ChevronRight, Table2, CalendarRange, GanttChartSquare } from 'lucide-react';
 import { Popover, PopoverTrigger, PopoverContent, Command, CommandInput, CommandList, CommandEmpty, CommandGroup, CommandItem, DropdownMenu, DropdownMenuTrigger, DropdownMenuContent, DropdownMenuItem, DropdownMenuSeparator, cn, Input, Button, CommandSeparator, Tooltip, TooltipTrigger, TooltipContent } from '@arbidocs/react/ui';

package/dist/files/index.cjs

@@ -5,21 +5,21 @@ var chunk223D4727_cjs = require('../chunk-223D4727.cjs');
 var chunkO4YPVYPO_cjs = require('../chunk-O4YPVYPO.cjs');
 var chunkUWIILWDI_cjs = require('../chunk-UWIILWDI.cjs');
 var chunk2WLXQGWC_cjs = require('../chunk-2WLXQGWC.cjs');
-var chunkVLCY46K6_cjs = require('../chunk-VLCY46K6.cjs');
 var chunk3AFWGEDJ_cjs = require('../chunk-3AFWGEDJ.cjs');
 var chunkDVUZTGVL_cjs = require('../chunk-DVUZTGVL.cjs');
 var chunkDETZZBG2_cjs = require('../chunk-DETZZBG2.cjs');
 var chunkR26BK7YL_cjs = require('../chunk-R26BK7YL.cjs');
 var chunkV4ISCZJ7_cjs = require('../chunk-V4ISCZJ7.cjs');
 var chunk2EI7NCUA_cjs = require('../chunk-2EI7NCUA.cjs');
-var chunkC2CWWEHO_cjs = require('../chunk-C2CWWEHO.cjs');
+require('../chunk-C4WSHRR6.cjs');
 var chunk32HW2Q33_cjs = require('../chunk-32HW2Q33.cjs');
-require('../chunk-FX3K6LNZ.cjs');
 require('../chunk-PPCATBOY.cjs');
-var chunkMHVNT4J3_cjs = require('../chunk-MHVNT4J3.cjs');
-require('../chunk-C4WSHRR6.cjs');
-var chunkULWRNGGE_cjs = require('../chunk-ULWRNGGE.cjs');
 var chunkKDG6FER6_cjs = require('../chunk-KDG6FER6.cjs');
+var chunkVLCY46K6_cjs = require('../chunk-VLCY46K6.cjs');
+var chunkC2CWWEHO_cjs = require('../chunk-C2CWWEHO.cjs');
+var chunkULWRNGGE_cjs = require('../chunk-ULWRNGGE.cjs');
+require('../chunk-FX3K6LNZ.cjs');
+var chunkMHVNT4J3_cjs = require('../chunk-MHVNT4J3.cjs');
 require('../chunk-DES3K4SD.cjs');
 var classVarianceAuthority = require('class-variance-authority');
 var ui = require('@arbidocs/react/ui');