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, cn as SkeletonGroupAnimation } from './types-961bd33013f0.js';
interface WorkbenchResizableSidebarItem {
    id: string;
    label: ReactNode;
    icon?: ReactNode;
    iconName?: string;
    count?: number;
    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;
    onItemSelect?: (value: {
        itemId: string;
    }) => void;
    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;
    headerStyle?: CSSProperties;
    cellStyle?: CSSProperties;
    [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 WorkbenchTableScrollRestoration {
    key: string;
    read(): {
        x: number;
        y: number;
        rowKey?: string;
        rowOffset?: number;
    } | undefined;
    write(position: {
        x: number;
        y: number;
        rowKey?: string;
        rowOffset?: number;
    }): void;
}
interface WorkbenchTableViewProps<Row = any> {
    scrollRestoration?: WorkbenchTableScrollRestoration;
    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;
    headerPresentation?: "classic-data-grid";
    fillRemainingWidthColumnKey?: string;
    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;
    scrollFooter?: ReactNode;
}
declare function WorkbenchTableView<Row = any>({ rows, columns, onRowClick, selectedRowKey, selectedLinkKey, activePrimaryColumn, activeTablePrimaryColumn, renderedRowCount, totalRowCount, tableMinWidth, minWidth, bodyMaxHeight, stickyFirstColumn, appearance, headerPresentation, fillRemainingWidthColumnKey, 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, scrollFooter, scrollRestoration, }: 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;
    cardInteraction?: 'button' | 'container';
    isSelected?: boolean;
    isMasonry?: boolean;
    galleryFieldKey?: string;
    galleryDensity?: 'comfortable' | 'compact' | 'detailed' | string;
    galleryBentoColumns?: 1 | 2 | 3 | number;
    galleryDetailVisibility?: 'all' | 'limit' | string;
    galleryDetailLimit?: number | string;
    galleryDetailPresentation?: 'lines' | 'tiles';
    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, cardInteraction, isSelected, isMasonry, galleryFieldKey, galleryDensity, galleryBentoColumns, galleryDetailVisibility, galleryDetailLimit, galleryDetailPresentation, 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, cardInteraction, 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, galleryDetailPresentation, 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;
    animation?: SkeletonGroupAnimation;
}
type WorkbenchCollectionKey = number | string;
type WorkbenchCollectionSelectionMode = 'multiple' | 'none' | 'single';
type WorkbenchCollectionSelectionBehavior = 'range' | 'replace' | 'toggle';
interface WorkbenchCollectionSelectionIntent {
    behavior?: WorkbenchCollectionSelectionBehavior;
    shiftKey?: boolean;
}
interface WorkbenchCollectionSelectionChangeDetails<Item> {
    item: Item;
    index: number;
    key: WorkbenchCollectionKey;
    behavior: WorkbenchCollectionSelectionBehavior;
}
interface UseWorkbenchCollectionSelectionOptions<Item> {
    items: readonly Item[];
    getItemKey: (item: Item, index: number) => WorkbenchCollectionKey;
    mode?: WorkbenchCollectionSelectionMode;
    behavior?: WorkbenchCollectionSelectionBehavior;
    selectedKeys?: Iterable<WorkbenchCollectionKey>;
    defaultSelectedKeys?: Iterable<WorkbenchCollectionKey>;
    isItemDisabled?: (item: Item, index: number) => boolean;
    onSelectionChange?: (selectedKeys: ReadonlySet<WorkbenchCollectionKey>, details: WorkbenchCollectionSelectionChangeDetails<Item>) => void;
}
interface WorkbenchCollectionSelectionController {
    mode: WorkbenchCollectionSelectionMode;
    selectedKeys: ReadonlySet<WorkbenchCollectionKey>;
    isSelected: (key: WorkbenchCollectionKey) => boolean;
    selectKey: (key: WorkbenchCollectionKey, intent?: WorkbenchCollectionSelectionIntent) => void;
    resetAnchor: () => void;
}
declare function useWorkbenchCollectionSelection<Item>({ items, getItemKey, mode, behavior, selectedKeys: controlledSelectedKeys, defaultSelectedKeys, isItemDisabled, onSelectionChange, }: UseWorkbenchCollectionSelectionOptions<Item>): WorkbenchCollectionSelectionController;
type WorkbenchCollectionLayoutMode = 'dense' | 'grid' | 'masonry' | 'rail';
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;
    selectFromEvent: (event: Pick<WorkbenchCollectionActivationEvent, 'shiftKey'>, 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;
    onSelectRow?: (intent: {
        rowId: string;
    }) => 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, onSelectRow, 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;
    titleKey?: string;
    description?: ReactNode;
    descriptionKey?: string;
    source?: ReactNode;
    sourceKey?: string;
    timestamp?: ReactNode;
    timestampValue?: number | string;
    marker?: ReactNode;
    action?: ReactNode;
}
interface WorkbenchEvidenceListProps {
    items: WorkbenchEvidenceItem[];
    emptyState?: ReactNode;
    ariaLabel?: string;
    className?: string;
    translate?: (key: string) => string;
}
declare function WorkbenchEvidenceList({ items, emptyState, ariaLabel, className, translate, }: 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;
interface WorkbenchRadarFilterRowDisclosureBase {
    expanded: boolean;
    controls: string;
    expandLabel: string;
    collapseLabel: string;
    onToggle: () => void;
}
interface WorkbenchRadarFilterRowIntegratedDisclosure extends WorkbenchRadarFilterRowDisclosureBase {
    mode: "integrated";
}
interface WorkbenchRadarFilterRowSeparateDisclosure extends WorkbenchRadarFilterRowDisclosureBase {
    mode: "separate";
}
interface WorkbenchRadarFilterRowBaseProps {
    label: ReactNode;
    value?: ReactNode;
    icon?: ReactNode;
    disabled?: boolean;
    tone?: WorkbenchVisualizationTone;
    className?: string;
}
type WorkbenchRadarFilterRowProps = WorkbenchRadarFilterRowBaseProps & ({
    onSelect: () => void;
    selected?: boolean;
    disclosure: WorkbenchRadarFilterRowSeparateDisclosure;
} | {
    onSelect: () => void;
    selected?: boolean;
    disclosure?: never;
} | {
    onSelect?: never;
    selected?: never;
    disclosure: WorkbenchRadarFilterRowIntegratedDisclosure;
});
interface WorkbenchRadarFilterChipProps {
    label: ReactNode;
    value?: ReactNode;
    icon?: ReactNode;
    selected?: boolean;
    disabled?: boolean;
    onSelect?: () => void;
    className?: string;
}
declare function WorkbenchRadarFilterRow(props: WorkbenchRadarFilterRowProps): react_jsx_runtime.JSX.Element;
declare function WorkbenchRadarFilterChip({ label, value, icon, selected, disabled, onSelect, className, }: WorkbenchRadarFilterChipProps): 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 WorkbenchCollectionSlotContext 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 WorkbenchCollectionSelectionChangeDetails as T, type UseWorkbenchCollectionSelectionOptions as U, type WorkbenchCollectionSelectionConfig as V, WorkbenchAssetGallery as W, type WorkbenchCollectionSelectionController as X, type WorkbenchCollectionSelectionIntent as Y, type WorkbenchCollectionSelectionMode as Z, type WorkbenchCollectionSkeletonConfig as _, type InteractiveTableClassNames as a, WorkbenchRadarFilterRow as a$, type WorkbenchCollectionSlots as a0, type WorkbenchCollectionStateConfig as a1, type WorkbenchCollectionTitlePlacement as a2, type WorkbenchCollectionTitleVisibility as a3, type WorkbenchCollectionVirtualizationAdapter as a4, type WorkbenchCollectionVirtualizationConfig as a5, type WorkbenchCollectionVirtualizationRenderOptions as a6, WorkbenchContentPane as a7, type WorkbenchContentPaneBodyProps as a8, type WorkbenchContentPaneClassNames as a9, type WorkbenchGallerySettingsOption as aA, WorkbenchGallerySettingsPanel as aB, type WorkbenchGallerySettingsPanelClassNames as aC, type WorkbenchGallerySettingsPanelProps as aD, type WorkbenchGallerySettingsValue as aE, WorkbenchGalleryView as aF, type WorkbenchGalleryViewProps as aG, type WorkbenchJourneyItem as aH, type WorkbenchJourneyItemState as aI, WorkbenchJourneyNavigation as aJ, type WorkbenchJourneyNavigationProps as aK, type WorkbenchLaneClassNames as aL, type WorkbenchLaneColumn as aM, type WorkbenchLaneRenderCardContext as aN, WorkbenchLaneView as aO, type WorkbenchLaneViewProps as aP, type WorkbenchMasonryItemSize as aQ, WorkbenchMasonryLayout as aR, type WorkbenchMasonryLayoutContext as aS, type WorkbenchMasonryLayoutProps as aT, WorkbenchMetricGrid as aU, type WorkbenchMetricGridDensity as aV, type WorkbenchMetricGridProps as aW, type WorkbenchMetricGridVariant as aX, type WorkbenchMetricItem as aY, WorkbenchRadarFilterChip as aZ, type WorkbenchRadarFilterChipProps as a_, type WorkbenchContentPaneProps as aa, WorkbenchContentToolbar as ab, type WorkbenchContentToolbarClassNames as ac, type WorkbenchContentToolbarProps as ad, type WorkbenchContentToolbarViewModeOption as ae, WorkbenchDetailSidebar as af, type WorkbenchDetailSidebarBodyProps as ag, type WorkbenchDetailSidebarClassNames as ah, type WorkbenchDetailSidebarField as ai, type WorkbenchDetailSidebarProps as aj, type WorkbenchDetailSidebarRenderContext as ak, type WorkbenchDetailSidebarSection as al, type WorkbenchEvidenceItem as am, WorkbenchEvidenceList as an, type WorkbenchEvidenceListProps as ao, WorkbenchGalleryCard as ap, type WorkbenchGalleryCardMetaContext as aq, type WorkbenchGalleryCardProps as ar, type WorkbenchGalleryCardRenderContext as as, type WorkbenchGalleryColumn as at, type WorkbenchGalleryLabels as au, type WorkbenchGalleryRecordVisual as av, WorkbenchGallerySettingsButton as aw, type WorkbenchGallerySettingsButtonClassNames as ax, type WorkbenchGallerySettingsButtonProps as ay, type WorkbenchGallerySettingsLabels as az, type InteractiveTableColumn as b, type WorkbenchRadarFilterRowDisclosureBase as b0, type WorkbenchRadarFilterRowIntegratedDisclosure as b1, type WorkbenchRadarFilterRowProps as b2, type WorkbenchRadarFilterRowSeparateDisclosure as b3, WorkbenchRadarInspectorSection as b4, type WorkbenchRadarLegendItem as b5, WorkbenchRadarMatrix as b6, type WorkbenchRadarMatrixProps as b7, WorkbenchRadarNavigation as b8, type WorkbenchRadarNavigationChild as b9, WorkbenchTableView as bA, type WorkbenchTableViewClassNames as bB, type WorkbenchTableViewColumn as bC, type WorkbenchTableViewHeaderContext as bD, type WorkbenchTableViewProps as bE, type WorkbenchTableViewRenderContext as bF, type WorkbenchVisualizationTone as bG, useWorkbenchCollectionSelection as bH, type WorkbenchCollectionActionsPlacement as bI, type WorkbenchCollectionActionsVisibility as bJ, type WorkbenchCollectionItemActionsConfig as bK, type WorkbenchCollectionItemAlign as bL, type WorkbenchRadarNavigationItem as ba, type WorkbenchRadarNavigationProps as bb, type WorkbenchRadarQuadrant as bc, WorkbenchRadarWorkspace as bd, type WorkbenchRadarWorkspaceProps as be, WorkbenchRankedList as bf, type WorkbenchRankedListItem as bg, type WorkbenchRankedListMetric as bh, type WorkbenchRankedListProps as bi, type WorkbenchRelationshipEdge as bj, WorkbenchRelationshipGraph as bk, type WorkbenchRelationshipGraphProps as bl, type WorkbenchRelationshipNode as bm, WorkbenchResizableSidebar as bn, type WorkbenchResizableSidebarClassNames as bo, type WorkbenchResizableSidebarItem as bp, type WorkbenchResizableSidebarProps as bq, type WorkbenchResizableSidebarSection as br, type WorkbenchScatterAxis as bs, WorkbenchScatterPlot as bt, type WorkbenchScatterPlotProps as bu, type WorkbenchScatterPoint as bv, type WorkbenchScatterThresholds as bw, WorkbenchSelectionTray as bx, type WorkbenchSelectionTrayItem as by, type WorkbenchSelectionTrayProps 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 };