@arbidocs/blocks 0.4.153 → 0.4.155

package/dist/connection/ConnectionProvider.d.ts

@@ -71,6 +71,13 @@ export interface ConnectedWorkspace {
     userId: string | undefined;
     /** Re-assert the workspace on the server session before a workspace-scoped write. */
     ensureWorkspaceOpen: () => Promise<void>;
+    /**
+     * Go into a workspace: select it (with a connection) and show it (`BlocksEnvironment.
+     * openWorkspace`, where a host without a connection also switches its session).
+     */
+    openWorkspace: (workspaceId: string, options?: {
+        name?: string;
+    }) => Promise<void>;
 }
 /**
  * The workspace for a connected kit: the `ConnectionProvider`'s when there is one, else the host's

package/dist/connection/files/DocumentSyncGlyph.d.ts

@@ -0,0 +1,28 @@
+/**
+ * DocumentSyncGlyph
+ *
+ * Marks a document that's saved on THIS device for offline use — the
+ * OneDrive/Drive "available offline" convention: a small badge on the file icon.
+ * A down-arrow-to-line (the universal "downloaded / saved locally" glyph) so it
+ * reads instantly as "kept on my device" — clearer than a hard-drive icon and
+ * never confused with the "ready" checkmark. A neutral grey badge: ambient
+ * metadata, not a status to draw the eye (the document "ready" status owns the
+ * coloured cyan/navy treatment).
+ *
+ * Pending offline edits are shown separately, as a "changes pending" document
+ * status in the Status column — not here — so the file icon stays quiet and only
+ * the genuinely-useful "you can open this offline" signal lives on it.
+ *
+ * Self-subscribing to the offline set so it updates even inside a memoized grid
+ * cell. Renders nothing for cloud-only docs (the common case).
+ */
+interface DocumentSyncGlyphProps {
+    docExtId: string;
+    size?: number;
+    className?: string;
+    /** Badge fill — neutral grey by default; pass e.g. `bg-green-600` for a
+     *  prominent "downloaded" badge. */
+    bgClassName?: string;
+}
+export declare function DocumentSyncGlyph({ docExtId, size, className, bgClassName, }: DocumentSyncGlyphProps): import("react").JSX.Element | null;
+export {};

package/dist/connection/files/explorer/ConnectedFilesExplorer.d.ts

@@ -0,0 +1,56 @@
+/**
+ * The workspace's files as a file explorer (OneDrive / Drive style), bound to the session: folders
+ * come from each document's `folder` path; renames, moves and deletes are written through
+ * `@arbidocs/react`.
+ *
+ *  - Breadcrumb navigation is the host's (`folderPath` / `onFolderPathChange`): it may keep the
+ *    folder in a filter, the URL or state.
+ *  - A virtualised tile grid that scales to thousands of documents, sized by `tileSize`.
+ *  - OS-style selection: click, ⌘/Ctrl-click, shift-range, the hover checkbox and a marquee.
+ *  - Drag files onto a folder tile to move them; drop OS files on the view to upload.
+ *
+ * Selection is the host's (`selectedIds` / `onSelectionChange`), so its bulk actions act on it.
+ */
+import { type ReactNode } from 'react';
+import { type ExplorerFolder, type ExplorerSort } from '../../../files/folders';
+import { type FileTileDocument } from './FileTiles';
+/** The zoom slider's bounds: the target tile width in px (smaller: more tiles per row). */
+export declare const TILE_MIN = 88;
+export declare const TILE_MAX = 232;
+export declare const TILE_DEFAULT = 200;
+export interface ConnectedFilesExplorerHandle {
+    /** Add a placeholder folder here and start naming it. */
+    triggerNewFolder: () => void;
+    /** Scroll the tile of `docId` into view, when it is displayed. */
+    scrollToDocument: (docId: string) => void;
+}
+export interface ConnectedFilesExplorerProps {
+    documents: FileTileDocument[];
+    isLoading: boolean;
+    /** The viewer may add, rename and move files here. */
+    canUpload: boolean;
+    selectedIds: string[];
+    onSelectionChange: (ids: string[]) => void;
+    onOpenDocument: (docId: string) => void;
+    onUploadFiles: (files: File[], folder?: string | null) => void;
+    /** The open folder (empty: the workspace root). */
+    folderPath: readonly string[];
+    onFolderPathChange: (path: string[]) => void;
+    /** A search across every folder (absent or empty: the open folder is listed). */
+    search?: string;
+    sort: ExplorerSort;
+    sortReversed: boolean;
+    /** The target tile width in px (`TILE_MIN`..`TILE_MAX`). */
+    tileSize: number;
+    /** The ids of the files displayed, in display order (a navigator steps the same list). */
+    onOrderedFilesChange?: (docIds: string[]) => void;
+    /** Move the selected files: the host opens its folder picker. Absent: not offered. */
+    onMoveSelected?: () => void;
+    /** Move a folder with its structure: the host opens its folder picker. */
+    onFolderMove?: (folder: ExplorerFolder) => void;
+    /** Open a document in the host's review view. Absent: not offered. */
+    onOpenInReview?: (docId: string) => void;
+    /** Shown instead of the explorer while the workspace has no documents and the viewer may add. */
+    emptyWorkspace?: ReactNode;
+}
+export declare const ConnectedFilesExplorer: import("react").ForwardRefExoticComponent<ConnectedFilesExplorerProps & import("react").RefAttributes<ConnectedFilesExplorerHandle>>;

package/dist/connection/files/explorer/FileTiles.d.ts

@@ -0,0 +1,87 @@
+/**
+ * The explorer's one tile binding. The presentation (`ExplorerFileTile`, `ExplorerFolderTile`,
+ * `ExplorerFileTooltip`) is in `files/`; this binds it to the session: @dnd-kit draggable and
+ * droppable, the document's live processing status, the copies kept offline, the open viewer, the
+ * document pill, the mail handoff and the member / label lookups. `FileTile` is a draggable
+ * document, `FolderTile` a droppable folder (separate components so the dnd hooks always run).
+ */
+import { type WorkspaceDocument } from '@arbidocs/react';
+import { type ExplorerDensity, type ExplorerMenuItem } from '../../../files/ExplorerTile';
+import { type ExplorerFolder } from '../../../files/folders';
+import { type FilesStartItem } from '../support';
+export type { ExplorerDensity };
+/** A workspace member as a tile shows them (avatar and name). */
+export interface FileTileUser {
+    external_id: string;
+    given_name: string;
+    family_name?: string | null;
+    email: string;
+    picture?: string | null;
+}
+/** A document row as the tiles read it (the session's rows carry these). */
+export type FileTileDocument = WorkspaceDocument & {
+    failed_stage?: string | null;
+};
+/** Whether a status is still being worked on. */
+export declare function isActiveDocumentStatus(status: string): boolean;
+/** The hover card of a document: the same in the explorer tiles and the table's name cell. */
+export declare function FileTooltipContent({ doc, modifiedBy, tagNameById, }: {
+    doc: FileTileDocument;
+    modifiedBy?: FileTileUser;
+    tagNameById: ReadonlyMap<string, string>;
+}): import("react").JSX.Element;
+/** The "Start…" submenu: one entry per thing the host can start on the file or folder. */
+export declare function startMenuItem(items: readonly FilesStartItem[]): ExplorerMenuItem[];
+interface FileTileProps {
+    doc: FileTileDocument;
+    density: ExplorerDensity;
+    selected: boolean;
+    /** Part of an in-flight drag (dimmed). */
+    dragging: boolean;
+    /** Any tile is being dragged: no hover card, so it cannot swallow the moves dnd-kit tracks. */
+    dndActive: boolean;
+    /** Being renamed inline. */
+    renaming: boolean;
+    /** The viewer may delete this document. */
+    canDelete: boolean;
+    /** The first-page thumbnail (absent: the file-type icon). */
+    thumbnailUrl?: string;
+    /** Who last changed the document (the hover card's avatar line). */
+    modifiedBy?: FileTileUser;
+    /** Label id → name, for the document's labels on the hover card. */
+    tagNameById: ReadonlyMap<string, string>;
+    onSelect: (doc: FileTileDocument, e: React.MouseEvent) => void;
+    onToggle: (doc: FileTileDocument, e: React.MouseEvent) => void;
+    onOpen: (doc: FileTileDocument) => void;
+    /** Open the document in the review view. Absent: not offered. */
+    onReview?: (doc: FileTileDocument) => void;
+    onStartRename: (doc: FileTileDocument) => void;
+    onCommitRename: (doc: FileTileDocument, name: string) => void;
+    onCancelRename: () => void;
+    onDownload: (doc: FileTileDocument) => void;
+    onMove?: (doc: FileTileDocument) => void;
+    onDelete: (doc: FileTileDocument) => void;
+}
+export declare const FileTile: import("react").NamedExoticComponent<FileTileProps>;
+interface FolderTileProps {
+    folder: ExplorerFolder;
+    density: ExplorerDensity;
+    /** Being renamed inline. */
+    editing?: boolean;
+    /** Every document beneath the folder is selected. */
+    selected?: boolean;
+    /** Some (not all) documents beneath the folder are selected. */
+    partiallySelected?: boolean;
+    /** Every document beneath the folder (its count of files still processing). */
+    documents: readonly FileTileDocument[];
+    onOpen: (folder: ExplorerFolder) => void;
+    /** Toggle the whole folder (all its documents). */
+    onToggleSelect?: (folder: ExplorerFolder, e: React.MouseEvent) => void;
+    onCommitName?: (folder: ExplorerFolder, name: string) => void;
+    onCancelName?: () => void;
+    onStartRename?: (folder: ExplorerFolder) => void;
+    onDownload?: (folder: ExplorerFolder) => void;
+    onMove?: (folder: ExplorerFolder) => void;
+    onDelete?: (folder: ExplorerFolder) => void;
+}
+export declare const FolderTile: import("react").NamedExoticComponent<FolderTileProps>;

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

@@ -0,0 +1,5 @@
+export { ConnectedFilesExplorer, TILE_DEFAULT, TILE_MAX, TILE_MIN, type ConnectedFilesExplorerHandle, type ConnectedFilesExplorerProps, } from './explorer/ConnectedFilesExplorer';
+export { FileTooltipContent, isActiveDocumentStatus, startMenuItem, type FileTileDocument, type FileTileUser, } from './explorer/FileTiles';
+export { DocumentSyncGlyph } from './DocumentSyncGlyph';
+export { FilesSupportProvider, useFilesSupport, useOfflineDocumentIds, useViewingDocumentId, type FilesStartItem, type FilesSupport, } from './support';
+export { useFilesStore, usePendingFolders } from './store';

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

@@ -0,0 +1,27 @@
+/**
+ * The Files kits' own state: empty folders the user created (a folder exists only through its
+ * documents, so a new one is a placeholder until something is moved into it), per workspace, for
+ * the session (kept in `sessionStorage`, so a reload keeps them).
+ */
+interface FilesState {
+    /** Placeholder folder paths per workspace. */
+    pendingFolders: Readonly<Record<string, readonly string[]>>;
+    addPendingFolder: (workspaceId: string, path: string) => void;
+    removePendingFolder: (workspaceId: string, path: string) => void;
+}
+export declare const useFilesStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<FilesState>, "setState" | "persist"> & {
+    setState(partial: FilesState | Partial<FilesState> | ((state: FilesState) => FilesState | Partial<FilesState>), replace?: false | undefined): unknown;
+    setState(state: FilesState | ((state: FilesState) => FilesState), replace: true): unknown;
+    persist: {
+        setOptions: (options: Partial<import("zustand/middleware").PersistOptions<FilesState, unknown, unknown>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: FilesState) => void) => () => void;
+        onFinishHydration: (fn: (state: FilesState) => void) => () => void;
+        getOptions: () => Partial<import("zustand/middleware").PersistOptions<FilesState, unknown, unknown>>;
+    };
+}>;
+/** A workspace's placeholder folders. */
+export declare function usePendingFolders(workspaceId: string | null | undefined): readonly string[];
+export {};

package/dist/connection/files/support.d.ts

@@ -0,0 +1,38 @@
+/**
+ * What a host adds to the connected Files kits (explorer, table, page). The kits read and write the
+ * documents on the signed-in session by themselves (`@arbidocs/react`); these are the host's own
+ * things they cannot know: its workflows ("Start…"), its chat, its mail, the copies it keeps
+ * offline, its viewer. Every field is optional: without one a kit offers less, never something
+ * that does nothing.
+ */
+import { type ReactNode } from 'react';
+import type { WorkspaceDocument } from '@arbidocs/react';
+/** Something the host can start on documents or a folder (a workflow, a skill). */
+export interface FilesStartItem {
+    id: string;
+    title: string;
+    run: () => void;
+}
+export interface FilesSupport {
+    /** What can be started on one file. */
+    startItemsForFile?: (document: WorkspaceDocument) => FilesStartItem[];
+    /** What can be started on everything in a folder (workflows that take a set of files). */
+    startItemsForFolder?: (folderPath: string) => FilesStartItem[];
+    /** Start a chat about one document. Absent: not offered. */
+    openDocumentChat?: (docId: string) => void;
+    /** Hand a document to the host's mail composer as an attachment (offered while mail is on). */
+    emailDocument?: (document: WorkspaceDocument) => Promise<void>;
+    /** The documents kept on this device for offline use, as a hook. */
+    useOfflineDocumentIds?: () => ReadonlySet<string>;
+    /** The document open in the host's viewer, as a hook (its tile is marked); null when closed. */
+    useViewingDocumentId?: () => string | null;
+}
+export declare function FilesSupportProvider({ value, children, }: {
+    value: FilesSupport;
+    children: ReactNode;
+}): import("react").JSX.Element;
+export declare function useFilesSupport(): FilesSupport;
+/** The documents kept offline (none without host support). */
+export declare function useOfflineDocumentIds(): ReadonlySet<string>;
+/** The document open in the host's viewer (none without host support). */
+export declare function useViewingDocumentId(): string | null;

package/dist/connection/projects/ConnectedProjectsPanel.d.ts

@@ -0,0 +1,34 @@
+/**
+ * The Projects panel ("Plan & Usage"): the base tab lists the user's projects (plan, usage,
+ * collaborators), the billing portal, the projects shared with them and the host's footer; each
+ * project the user opens gets a closeable tab with its detail. "New project" sits after the tabs.
+ *
+ * Opening a project anywhere goes through `BlocksEnvironment.openProject`. A host that opens
+ * project tabs from elsewhere (a workspace's project band, a quota warning) keeps the tabs itself
+ * (`tabs`); without it the panel keeps them and opens its own projects' tabs.
+ */
+import { type ReactNode } from 'react';
+/** The base tab's id. */
+export declare const PROJECTS_BASE_TAB_ID = "projects";
+/** The panel's project tabs, kept by a host. */
+export interface ProjectPanelTabs {
+    /** The open project tabs, in order. */
+    openProjectIds: string[];
+    /** The project shown, or `null` for the base list. */
+    activeProjectId: string | null;
+    /** Show a project's tab (`null`: the base list). */
+    onSelect: (projectId: string | null) => void;
+    onClose: (projectId: string) => void;
+}
+export interface ConnectedProjectsPanelProps {
+    /** Host-kept tabs; the panel keeps its own without. */
+    tabs?: ProjectPanelTabs;
+    /** A project's storage section, at the foot of its detail. */
+    projectStorage?: (projectId: string) => ReactNode;
+    /** After the lists on the base tab (e.g. the deployment's storage, for its admins). */
+    footer?: ReactNode;
+    /** At the right of the tab header (e.g. the panel's mode switcher). */
+    headerRight?: ReactNode;
+    className?: string;
+}
+export declare function ConnectedProjectsPanel({ tabs: hostTabs, projectStorage, footer, headerRight, className, }: ConnectedProjectsPanelProps): import("react").JSX.Element;

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

@@ -0,0 +1 @@
+export { ConnectedProjectsPanel, PROJECTS_BASE_TAB_ID, type ConnectedProjectsPanelProps, type ProjectPanelTabs, } from './ConnectedProjectsPanel';

package/dist/connection/workspace-dashboard/ConnectedWorkspaceDashboard.d.ts

@@ -0,0 +1,37 @@
+/**
+ * The open workspace's home: what a returning person needs, in order. What they can start (the
+ * host's Start band), then what is recent (the last files and threads, each a way back in), then
+ * its facts (upcoming dated ones, the newest others) beside the host's agenda.
+ *
+ * Every section always shows, each with its own empty state, so a new workspace has the same
+ * layout as a busy one. A row opens its thing (`BlocksEnvironment.openDocument` /
+ * `openConversation`); the sections, a fact, "New" and the empty states go through `actions`, the
+ * host's pages and dialogs.
+ */
+import { type ReactNode } from 'react';
+/** What a dashboard hands back to its host: its pages and dialogs. */
+export interface WorkspaceDashboardActions {
+    /** A section's header: the Files, Threads or Facts page. */
+    openSection: (section: 'documents' | 'threads' | 'facts') => void;
+    /** A fact itself (the Facts page, at that fact). */
+    openFact: (factId: string) => void;
+    /** "New fact": the Facts page with its composer open. */
+    newFact: () => void;
+    /** "New" on Threads: the new-thread dialog. */
+    newThread: () => void;
+    /** The empty Threads card: a new, blank thread. */
+    ask: () => void;
+    /** The empty Files card: add files. */
+    addFiles: () => void;
+}
+export interface ConnectedWorkspaceDashboardProps {
+    actions: WorkspaceDashboardActions;
+    /** The Start band: what the workspace can do, each one click from underway. */
+    start?: ReactNode;
+    /** The Files section's add control (a source menu, say). */
+    addFilesAction?: ReactNode;
+    /** Beside the facts: what is coming up (the calendar's agenda, say). */
+    aside?: ReactNode;
+    testId?: string;
+}
+export declare function ConnectedWorkspaceDashboard({ actions, start, addFilesAction, aside, testId, }: ConnectedWorkspaceDashboardProps): import("react").JSX.Element;

package/dist/connection/workspace-dashboard/dashboard-rows.d.ts

@@ -0,0 +1,42 @@
+import type { ConnectedConversation, ConnectedDocument } from '../workspaceData';
+/**
+ * Rows per card: as far back as "recent" usefully reaches, and what lets the whole dashboard land
+ * on one 900px-tall screen.
+ */
+export declare const RECENT_ROWS = 5;
+/** Rows per facts group: a glanceable band, not a third list. */
+export declare const FACT_ROWS = 3;
+/** "30 Jun": an upcoming date shows as the date, not an age. */
+export declare function shortDate(iso: string): string;
+/** "14:30 · 4 Jan": the exact time (24h) before the date. */
+export declare function timeAndDate(iso: string | null | undefined): string;
+/** "low-content" → "Low content": a processing state in words. */
+export declare function humanizeStatus(status: string): string;
+export interface DashboardRowData {
+    id: string;
+    title: string;
+    subtitle: string;
+    time: string;
+}
+/** A task says where it stands (and when it is due); a plain thread says how long it is. */
+export declare function recentConversations(conversations: ConnectedConversation[]): DashboardRowData[];
+/** A file still processing says so; otherwise its length. */
+export declare function recentDocuments(documents: ConnectedDocument[]): Array<DashboardRowData & {
+    fileName: string | null | undefined;
+}>;
+export type DashboardFactRow = Omit<DashboardRowData, 'subtitle'>;
+interface DashboardFact {
+    external_id: string;
+    text: string;
+    date_start?: string | null;
+    created_at?: string | null;
+}
+/**
+ * Upcoming: dated facts from today on, soonest first (what you plan around). Recent: the newest of
+ * the rest (what the work just learned), stamped like the other rows.
+ */
+export declare function splitFacts(facts: DashboardFact[], now?: Date): {
+    upcoming: DashboardFactRow[];
+    recent: DashboardFactRow[];
+};
+export {};

package/dist/connection/workspace-dashboard/index.d.ts

@@ -0,0 +1 @@
+export { ConnectedWorkspaceDashboard, type ConnectedWorkspaceDashboardProps, type WorkspaceDashboardActions, } from './ConnectedWorkspaceDashboard';

package/dist/connection/workspace-list/ConnectedWorkspaceList.d.ts

@@ -0,0 +1,37 @@
+/**
+ * The user's workspaces, grouped by project, as cards or as a table: the page a user picks a
+ * workspace from. A filter over projects and workspace kinds, "New" (the host's create dialog), a
+ * project's name opens the project (`BlocksEnvironment.openProject`), a workspace opens it
+ * (`useConnectedWorkspace().openWorkspace`), and the table deletes a selection.
+ *
+ * A host may keep the view, the filters and the table's column state across visits (controlled
+ * props), and add tabs of its own beside "Workspaces" (`extraTabs`, with `children` as their body).
+ */
+import { type ReactNode } from 'react';
+import type { GridState } from 'ag-grid-community';
+import { type Tab } from '../../shell/TabHeader';
+import { type WorkspaceListFilters, type WorkspaceListLabels } from './useConnectedWorkspaceList';
+import type { RenderWorkspaceMember } from './workspaceTable';
+export type WorkspaceListView = 'cards' | 'table';
+/** The base tab's id. */
+export declare const WORKSPACES_TAB_ID = "workspaces";
+export interface ConnectedWorkspaceListProps {
+    /** Open the host's new-workspace dialog, in a project when given. */
+    onCreateWorkspace: (projectId?: string) => void;
+    view?: WorkspaceListView;
+    onViewChange?: (view: WorkspaceListView) => void;
+    filters?: WorkspaceListFilters;
+    onFiltersChange?: (filters: WorkspaceListFilters) => void;
+    /** The table's column state (widths, order, sort). */
+    gridState?: GridState;
+    onGridStateChange?: (state: GridState) => void;
+    /** A person in the table's Members column. Default: a plain avatar. */
+    renderMember?: RenderWorkspaceMember;
+    /** The host's tabs after "Workspaces"; `children` is the body while one of them is active. */
+    extraTabs?: Tab[];
+    activeTab?: string;
+    onTabChange?: (tabId: string) => void;
+    children?: ReactNode;
+    labels?: Partial<WorkspaceListLabels>;
+}
+export declare function ConnectedWorkspaceList({ onCreateWorkspace, view: controlledView, onViewChange, filters, onFiltersChange, gridState, onGridStateChange, renderMember, extraTabs, activeTab, onTabChange, children, labels, }: ConnectedWorkspaceListProps): import("react").JSX.Element;

package/dist/connection/workspace-list/WorkspaceCardsView.d.ts

@@ -0,0 +1,15 @@
+import { type WorkspaceSummary } from '../../workspaces/WorkspaceCard';
+import { type GroupedWorkspace } from '../../workspaces/workspace-groups';
+import type { ConnectedWorkspaceListState } from './useConnectedWorkspaceList';
+/** A workspace as its card shows it: summed counts, people only (owners first). */
+export declare function toWorkspaceSummary(workspace: GroupedWorkspace, selfId: string | undefined): WorkspaceSummary;
+export interface WorkspaceCardsViewProps {
+    list: ConnectedWorkspaceListState;
+    /** The open workspace (its card is marked current). */
+    currentWorkspaceId: string | null;
+    onOpenWorkspace: (workspace: GroupedWorkspace) => void;
+    onOpenProject: (projectId: string) => void;
+    onCreateWorkspace: (projectId?: string) => void;
+    createDisabledReason?: string;
+}
+export declare function WorkspaceCardsView({ list, currentWorkspaceId, onOpenWorkspace, onOpenProject, onCreateWorkspace, createDisabledReason, }: WorkspaceCardsViewProps): import("react").JSX.Element;

package/dist/connection/workspace-list/WorkspaceFilterMenu.d.ts

@@ -0,0 +1,4 @@
+import type { ConnectedWorkspaceListState } from './useConnectedWorkspaceList';
+export declare function WorkspaceFilterMenu({ list }: {
+    list: ConnectedWorkspaceListState;
+}): import("react").JSX.Element;

package/dist/connection/workspace-list/WorkspaceTableView.d.ts

@@ -0,0 +1,13 @@
+import type { GridState } from 'ag-grid-community';
+import type { GroupedWorkspace } from '../../workspaces/workspace-groups';
+import type { ConnectedWorkspaceListState } from './useConnectedWorkspaceList';
+import { type RenderWorkspaceMember } from './workspaceTable';
+export interface WorkspaceTableViewProps {
+    list: ConnectedWorkspaceListState;
+    onOpenWorkspace: (workspace: GroupedWorkspace) => void;
+    onOpenProject: (projectId: string) => void;
+    renderMember: RenderWorkspaceMember;
+    gridState?: GridState;
+    onGridStateChange?: (state: GridState) => void;
+}
+export declare function WorkspaceTableView({ list, onOpenWorkspace, onOpenProject, renderMember, gridState, onGridStateChange, }: WorkspaceTableViewProps): import("react").JSX.Element;

package/dist/connection/workspace-list/index.d.ts

@@ -0,0 +1,5 @@
+export { ConnectedWorkspaceList, WORKSPACES_TAB_ID, type ConnectedWorkspaceListProps, type WorkspaceListView, } from './ConnectedWorkspaceList';
+export { useConnectedWorkspaceList, DEFAULT_WORKSPACE_LIST_LABELS, type ConnectedWorkspaceListState, type UseConnectedWorkspaceListOptions, type WorkspaceListFilters, type WorkspaceListLabels, } from './useConnectedWorkspaceList';
+export { toWorkspaceSummary } from './WorkspaceCardsView';
+export type { RenderWorkspaceMember } from './workspaceTable';
+export { projectGroupBilling, type ProjectGroupBilling } from './projectBilling';

package/dist/connection/workspace-list/projectBilling.d.ts

@@ -0,0 +1,21 @@
+/**
+ * What a project's group in the workspace list says about the project itself: its plan badge (own
+ * projects, where plans are sold), the usage readout beside its name, and the plan and limits
+ * breakdown behind the name. One source for the cards' bands and the table's headings.
+ */
+import type { ReactNode } from 'react';
+import type { components } from '@arbidocs/client';
+type Project = components['schemas']['ProjectResponse'];
+export interface ProjectGroupBilling {
+    /** The plan badge: own projects only, where plans are sold. */
+    planBadge?: ReactNode;
+    /** Plan and usage, right after the name (projects with quotas). */
+    readout?: ReactNode;
+    /** The plan and limits panel behind the name; meters for own projects only. */
+    breakdown?: ReactNode;
+}
+export declare function projectGroupBilling(project: Project | undefined, { isOwned, stripeEnabled }: {
+    isOwned: boolean;
+    stripeEnabled: boolean;
+}): ProjectGroupBilling;
+export {};