@inf-monkeys-tech/monkeys-design 1.0.53 → 1.0.54

package/dist/WorkbenchRadarMatrix-3b2384181e2d.d.mts

@@ -0,0 +1,1257 @@
+import * as React from 'react';
+import { ReactNode, MouseEvent, ElementType, CSSProperties, ComponentPropsWithoutRef, ComponentType, HTMLAttributes, KeyboardEvent, DragEvent } from 'react';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { c1 as BaseTableSortDirection, c as BaseAppearance, bL as BaseTableColumnSizes, bJ as BaseTableColumnOrderChangeDetail, bK as BaseTableColumnSizeChangeDetail } from './types-c6ec8b90925b.mjs';
+interface WorkbenchResizableSidebarItem {
+    id: string;
+    label: ReactNode;
+    icon?: ReactNode;
+    active?: boolean;
+    disabled?: boolean;
+    href?: string;
+    to?: string;
+    title?: string;
+    endContent?: ReactNode;
+    className?: string;
+    onClick?: (event: MouseEvent<HTMLElement>) => void;
+}
+interface WorkbenchResizableSidebarSection {
+    id: string;
+    label?: ReactNode;
+    items: WorkbenchResizableSidebarItem[];
+    className?: string;
+    labelClassName?: string;
+}
+interface WorkbenchResizableSidebarClassNames {
+    root?: string;
+    header?: string;
+    title?: string;
+    collapseButton?: string;
+    list?: string;
+    section?: string;
+    sectionLabel?: string;
+    item?: string;
+    itemIcon?: string;
+    itemLabel?: string;
+    resizeHandle?: string;
+    mobileNav?: string;
+    mobileItem?: string;
+}
+interface WorkbenchResizableSidebarProps {
+    title?: ReactNode;
+    items: WorkbenchResizableSidebarItem[];
+    sections?: WorkbenchResizableSidebarSection[];
+    activeItemId?: string;
+    itemAs?: ElementType;
+    collapsed?: boolean;
+    defaultCollapsed?: boolean;
+    onCollapsedChange?: (collapsed: boolean) => void;
+    width?: number;
+    onWidthChange?: (width: number) => void;
+    defaultWidth?: number;
+    minWidth?: number;
+    maxWidth?: number;
+    collapsedWidth?: number;
+    collapseThreshold?: number;
+    storageKey?: string;
+    resizable?: boolean;
+    collapsible?: boolean;
+    collapseLabel?: string;
+    expandLabel?: string;
+    resizeLabel?: string;
+    desktopClassName?: string;
+    mobileClassName?: string;
+    className?: string;
+    classNames?: WorkbenchResizableSidebarClassNames;
+    style?: CSSProperties;
+}
+declare const WorkbenchResizableSidebar: React.ForwardRefExoticComponent<WorkbenchResizableSidebarProps & React.RefAttributes<HTMLElement>>;
+interface WorkbenchContentPaneClassNames {
+    root?: string;
+    header?: string;
+    body?: string;
+    footer?: string;
+}
+interface WorkbenchContentPaneBodyProps extends Omit<ComponentPropsWithoutRef<'div'>, 'children' | 'className'> {
+    className?: string;
+}
+interface WorkbenchContentPaneProps extends Omit<ComponentPropsWithoutRef<'section'>, 'children' | 'className' | 'style'> {
+    as?: ElementType;
+    bodyAs?: ElementType;
+    header?: ReactNode;
+    footer?: ReactNode;
+    children?: ReactNode;
+    className?: string;
+    headerClassName?: string;
+    bodyClassName?: string;
+    footerClassName?: string;
+    bodyProps?: WorkbenchContentPaneBodyProps;
+    classNames?: WorkbenchContentPaneClassNames;
+    style?: CSSProperties;
+    [key: string]: any;
+}
+declare const WorkbenchContentPane: React.ForwardRefExoticComponent<Omit<WorkbenchContentPaneProps, "ref"> & React.RefAttributes<HTMLElement>>;
+interface WorkbenchGalleryColumn {
+    key: string;
+    label?: ReactNode;
+    renderType?: string;
+    type?: string;
+    wrap?: boolean;
+    [key: string]: any;
+}
+interface WorkbenchGallerySettingsValue {
+    visibleColumnKeys?: string[];
+    galleryFieldKey?: string;
+    galleryLayout?: 'fixed' | 'masonry' | string;
+    galleryDensity?: 'comfortable' | 'compact' | 'detailed' | string;
+    galleryGridColumns?: 'auto' | number | string;
+    galleryBentoColumns?: 1 | 2 | 3 | number;
+    galleryDetailVisibility?: 'all' | 'limit' | string;
+    galleryDetailLimit?: number | string;
+    [key: string]: any;
+}
+interface WorkbenchGallerySettingsOption<Value extends number | string = string> {
+    value: Value;
+    label: ReactNode;
+    disabled?: boolean;
+}
+interface WorkbenchGallerySettingsLabels {
+    settingsButton?: ReactNode;
+    title?: ReactNode;
+    visibleColumns?: ReactNode;
+    coverField?: ReactNode;
+    autoDetect?: ReactNode;
+    cardDensity?: ReactNode;
+    cardColumns?: ReactNode;
+    detailColumns?: ReactNode;
+    fieldVisibility?: ReactNode;
+    fieldLimit?: ReactNode;
+    fieldLimitHint?: ReactNode;
+    layout?: ReactNode;
+    compact?: ReactNode;
+    comfortable?: ReactNode;
+    detailed?: ReactNode;
+    autoColumns?: ReactNode;
+    columns?: (count: number) => ReactNode;
+    bentoColumns?: (count: number) => ReactNode;
+    topLimit?: ReactNode;
+    allFields?: ReactNode;
+    adaptiveGrid?: ReactNode;
+    masonry?: ReactNode;
+}
+interface WorkbenchGallerySettingsPanelClassNames {
+    root?: string;
+    section?: string;
+    sectionHeader?: string;
+    columnList?: string;
+    columnItem?: string;
+    control?: string;
+}
+interface WorkbenchGallerySettingsPanelProps {
+    columns?: WorkbenchGalleryColumn[];
+    galleryFieldOptions?: WorkbenchGalleryColumn[];
+    value?: WorkbenchGallerySettingsValue;
+    onValueChange?: (nextValue: WorkbenchGallerySettingsValue, patch: Partial<WorkbenchGallerySettingsValue>) => void;
+    labels?: WorkbenchGallerySettingsLabels;
+    densityOptions?: Array<WorkbenchGallerySettingsOption>;
+    gridColumnOptions?: Array<WorkbenchGallerySettingsOption<'auto' | number>>;
+    bentoColumnOptions?: Array<WorkbenchGallerySettingsOption<number>>;
+    detailVisibilityOptions?: Array<WorkbenchGallerySettingsOption>;
+    layoutOptions?: Array<WorkbenchGallerySettingsOption>;
+    getColumnLabel?: (column: WorkbenchGalleryColumn) => ReactNode;
+    getColumnDescription?: (column: WorkbenchGalleryColumn) => ReactNode;
+    showColumnVisibility?: boolean;
+    showGalleryControls?: boolean;
+    showLayoutControl?: boolean;
+    showGridColumns?: boolean;
+    showDetailColumns?: boolean;
+    allowEmptyVisibleColumns?: boolean;
+    className?: string;
+    classNames?: WorkbenchGallerySettingsPanelClassNames;
+}
+interface WorkbenchGallerySettingsButtonClassNames {
+    root?: string;
+    trigger?: string;
+    popover?: string;
+    header?: string;
+    panel?: string;
+}
+interface WorkbenchGallerySettingsButtonProps extends WorkbenchGallerySettingsPanelProps {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    triggerIcon?: ReactNode;
+    triggerLabel?: ReactNode;
+    triggerTitle?: string;
+    align?: 'end' | 'start';
+    popoverWidth?: number;
+    panelHeader?: ReactNode;
+    panelBefore?: ReactNode;
+    panelAfter?: ReactNode;
+    panelClassName?: string;
+    buttonClassName?: string;
+    popoverClassName?: string;
+    buttonClassNames?: WorkbenchGallerySettingsButtonClassNames;
+}
+declare function WorkbenchGallerySettingsPanel({ columns, galleryFieldOptions, value, onValueChange, labels, densityOptions, gridColumnOptions, bentoColumnOptions, detailVisibilityOptions, layoutOptions, getColumnLabel, getColumnDescription, showColumnVisibility, showGalleryControls, showLayoutControl, showGridColumns, showDetailColumns, allowEmptyVisibleColumns, className, classNames, }: WorkbenchGallerySettingsPanelProps): react_jsx_runtime.JSX.Element;
+declare function WorkbenchGallerySettingsButton({ open, defaultOpen, onOpenChange, triggerIcon, triggerLabel, triggerTitle, align, popoverWidth, panelHeader, panelBefore, panelAfter, panelClassName, buttonClassName, popoverClassName, buttonClassNames, labels, className, classNames, ...panelProps }: WorkbenchGallerySettingsButtonProps): react_jsx_runtime.JSX.Element;
+interface WorkbenchContentToolbarViewModeOption {
+    value: string;
+    label: ReactNode;
+    icon?: ReactNode;
+    disabled?: boolean;
+}
+interface WorkbenchContentToolbarClassNames {
+    root?: string;
+    start?: string;
+    end?: string;
+    viewModeRoot?: string;
+    viewModeTrigger?: string;
+    viewModeMenu?: string;
+    viewModeItem?: string;
+    settings?: string;
+}
+interface WorkbenchContentToolbarProps extends Omit<ComponentPropsWithoutRef<'div'>, 'children' | 'className'> {
+    as?: ElementType;
+    children?: ReactNode;
+    end?: ReactNode;
+    viewMode?: string;
+    viewModeOptions?: WorkbenchContentToolbarViewModeOption[];
+    onViewModeChange?: (nextValue: string, option: WorkbenchContentToolbarViewModeOption) => void;
+    gallerySettings?: false | WorkbenchGallerySettingsButtonProps;
+    gallerySettingsPlacement?: 'end' | 'start';
+    className?: string;
+    startClassName?: string;
+    endClassName?: string;
+    classNames?: WorkbenchContentToolbarClassNames;
+    [key: string]: any;
+}
+declare const WorkbenchContentToolbar: React.ForwardRefExoticComponent<Omit<WorkbenchContentToolbarProps, "ref"> & React.RefAttributes<HTMLElement>>;
+interface WorkbenchDetailSidebarClassNames {
+    root?: string;
+    header?: string;
+    body?: string;
+    footer?: string;
+    resizeHandle?: string;
+    autoBody?: string;
+    section?: string;
+    sectionHeader?: string;
+    sectionTitle?: string;
+    sectionDescription?: string;
+    descriptionList?: string;
+    descriptionListItem?: string;
+    descriptionListTerm?: string;
+    descriptionListValue?: string;
+    fieldLabel?: string;
+    fieldLabelIcon?: string;
+    fieldValue?: string;
+    mediaValue?: string;
+    mediaImage?: string;
+    mediaCaption?: string;
+    emptyState?: string;
+}
+interface WorkbenchDetailSidebarBodyProps extends Omit<ComponentPropsWithoutRef<'div'>, 'children' | 'className'> {
+    className?: string;
+}
+interface WorkbenchDetailSidebarField<Row = any> {
+    key: string;
+    label?: ReactNode;
+    labelIcon?: ElementType | ReactNode;
+    icon?: ElementType | ReactNode;
+    renderType?: string;
+    value?: ((record: null | Row | undefined, field: WorkbenchDetailSidebarField<Row>) => ReactNode) | ReactNode;
+    description?: ReactNode;
+    hidden?: ((field: WorkbenchDetailSidebarField<Row>, record: null | Row | undefined) => boolean) | boolean;
+    emptyValue?: ReactNode;
+    [key: string]: any;
+}
+interface WorkbenchDetailSidebarSection<Row = any> {
+    id?: string;
+    title?: ReactNode;
+    description?: ReactNode;
+    fields?: WorkbenchDetailSidebarField<Row>[];
+    columns?: 1 | 2 | 3;
+    hidden?: ((section: WorkbenchDetailSidebarSection<Row>, record: null | Row | undefined) => boolean) | boolean;
+    emptyState?: ReactNode;
+    [key: string]: any;
+}
+interface WorkbenchDetailSidebarRenderContext<Row = any> {
+    field: WorkbenchDetailSidebarField<Row>;
+    fieldIndex: number;
+    section: WorkbenchDetailSidebarSection<Row>;
+    sectionIndex: number;
+    record: null | Row | undefined;
+}
+interface WorkbenchDetailSidebarProps<Row = any> extends Omit<ComponentPropsWithoutRef<'aside'>, 'children' | 'className' | 'style'> {
+    as?: ElementType;
+    bodyAs?: ElementType;
+    open?: boolean;
+    width?: number | string;
+    header?: ReactNode;
+    footer?: ReactNode;
+    resizeHandle?: ReactNode;
+    children?: ReactNode;
+    record?: null | Row;
+    fields?: WorkbenchDetailSidebarField<Row>[];
+    sections?: WorkbenchDetailSidebarSection<Row>[];
+    fieldColumns?: 1 | 2 | 3;
+    emptyValue?: ReactNode;
+    emptyState?: ReactNode;
+    getFieldValue?: (field: WorkbenchDetailSidebarField<Row>, record: null | Row | undefined, context: WorkbenchDetailSidebarRenderContext<Row>) => unknown;
+    renderFieldValue?: (field: WorkbenchDetailSidebarField<Row>, record: null | Row | undefined, context: WorkbenchDetailSidebarRenderContext<Row>) => ReactNode;
+    formatFieldValue?: (value: unknown, context: WorkbenchDetailSidebarRenderContext<Row>) => ReactNode;
+    formatFieldLabel?: (label: ReactNode, context: Omit<WorkbenchDetailSidebarRenderContext<Row>, 'fieldIndex'> & {
+        field: WorkbenchDetailSidebarField<Row>;
+        fieldIndex?: number;
+    }) => ReactNode;
+    className?: string;
+    headerClassName?: string;
+    bodyClassName?: string;
+    footerClassName?: string;
+    resizeHandleClassName?: string;
+    bodyProps?: WorkbenchDetailSidebarBodyProps;
+    classNames?: WorkbenchDetailSidebarClassNames;
+    style?: CSSProperties;
+    [key: string]: any;
+}
+declare const WorkbenchDetailSidebar: React.ForwardRefExoticComponent<Omit<WorkbenchDetailSidebarProps<any>, "ref"> & React.RefAttributes<HTMLElement>>;
+interface WorkbenchTableViewColumn {
+    key: string;
+    label?: ReactNode;
+    helperText?: ReactNode;
+    renderType?: string;
+    type?: string;
+    description?: ReactNode;
+    meta?: ReactNode;
+    actions?: ReactNode;
+    trailing?: ReactNode;
+    wrap?: boolean;
+    align?: 'center' | 'left' | 'right';
+    width?: number | string;
+    minWidth?: number | string;
+    maxWidth?: number | string;
+    sortable?: boolean;
+    sortDirection?: BaseTableSortDirection;
+    sortLabel?: string;
+    draggable?: boolean;
+    dragLabel?: string;
+    resizable?: boolean;
+    resizeLabel?: string;
+    compactHeaderClassName?: string;
+    compactCellClassName?: string;
+    headerClassName?: string;
+    cellClassName?: string;
+    [key: string]: any;
+}
+interface WorkbenchTableViewClassNames {
+    root?: string;
+    scrollArea?: string;
+    table?: string;
+    header?: string;
+    headerRow?: string;
+    headerCell?: string;
+    body?: string;
+    row?: string;
+    cell?: string;
+    footer?: string;
+    helper?: string;
+}
+interface WorkbenchTableViewRenderContext<Row = any> {
+    row: Row;
+    rowIndex: number;
+    column: WorkbenchTableViewColumn;
+    columnIndex: number;
+    compact: boolean;
+    surface: 'list' | string;
+}
+interface WorkbenchTableViewHeaderContext<Row = any> {
+    column: WorkbenchTableViewColumn;
+    columnIndex: number;
+    columns: WorkbenchTableViewColumn[];
+    rows: Row[];
+    columnType?: string;
+}
+interface WorkbenchTableViewProps<Row = any> {
+    rows?: Row[];
+    columns?: WorkbenchTableViewColumn[];
+    onRowClick?: (row: Row, rowIndex: number) => void;
+    selectedRowKey?: string;
+    selectedLinkKey?: string;
+    activePrimaryColumn?: null | WorkbenchTableViewColumn;
+    activeTablePrimaryColumn?: null | WorkbenchTableViewColumn;
+    renderedRowCount?: number;
+    totalRowCount?: number;
+    tableMinWidth?: number;
+    minWidth?: number;
+    bodyMaxHeight?: number | string;
+    stickyFirstColumn?: boolean;
+    appearance?: BaseAppearance;
+    columnOrder?: string[];
+    columnSizes?: BaseTableColumnSizes;
+    columnDragEnabled?: boolean;
+    columnResizeEnabled?: boolean;
+    className?: string;
+    tableClassName?: string;
+    rowClassName?: ((row: Row, rowIndex: number) => string | undefined) | string;
+    classNames?: WorkbenchTableViewClassNames;
+    style?: CSSProperties;
+    renderCell?: (column: WorkbenchTableViewColumn, row: Row, context: WorkbenchTableViewRenderContext<Row>) => ReactNode;
+    renderFieldValue?: (column: WorkbenchTableViewColumn, row: Row, context: WorkbenchTableViewRenderContext<Row>) => ReactNode;
+    renderColumnHeader?: (column: WorkbenchTableViewColumn, context: WorkbenchTableViewHeaderContext<Row>) => ReactNode;
+    onColumnOrderChange?: (nextOrder: string[], detail: BaseTableColumnOrderChangeDetail) => void;
+    onColumnSizeChange?: (columnId: string, width: number, detail: BaseTableColumnSizeChangeDetail) => void;
+    onSort?: (columnKey: string, column: WorkbenchTableViewColumn) => void;
+    formatLabel?: (value: ReactNode, context?: {
+        column?: WorkbenchTableViewColumn;
+    }) => ReactNode;
+    getColumnDataType?: (columnKey: string, rows: Row[], column?: WorkbenchTableViewColumn) => string | undefined;
+    getColumnIcon?: (columnType?: string, column?: WorkbenchTableViewColumn) => ComponentType<{
+        className?: string;
+    }> | null | ReactNode | undefined;
+    getColumnTypeIcon?: (columnType?: string, column?: WorkbenchTableViewColumn) => ComponentType<{
+        className?: string;
+    }> | null | ReactNode | undefined;
+    getRowKey?: (row: Row, rowIndex: number) => number | string;
+    getRowSelectionKey?: (row: Row, rowIndex: number) => number | string | undefined;
+    isActionColumn?: (column: WorkbenchTableViewColumn) => boolean;
+    isActionField?: (column: WorkbenchTableViewColumn) => boolean;
+    isRowDisabled?: (row: Row, rowIndex: number) => boolean;
+    isWorkbenchPlaceholderRow?: (row: Row, rowIndex?: number) => boolean;
+    emptyState?: ReactNode;
+    hiddenRowsMessage?: ((hiddenRowCount: number, renderedRowCount: number, totalRowCount: number) => ReactNode) | ReactNode;
+}
+declare function WorkbenchTableView<Row = any>({ rows, columns, onRowClick, selectedRowKey, selectedLinkKey, activePrimaryColumn, activeTablePrimaryColumn, renderedRowCount, totalRowCount, tableMinWidth, minWidth, bodyMaxHeight, stickyFirstColumn, appearance, columnOrder, columnSizes, columnDragEnabled, columnResizeEnabled, className, tableClassName, rowClassName, classNames, style, renderCell, renderFieldValue, renderColumnHeader, onColumnOrderChange, onColumnSizeChange, onSort, formatLabel, getColumnDataType, getColumnIcon, getColumnTypeIcon, getRowKey, getRowSelectionKey, isActionColumn, isActionField, isRowDisabled, isWorkbenchPlaceholderRow, emptyState, hiddenRowsMessage, }: WorkbenchTableViewProps<Row>): react_jsx_runtime.JSX.Element;
+interface InteractiveTableColumn {
+    key: string;
+    label?: ReactNode;
+    description?: ReactNode;
+    align?: 'center' | 'left' | 'right';
+    width?: number | string;
+    minWidth?: number;
+    maxWidth?: number;
+    sortable?: boolean;
+    sortDirection?: BaseTableSortDirection;
+    sortLabel?: string;
+    draggable?: boolean;
+    resizable?: boolean;
+    className?: string;
+    headerClassName?: string;
+    cellClassName?: string;
+    wrap?: boolean;
+    [key: string]: any;
+}
+interface InteractiveTableClassNames {
+    root?: string;
+    header?: string;
+    headerLeading?: string;
+    headerTitle?: string;
+    headerDescription?: string;
+    headerActions?: string;
+    scrollArea?: string;
+    table?: string;
+    tableHeader?: string;
+    headerRow?: string;
+    headerCell?: string;
+    body?: string;
+    row?: string;
+    pinnedTopRow?: string;
+    cell?: string;
+    empty?: string;
+}
+interface InteractiveTableRenderContext<Row = any> {
+    row: Row;
+    rowIndex: number;
+    column: InteractiveTableColumn;
+    columnIndex: number;
+    isPinnedTopRow: boolean;
+}
+interface InteractiveTableHeaderContext<Row = any> {
+    column: InteractiveTableColumn;
+    columnIndex: number;
+    columns: InteractiveTableColumn[];
+    rows: Row[];
+}
+interface InteractiveTableRowState {
+    disabled?: boolean;
+    pending?: boolean;
+    saving?: boolean;
+    selected?: boolean;
+}
+interface InteractiveTableHeaderProps {
+    title?: ReactNode;
+    description?: ReactNode;
+    actions?: ReactNode;
+    resetColumnSizesLabel?: ReactNode;
+}
+interface InteractiveTableColumnMenuLabels {
+    columnActions?: ReactNode;
+    freezeColumn?: ReactNode;
+    freezeEndColumn?: ReactNode;
+    unfreezeColumn?: ReactNode;
+    unfreezeEndColumn?: ReactNode;
+    unfreezeAllColumns?: ReactNode;
+    resetColumnWidth?: ReactNode;
+    frozenColumnTitle?: string;
+}
+interface InteractiveTableProps<Row = any, PinnedTopRow = Row> {
+    rows?: Row[];
+    columns?: InteractiveTableColumn[];
+    pinnedTopRows?: PinnedTopRow[];
+    getRowKey?: (row: Row, rowIndex: number) => number | string;
+    getPinnedTopRowKey?: (row: PinnedTopRow, rowIndex: number) => number | string;
+    renderCell?: (column: InteractiveTableColumn, row: Row, context: InteractiveTableRenderContext<Row>) => ReactNode;
+    renderPinnedTopCell?: (column: InteractiveTableColumn, row: PinnedTopRow, context: InteractiveTableRenderContext<PinnedTopRow>) => ReactNode;
+    renderColumnHeader?: (column: InteractiveTableColumn, context: InteractiveTableHeaderContext<Row>) => ReactNode;
+    onRowClick?: (row: Row, rowIndex: number) => void;
+    getRowState?: (row: Row, rowIndex: number) => InteractiveTableRowState | undefined;
+    rowClassName?: ((row: Row, rowIndex: number) => string | undefined) | string;
+    pinnedTopRowClassName?: ((row: PinnedTopRow, rowIndex: number) => string | undefined) | string;
+    emptyState?: ReactNode;
+    header?: InteractiveTableHeaderProps;
+    showResetColumnSizes?: boolean;
+    columnMenuLabels?: InteractiveTableColumnMenuLabels;
+    columnStorageKey?: string;
+    columnOrder?: string[];
+    columnSizes?: BaseTableColumnSizes;
+    defaultColumnSizes?: BaseTableColumnSizes;
+    columnDragEnabled?: boolean;
+    columnResizeEnabled?: boolean;
+    frozenColumnCount?: number;
+    frozenEndColumnCount?: number;
+    tableMinWidth?: number;
+    bodyMaxHeight?: number | string;
+    appearance?: BaseAppearance;
+    className?: string;
+    tableClassName?: string;
+    classNames?: InteractiveTableClassNames;
+    style?: CSSProperties;
+    onColumnOrderChange?: (nextOrder: string[], detail: BaseTableColumnOrderChangeDetail) => void;
+    onColumnSizeChange?: (columnId: string, width: number, detail: BaseTableColumnSizeChangeDetail) => void;
+    onResetColumnSizes?: (nextSizes: BaseTableColumnSizes) => void;
+    onFrozenColumnCountChange?: (nextCount: number) => void;
+    onFrozenEndColumnCountChange?: (nextCount: number) => void;
+    onSort?: (columnKey: string, column: InteractiveTableColumn) => void;
+}
+interface InteractiveTableEditableTextCellProps {
+    value?: null | string;
+    placeholder?: string;
+    disabled?: boolean;
+    multiline?: boolean;
+    commitOnBlur?: boolean;
+    className?: string;
+    inputClassName?: string;
+    onCommit?: (value: string) => Promise<void> | void;
+}
+interface InteractiveTableReadonlyCellProps {
+    children?: ReactNode;
+    mono?: boolean;
+    className?: string;
+}
+interface InteractiveTableSelectOption<T extends string = string> {
+    value: T;
+    label: string;
+}
+interface InteractiveTableSelectCellProps<T extends string = string> {
+    value: T;
+    options: Array<InteractiveTableSelectOption<T>>;
+    disabled?: boolean;
+    ariaLabel: string;
+    children: ReactNode;
+    className?: string;
+    onChange?: (nextValue: T) => void;
+}
+declare function InteractiveTable<Row = any, PinnedTopRow = Row>({ rows, columns, pinnedTopRows, getRowKey, getPinnedTopRowKey, renderCell, renderPinnedTopCell, renderColumnHeader, onRowClick, getRowState, rowClassName, pinnedTopRowClassName, emptyState, columnMenuLabels, columnStorageKey, columnOrder, columnSizes, defaultColumnSizes, columnDragEnabled, columnResizeEnabled, frozenColumnCount, frozenEndColumnCount, tableMinWidth, bodyMaxHeight, appearance, className, tableClassName, classNames, style, onColumnOrderChange, onColumnSizeChange, onResetColumnSizes, onFrozenColumnCountChange, onFrozenEndColumnCountChange, onSort, }: InteractiveTableProps<Row, PinnedTopRow>): react_jsx_runtime.JSX.Element;
+declare function InteractiveTableEditableTextCell({ value, placeholder, disabled, multiline, commitOnBlur, className, inputClassName, onCommit, }: InteractiveTableEditableTextCellProps): react_jsx_runtime.JSX.Element;
+declare function InteractiveTableReadonlyCell({ children, mono, className, }: InteractiveTableReadonlyCellProps): react_jsx_runtime.JSX.Element;
+declare function InteractiveTableSelectCell<T extends string = string>({ value, options, disabled, ariaLabel, children, className, onChange, }: InteractiveTableSelectCellProps<T>): react_jsx_runtime.JSX.Element;
+interface WorkbenchGalleryRecordVisual {
+    Icon?: ComponentType<{
+        className?: string;
+    }> | ReactNode;
+    icon?: ComponentType<{
+        className?: string;
+    }> | ReactNode;
+    chipClassName?: string;
+    iconClassName?: string;
+    label?: ReactNode;
+    title?: ReactNode;
+    [key: string]: any;
+}
+interface WorkbenchGalleryLabels {
+    fieldCount?: (count: number) => ReactNode;
+    coverOnlyHint?: ReactNode;
+}
+interface WorkbenchGalleryCardProps<Row = any> {
+    row: Row;
+    columns: WorkbenchGalleryColumn[];
+    onClick?: () => void;
+    isSelected?: boolean;
+    isMasonry?: boolean;
+    galleryFieldKey?: string;
+    galleryDensity?: 'comfortable' | 'compact' | 'detailed' | string;
+    galleryBentoColumns?: 1 | 2 | 3 | number;
+    galleryDetailVisibility?: 'all' | 'limit' | string;
+    galleryDetailLimit?: number | string;
+    shouldEnhanceMultimodal?: boolean;
+    getFieldValue?: (column: WorkbenchGalleryColumn, row: Row) => unknown;
+    isMediaColumn?: (column: WorkbenchGalleryColumn, row: Row) => boolean;
+    isTitleCandidate?: (column: WorkbenchGalleryColumn, row: Row) => boolean;
+    isSummaryCandidate?: (column: WorkbenchGalleryColumn, row: Row) => boolean;
+    getDisplayText?: (value: unknown) => ReactNode;
+    renderFieldValue?: (column: WorkbenchGalleryColumn, row: Row, context: {
+        compact?: boolean;
+        surface?: string;
+    }) => ReactNode;
+    getImagePreviewSrc?: (value: unknown, rowId?: number | string, columnLabel?: ReactNode) => string;
+    isImageField?: (column: WorkbenchGalleryColumn, value: unknown) => boolean;
+    isAudioField?: (column: WorkbenchGalleryColumn, value: unknown) => boolean;
+    AudioPlayerComponent?: ComponentType<{
+        filename: string;
+    }>;
+    cardVariant?: 'chromatic-bento' | 'default' | 'image-only' | 'preview-only' | string;
+    renderPreview?: (context: WorkbenchGalleryCardRenderContext<Row>) => ReactNode;
+    renderMeta?: (context: WorkbenchGalleryCardMetaContext<Row>) => ReactNode;
+    renderLeadingVisual?: (context: WorkbenchGalleryCardMetaContext<Row> & {
+        iconVisual?: null | WorkbenchGalleryRecordVisual;
+    }) => ReactNode;
+    resolveRecordVisual?: (value: unknown, row: Row, iconColumn?: WorkbenchGalleryColumn) => null | undefined | WorkbenchGalleryRecordVisual;
+    hiddenDetailFieldKeys?: string[];
+    labels?: WorkbenchGalleryLabels;
+    formatLabel?: (value: ReactNode, context?: {
+        column?: WorkbenchGalleryColumn;
+    }) => ReactNode;
+    className?: string;
+}
+interface WorkbenchGalleryCardRenderContext<Row = any> {
+    row: Row;
+    mediaColumn?: null | WorkbenchGalleryColumn;
+    mediaValue: unknown;
+    isImageMedia: boolean;
+    isAudioMedia: boolean;
+    iconVisual?: null | WorkbenchGalleryRecordVisual;
+    IconComponent?: ComponentType<{
+        className?: string;
+    }> | null;
+    previewClassName: string;
+}
+interface WorkbenchGalleryCardMetaContext<Row = any> {
+    row: Row;
+    contentColumns: WorkbenchGalleryColumn[];
+    detailColumns: WorkbenchGalleryColumn[];
+    titleColumn?: null | WorkbenchGalleryColumn;
+    summaryColumn?: null | WorkbenchGalleryColumn;
+    getDisplayText: (value: unknown) => ReactNode;
+    getFieldValue: (column: WorkbenchGalleryColumn, row: Row) => unknown;
+}
+declare function WorkbenchGalleryCard<Row = any>({ row, columns, onClick, isSelected, isMasonry, galleryFieldKey, galleryDensity, galleryBentoColumns, galleryDetailVisibility, galleryDetailLimit, shouldEnhanceMultimodal, getFieldValue, isMediaColumn, isTitleCandidate, isSummaryCandidate, getDisplayText, renderFieldValue, getImagePreviewSrc, isImageField, isAudioField, AudioPlayerComponent, cardVariant, renderPreview, renderMeta, renderLeadingVisual, resolveRecordVisual, hiddenDetailFieldKeys, labels, formatLabel, className, }: WorkbenchGalleryCardProps<Row>): react_jsx_runtime.JSX.Element;
+interface WorkbenchMasonryItemSize {
+    width?: number | string;
+    height?: number | string;
+    columnSpan?: number;
+    rowSpan?: number;
+}
+interface WorkbenchMasonryLayoutContext {
+    columnCount: number;
+    columnSpan?: number;
+    columnWidth: number;
+    containerWidth: number;
+    gap: number;
+    itemWidth?: number;
+    placementStrategy: 'dense' | 'shelf' | 'shortest';
+    rowSpan?: number;
+    rowHeight: number;
+    size?: WorkbenchMasonryItemSize;
+}
+interface WorkbenchMasonryLayoutProps<Item = any> {
+    items?: readonly Item[];
+    renderItem: (item: Item, context: WorkbenchMasonryLayoutContext) => ReactNode;
+    getItemKey?: (item: Item, index: number) => number | string;
+    getItemSize?: (item: Item, context: WorkbenchMasonryLayoutContext) => undefined | WorkbenchMasonryItemSize;
+    columnWidth?: number | string;
+    columnCount?: number;
+    gap?: number;
+    rowHeight?: number;
+    placementStrategy?: 'dense' | 'shelf' | 'shortest';
+    containerProps?: Omit<HTMLAttributes<HTMLDivElement>, 'children'>;
+    getItemProps?: (item: Item, context: WorkbenchMasonryLayoutContext) => Omit<HTMLAttributes<HTMLDivElement>, 'children'>;
+    className?: string;
+}
+declare function WorkbenchMasonryLayout<Item = any>({ items, renderItem, getItemKey, getItemSize, columnWidth, columnCount: requestedColumnCount, gap, rowHeight, placementStrategy, containerProps, getItemProps, className, }: WorkbenchMasonryLayoutProps<Item>): react_jsx_runtime.JSX.Element;
+interface WorkbenchGalleryViewProps<Row = any> extends Omit<WorkbenchGalleryCardProps<Row>, 'columns' | 'isMasonry' | 'isSelected' | 'onClick' | 'row'> {
+    rows?: Row[];
+    columns?: WorkbenchGalleryColumn[];
+    onRowClick?: (row: Row, rowIndex: number) => void;
+    selectedLinkKey?: string;
+    selectedRowKey?: string;
+    className?: string;
+    isMasonry?: boolean;
+    galleryLayoutMode?: 'auto' | 'rail' | string;
+    galleryRailCardWidth?: number;
+    galleryGridColumns?: 'auto' | number | string;
+    galleryGridCardWidth?: number | string;
+    galleryMasonryColumnWidth?: number | string;
+    masonryPlacementStrategy?: 'dense' | 'shelf';
+    getMasonryItemSize?: (row: Row, context: {
+        defaultSize: WorkbenchMasonryItemSize;
+        columnCount: number;
+        columnWidth: number;
+        containerWidth: number;
+        gap: number;
+        placementStrategy: 'dense' | 'shelf';
+        rowHeight: number;
+    }) => undefined | WorkbenchMasonryItemSize;
+}
+declare function WorkbenchGalleryView<Row = any>({ rows, columns, onRowClick, selectedLinkKey, selectedRowKey, className, isMasonry, galleryLayoutMode, galleryRailCardWidth, galleryGridColumns, galleryGridCardWidth, galleryMasonryColumnWidth, masonryPlacementStrategy, galleryFieldKey, galleryDensity, galleryBentoColumns, galleryDetailVisibility, galleryDetailLimit, shouldEnhanceMultimodal, getFieldValue, isMediaColumn, isTitleCandidate, isSummaryCandidate, getDisplayText, renderFieldValue, getImagePreviewSrc, isImageField, isAudioField, AudioPlayerComponent, cardVariant, renderPreview, renderMeta, renderLeadingVisual, resolveRecordVisual, hiddenDetailFieldKeys, labels, formatLabel, getMasonryItemSize, }: WorkbenchGalleryViewProps<Row>): react_jsx_runtime.JSX.Element;
+type WorkbenchCollectionLoadingVariant = 'skeleton' | 'spinner';
+interface WorkbenchCollectionSkeletonConfig {
+    count?: number;
+    loadMoreCount?: number;
+    aspectRatios?: readonly number[];
+    animated?: boolean;
+}
+type WorkbenchCollectionKey = number | string;
+type WorkbenchCollectionLayoutMode = 'dense' | 'grid' | 'masonry' | 'rail';
+type WorkbenchCollectionSelectionMode = 'multiple' | 'none' | 'single';
+type WorkbenchCollectionSelectionBehavior = 'range' | 'replace' | 'toggle';
+type WorkbenchCollectionActivationEvent = KeyboardEvent<HTMLElement> | MouseEvent<HTMLElement>;
+type WorkbenchCollectionItemStatus = 'failed' | 'idle' | 'loading' | 'pending' | string;
+type WorkbenchCollectionItemSlotName = 'actions' | 'badges' | 'body' | 'detail' | 'detailTrigger' | 'fallback' | 'footer' | 'header' | 'media' | 'meta' | 'selectionControl' | 'statusOverlay' | 'title' | 'top';
+type WorkbenchCollectionResponsive<Value> = {
+    mobile?: Value;
+    tablet?: Value;
+    desktop?: Value;
+} | Value;
+type WorkbenchCollectionItemSize = WorkbenchMasonryItemSize;
+interface WorkbenchCollectionLayoutContext {
+    mode: WorkbenchCollectionLayoutMode;
+    columnCount: number;
+    columnSpan?: number;
+    columnWidth: number;
+    containerWidth: number;
+    gap: number;
+    itemWidth?: number;
+    placementStrategy: 'dense' | 'shelf' | 'shortest';
+    rowSpan?: number;
+    rowHeight: number;
+    size?: WorkbenchCollectionItemSize;
+}
+interface WorkbenchCollectionLayoutSnapshot {
+    mode: WorkbenchCollectionLayoutMode;
+    columnCount: number;
+    columnWidth: number;
+    containerWidth: number;
+    gap: number;
+    itemCount: number;
+}
+interface WorkbenchCollectionItemContext<Item> {
+    item: Item;
+    index: number;
+    key: WorkbenchCollectionKey;
+    status: WorkbenchCollectionItemStatus;
+    disabled: boolean;
+    selected: boolean;
+    selectionMode: WorkbenchCollectionSelectionMode;
+    layout: WorkbenchCollectionLayoutContext;
+    select: (behavior?: WorkbenchCollectionSelectionBehavior) => void;
+    preview: () => void;
+    detail: () => void;
+    renderSlot: (name: WorkbenchCollectionItemSlotName) => ReactNode;
+    notifyMediaLoad: () => void;
+    notifyMediaError: (error?: unknown) => void;
+}
+interface WorkbenchCollectionStateConfig {
+    loading?: boolean;
+    loadingMore?: boolean;
+    error?: unknown;
+    empty?: boolean;
+    hasMore?: boolean;
+    permission?: boolean;
+    offline?: boolean;
+}
+interface WorkbenchCollectionSelectionConfig<Item> {
+    mode?: WorkbenchCollectionSelectionMode;
+    selectedKeys?: Iterable<WorkbenchCollectionKey>;
+    defaultSelectedKeys?: Iterable<WorkbenchCollectionKey>;
+    behavior?: WorkbenchCollectionSelectionBehavior;
+    isItemDisabled?: (item: Item, index: number) => boolean;
+}
+interface WorkbenchCollectionGroupingConfig<Item> {
+    getGroupKey: (item: Item, index: number) => WorkbenchCollectionKey;
+    getGroupLabel?: (groupKey: WorkbenchCollectionKey, firstItem: Item) => ReactNode;
+}
+interface WorkbenchCollectionLoadingConfig {
+    rootMargin?: string;
+    threshold?: number;
+    /** Request another page while the configured scroll viewport is not filled. */
+    autoFill?: boolean;
+    /** Collection loading defaults to a layout-aware skeleton. */
+    variant?: WorkbenchCollectionLoadingVariant;
+    skeleton?: WorkbenchCollectionSkeletonConfig;
+}
+type WorkbenchCollectionHoverEffect = 'highlight' | 'lift-shadow' | 'lift' | 'none' | 'scale' | 'shadow';
+type WorkbenchCollectionTitleVisibility = 'always' | 'hover' | 'never';
+type WorkbenchCollectionTitlePlacement = 'above' | 'below' | 'overlay-bottom' | 'overlay-center' | 'overlay-top';
+type WorkbenchCollectionActionsVisibility = 'always' | 'hover' | 'never';
+type WorkbenchCollectionActionsPlacement = 'above' | 'below' | 'overlay-bottom' | 'overlay-top';
+type WorkbenchCollectionItemAlign = 'center' | 'end' | 'start';
+interface WorkbenchCollectionItemTitleConfig<Item> {
+    getContent?: (item: Item, context: WorkbenchCollectionItemContext<Item>) => ReactNode;
+    visibility?: WorkbenchCollectionTitleVisibility;
+    placement?: WorkbenchCollectionTitlePlacement;
+    align?: WorkbenchCollectionItemAlign;
+    maxLines?: number;
+    surface?: 'none' | 'scrim' | 'surface';
+}
+interface WorkbenchCollectionItemActionsConfig {
+    visibility?: WorkbenchCollectionActionsVisibility;
+    placement?: WorkbenchCollectionActionsPlacement;
+    align?: WorkbenchCollectionItemAlign;
+    wrap?: boolean;
+}
+interface WorkbenchCollectionItemConfig<Item> {
+    title?: WorkbenchCollectionItemTitleConfig<Item>;
+    actions?: WorkbenchCollectionItemActionsConfig;
+}
+interface WorkbenchCollectionAppearanceConfig {
+    density?: 'comfortable' | 'compact' | 'detailed' | string;
+    radius?: 'lg' | 'md' | 'none' | 'sm' | 'xl' | string;
+    mediaFit?: 'contain' | 'cover' | 'natural';
+    hover?: WorkbenchCollectionHoverEffect;
+    selection?: 'none' | 'outline' | 'ring';
+}
+interface WorkbenchCollectionLabels {
+    collection: string;
+    loading: string;
+    empty: string;
+    loadError: string;
+    refreshError: string;
+    retry: string;
+    loadingMore: string;
+    permission: string;
+    offline: string;
+    requestAccess: string;
+}
+interface WorkbenchCollectionVirtualizationRenderOptions<Item> {
+    items: readonly Item[];
+    keys: readonly WorkbenchCollectionKey[];
+    layout: WorkbenchCollectionLayoutConfig<Item>;
+    scrollOwner: HTMLElement | null;
+    renderItem: (item: Item, index: number, layout: WorkbenchCollectionLayoutContext) => ReactNode;
+}
+interface WorkbenchCollectionVirtualizationAdapter<Item> {
+    supports?: (mode: WorkbenchCollectionLayoutMode) => boolean;
+    render: (options: WorkbenchCollectionVirtualizationRenderOptions<Item>) => ReactNode;
+}
+interface WorkbenchCollectionVirtualizationConfig<Item> {
+    enabled?: boolean;
+    adapter?: WorkbenchCollectionVirtualizationAdapter<Item>;
+    fallback?: 'error' | 'render-all';
+}
+interface WorkbenchCollectionLayoutConfig<Item> {
+    mode: WorkbenchCollectionLayoutMode;
+    columns?: 'auto' | WorkbenchCollectionResponsive<number>;
+    /** Control whether an underfilled automatic grid stretches its items or preserves full-grid card widths. */
+    underfilledBehavior?: 'preserve-columns' | 'stretch-items';
+    maxColumns?: WorkbenchCollectionResponsive<number>;
+    minCardWidth?: number | string;
+    idealCardWidth?: number | string;
+    maxCardWidth?: number | string;
+    cardWidth?: number | string;
+    columnWidth?: number | string;
+    gap?: number;
+    rowHeight?: number;
+    placementStrategy?: 'dense' | 'shelf' | 'shortest';
+    padding?: number | string;
+    fillHeight?: boolean;
+    maxHeight?: number | string;
+    scrollOwner?: 'parent' | 'self' | HTMLElement | null;
+    getItemSize?: (item: Item, context: WorkbenchCollectionLayoutContext) => undefined | WorkbenchCollectionItemSize;
+    getItemAspectRatio?: (item: Item, index: number) => number | undefined;
+}
+interface WorkbenchCollectionConfig<Item> {
+    getItemKey?: (item: Item, index: number) => WorkbenchCollectionKey;
+    getItemStatus?: (item: Item, index: number) => WorkbenchCollectionItemStatus;
+    layout: WorkbenchCollectionLayoutConfig<Item>;
+    state?: WorkbenchCollectionStateConfig;
+    selection?: WorkbenchCollectionSelectionConfig<Item>;
+    grouping?: WorkbenchCollectionGroupingConfig<Item>;
+    loading?: WorkbenchCollectionLoadingConfig;
+    virtualization?: WorkbenchCollectionVirtualizationConfig<Item>;
+    item?: WorkbenchCollectionItemConfig<Item>;
+    appearance?: WorkbenchCollectionAppearanceConfig;
+    labels?: Partial<WorkbenchCollectionLabels>;
+    scrollRestorationKey?: string;
+}
+interface WorkbenchCollectionSlotContext<Item> {
+    items: readonly Item[];
+    error?: unknown;
+    loading: boolean;
+    loadingMore: boolean;
+    selectedKeys: ReadonlySet<WorkbenchCollectionKey>;
+    retry: () => void;
+}
+interface WorkbenchCollectionGroupContext<Item> {
+    key: WorkbenchCollectionKey;
+    label?: ReactNode;
+    items: readonly Item[];
+    groupIndex: number;
+}
+type WorkbenchCollectionItemSlots<Item> = Partial<Record<WorkbenchCollectionItemSlotName, (item: Item, context: WorkbenchCollectionItemContext<Item>) => ReactNode>>;
+interface WorkbenchCollectionSlots<Item> {
+    header?: ((context: WorkbenchCollectionSlotContext<Item>) => ReactNode) | ReactNode;
+    toolbar?: ((context: WorkbenchCollectionSlotContext<Item>) => ReactNode) | ReactNode;
+    beforeItems?: ((context: WorkbenchCollectionSlotContext<Item>) => ReactNode) | ReactNode;
+    groupHeading?: (group: WorkbenchCollectionGroupContext<Item>, context: WorkbenchCollectionSlotContext<Item>) => ReactNode;
+    selectionToolbar?: ((context: WorkbenchCollectionSlotContext<Item>) => ReactNode) | ReactNode;
+    loading?: ((context: WorkbenchCollectionSlotContext<Item>) => ReactNode) | ReactNode;
+    empty?: ((context: WorkbenchCollectionSlotContext<Item>) => ReactNode) | ReactNode;
+    error?: ((context: WorkbenchCollectionSlotContext<Item>) => ReactNode) | ReactNode;
+    permission?: ((context: WorkbenchCollectionSlotContext<Item>) => ReactNode) | ReactNode;
+    offline?: ((context: WorkbenchCollectionSlotContext<Item>) => ReactNode) | ReactNode;
+    loadMore?: ((context: WorkbenchCollectionSlotContext<Item>) => ReactNode) | ReactNode;
+    footer?: ((context: WorkbenchCollectionSlotContext<Item>) => ReactNode) | ReactNode;
+    item?: WorkbenchCollectionItemSlots<Item>;
+}
+interface WorkbenchCollectionCallbacks<Item> {
+    onItemClick?: (item: Item, context: WorkbenchCollectionItemContext<Item>, event: WorkbenchCollectionActivationEvent) => void;
+    onItemDoubleClick?: (item: Item, context: WorkbenchCollectionItemContext<Item>, event: MouseEvent<HTMLElement>) => void;
+    onItemHoverChange?: (item: Item, context: WorkbenchCollectionItemContext<Item>, hovered: boolean, event: MouseEvent<HTMLElement>) => void;
+    onItemPreview?: (item: Item, context: WorkbenchCollectionItemContext<Item>) => void;
+    onItemDetail?: (item: Item, context: WorkbenchCollectionItemContext<Item>) => void;
+    onItemDragStart?: (item: Item, context: WorkbenchCollectionItemContext<Item>, event: DragEvent<HTMLElement>) => void;
+    onItemDrop?: (item: Item, context: WorkbenchCollectionItemContext<Item>, event: DragEvent<HTMLElement>) => void;
+    onSelectionChange?: (selectedKeys: ReadonlySet<WorkbenchCollectionKey>, details: {
+        item: Item;
+        key: WorkbenchCollectionKey;
+        behavior: WorkbenchCollectionSelectionBehavior;
+    }) => void;
+    onLoadMore?: () => Promise<void> | void;
+    onRetry?: () => void;
+    onRequestAccess?: () => void;
+    onLayoutChange?: (snapshot: WorkbenchCollectionLayoutSnapshot) => void;
+    onLayoutReady?: (snapshot: WorkbenchCollectionLayoutSnapshot) => void;
+    onMediaLoad?: (item: Item, context: WorkbenchCollectionItemContext<Item>) => void;
+    onMediaError?: (item: Item, context: WorkbenchCollectionItemContext<Item>, error?: unknown) => void;
+}
+interface WorkbenchCollectionClassNames {
+    root?: string;
+    header?: string;
+    toolbar?: string;
+    selectionToolbar?: string;
+    beforeItems?: string;
+    items?: string;
+    layout?: string;
+    group?: string;
+    groupHeading?: string;
+    item?: string;
+    itemContent?: string;
+    itemTitle?: string;
+    itemActions?: string;
+    status?: string;
+    loadMore?: string;
+    footer?: string;
+}
+interface WorkbenchCollectionProps<Item> {
+    items: readonly Item[];
+    config: WorkbenchCollectionConfig<Item>;
+    renderItem: (item: Item, context: WorkbenchCollectionItemContext<Item>) => ReactNode;
+    slots?: WorkbenchCollectionSlots<Item>;
+    callbacks?: WorkbenchCollectionCallbacks<Item>;
+    className?: string;
+    classNames?: WorkbenchCollectionClassNames;
+    style?: CSSProperties;
+    ariaLabel?: string;
+}
+declare function WorkbenchCollection<Item>({ items, config, renderItem, slots, callbacks, className, classNames, style, ariaLabel, }: WorkbenchCollectionProps<Item>): react_jsx_runtime.JSX.Element;
+interface WorkbenchLaneColumn<ColumnId extends string = string> {
+    id: ColumnId;
+    label?: ReactNode;
+    icon?: ReactNode;
+    className?: string;
+    headerClassName?: string;
+    bodyClassName?: string;
+    badgeClassName?: string;
+    iconClassName?: string;
+}
+interface WorkbenchLaneClassNames {
+    root?: string;
+    column?: string;
+    columnHeader?: string;
+    columnIcon?: string;
+    columnBadge?: string;
+    columnCount?: string;
+    columnBody?: string;
+    cardWrapper?: string;
+    overlayWrapper?: string;
+    emptyColumn?: string;
+}
+interface WorkbenchLaneRenderCardContext<Row = any, ColumnId extends string = string> {
+    row: Row;
+    rowIndex: number;
+    column: WorkbenchLaneColumn<ColumnId>;
+    isDragging: boolean;
+    isOverlay: boolean;
+}
+interface WorkbenchLaneViewProps<Row = any, ColumnId extends string = string> {
+    rows?: Row[];
+    columns?: Array<WorkbenchLaneColumn<ColumnId>>;
+    getRowId?: (row: Row, rowIndex: number) => string;
+    getColumnId?: (row: Row, rowIndex: number) => ColumnId;
+    renderCard?: (row: Row, context: WorkbenchLaneRenderCardContext<Row, ColumnId>) => ReactNode;
+    renderOverlayCard?: (row: Row, context: WorkbenchLaneRenderCardContext<Row, ColumnId>) => ReactNode;
+    onMoveRow?: (rowId: string, nextColumnId: ColumnId, row: Row) => void;
+    emptyColumn?: ReactNode;
+    activationDistance?: number;
+    columnWidth?: number | string;
+    columnMinHeight?: number | string;
+    className?: string;
+    classNames?: WorkbenchLaneClassNames;
+    style?: CSSProperties;
+}
+declare function WorkbenchLaneView<Row = any, ColumnId extends string = string>({ rows, columns, getRowId, getColumnId, renderCard, renderOverlayCard, onMoveRow, emptyColumn, activationDistance, columnWidth, columnMinHeight, className, classNames, style, }: WorkbenchLaneViewProps<Row, ColumnId>): react_jsx_runtime.JSX.Element;
+interface WorkbenchMetricItem {
+    id: string;
+    label: ReactNode;
+    value: ReactNode;
+    progress?: number;
+    description?: ReactNode;
+}
+type WorkbenchMetricGridVariant = "bars" | "cards" | "list";
+type WorkbenchMetricGridDensity = "comfortable" | "compact";
+interface WorkbenchMetricGridProps {
+    items: WorkbenchMetricItem[];
+    variant?: WorkbenchMetricGridVariant;
+    density?: WorkbenchMetricGridDensity;
+    emptyState?: ReactNode;
+    ariaLabel?: string;
+    className?: string;
+    itemClassName?: string;
+}
+declare function WorkbenchMetricGrid({ items, variant, density, emptyState, ariaLabel, className, itemClassName, }: WorkbenchMetricGridProps): null | react_jsx_runtime.JSX.Element;
+type WorkbenchVisualizationTone = "accent" | "muted" | "primary" | "secondary";
+interface WorkbenchScatterPoint {
+    id: string;
+    label: string;
+    x: number;
+    y: number;
+    size?: number;
+    description?: string;
+    tone?: WorkbenchVisualizationTone;
+}
+interface WorkbenchScatterAxis {
+    label: string;
+    min?: number;
+    max?: number;
+}
+interface WorkbenchScatterThresholds {
+    x?: number;
+    y?: number;
+}
+interface WorkbenchScatterPlotProps {
+    points: WorkbenchScatterPoint[];
+    xAxis: WorkbenchScatterAxis;
+    yAxis: WorkbenchScatterAxis;
+    thresholds?: WorkbenchScatterThresholds;
+    selectedPointId?: string;
+    onPointSelect?: (point: WorkbenchScatterPoint) => void;
+    width?: number;
+    height?: number;
+    emptyState?: ReactNode;
+    ariaLabel?: string;
+    className?: string;
+}
+declare function WorkbenchScatterPlot({ points, xAxis, yAxis, thresholds, selectedPointId, onPointSelect, width, height, emptyState, ariaLabel, className, }: WorkbenchScatterPlotProps): null | react_jsx_runtime.JSX.Element;
+interface WorkbenchRelationshipNode {
+    id: string;
+    label: string;
+    meta?: string;
+    tone?: WorkbenchVisualizationTone;
+}
+interface WorkbenchRelationshipEdge {
+    id?: string;
+    sourceId: string;
+    targetId: string;
+    label?: string;
+}
+interface WorkbenchRelationshipGraphProps {
+    nodes: WorkbenchRelationshipNode[];
+    edges: WorkbenchRelationshipEdge[];
+    selectedNodeId?: string;
+    onNodeSelect?: (node: WorkbenchRelationshipNode) => void;
+    width?: number;
+    height?: number;
+    emptyState?: ReactNode;
+    ariaLabel?: string;
+    className?: string;
+    variant?: "default" | "radar";
+}
+declare function WorkbenchRelationshipGraph({ nodes, edges, selectedNodeId, onNodeSelect, width, height, emptyState, ariaLabel, className, variant, }: WorkbenchRelationshipGraphProps): null | react_jsx_runtime.JSX.Element;
+type WorkbenchJourneyItemState = "complete" | "current" | "upcoming";
+interface WorkbenchJourneyItem {
+    id: string;
+    label: ReactNode;
+    eyebrow?: ReactNode;
+    state?: WorkbenchJourneyItemState;
+    disabled?: boolean;
+}
+interface WorkbenchJourneyNavigationProps {
+    items: WorkbenchJourneyItem[];
+    onItemSelect?: (item: WorkbenchJourneyItem) => void;
+    ariaLabel?: string;
+    className?: string;
+}
+declare function WorkbenchJourneyNavigation({ items, onItemSelect, ariaLabel, className, }: WorkbenchJourneyNavigationProps): react_jsx_runtime.JSX.Element;
+interface WorkbenchRankedListMetric {
+    id: string;
+    label: ReactNode;
+    value: ReactNode;
+}
+interface WorkbenchRankedListItem {
+    id: string;
+    label: ReactNode;
+    description?: ReactNode;
+    score?: ReactNode;
+    tags?: ReactNode[];
+    metrics?: WorkbenchRankedListMetric[];
+    leading?: ReactNode;
+    trailing?: ReactNode;
+}
+interface WorkbenchRankedListProps {
+    items: WorkbenchRankedListItem[];
+    selectedItemId?: string;
+    onItemSelect?: (item: WorkbenchRankedListItem) => void;
+    emptyState?: ReactNode;
+    ariaLabel?: string;
+    className?: string;
+}
+declare function WorkbenchRankedList({ items, selectedItemId, onItemSelect, emptyState, ariaLabel, className, }: WorkbenchRankedListProps): null | react_jsx_runtime.JSX.Element;
+interface WorkbenchSelectionTrayItem {
+    id: string;
+    label: ReactNode;
+    meta?: ReactNode;
+}
+interface WorkbenchSelectionTrayProps {
+    title: ReactNode;
+    description?: ReactNode;
+    items: WorkbenchSelectionTrayItem[];
+    onRemove?: (item: WorkbenchSelectionTrayItem) => void;
+    removeLabel?: (item: WorkbenchSelectionTrayItem) => string;
+    actions?: ReactNode;
+    emptyState?: ReactNode;
+    className?: string;
+}
+declare function WorkbenchSelectionTray({ title, description, items, onRemove, removeLabel, actions, emptyState, className, }: WorkbenchSelectionTrayProps): react_jsx_runtime.JSX.Element;
+interface WorkbenchEvidenceItem {
+    id: string;
+    title: ReactNode;
+    description?: ReactNode;
+    source?: ReactNode;
+    timestamp?: ReactNode;
+    marker?: ReactNode;
+    action?: ReactNode;
+}
+interface WorkbenchEvidenceListProps {
+    items: WorkbenchEvidenceItem[];
+    emptyState?: ReactNode;
+    ariaLabel?: string;
+    className?: string;
+}
+declare function WorkbenchEvidenceList({ items, emptyState, ariaLabel, className, }: WorkbenchEvidenceListProps): null | react_jsx_runtime.JSX.Element;
+interface WorkbenchAssetGalleryItem {
+    id: string;
+    url: string;
+    alt: string;
+    title?: ReactNode;
+    description?: ReactNode;
+    badges?: ReactNode[];
+}
+interface WorkbenchAssetGalleryProps {
+    items: WorkbenchAssetGalleryItem[];
+    selectedItemId?: string;
+    onItemSelect?: (item: WorkbenchAssetGalleryItem) => void;
+    emptyState?: ReactNode;
+    ariaLabel?: string;
+    className?: string;
+}
+declare function WorkbenchAssetGallery({ items, selectedItemId, onItemSelect, emptyState, ariaLabel, className, }: WorkbenchAssetGalleryProps): null | react_jsx_runtime.JSX.Element;
+interface WorkbenchRadarNavigationChild {
+    id: string;
+    label: ReactNode;
+    icon?: ReactNode;
+}
+interface WorkbenchRadarNavigationItem {
+    id: string;
+    label: ReactNode;
+    icon?: ReactNode;
+    children?: WorkbenchRadarNavigationChild[];
+}
+interface WorkbenchRadarWorkspaceProps {
+    navigationItems?: WorkbenchRadarNavigationItem[];
+    activeNavigationId?: string;
+    activeNavigationChildId?: string;
+    onNavigationSelect?: (item: WorkbenchRadarNavigationItem) => void;
+    onNavigationChildSelect?: (child: WorkbenchRadarNavigationChild, parent: WorkbenchRadarNavigationItem) => void;
+    navigationFooter?: ReactNode;
+    navigation?: ReactNode;
+    children: ReactNode;
+    inspector?: ReactNode;
+    inspectorLabel?: string;
+    className?: string;
+    contentClassName?: string;
+    minimumHeight?: number | string;
+    ariaLabel?: string;
+}
+interface WorkbenchRadarNavigationProps {
+    items: WorkbenchRadarNavigationItem[];
+    activeItemId?: string;
+    activeChildId?: string;
+    onItemSelect?: (item: WorkbenchRadarNavigationItem) => void;
+    onChildSelect?: (child: WorkbenchRadarNavigationChild, parent: WorkbenchRadarNavigationItem) => void;
+    footer?: ReactNode;
+    ariaLabel?: string;
+}
+declare function WorkbenchRadarNavigation({ items, activeItemId, activeChildId, onItemSelect, onChildSelect, footer, ariaLabel, }: WorkbenchRadarNavigationProps): react_jsx_runtime.JSX.Element;
+declare function WorkbenchRadarWorkspace({ navigationItems, activeNavigationId, activeNavigationChildId, onNavigationSelect, onNavigationChildSelect, navigationFooter, navigation, children, inspector, inspectorLabel, className, contentClassName, minimumHeight, ariaLabel, }: WorkbenchRadarWorkspaceProps): react_jsx_runtime.JSX.Element;
+declare function WorkbenchRadarInspectorSection({ title, icon, description, children, className, }: {
+    title: ReactNode;
+    icon?: ReactNode;
+    description?: ReactNode;
+    children?: ReactNode;
+    className?: string;
+}): react_jsx_runtime.JSX.Element;
+declare function WorkbenchRadarFilterChip({ label, value, icon, selected, onSelect, className, }: {
+    label: ReactNode;
+    value?: ReactNode;
+    icon?: ReactNode;
+    selected?: boolean;
+    onSelect?: () => void;
+    className?: string;
+}): react_jsx_runtime.JSX.Element;
+interface WorkbenchRadarQuadrant {
+    id: "high-high" | "high-low" | "low-high" | "low-low";
+    title: ReactNode;
+    description?: ReactNode;
+}
+interface WorkbenchRadarLegendItem {
+    id: string;
+    label: ReactNode;
+    tone?: WorkbenchVisualizationTone;
+}
+interface WorkbenchRadarMatrixProps {
+    points: WorkbenchScatterPoint[];
+    xAxis: WorkbenchScatterAxis;
+    yAxis: WorkbenchScatterAxis;
+    thresholds?: WorkbenchScatterThresholds;
+    quadrants?: WorkbenchRadarQuadrant[];
+    legend?: WorkbenchRadarLegendItem[];
+    selectedPointId?: string;
+    onPointSelect?: (point: WorkbenchScatterPoint) => void;
+    width?: number;
+    height?: number;
+    labelLimit?: number;
+    emptyState?: ReactNode;
+    ariaLabel?: string;
+    className?: string;
+}
+declare function WorkbenchRadarMatrix({ points, xAxis, yAxis, thresholds, quadrants, legend, selectedPointId, onPointSelect, width, height, labelLimit, emptyState, ariaLabel, className, }: WorkbenchRadarMatrixProps): null | react_jsx_runtime.JSX.Element;
+export { type WorkbenchCollectionTitleVisibility as $, type WorkbenchCollectionItemConfig as A, type WorkbenchCollectionItemContext as B, type WorkbenchCollectionItemSize as C, type WorkbenchCollectionItemSlotName as D, type WorkbenchCollectionItemSlots as E, type WorkbenchCollectionItemStatus as F, type WorkbenchCollectionItemTitleConfig as G, type WorkbenchCollectionKey as H, InteractiveTable as I, type WorkbenchCollectionLabels as J, type WorkbenchCollectionLayoutConfig as K, type WorkbenchCollectionLayoutContext as L, type WorkbenchCollectionLayoutMode as M, type WorkbenchCollectionLayoutSnapshot as N, type WorkbenchCollectionLoadingConfig as O, type WorkbenchCollectionLoadingVariant as P, type WorkbenchCollectionProps as Q, type WorkbenchCollectionResponsive as R, type WorkbenchCollectionSelectionBehavior as S, type WorkbenchCollectionSelectionConfig as T, type WorkbenchCollectionSelectionMode as U, type WorkbenchCollectionSkeletonConfig as V, WorkbenchAssetGallery as W, type WorkbenchCollectionSlotContext as X, type WorkbenchCollectionSlots as Y, type WorkbenchCollectionStateConfig as Z, type WorkbenchCollectionTitlePlacement as _, type InteractiveTableClassNames as a, type WorkbenchRadarNavigationChild as a$, type WorkbenchCollectionVirtualizationAdapter as a0, type WorkbenchCollectionVirtualizationConfig as a1, type WorkbenchCollectionVirtualizationRenderOptions as a2, WorkbenchContentPane as a3, type WorkbenchContentPaneBodyProps as a4, type WorkbenchContentPaneClassNames as a5, type WorkbenchContentPaneProps as a6, WorkbenchContentToolbar as a7, type WorkbenchContentToolbarClassNames as a8, type WorkbenchContentToolbarProps as a9, type WorkbenchGallerySettingsValue as aA, WorkbenchGalleryView as aB, type WorkbenchGalleryViewProps as aC, type WorkbenchJourneyItem as aD, type WorkbenchJourneyItemState as aE, WorkbenchJourneyNavigation as aF, type WorkbenchJourneyNavigationProps as aG, type WorkbenchLaneClassNames as aH, type WorkbenchLaneColumn as aI, type WorkbenchLaneRenderCardContext as aJ, WorkbenchLaneView as aK, type WorkbenchLaneViewProps as aL, type WorkbenchMasonryItemSize as aM, WorkbenchMasonryLayout as aN, type WorkbenchMasonryLayoutContext as aO, type WorkbenchMasonryLayoutProps as aP, WorkbenchMetricGrid as aQ, type WorkbenchMetricGridDensity as aR, type WorkbenchMetricGridProps as aS, type WorkbenchMetricGridVariant as aT, type WorkbenchMetricItem as aU, WorkbenchRadarFilterChip as aV, WorkbenchRadarInspectorSection as aW, type WorkbenchRadarLegendItem as aX, WorkbenchRadarMatrix as aY, type WorkbenchRadarMatrixProps as aZ, WorkbenchRadarNavigation as a_, type WorkbenchContentToolbarViewModeOption as aa, WorkbenchDetailSidebar as ab, type WorkbenchDetailSidebarBodyProps as ac, type WorkbenchDetailSidebarClassNames as ad, type WorkbenchDetailSidebarField as ae, type WorkbenchDetailSidebarProps as af, type WorkbenchDetailSidebarRenderContext as ag, type WorkbenchDetailSidebarSection as ah, type WorkbenchEvidenceItem as ai, WorkbenchEvidenceList as aj, type WorkbenchEvidenceListProps as ak, WorkbenchGalleryCard as al, type WorkbenchGalleryCardMetaContext as am, type WorkbenchGalleryCardProps as an, type WorkbenchGalleryCardRenderContext as ao, type WorkbenchGalleryColumn as ap, type WorkbenchGalleryLabels as aq, type WorkbenchGalleryRecordVisual as ar, WorkbenchGallerySettingsButton as as, type WorkbenchGallerySettingsButtonClassNames as at, type WorkbenchGallerySettingsButtonProps as au, type WorkbenchGallerySettingsLabels as av, type WorkbenchGallerySettingsOption as aw, WorkbenchGallerySettingsPanel as ax, type WorkbenchGallerySettingsPanelClassNames as ay, type WorkbenchGallerySettingsPanelProps as az, type InteractiveTableColumn as b, type WorkbenchRadarNavigationItem as b0, type WorkbenchRadarNavigationProps as b1, type WorkbenchRadarQuadrant as b2, WorkbenchRadarWorkspace as b3, type WorkbenchRadarWorkspaceProps as b4, WorkbenchRankedList as b5, type WorkbenchRankedListItem as b6, type WorkbenchRankedListMetric as b7, type WorkbenchRankedListProps as b8, type WorkbenchRelationshipEdge as b9, type WorkbenchCollectionItemAlign as bA, WorkbenchRelationshipGraph as ba, type WorkbenchRelationshipGraphProps as bb, type WorkbenchRelationshipNode as bc, WorkbenchResizableSidebar as bd, type WorkbenchResizableSidebarClassNames as be, type WorkbenchResizableSidebarItem as bf, type WorkbenchResizableSidebarProps as bg, type WorkbenchResizableSidebarSection as bh, type WorkbenchScatterAxis as bi, WorkbenchScatterPlot as bj, type WorkbenchScatterPlotProps as bk, type WorkbenchScatterPoint as bl, type WorkbenchScatterThresholds as bm, WorkbenchSelectionTray as bn, type WorkbenchSelectionTrayItem as bo, type WorkbenchSelectionTrayProps as bp, WorkbenchTableView as bq, type WorkbenchTableViewClassNames as br, type WorkbenchTableViewColumn as bs, type WorkbenchTableViewHeaderContext as bt, type WorkbenchTableViewProps as bu, type WorkbenchTableViewRenderContext as bv, type WorkbenchVisualizationTone as bw, type WorkbenchCollectionActionsPlacement as bx, type WorkbenchCollectionActionsVisibility as by, type WorkbenchCollectionItemActionsConfig as bz, type InteractiveTableColumnMenuLabels as c, InteractiveTableEditableTextCell as d, type InteractiveTableEditableTextCellProps as e, type InteractiveTableHeaderContext as f, type InteractiveTableHeaderProps as g, type InteractiveTableProps as h, InteractiveTableReadonlyCell as i, type InteractiveTableReadonlyCellProps as j, type InteractiveTableRenderContext as k, type InteractiveTableRowState as l, InteractiveTableSelectCell as m, type InteractiveTableSelectCellProps as n, type InteractiveTableSelectOption as o, type WorkbenchAssetGalleryItem as p, type WorkbenchAssetGalleryProps as q, WorkbenchCollection as r, type WorkbenchCollectionActivationEvent as s, type WorkbenchCollectionAppearanceConfig as t, type WorkbenchCollectionCallbacks as u, type WorkbenchCollectionClassNames as v, type WorkbenchCollectionConfig as w, type WorkbenchCollectionGroupContext as x, type WorkbenchCollectionGroupingConfig as y, type WorkbenchCollectionHoverEffect as z };