@pstdio/ui 0.15.0 → 0.17.0

package/dist/components/data-table/data-table-stats.d.ts

@@ -0,0 +1,19 @@
+import { RowData } from './types';
+export interface HistogramBin {
+    start: number;
+    end: number;
+    count: number;
+}
+export interface HistogramStat {
+    min: number;
+    max: number;
+    bins: HistogramBin[];
+}
+export interface TopValueStat {
+    label: string;
+    count: number;
+    percentage: number;
+}
+export declare const countUniqueStatValues: (rows: RowData[], columnId: string) => number;
+export declare const buildTopValuesStat: (rows: RowData[], columnId: string, limit: number) => TopValueStat[];
+export declare const buildHistogramStat: (rows: RowData[], columnId: string, binCount: number) => HistogramStat | null;

package/dist/components/data-table/data-table-table-parts.d.ts

@@ -0,0 +1,21 @@
+import { Header, HeaderGroup, Row, Table as TanStackTable } from '@tanstack/react-table';
+import { DataTableProps, RowData } from './types';
+interface DataTableColumnHeaderProps {
+    header: Header<RowData, unknown>;
+    headerGroup: HeaderGroup<RowData>;
+    table: TanStackTable<RowData>;
+    fullWidth?: boolean;
+    hasDescription?: boolean;
+}
+export declare const DataTableColumnHeader: (props: DataTableColumnHeaderProps) => import("react/jsx-runtime").JSX.Element;
+interface DataTableBodyRowProps {
+    row: Row<RowData>;
+    noBorder?: boolean;
+    rowIsInteractive: boolean;
+    rowIsActive: boolean;
+    rowIsSelected: boolean;
+    onRowClick?: DataTableProps["onRowClick"];
+    getCellContextMenuActions?: DataTableProps["getCellContextMenuActions"];
+}
+export declare const DataTableBodyRow: (props: DataTableBodyRowProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/data-table/data-table.story-descriptions.d.ts

@@ -0,0 +1,6 @@
+export declare const columnDescriptions: {
+    Invoice: string;
+    Amount: string;
+    Status: string;
+    Region: string;
+};

package/dist/components/data-table/data-table.story-fixtures.d.ts

@@ -0,0 +1,6 @@
+import { RowData } from './types';
+export declare const tableRows: RowData[];
+export declare const generateTableRows: (count: number) => RowData[];
+export declare const thousandTableRows: RowData[];
+export declare const columnManagementRows: RowData[];
+export declare const friendlyJsonRows: RowData[];

package/dist/components/data-table/friendly-json-display.d.ts

@@ -0,0 +1,31 @@
+export interface FriendlyJsonDisplayProps {
+    value: unknown;
+}
+export declare const parseJsonCellValue: (value: unknown) => unknown;
+export declare const buildJsonFields: (value: unknown) => {
+    label: string;
+    value: unknown;
+}[];
+export declare const isJsonImageValue: (value: unknown, label: string) => boolean;
+export declare const isJsonImageArray: (value: unknown, label: string) => boolean;
+export declare const getJsonCellSummary: (value: unknown) => string;
+export declare const buildFriendlyJsonParams: (value: unknown) => {
+    id: string;
+    name: string;
+    type: "readOnly";
+    value: string | number | boolean | (string | number | boolean | null)[] | {
+        type: "image";
+        src: string;
+        alt: string;
+        images?: undefined;
+    } | {
+        type: "image-gallery";
+        images: {
+            src: string;
+            alt: string;
+        }[];
+        src?: undefined;
+        alt?: undefined;
+    } | null;
+}[];
+export declare const FriendlyJsonDisplay: (props: FriendlyJsonDisplayProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/data-table/index.d.ts

@@ -1,3 +1,5 @@
 export { DataTable } from './data-table';
+export type { FriendlyJsonDisplayProps } from './friendly-json-display';
+export { FriendlyJsonDisplay } from './friendly-json-display';
 export { formatDisplayValue, getIcon } from './helpers';
-export type { DataTableProps, RowData } from './types';
+export type { DataTableCategoricalColor, DataTableCategoricalValue, DataTableCellContext, DataTableCellContextAction, DataTableColorScaleStop, DataTableColumnRenderer, DataTableColumnStat, DataTableProps, DataTableRowAction, DataTableSelectionAction, DataTableThemeColor, RowData, } from './types';

package/dist/components/data-table/json-cell.d.ts

@@ -0,0 +1,6 @@
+interface JsonCellProps {
+    columnLabel: string;
+    value: unknown;
+}
+export declare const JsonCell: (props: JsonCellProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/data-table/pagination-footer.d.ts

@@ -1,5 +1,8 @@
 import { useReactTable } from '@tanstack/react-table';
 import { RowData } from './types';
-export declare function PaginationFooter({ table }: {
+export declare function PaginationFooter({ table, pageIndex, pageSize, pageSizeOptions, }: {
     table: ReturnType<typeof useReactTable<RowData>>;
+    pageIndex: number;
+    pageSize: number;
+    pageSizeOptions: number[];
 }): import("react/jsx-runtime").JSX.Element;

package/dist/components/data-table/selection-toolbar.d.ts

@@ -1,9 +1,11 @@
+import { DataTableSelectionAction, RowData } from './types';
 interface SelectionToolbarProps {
     selectedCount: number;
     totalCount: number;
     onClearSelection: () => void;
     onSelectAll: () => void;
-    onCSVDownload: () => void;
+    actions: DataTableSelectionAction[];
+    selectedRows: RowData[];
 }
 export declare function SelectionToolbar(props: SelectionToolbarProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/components/data-table/types.d.ts

@@ -5,11 +5,80 @@ export type DisplayValue = {
     display: ReactNode;
     sortValue?: unknown;
 };
+export interface DataTableThemeColor {
+    light: string;
+    dark: string;
+    foreground?: {
+        light: string;
+        dark: string;
+    };
+}
+export interface DataTableColorScaleStop {
+    value: number;
+    color: DataTableThemeColor;
+}
+export type DataTableCategoricalValue = string | number | boolean | null;
+export interface DataTableCategoricalColor {
+    value: DataTableCategoricalValue;
+    color: DataTableThemeColor;
+}
+export type DataTableColumnRenderer = {
+    type: "json";
+} | {
+    type: "color-scale";
+    stops: DataTableColorScaleStop[];
+} | {
+    type: "categorical-color";
+    categories: DataTableCategoricalColor[];
+};
+export type DataTableColumnStat = {
+    type: "unique";
+} | {
+    type: "histogram";
+    bins?: number;
+} | {
+    type: "top-values";
+    limit?: number;
+};
+export interface DataTableSelectionAction {
+    label: string;
+    icon?: ReactNode;
+    destructive?: boolean;
+    onSelect: (rows: RowData[]) => void;
+}
+export interface DataTableRowAction {
+    label: string;
+    icon?: ReactNode;
+    destructive?: boolean;
+    onSelect: (row: RowData) => void;
+}
+export interface DataTableCellContext {
+    row: RowData;
+    rowId: string;
+    columnId: string;
+    value: unknown;
+}
+export interface DataTableCellContextAction {
+    label: string;
+    icon?: ReactNode;
+    destructive?: boolean;
+    onSelect: (context: DataTableCellContext) => void;
+}
 export interface DataTableProps {
     data: RowData[];
     isReadOnly?: boolean;
     noBorder?: boolean;
     fullWidth?: boolean;
+    initialPageSize?: number;
+    pageSizeOptions?: number[];
+    selectionMode?: "none" | "multiple";
+    selectionActions?: DataTableSelectionAction[];
+    rowActions?: DataTableRowAction[];
+    compactHeaders?: Partial<Record<string, string>>;
+    getRowId?: (row: RowData, index: number) => string;
+    toolbarStorageKey?: string;
+    enableRowActivation?: boolean;
+    getCellContextMenuActions?: (context: DataTableCellContext) => DataTableCellContextAction[];
     onCSVUpload?: (csv: string) => Promise<void>;
     onCSVDownload?: (scenarios: string[]) => void;
     hiddenColumns?: string[];
@@ -17,4 +86,7 @@ export interface DataTableProps {
     isRowInteractive?: (row: RowData) => boolean;
     activeRowId?: string | null;
     columnIcons?: Partial<Record<string, ReactNode>>;
+    columnDescriptions?: Partial<Record<string, string>>;
+    columnStats?: Partial<Record<string, DataTableColumnStat>>;
+    columnRenderers?: Partial<Record<string, DataTableColumnRenderer>>;
 }

package/dist/components/diff-viewer/diff-card.d.ts

@@ -40,6 +40,7 @@ export declare const resolveRequestedDiffPath: (input: {
     hasDiffContent: boolean;
 }) => string | null;
 export declare const shouldShowDiffStats: (filePath: string) => boolean;
+export declare const resolveDiffFilePath: (diff: Diff) => string;
 export declare const DiffCard: (props: DiffCardProps) => import("react/jsx-runtime").JSX.Element;
 export declare const DiffCardHeader: (props: DiffCardHeaderProps) => import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/components/diff-viewer/diff-drawer-scroll.d.ts

@@ -1,13 +1,4 @@
 import { Diff } from './diff-card';
-import { DiffViewMode } from './types';
-interface EstimateDiffRangeHeightInput {
-    diffs: Diff[];
-    collapsedPaths: Set<string>;
-    largeDiffOptInPaths: Set<string>;
-    diffViewMode: DiffViewMode;
-    startIndex: number;
-    endIndex: number;
-}
 interface SelectedExpansionCommand {
     action: string;
     id: number;
@@ -21,11 +12,6 @@ interface ResolveSelectedScrollStateInput {
     expansionCommand: SelectedExpansionCommand | null;
     completedScrollCommandId: number | null;
 }
-export interface RenderedDiffItem {
-    element: HTMLElement;
-    index: number;
-}
-export declare const estimateDiffRangeHeight: (input: EstimateDiffRangeHeightInput) => number;
 export declare const resolveSelectedScrollState: (input: ResolveSelectedScrollStateInput) => {
     selectedScrollPath: string | null;
     selectedScrollKey: string | null;
@@ -39,9 +25,4 @@ export declare const includePinnedDiffIndexes: (input: {
     selectedScrollIndex: number;
     shouldPinSelectedScrollIndex: boolean;
 }) => number[];
-export declare const getRenderedDiffItems: (scrollElement: HTMLElement | null) => RenderedDiffItem[];
-export declare const getElementScrollOffset: (input: {
-    element: HTMLElement;
-    scrollElement: HTMLElement | null;
-}) => number;
 export {};

package/dist/components/diff-viewer/diff-drawer.d.ts

@@ -25,4 +25,5 @@ export declare const buildInitialCollapsedPaths: (diffs: Diff[]) => Set<string>;
 export declare const buildAllCollapsedPaths: (diffs: Diff[]) => Set<string>;
 export declare const toggleCollapsedPath: (collapsedPaths: Set<string>, path: string) => Set<string>;
 export declare const resolveCollapsedPathsForSelectedDiff: (diffs: Diff[], collapsedPaths: Set<string>, selectedDiffPath: string | null) => Set<string>;
+export declare const resolveCollapsedPathsForNavigation: (diffs: Diff[], collapsedPaths: Set<string>, selectedDiffPath: string, previousNavigatedPath: string | null) => Set<string>;
 export declare function DiffDrawer(props: DiffDrawerProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/diff-viewer/index.d.ts

@@ -1,3 +1,5 @@
+export { CodeDiffEditor, CodeEditor } from './code-editor';
+export { DiffBubble } from './diff-bubble';
 export type { Diff } from './diff-card';
 export { DiffDrawer } from './diff-drawer';
 export { DiffViewer, type DiffViewerProps } from './diff-viewer';

package/dist/components/diff-viewer/use-selected-diff-scroll.d.ts

@@ -1,16 +1,20 @@
+import { Virtualizer } from '@tanstack/react-virtual';
 import { Diff } from './diff-card';
 import { DiffExpansionCommand } from './diff-drawer';
-import { DiffViewMode } from './types';
 interface UseSelectedDiffScrollInput {
     diffs: Diff[];
     selectedDiffPath: string | null;
     collapsedPaths: Set<string>;
-    largeDiffOptInPaths: Set<string>;
     expansionCommand: DiffExpansionCommand | null;
-    diffViewMode: DiffViewMode;
     scrollRef: {
         current: HTMLDivElement | null;
     };
+    virtualizerRef: {
+        current: Virtualizer<HTMLDivElement, Element> | null;
+    };
+    suppressScrollAdjustRef: {
+        current: boolean;
+    };
 }
 export declare const useSelectedDiffScroll: (input: UseSelectedDiffScrollInput) => {
     selectedScrollIndex: number;

package/dist/components/internal/style-guide.d.ts

@@ -0,0 +1,14 @@
+import { ReactNode } from 'react';
+import { TokenEditorPresetId, TokenEditorValues } from './token-editor-data';
+export interface TokenPreviewScopeProps {
+    values: TokenEditorValues;
+    children: ReactNode;
+}
+export interface TokenEditorOverlayProps {
+    basePresetId?: TokenEditorPresetId;
+    baseValues?: TokenEditorValues;
+    values: TokenEditorValues;
+    onChange: (values: TokenEditorValues) => void;
+}
+export declare const TokenPreviewScope: (props: TokenPreviewScopeProps) => import("react/jsx-runtime").JSX.Element;
+export declare const TokenEditorOverlay: (props: TokenEditorOverlayProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/internal/token-editor-controls.d.ts

@@ -0,0 +1,8 @@
+import { TokenEditorToken } from './token-editor-data';
+interface TokenEditorControlProps {
+    token: TokenEditorToken;
+    value: string;
+    onValueChange: (tokenId: string, value: string) => void;
+}
+export declare const TokenValueEditor: (props: TokenEditorControlProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/internal/token-editor-data.d.ts

@@ -0,0 +1,40 @@
+export type TokenEditorPresetId = "pst-dark" | "pst-light" | "monokai" | "solarized";
+export type TokenEditorMode = "light" | "dark";
+export type TokenEditorTokenKind = "border" | "color" | "dimension" | "font" | "number";
+export type TokenEditorValues = Record<string, string>;
+export interface TokenEditorToken {
+    id: string;
+    cssVariable: string;
+    defaultValue: string;
+    darkValue: string;
+    groupId: string;
+    kind: TokenEditorTokenKind;
+    lightValue: string;
+    name: string;
+}
+export interface TokenEditorGroup {
+    id: string;
+    title: string;
+    description: string;
+    tokens: TokenEditorToken[];
+}
+export interface TokenEditorPreset {
+    id: TokenEditorPresetId;
+    label: string;
+    values: TokenEditorValues;
+}
+export declare const tokenEditorGroups: TokenEditorGroup[];
+export declare const tokenEditorTokens: TokenEditorToken[];
+export declare const pstLightTokenEditorValues: {
+    [k: string]: string;
+};
+export declare const pstDarkTokenEditorValues: {
+    [k: string]: string;
+};
+export declare const tokenEditorPresets: TokenEditorPreset[];
+export declare const defaultTokenEditorValues: {
+    [k: string]: string;
+};
+export declare const createTokenEditorStyle: (values: TokenEditorValues) => {
+    [k: string]: string;
+};

package/dist/components/internal/token-editor-state.d.ts

@@ -0,0 +1,22 @@
+import { TokenEditorPresetId, TokenEditorValues } from './token-editor-data';
+import { ThemePreference, ThemePreferenceOption } from '../../utils/apply-theme-preference';
+interface UseTokenEditorValuesOptions {
+    themePreference?: ThemePreference;
+    themePreferences?: readonly ThemePreferenceOption[];
+}
+export declare const getDefaultTokenEditorPresetId: () => TokenEditorPresetId;
+export declare const getDefaultTokenEditorValues: (presetId?: TokenEditorPresetId) => {
+    [k: string]: string;
+};
+export declare const getTokenEditorOverrides: (values: TokenEditorValues, baseValues: TokenEditorValues) => {
+    [k: string]: string;
+};
+export declare const useTokenEditorValues: (options?: UseTokenEditorValuesOptions) => {
+    values: TokenEditorValues;
+    setValues: (nextValues: TokenEditorValues) => void;
+    basePresetId: TokenEditorPresetId;
+    baseValues: TokenEditorValues;
+    themePreference: string;
+};
+export declare const exportTokenEditorOverrides: (values: TokenEditorValues, basePresetId?: TokenEditorPresetId, baseValues?: TokenEditorValues) => void;
+export {};

package/dist/components/{data-renderer → kanban-renderer}/display-menu.d.ts

@@ -1,11 +1,11 @@
-import { MenuOption } from './data-renderer-helpers';
-import { DataRendererSettings } from './types';
+import { MenuOption } from './kanban-renderer-helpers';
+import { KanbanRendererSettings } from './types';
 interface DisplayMenuProps {
-    settings: DataRendererSettings;
+    settings: KanbanRendererSettings;
     groupingOptions: MenuOption[];
     orderingOptions: MenuOption[];
     displayPropertyOptions: MenuOption[];
-    onViewModeChange: (value: DataRendererSettings["viewMode"]) => void;
+    onViewModeChange: (value: KanbanRendererSettings["viewMode"]) => void;
     onColumnGroupingChange: (value: string) => void;
     onRowGroupingChange: (value: string) => void;
     onOrderingAttributeIdChange: (value: string) => void;

package/dist/components/{data-renderer → kanban-renderer}/filter-menu.d.ts

@@ -1,8 +1,8 @@
-import { FilterCategoryView } from './data-renderer-helpers';
-import { DataRendererFilterState } from './types';
+import { FilterCategoryView } from './kanban-renderer-helpers';
+import { KanbanRendererFilterState } from './types';
 interface FilterMenuProps {
     categories: FilterCategoryView[];
-    filters: DataRendererFilterState;
+    filters: KanbanRendererFilterState;
     countsByCategory: Record<string, Record<string, number>>;
     onToggleFilterValue: (attributeId: string, value: string) => void;
     onClearFilter: (attributeId: string) => void;

package/dist/components/kanban-renderer/index.d.ts

@@ -0,0 +1,19 @@
+export { DisplayMenu } from './display-menu';
+export { FilterMenu } from './filter-menu';
+export type { BoardColumnConfig, KanbanRendererProps } from './kanban-renderer';
+export { KanbanRenderer } from './kanban-renderer';
+export type { KanbanRendererBoardColumn, KanbanRendererBoardColumnAction, KanbanRendererBoardItem, } from './kanban-renderer-board';
+export { KanbanRendererBoard } from './kanban-renderer-board';
+export type { KanbanRendererCardProps } from './kanban-renderer-card';
+export { KanbanRendererCard } from './kanban-renderer-card';
+export { KanbanRendererCreateDialog } from './kanban-renderer-create-dialog';
+export type { AttributeBadge, FilterCategoryView, MenuOption } from './kanban-renderer-helpers';
+export { buildDisplayPropertyOptions, buildFilterCategories, buildGroupingOptions, buildOrderingOptions, collectDisplayBadges, getAttributeStringValues, getAttributeValue, getEnumOptions, renderAttributeBadge, sanitizeFilters, sanitizeSettings, } from './kanban-renderer-helpers';
+export type { KanbanRendererListItem } from './kanban-renderer-list';
+export { KanbanRendererList } from './kanban-renderer-list';
+export type { KanbanRendererToolbarProps } from './kanban-renderer-toolbar';
+export { KanbanRendererToolbar } from './kanban-renderer-toolbar';
+export type { AttributeDescriptor, AttributeDisplayDescriptor, AttributeKind, AttributesSource, AttributeType, EnumOption, EnumOptions, EnumOptionsSource, KanbanRendererCreateField, KanbanRendererCreateFieldType, KanbanRendererCreateRowConfig, KanbanRendererCreateSubmission, KanbanRendererFilterState, KanbanRendererOrdering, KanbanRendererRow, KanbanRendererSavedView, KanbanRendererSettings, SortDirection, ViewMode, } from './types';
+export { findAttribute, isAttributesSource, isEnumOptionsSource, MANUAL_ORDERING, NO_GROUPING, } from './types';
+export { isActiveKanbanRendererViewDirty, useKanbanRendererStore } from './use-kanban-renderer-store';
+export { resolveAttributeOptions, useResolvedAttributes } from './use-resolved-attributes';

package/dist/components/kanban-renderer/kanban-renderer-attribute-badge.d.ts

@@ -0,0 +1,7 @@
+import { AttributeBadge } from './kanban-renderer-helpers';
+interface KanbanRendererAttributeBadgeProps {
+    badge: AttributeBadge;
+    onChange?: (attributeId: string, value: unknown) => void;
+}
+export declare const KanbanRendererAttributeBadge: (props: KanbanRendererAttributeBadgeProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/{data-renderer/data-renderer-board-column-header.d.ts → kanban-renderer/kanban-renderer-board-column-header.d.ts}

@@ -1,6 +1,6 @@
-import { DataRendererBoardColumn } from './data-renderer-board';
+import { KanbanRendererBoardColumn } from './kanban-renderer-board';
 interface ColumnHeaderProps {
-    column: DataRendererBoardColumn;
+    column: KanbanRendererBoardColumn;
     onCreateStart?: (columnId: string) => void;
     onColumnAction?: (columnId: string, actionId: string) => Promise<void> | void;
 }

package/dist/components/{data-renderer/data-renderer-board-group-section.d.ts → kanban-renderer/kanban-renderer-board-group-section.d.ts}

@@ -1,8 +1,8 @@
 import { DragEvent } from 'react';
-import { DataRendererBoardGroup } from './data-renderer-board';
+import { KanbanRendererBoardGroup } from './kanban-renderer-board';
 interface GroupSectionProps {
     columnId: string;
-    group: DataRendererBoardGroup;
+    group: KanbanRendererBoardGroup;
     selectedItemId: string | null;
     canDragIn: boolean;
     canDragOut: boolean;

package/dist/components/{data-renderer/data-renderer-board-move.d.ts → kanban-renderer/kanban-renderer-board-move.d.ts}

@@ -1,6 +1,6 @@
-import { DataRendererSettings } from './types';
+import { KanbanRendererSettings } from './types';
 interface ApplyBoardMoveItemInput {
-    settings: Pick<DataRendererSettings, "columnGrouping" | "ordering" | "rowGrouping">;
+    settings: Pick<KanbanRendererSettings, "columnGrouping" | "ordering" | "rowGrouping">;
     rowId: string;
     targetColumnId: string;
     targetGroupKey?: string;
@@ -9,7 +9,7 @@ interface ApplyBoardMoveItemInput {
     onReorder?: (rowId: string, beforeRowId?: string) => Promise<void> | void;
 }
 interface ApplyBoardMoveToGroupInput {
-    settings: Pick<DataRendererSettings, "ordering" | "rowGrouping">;
+    settings: Pick<KanbanRendererSettings, "ordering" | "rowGrouping">;
     rowId: string;
     targetGroupKey: string;
     beforeItemId?: string;

package/dist/components/{data-renderer/data-renderer-board.d.ts → kanban-renderer/kanban-renderer-board.d.ts}

@@ -1,38 +1,39 @@
 import { ComponentProps, ComponentType } from 'react';
-import { ResourceContextAction } from '../resource-context-menu';
-import { DataRendererCard } from './data-renderer-card';
-type DataRendererCardProps = ComponentProps<typeof DataRendererCard>;
-export interface DataRendererBoardItem {
+import { ResourceContextAction } from '../overlays/resource-context-menu';
+import { KanbanRendererCard } from './kanban-renderer-card';
+type KanbanRendererCardProps = ComponentProps<typeof KanbanRendererCard>;
+export interface KanbanRendererBoardItem {
     id: string;
-    cardProps: Omit<DataRendererCardProps, "draggable" | "onDragStart" | "onDragEnd" | "isSelected">;
+    cardProps: Omit<KanbanRendererCardProps, "draggable" | "onDragStart" | "onDragEnd" | "isSelected">;
     contextMenuActions?: ResourceContextAction[];
 }
-export interface DataRendererBoardColumnAction {
+export interface KanbanRendererBoardColumnAction {
     id: string;
     label: string;
     icon: ComponentType<{
         size?: number | string;
     }>;
 }
-export interface DataRendererBoardGroup {
+export interface KanbanRendererBoardGroup {
     key: string;
     label: string;
-    items: DataRendererBoardItem[];
+    items: KanbanRendererBoardItem[];
 }
-export interface DataRendererBoardColumn {
+export interface KanbanRendererBoardColumn {
     id: string;
     label: string;
     createLabel?: string;
     color?: string;
-    items: DataRendererBoardItem[];
-    groups?: DataRendererBoardGroup[];
+    icon?: string | null;
+    items: KanbanRendererBoardItem[];
+    groups?: KanbanRendererBoardGroup[];
     canDragIn: boolean;
     canDragOut: boolean;
     canCreate: boolean;
-    actions: DataRendererBoardColumnAction[];
+    actions: KanbanRendererBoardColumnAction[];
 }
-interface DataRendererBoardProps {
-    columns: DataRendererBoardColumn[];
+interface KanbanRendererBoardProps {
+    columns: KanbanRendererBoardColumn[];
     selectedItemId?: string | null;
     onMoveItem?: (itemId: string, targetColumnId: string, context?: {
         beforeItemId?: string;
@@ -44,5 +45,5 @@ interface DataRendererBoardProps {
     onCreateStart?: (columnId: string) => void;
     onColumnAction?: (columnId: string, actionId: string) => Promise<void> | void;
 }
-export declare const DataRendererBoard: (props: DataRendererBoardProps) => import("react/jsx-runtime").JSX.Element;
+export declare const KanbanRendererBoard: (props: KanbanRendererBoardProps) => import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/components/{data-renderer/data-renderer-card.d.ts → kanban-renderer/kanban-renderer-card.d.ts}

@@ -1,7 +1,8 @@
 import { DragEventHandler, ReactNode } from 'react';
-import { WorkspaceBadgeProps } from '../workspace-badge';
-import { AttributeBadge } from './data-renderer-helpers';
-export interface DataRendererCardProps {
+import { WorkspaceBadgeProps } from '../primitives/workspace-badge';
+import { AttributeBadge } from './kanban-renderer-helpers';
+export interface KanbanRendererCardProps {
+    eyebrow?: string;
     title: string;
     badges?: AttributeBadge[];
     customSlots?: ReactNode[];
@@ -13,4 +14,4 @@ export interface DataRendererCardProps {
     onDragEnd?: DragEventHandler<HTMLDivElement>;
     onClick?: () => void;
 }
-export declare const DataRendererCard: (props: DataRendererCardProps) => import("react/jsx-runtime").JSX.Element;
+export declare const KanbanRendererCard: (props: KanbanRendererCardProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/{data-renderer/data-renderer-content.d.ts → kanban-renderer/kanban-renderer-content.d.ts}

@@ -1,11 +1,11 @@
 import { ReactNode } from 'react';
-import { DataRendererBoardColumn } from './data-renderer-board';
-import { DataRendererListItem } from './data-renderer-list';
-import { DataRendererSettings } from './types';
-interface DataRendererContentProps {
-    viewMode: DataRendererSettings["viewMode"];
-    boardColumns: DataRendererBoardColumn[];
-    listItems: DataRendererListItem[];
+import { KanbanRendererBoardColumn } from './kanban-renderer-board';
+import { KanbanRendererListItem } from './kanban-renderer-list';
+import { KanbanRendererSettings } from './types';
+interface KanbanRendererContentProps {
+    viewMode: KanbanRendererSettings["viewMode"];
+    boardColumns: KanbanRendererBoardColumn[];
+    listItems: KanbanRendererListItem[];
     listExpandedGroups: Record<string, boolean>;
     selectedRowId: string | null;
     emptyState?: ReactNode;
@@ -23,5 +23,5 @@ interface DataRendererContentProps {
     onListExpandedGroupChange: (rowId: string, isExpanded: boolean) => void;
     listKey: string;
 }
-export declare const DataRendererContent: (props: DataRendererContentProps) => import("react/jsx-runtime").JSX.Element;
+export declare const KanbanRendererContent: (props: KanbanRendererContentProps) => import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/components/kanban-renderer/kanban-renderer-create-dialog.d.ts

@@ -0,0 +1,12 @@
+import { AttributeDescriptor, KanbanRendererCreateRowConfig, KanbanRendererCreateSubmission } from './types';
+interface KanbanRendererCreateDialogProps {
+    open: boolean;
+    columnId: string;
+    columnAttributeId?: string;
+    attributes: AttributeDescriptor[];
+    config: KanbanRendererCreateRowConfig;
+    onClose: () => void;
+    onSubmit: (submission: KanbanRendererCreateSubmission) => Promise<void> | void;
+}
+export declare const KanbanRendererCreateDialog: (props: KanbanRendererCreateDialogProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/kanban-renderer/kanban-renderer-create-field.d.ts

@@ -0,0 +1,10 @@
+import { KanbanRendererCreateField } from './types';
+interface CreateFieldControlProps {
+    disabled: boolean;
+    field: KanbanRendererCreateField;
+    removeLabel: string;
+    value: unknown;
+    onChange: (value: unknown) => void;
+}
+export declare const CreateFieldControl: (props: CreateFieldControlProps) => import("react/jsx-runtime").JSX.Element;
+export {};