@inf-monkeys-tech/monkeys-design 0.4.31 → 0.4.33

package/dist/components/workbench/index.d.ts

@@ -0,0 +1,752 @@
+import * as React from 'react';
+import { ReactNode, MouseEvent, ElementType, CSSProperties, ComponentPropsWithoutRef, ComponentType } from 'react';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { aZ as BaseTableSortDirection, c as BaseAppearance, aI as BaseTableColumnSizes, aG as BaseTableColumnOrderChangeDetail, aH as BaseTableColumnSizeChangeDetail } from '../../types-CZALgtez.js';
+import '@radix-ui/react-context-menu';
+
+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 WorkbenchResizableSidebarClassNames {
+    root?: string;
+    header?: string;
+    title?: string;
+    collapseButton?: string;
+    list?: string;
+    item?: string;
+    itemIcon?: string;
+    itemLabel?: string;
+    resizeHandle?: string;
+    mobileNav?: string;
+    mobileItem?: string;
+}
+interface WorkbenchResizableSidebarProps {
+    title?: ReactNode;
+    items: WorkbenchResizableSidebarItem[];
+    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?: 'compact' | 'comfortable' | 'detailed' | string;
+    galleryGridColumns?: number | 'auto' | string;
+    galleryBentoColumns?: 1 | 2 | 3 | number;
+    galleryDetailVisibility?: 'all' | 'limit' | string;
+    galleryDetailLimit?: number | string;
+    [key: string]: any;
+}
+interface WorkbenchGallerySettingsOption<Value extends string | number = 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<number | 'auto'>>;
+    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?: 'start' | 'end';
+    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?: WorkbenchGallerySettingsButtonProps | false;
+    gallerySettingsPlacement?: 'start' | 'end';
+    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?: ReactNode | ElementType;
+    icon?: ReactNode | ElementType;
+    renderType?: string;
+    value?: ReactNode | ((record: Row | null | undefined, field: WorkbenchDetailSidebarField<Row>) => ReactNode);
+    description?: ReactNode;
+    hidden?: boolean | ((field: WorkbenchDetailSidebarField<Row>, record: Row | null | undefined) => boolean);
+    emptyValue?: ReactNode;
+    [key: string]: any;
+}
+interface WorkbenchDetailSidebarSection<Row = any> {
+    id?: string;
+    title?: ReactNode;
+    description?: ReactNode;
+    fields?: WorkbenchDetailSidebarField<Row>[];
+    columns?: 1 | 2 | 3;
+    hidden?: boolean | ((section: WorkbenchDetailSidebarSection<Row>, record: Row | null | undefined) => boolean);
+    emptyState?: ReactNode;
+    [key: string]: any;
+}
+interface WorkbenchDetailSidebarRenderContext<Row = any> {
+    field: WorkbenchDetailSidebarField<Row>;
+    fieldIndex: number;
+    section: WorkbenchDetailSidebarSection<Row>;
+    sectionIndex: number;
+    record: Row | null | 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?: Row | null;
+    fields?: WorkbenchDetailSidebarField<Row>[];
+    sections?: WorkbenchDetailSidebarSection<Row>[];
+    fieldColumns?: 1 | 2 | 3;
+    emptyValue?: ReactNode;
+    emptyState?: ReactNode;
+    getFieldValue?: (field: WorkbenchDetailSidebarField<Row>, record: Row | null | undefined, context: WorkbenchDetailSidebarRenderContext<Row>) => unknown;
+    renderFieldValue?: (field: WorkbenchDetailSidebarField<Row>, record: Row | null | 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?: 'left' | 'center' | '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?: WorkbenchTableViewColumn | null;
+    activeTablePrimaryColumn?: WorkbenchTableViewColumn | null;
+    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?: string | ((row: Row, rowIndex: number) => string | undefined);
+    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) => ReactNode | ComponentType<{
+        className?: string;
+    }> | null | undefined;
+    getColumnTypeIcon?: (columnType?: string, column?: WorkbenchTableViewColumn) => ReactNode | ComponentType<{
+        className?: string;
+    }> | null | undefined;
+    getRowKey?: (row: Row, rowIndex: number) => string | number;
+    getRowSelectionKey?: (row: Row, rowIndex: number) => string | number | undefined;
+    isActionColumn?: (column: WorkbenchTableViewColumn) => boolean;
+    isActionField?: (column: WorkbenchTableViewColumn) => boolean;
+    isRowDisabled?: (row: Row, rowIndex: number) => boolean;
+    isWorkbenchPlaceholderRow?: (row: Row, rowIndex?: number) => boolean;
+    emptyState?: ReactNode;
+    hiddenRowsMessage?: ReactNode | ((hiddenRowCount: number, renderedRowCount: number, totalRowCount: number) => 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?: 'left' | 'center' | '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) => string | number;
+    getPinnedTopRowKey?: (row: PinnedTopRow, rowIndex: number) => string | number;
+    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?: string | ((row: Row, rowIndex: number) => string | undefined);
+    pinnedTopRowClassName?: string | ((row: PinnedTopRow, rowIndex: number) => string | undefined);
+    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?: string | null;
+    placeholder?: string;
+    disabled?: boolean;
+    multiline?: boolean;
+    commitOnBlur?: boolean;
+    className?: string;
+    inputClassName?: string;
+    onCommit?: (value: string) => void | Promise<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?: 'compact' | 'comfortable' | '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?: string | number, columnLabel?: ReactNode) => string;
+    isImageField?: (column: WorkbenchGalleryColumn, value: unknown) => boolean;
+    isAudioField?: (column: WorkbenchGalleryColumn, value: unknown) => boolean;
+    AudioPlayerComponent?: ComponentType<{
+        filename: string;
+    }>;
+    cardVariant?: 'default' | 'image-only' | 'preview-only' | 'chromatic-bento' | string;
+    renderPreview?: (context: WorkbenchGalleryCardRenderContext<Row>) => ReactNode;
+    renderMeta?: (context: WorkbenchGalleryCardMetaContext<Row>) => ReactNode;
+    renderLeadingVisual?: (context: WorkbenchGalleryCardMetaContext<Row> & {
+        iconVisual?: WorkbenchGalleryRecordVisual | null;
+    }) => ReactNode;
+    resolveRecordVisual?: (value: unknown, row: Row, iconColumn?: WorkbenchGalleryColumn) => WorkbenchGalleryRecordVisual | null | undefined;
+    hiddenDetailFieldKeys?: string[];
+    labels?: WorkbenchGalleryLabels;
+    formatLabel?: (value: ReactNode, context?: {
+        column?: WorkbenchGalleryColumn;
+    }) => ReactNode;
+    className?: string;
+}
+interface WorkbenchGalleryCardRenderContext<Row = any> {
+    row: Row;
+    mediaColumn?: WorkbenchGalleryColumn | null;
+    mediaValue: unknown;
+    isImageMedia: boolean;
+    isAudioMedia: boolean;
+    iconVisual?: WorkbenchGalleryRecordVisual | null;
+    IconComponent?: ComponentType<{
+        className?: string;
+    }> | null;
+    previewClassName: string;
+}
+interface WorkbenchGalleryCardMetaContext<Row = any> {
+    row: Row;
+    contentColumns: WorkbenchGalleryColumn[];
+    detailColumns: WorkbenchGalleryColumn[];
+    titleColumn?: WorkbenchGalleryColumn | null;
+    summaryColumn?: WorkbenchGalleryColumn | null;
+    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: 'shelf' | 'dense';
+    rowSpan?: number;
+    rowHeight: number;
+    size?: WorkbenchMasonryItemSize;
+}
+interface WorkbenchMasonryLayoutProps<Item = any> {
+    items?: Item[];
+    renderItem: (item: Item, context: WorkbenchMasonryLayoutContext) => ReactNode;
+    getItemKey?: (item: Item, index: number) => string | number;
+    getItemSize?: (item: Item, context: WorkbenchMasonryLayoutContext) => WorkbenchMasonryItemSize | undefined;
+    columnWidth?: number | string;
+    gap?: number;
+    rowHeight?: number;
+    placementStrategy?: 'shelf' | 'dense';
+    className?: string;
+}
+declare function WorkbenchMasonryLayout<Item = any>({ items, renderItem, getItemKey, getItemSize, columnWidth, gap, rowHeight, placementStrategy, className, }: WorkbenchMasonryLayoutProps<Item>): react_jsx_runtime.JSX.Element;
+
+interface WorkbenchGalleryViewProps<Row = any> extends Omit<WorkbenchGalleryCardProps<Row>, 'row' | 'columns' | 'onClick' | 'isSelected' | 'isMasonry'> {
+    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?: number | 'auto' | string;
+    galleryGridCardWidth?: number | string;
+    galleryMasonryColumnWidth?: number | string;
+    masonryPlacementStrategy?: 'shelf' | 'dense';
+    getMasonryItemSize?: (row: Row, context: {
+        defaultSize: WorkbenchMasonryItemSize;
+        columnCount: number;
+        columnWidth: number;
+        containerWidth: number;
+        gap: number;
+        placementStrategy: 'shelf' | 'dense';
+        rowHeight: number;
+    }) => WorkbenchMasonryItemSize | undefined;
+}
+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;
+
+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;
+
+export { InteractiveTable, type InteractiveTableClassNames, type InteractiveTableColumn, type InteractiveTableColumnMenuLabels, InteractiveTableEditableTextCell, type InteractiveTableEditableTextCellProps, type InteractiveTableHeaderContext, type InteractiveTableHeaderProps, type InteractiveTableProps, InteractiveTableReadonlyCell, type InteractiveTableReadonlyCellProps, type InteractiveTableRenderContext, type InteractiveTableRowState, InteractiveTableSelectCell, type InteractiveTableSelectCellProps, type InteractiveTableSelectOption, WorkbenchContentPane, type WorkbenchContentPaneBodyProps, type WorkbenchContentPaneClassNames, type WorkbenchContentPaneProps, WorkbenchContentToolbar, type WorkbenchContentToolbarClassNames, type WorkbenchContentToolbarProps, type WorkbenchContentToolbarViewModeOption, WorkbenchDetailSidebar, type WorkbenchDetailSidebarBodyProps, type WorkbenchDetailSidebarClassNames, type WorkbenchDetailSidebarField, type WorkbenchDetailSidebarProps, type WorkbenchDetailSidebarRenderContext, type WorkbenchDetailSidebarSection, WorkbenchGalleryCard, type WorkbenchGalleryCardMetaContext, type WorkbenchGalleryCardProps, type WorkbenchGalleryCardRenderContext, type WorkbenchGalleryColumn, type WorkbenchGalleryLabels, type WorkbenchGalleryRecordVisual, WorkbenchGallerySettingsButton, type WorkbenchGallerySettingsButtonClassNames, type WorkbenchGallerySettingsButtonProps, type WorkbenchGallerySettingsLabels, type WorkbenchGallerySettingsOption, WorkbenchGallerySettingsPanel, type WorkbenchGallerySettingsPanelClassNames, type WorkbenchGallerySettingsPanelProps, type WorkbenchGallerySettingsValue, WorkbenchGalleryView, type WorkbenchGalleryViewProps, type WorkbenchLaneClassNames, type WorkbenchLaneColumn, type WorkbenchLaneRenderCardContext, WorkbenchLaneView, type WorkbenchLaneViewProps, type WorkbenchMasonryItemSize, WorkbenchMasonryLayout, type WorkbenchMasonryLayoutContext, type WorkbenchMasonryLayoutProps, WorkbenchResizableSidebar, type WorkbenchResizableSidebarClassNames, type WorkbenchResizableSidebarItem, type WorkbenchResizableSidebarProps, WorkbenchTableView, type WorkbenchTableViewClassNames, type WorkbenchTableViewColumn, type WorkbenchTableViewHeaderContext, type WorkbenchTableViewProps, type WorkbenchTableViewRenderContext };