@nodeblocks/frontend-list-organization-block 0.2.3 → 0.4.0

package/dist/index.d.ts

@@ -1,2 +1,578 @@
-export { default as ListOrganizations } from './list-organizations';
-//# sourceMappingURL=index.d.ts.map
+import { TableCellProps, Stack, StackProps, TypographyProps, TabsProps, TabProps, Box, MenuProps, TableHeadProps, TableRowProps, TableBodyProps, IconButtonProps, TableContainer, TableProps } from '@mui/material';
+import { ReactNode, ComponentProps, SyntheticEvent, ReactElement, MouseEvent } from 'react';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { SetRequired } from 'type-fest';
+import { Breakpoint } from '@mui/material/styles';
+
+/**
+ * The function to be passed into a block component as `children` to selectively override default blocks, or just a `ReactNode`.
+ *
+ * @example
+ * <Block>
+ *   {({ defaultBlocks: { header, ...defaultBlocks }, defaultBlockOrder }) => ({
+ *     blocks: {
+ *       ...defaultBlocks,
+ *       header: {
+ *         ...header,
+ *         props: {
+ *           ...header.props,
+ *           label: "Custom Label"
+ *         }
+ *       },
+ *       subheader: <CustomComponent />
+ *     },
+ *     blockOrder: ["header", "subheader", "body", "footer"]
+ *   })}
+ * </Block>
+ */
+type BlocksOverride<DefaultBlocks, CustomBlocks> = (({ defaultBlocks, defaultBlockOrder, }: {
+    defaultBlocks: DefaultBlocks;
+    defaultBlockOrder: readonly (keyof DefaultBlocks)[];
+}) => {
+    blocks: Partial<DefaultBlocks> & CustomBlocks;
+    blockOrder: readonly (keyof DefaultBlocks)[] | readonly (keyof CustomBlocks)[];
+}) | ReactNode;
+
+interface BaseTableTab<TValue extends string | number = string> {
+    label: ReactNode;
+    value: TValue;
+    disabled?: boolean;
+}
+type BaseTableColumnContext<TRow, K extends keyof TRow> = {
+    row: TRow;
+    rowIndex: number;
+    column: BaseTableColumnByField<TRow, K>;
+};
+type ResponsivePin<T extends 'left' | 'right' = 'left' | 'right'> = T | Partial<Record<Breakpoint, T | null>>;
+type BaseTableColumnByField<TRow, K extends keyof TRow> = {
+    field: K;
+    headLabel: ReactNode;
+    align?: TableCellProps['align'];
+    width?: number;
+    pin?: ResponsivePin;
+    valueFormatter?: (value: TRow[K], context: BaseTableColumnContext<TRow, K>) => unknown;
+    renderCell?: (value: TRow[K], context: BaseTableColumnContext<TRow, K>) => ReactNode;
+};
+type BaseTableColumn<TRow> = {
+    [K in keyof TRow]-?: BaseTableColumnByField<TRow, K>;
+}[keyof TRow];
+interface BaseTableRowAction<TRow> {
+    label: ReactNode;
+    icon?: ReactNode;
+    onClick: (row: TRow) => void;
+    disabled?: boolean;
+}
+interface BaseTablePaginationProps {
+    page: number;
+    pageSize: number;
+    total: number;
+    onPageChange: (page: number) => void;
+}
+interface BaseTableNoRowsOverlay {
+    icon?: ReactNode;
+    title: ReactNode;
+    description?: ReactNode;
+    action?: {
+        icon?: ReactNode;
+        label: ReactNode;
+        onClick: () => void;
+        disabled?: boolean;
+    };
+}
+interface BaseTableActionColumn {
+    pin?: ResponsivePin<'right'>;
+}
+interface BaseTableSearchChip {
+    key: string;
+    label: ReactNode;
+}
+type BaseTableContextValue<TRow extends Record<string, unknown> = Record<string, unknown>, TTabValue extends string | number = string, TBaseTableColumn extends BaseTableColumn<TRow> = BaseTableColumn<TRow>> = {
+    isLoading?: boolean;
+    headerTitle?: ReactNode;
+    headerActions?: ReactNode;
+    searchChipsTitle?: ReactNode;
+    searchChips?: BaseTableSearchChip[];
+    onSearchChipDelete?: (chip: BaseTableSearchChip, index: number, event: SyntheticEvent) => void;
+    tabs?: BaseTableTab<TTabValue>[];
+    activeTab?: TTabValue;
+    onTabChange?: (tab: TTabValue) => void;
+    columns: TBaseTableColumn[];
+    rows: TRow[];
+    actionColumn?: BaseTableActionColumn;
+    rowActions?: (row: TRow) => BaseTableRowAction<TRow>[];
+    pagination?: BaseTablePaginationProps;
+    noRowsOverlay?: BaseTableNoRowsOverlay;
+    onRowClick?: (row: TRow) => void;
+    getRowId?: (row: TRow, rowIndex: number) => string | number;
+};
+type BaseTableProps<TRow extends Record<string, unknown>, TTabValue extends string | number = string> = Omit<ComponentProps<typeof Stack>, 'children'> & BaseTableContextValue<TRow, TTabValue>;
+
+type RowMenuOpenHandler<TRow> = (event: MouseEvent<HTMLElement>, row: TRow) => void;
+type BaseTablePinnedShadowState = {
+    left: boolean;
+    right: boolean;
+};
+type BaseTableColumnPinMeta = {
+    pin?: 'left' | 'right';
+    left?: number;
+    right?: number;
+    isLeftBoundary?: boolean;
+    isRightBoundary?: boolean;
+    showBoundaryShadow?: boolean;
+};
+/**
+ * Renders the table title area from explicit children or root context.
+ */
+declare const BaseTableHeaderTitle: <TRow extends Record<string, unknown>, TTabValue extends string | number = string>(props: Partial<TypographyProps>) => react_jsx_runtime.JSX.Element | null;
+/**
+ * Renders the right-aligned header action slot from explicit children or root context.
+ */
+declare const BaseTableHeaderActions: <TRow extends Record<string, unknown>, TTabValue extends string | number = string>(props: Partial<Omit<StackProps, "direction">>) => react_jsx_runtime.JSX.Element | null;
+declare const defaultHeaderBlocks: {
+    title: ReactElement<Partial<TypographyProps>, <TRow extends Record<string, unknown>, TTabValue extends string | number = string>(props: Partial<TypographyProps>) => react_jsx_runtime.JSX.Element | null>;
+    actions: ReactElement<Partial<Omit<StackProps, "direction">>, <TRow extends Record<string, unknown>, TTabValue extends string | number = string>(props: Partial<Omit<StackProps, "direction">>) => react_jsx_runtime.JSX.Element | null>;
+};
+/**
+ * Composes the header title and action blocks at the top of the table layout.
+ */
+declare const BaseTableHeader: <TRow extends Record<string, unknown>, TTabValue extends string | number = string, CustomBlocks extends Record<string, ReactNode> = {}>(props: Partial<Omit<StackProps, "children">> & {
+    children?: BlocksOverride<typeof defaultHeaderBlocks, CustomBlocks>;
+}) => react_jsx_runtime.JSX.Element | null;
+/**
+ * Renders the loading placeholder shown while table data is pending.
+ */
+declare const BaseTableContentLoader: <TRow extends Record<string, unknown>, TTabValue extends string | number = string>(props: Partial<StackProps>) => react_jsx_runtime.JSX.Element;
+/**
+ * Renders the tab strip and forwards tab changes through root context when needed.
+ */
+declare const BaseTableTabs: <TRow extends Record<string, unknown>, TTabValue extends string | number = string>(props: Partial<TabsProps> & {
+    tabProps?: Partial<Omit<TabProps, "label" | "value" | "disabled">>;
+}) => react_jsx_runtime.JSX.Element | null;
+/**
+ * Renders the selected search chips section from explicit props or root context.
+ */
+declare const BaseTableSearchChips: <TRow extends Record<string, unknown>, TTabValue extends string | number = string>(props: Partial<Omit<ComponentProps<typeof Stack>, "children"> & Pick<BaseTableContextValue<TRow, TTabValue>, "searchChipsTitle" | "searchChips" | "onSearchChipDelete"> & {
+    children?: ReactNode;
+}>) => react_jsx_runtime.JSX.Element | null;
+type BaseTableContentGridHeadCellProps<TRow extends Record<string, unknown>> = Partial<TableCellProps> & {
+    column: BaseTableColumnByField<TRow, keyof TRow>;
+    pinMeta?: BaseTableColumnPinMeta;
+    labelProps?: Partial<TypographyProps> | undefined;
+    children?: ReactNode;
+};
+/**
+ * Renders one head cell, including pinned-column styling and label fallback.
+ */
+declare const BaseTableContentGridHeadCell: <TRow extends Record<string, unknown>>(props: BaseTableContentGridHeadCellProps<TRow>) => react_jsx_runtime.JSX.Element;
+type BaseTableContentGridBodyCellProps<TRow extends Record<string, unknown>> = Partial<TableCellProps> & {
+    column: BaseTableColumnByField<TRow, keyof TRow>;
+    pinMeta?: BaseTableColumnPinMeta;
+    row: TRow;
+    rowIndex: number;
+};
+/**
+ * Renders one body cell from row data, formatter output, and pinned-column styles.
+ */
+declare const BaseTableContentGridBodyCell: <TRow extends Record<string, unknown>>(props: BaseTableContentGridBodyCellProps<TRow>) => react_jsx_runtime.JSX.Element;
+type BaseTableContentGridHeadActionCellProps = Partial<TableCellProps> & {
+    pinMeta?: BaseTableColumnPinMeta;
+};
+/**
+ * Renders the head-side action column cell shell.
+ */
+declare const BaseTableContentGridHeadActionCell: (props: BaseTableContentGridHeadActionCellProps) => react_jsx_runtime.JSX.Element;
+type BaseTableContentGridBodyActionCellProps<TRow extends Record<string, unknown>> = Partial<TableCellProps> & {
+    row: TRow;
+    showActionMenu: boolean;
+    pinMeta?: BaseTableColumnPinMeta;
+    iconButtonProps?: Partial<IconButtonProps> | undefined;
+    icon?: ReactNode;
+    onOpenRowMenu?: RowMenuOpenHandler<TRow> | undefined;
+};
+/**
+ * Renders the body-side action trigger cell and opens the row menu when enabled.
+ */
+declare const BaseTableContentGridBodyActionCell: <TRow extends Record<string, unknown>>(props: BaseTableContentGridBodyActionCellProps<TRow>) => react_jsx_runtime.JSX.Element;
+type BaseTableContentGridHeadCellRenderArgs<TRow extends Record<string, unknown>> = Pick<ComponentProps<typeof BaseTableContentGridHeadCell<TRow>>, 'column' | 'pinMeta'> & {
+    columnIndex: number;
+};
+type BaseTableContentGridHeadActionCellRenderArgs<TRow extends Record<string, unknown>> = {
+    rowActions?: BaseTableContextValue<TRow>['rowActions'];
+    actionColumnPinMeta?: BaseTableContentGridHeadActionCellProps['pinMeta'];
+};
+type BaseTableContentGridBodyCellRenderArgs<TRow extends Record<string, unknown>> = Pick<ComponentProps<typeof BaseTableContentGridBodyCell<TRow>>, 'column' | 'pinMeta' | 'row' | 'rowIndex'> & {
+    columnIndex: number;
+};
+type BaseTableContentGridBodyActionCellRenderArgs<TRow extends Record<string, unknown>> = Pick<ComponentProps<typeof BaseTableContentGridBodyActionCell<TRow>>, 'row' | 'showActionMenu' | 'onOpenRowMenu'> & {
+    rowIndex: number;
+    actionColumnPinMeta?: BaseTableContentGridBodyActionCellProps<TRow>['pinMeta'];
+};
+declare const defaultContentGridHeadRowBlocks: {
+    cell: ReactElement<Partial<TableCellProps> & {
+        column: BaseTableColumnByField<Record<string, unknown>, string>;
+        pinMeta?: BaseTableColumnPinMeta;
+        labelProps?: Partial<TypographyProps> | undefined;
+        children?: ReactNode;
+    }, <TRow extends Record<string, unknown>>(props: BaseTableContentGridHeadCellProps<TRow>) => react_jsx_runtime.JSX.Element>;
+    actionCell: ReactElement<Partial<TableCellProps> & {
+        pinMeta?: BaseTableColumnPinMeta;
+    }, (props: BaseTableContentGridHeadActionCellProps) => react_jsx_runtime.JSX.Element>;
+};
+type BaseTableContentGridHeadRowProps<TRow extends Record<string, unknown>, CustomBlocks extends Record<string, ReactNode> = {}> = Partial<Omit<TableRowProps, 'children'>> & {
+    columns: BaseTableContextValue<TRow>['columns'];
+    rowActions?: ((row: TRow) => BaseTableRowAction<TRow>[]) | undefined;
+    headCell?: ReactNode | ((args: BaseTableContentGridHeadCellRenderArgs<TRow>) => ReactNode);
+    actionHeadCell?: ReactNode | ((args: BaseTableContentGridHeadActionCellRenderArgs<TRow>) => ReactNode);
+    columnPinMeta?: BaseTableColumnPinMeta[];
+    actionColumnPinMeta?: BaseTableColumnPinMeta;
+    children?: BlocksOverride<typeof defaultContentGridHeadRowBlocks, CustomBlocks>;
+};
+/**
+ * Renders the head row and resolves head cell overrides for each column.
+ */
+declare const BaseTableContentGridHeadRow: <TRow extends Record<string, unknown>>(props: BaseTableContentGridHeadRowProps<TRow>) => react_jsx_runtime.JSX.Element;
+declare const defaultBodyRowBlocks: {
+    cell: ReactElement<Partial<TableCellProps> & {
+        column: BaseTableColumnByField<Record<string, unknown>, string>;
+        pinMeta?: BaseTableColumnPinMeta;
+        row: Record<string, unknown>;
+        rowIndex: number;
+    }, <TRow extends Record<string, unknown>>(props: BaseTableContentGridBodyCellProps<TRow>) => react_jsx_runtime.JSX.Element>;
+    actionCell: ReactElement<Partial<TableCellProps> & {
+        row: Record<string, unknown>;
+        showActionMenu: boolean;
+        pinMeta?: BaseTableColumnPinMeta;
+        iconButtonProps?: Partial<IconButtonProps> | undefined;
+        icon?: ReactNode;
+        onOpenRowMenu?: RowMenuOpenHandler<Record<string, unknown>> | undefined;
+    }, <TRow extends Record<string, unknown>>(props: BaseTableContentGridBodyActionCellProps<TRow>) => react_jsx_runtime.JSX.Element>;
+};
+type BaseTableContentGridBodyRowProps<TRow extends Record<string, unknown>, CustomBlocks extends Record<string, ReactNode> = {}> = {
+    row: TRow;
+    rowIndex: number;
+    columns: BaseTableContextValue<TRow>['columns'];
+    rowActions?: ((row: TRow) => BaseTableRowAction<TRow>[]) | undefined;
+    onRowClick?: ((row: TRow) => void) | undefined;
+    onOpenRowMenu?: RowMenuOpenHandler<TRow> | undefined;
+    bodyCell?: ReactNode | ((args: BaseTableContentGridBodyCellRenderArgs<TRow>) => ReactNode);
+    actionBodyCell?: ReactNode | ((args: BaseTableContentGridBodyActionCellRenderArgs<TRow>) => ReactNode);
+    columnPinMeta?: BaseTableColumnPinMeta[];
+    actionColumnPinMeta?: BaseTableColumnPinMeta;
+    children?: BlocksOverride<typeof defaultBodyRowBlocks, CustomBlocks>;
+} & Partial<Omit<TableRowProps, 'children'>>;
+/**
+ * Renders one body row, including hover behavior and per-row action visibility.
+ */
+declare const BaseTableContentGridBodyRow: <TRow extends Record<string, unknown>>(props: BaseTableContentGridBodyRowProps<TRow>) => react_jsx_runtime.JSX.Element;
+declare const defaultContentGridHeadBlocks: {
+    row: ReactElement<Partial<Omit<TableRowProps, "children">> & {
+        columns: BaseTableColumnByField<Record<string, unknown>, string>[];
+        rowActions?: ((row: Record<string, unknown>) => BaseTableRowAction<Record<string, unknown>>[]) | undefined;
+        headCell?: ReactNode | ((args: BaseTableContentGridHeadCellRenderArgs<Record<string, unknown>>) => ReactNode);
+        actionHeadCell?: ReactNode | ((args: BaseTableContentGridHeadActionCellRenderArgs<Record<string, unknown>>) => ReactNode);
+        columnPinMeta?: BaseTableColumnPinMeta[];
+        actionColumnPinMeta?: BaseTableColumnPinMeta;
+        children?: BlocksOverride<{
+            cell: ReactElement<Partial<TableCellProps> & {
+                column: BaseTableColumnByField<Record<string, unknown>, string>;
+                pinMeta?: BaseTableColumnPinMeta;
+                labelProps?: Partial<TypographyProps> | undefined;
+                children?: ReactNode;
+            }, <TRow extends Record<string, unknown>>(props: BaseTableContentGridHeadCellProps<TRow>) => react_jsx_runtime.JSX.Element>;
+            actionCell: ReactElement<Partial<TableCellProps> & {
+                pinMeta?: BaseTableColumnPinMeta;
+            }, (props: BaseTableContentGridHeadActionCellProps) => react_jsx_runtime.JSX.Element>;
+        }, {}>;
+    }, <TRow extends Record<string, unknown>>(props: BaseTableContentGridHeadRowProps<TRow>) => react_jsx_runtime.JSX.Element>;
+};
+type BaseTableContentGridHeadRowRenderArgs<TRow extends Record<string, unknown>> = Pick<ComponentProps<typeof BaseTableContentGridHeadRow<TRow>>, 'columns' | 'rowActions' | 'columnPinMeta' | 'actionColumnPinMeta'>;
+type BaseTableContentGridHeadProps<TRow extends Record<string, unknown>, CustomBlocks extends Record<string, ReactNode> = {}> = Partial<Omit<TableHeadProps, 'children'>> & {
+    columns: BaseTableContextValue<TRow>['columns'];
+    rowActions?: ((row: TRow) => BaseTableRowAction<TRow>[]) | undefined;
+    headRow?: ReactNode | ((args: BaseTableContentGridHeadRowRenderArgs<TRow>) => ReactNode);
+    headCell?: BaseTableContentGridHeadRowProps<TRow>['headCell'];
+    actionHeadCell?: BaseTableContentGridHeadRowProps<TRow>['actionHeadCell'];
+    columnPinMeta?: BaseTableColumnPinMeta[];
+    actionColumnPinMeta?: BaseTableColumnPinMeta;
+    children?: BlocksOverride<typeof defaultContentGridHeadBlocks, CustomBlocks>;
+};
+/**
+ * Renders the table head section and delegates row composition to the head row block.
+ */
+declare const BaseTableContentGridHead: <TRow extends Record<string, unknown>>(props: BaseTableContentGridHeadProps<TRow>) => react_jsx_runtime.JSX.Element;
+declare const defaultGridBodyBlocks: {
+    row: ReactElement<{
+        row: Record<string, unknown>;
+        rowIndex: number;
+        columns: BaseTableColumnByField<Record<string, unknown>, string>[];
+        rowActions?: ((row: Record<string, unknown>) => BaseTableRowAction<Record<string, unknown>>[]) | undefined;
+        onRowClick?: ((row: Record<string, unknown>) => void) | undefined;
+        onOpenRowMenu?: RowMenuOpenHandler<Record<string, unknown>> | undefined;
+        bodyCell?: ReactNode | ((args: BaseTableContentGridBodyCellRenderArgs<Record<string, unknown>>) => ReactNode);
+        actionBodyCell?: ReactNode | ((args: BaseTableContentGridBodyActionCellRenderArgs<Record<string, unknown>>) => ReactNode);
+        columnPinMeta?: BaseTableColumnPinMeta[];
+        actionColumnPinMeta?: BaseTableColumnPinMeta;
+        children?: BlocksOverride<{
+            cell: ReactElement<Partial<TableCellProps> & {
+                column: BaseTableColumnByField<Record<string, unknown>, string>;
+                pinMeta?: BaseTableColumnPinMeta;
+                row: Record<string, unknown>;
+                rowIndex: number;
+            }, <TRow extends Record<string, unknown>>(props: BaseTableContentGridBodyCellProps<TRow>) => react_jsx_runtime.JSX.Element>;
+            actionCell: ReactElement<Partial<TableCellProps> & {
+                row: Record<string, unknown>;
+                showActionMenu: boolean;
+                pinMeta?: BaseTableColumnPinMeta;
+                iconButtonProps?: Partial<IconButtonProps> | undefined;
+                icon?: ReactNode;
+                onOpenRowMenu?: RowMenuOpenHandler<Record<string, unknown>> | undefined;
+            }, <TRow extends Record<string, unknown>>(props: BaseTableContentGridBodyActionCellProps<TRow>) => react_jsx_runtime.JSX.Element>;
+        }, {}>;
+    } & Partial<Omit<TableRowProps, "children">>, <TRow extends Record<string, unknown>>(props: BaseTableContentGridBodyRowProps<TRow>) => react_jsx_runtime.JSX.Element>;
+};
+type BaseTableContentGridBodyRowRenderArgs<TRow extends Record<string, unknown>> = Pick<ComponentProps<typeof BaseTableContentGridBodyRow<TRow>>, 'row' | 'rowIndex' | 'columns' | 'rowActions' | 'onRowClick' | 'onOpenRowMenu' | 'columnPinMeta' | 'actionColumnPinMeta'>;
+type BaseTableContentGridBodyProps<TRow extends Record<string, unknown>, CustomBlocks extends Record<string, ReactNode> = {}> = Partial<Omit<TableBodyProps, 'children'>> & {
+    columns: BaseTableContextValue<TRow>['columns'];
+    rows: TRow[];
+    rowActions?: ((row: TRow) => BaseTableRowAction<TRow>[]) | undefined;
+    onRowClick?: ((row: TRow) => void) | undefined;
+    getRowId?: ((row: TRow, rowIndex: number) => string | number) | undefined;
+    onOpenRowMenu?: RowMenuOpenHandler<TRow> | undefined;
+    bodyRow?: ReactNode | ((args: BaseTableContentGridBodyRowRenderArgs<TRow>) => ReactNode);
+    bodyCell?: BaseTableContentGridBodyRowProps<TRow>['bodyCell'];
+    actionBodyCell?: BaseTableContentGridBodyRowProps<TRow>['actionBodyCell'];
+    columnPinMeta?: BaseTableColumnPinMeta[];
+    actionColumnPinMeta?: BaseTableColumnPinMeta;
+    children?: BlocksOverride<typeof defaultGridBodyBlocks, CustomBlocks>;
+};
+/**
+ * Renders the table body section and resolves row-level overrides for each record.
+ */
+declare const BaseTableContentGridBody: <TRow extends Record<string, unknown>>(props: BaseTableContentGridBodyProps<TRow>) => react_jsx_runtime.JSX.Element;
+type BaseTableContentGridRowMenuProps<TRow extends Record<string, unknown>> = Partial<Omit<MenuProps, 'anchorEl' | 'open' | 'onClose'>> & {
+    menuAnchorEl: HTMLElement | null;
+    menuRow: TRow | null;
+    menuActions: BaseTableRowAction<TRow>[];
+    onClose: () => void;
+};
+/**
+ * Renders the contextual row action menu anchored to the current trigger element.
+ */
+declare const BaseTableContentGridRowMenu: <TRow extends Record<string, unknown>>(props: BaseTableContentGridRowMenuProps<TRow>) => react_jsx_runtime.JSX.Element;
+/**
+ * Renders the no-results fallback panel when the table has no rows to show.
+ */
+declare const BaseTableContentEmptyState: <TRow extends Record<string, unknown>, TTabValue extends string | number = string>(props: Partial<ComponentProps<typeof Box> & Pick<BaseTableContextValue<TRow, TTabValue>, "noRowsOverlay">>) => react_jsx_runtime.JSX.Element;
+type BaseTableContentGridTableProps = Partial<Omit<ComponentProps<typeof TableContainer>, 'children'>> & {
+    children?: ReactNode;
+    tableProps?: Partial<TableProps>;
+    onPinnedShadowChange?: (state: BaseTablePinnedShadowState) => void;
+    onHorizontalOverflowChange?: (overflow: boolean) => void;
+    showLeftPinnedShadow?: boolean;
+    showRightPinnedShadow?: boolean;
+};
+/**
+ * Wraps the scrollable table container and reports pinned shadow visibility state.
+ */
+declare const BaseTableContentGridTable: (props: BaseTableContentGridTableProps) => react_jsx_runtime.JSX.Element;
+declare const defaultGridBlocks: {
+    table: ReactElement<ComponentProps<typeof BaseTableContentGridTable>>;
+    head: ReactElement<ComponentProps<typeof BaseTableContentGridHead>>;
+    body: ReactElement<ComponentProps<typeof BaseTableContentGridBody>>;
+    rowMenu: ReactElement<ComponentProps<typeof BaseTableContentGridRowMenu>>;
+    emptyState: ReactElement<ComponentProps<typeof BaseTableContentEmptyState>>;
+};
+type BaseTableContentGridProps<TRow extends Record<string, unknown>, TTabValue extends string | number = string, CustomBlocks extends Record<string, ReactNode> = {}> = Partial<Omit<ComponentProps<typeof Stack>, 'children'> & Pick<BaseTableContextValue<TRow, TTabValue>, 'columns' | 'rows' | 'actionColumn' | 'rowActions' | 'noRowsOverlay' | 'onRowClick' | 'getRowId'> & {
+    emptyState?: ReactNode;
+    head?: ReactNode | ((args: Omit<ComponentProps<typeof BaseTable.Content.Grid.Head<TRow>>, 'children'>) => ReactNode);
+    body?: ReactNode | ((args: Omit<SetRequired<ComponentProps<typeof BaseTable.Content.Grid.Body<TRow>>, 'onOpenRowMenu'>, 'children'>) => ReactNode);
+    rowMenu?: ReactNode | ((args: Omit<ComponentProps<typeof BaseTableContentGridRowMenu<TRow>>, 'children'>) => ReactNode);
+    headRow?: BaseTableContentGridHeadProps<TRow>['headRow'];
+    headCell?: BaseTableContentGridHeadProps<TRow>['headCell'];
+    actionHeadCell?: BaseTableContentGridHeadProps<TRow>['actionHeadCell'];
+    bodyRow?: BaseTableContentGridBodyProps<TRow>['bodyRow'];
+    bodyCell?: BaseTableContentGridBodyProps<TRow>['bodyCell'];
+    actionBodyCell?: BaseTableContentGridBodyProps<TRow>['actionBodyCell'];
+    children?: BlocksOverride<typeof defaultGridBlocks, CustomBlocks>;
+}>;
+/**
+ * Coordinates the grid table, head, body, row menu, and empty-state blocks.
+ */
+declare const BaseTableContentGrid: <TRow extends Record<string, unknown>, TTabValue extends string | number = string>(props: BaseTableContentGridProps<TRow, TTabValue>) => react_jsx_runtime.JSX.Element;
+declare const defaultContentBlocks: {
+    loader: ReactElement<ComponentProps<typeof BaseTableContentLoader>>;
+    emptyState: ReactElement<ComponentProps<typeof BaseTableContentEmptyState>>;
+    grid: ReactElement<ComponentProps<typeof BaseTableContentGrid>>;
+};
+/**
+ * Chooses between the loader, empty-state, and grid branches for the content area.
+ */
+declare const BaseTableContent: <TRow extends Record<string, unknown>, TTabValue extends string | number = string, CustomBlocks extends Record<string, ReactNode> = {}>(props: Partial<Omit<ComponentProps<typeof Box>, "children"> & Pick<BaseTableContextValue<TRow, TTabValue>, "isLoading" | "rows"> & {
+    children?: BlocksOverride<typeof defaultContentBlocks, CustomBlocks>;
+}>) => react_jsx_runtime.JSX.Element;
+/**
+ * Renders pagination controls only when rows exist and loading is complete.
+ */
+declare const BaseTablePagination: <TRow extends Record<string, unknown>, TTabValue extends string | number = string>(props: Partial<ComponentProps<typeof Stack> & Pick<BaseTableContextValue<TRow, TTabValue>, "pagination" | "rows" | "isLoading">>) => react_jsx_runtime.JSX.Element | null;
+declare const defaultBlocks: {
+    header: ReactElement<ComponentProps<typeof BaseTableHeader>>;
+    tabs: ReactElement<ComponentProps<typeof BaseTableTabs>>;
+    searchChips: ReactElement<ComponentProps<typeof BaseTableSearchChips>>;
+    content: ReactElement<ComponentProps<typeof BaseTableContent>>;
+    pagination: ReactElement<ComponentProps<typeof BaseTablePagination>>;
+};
+type BaseTableWithChildrenProps<TRow extends Record<string, unknown>, TTabValue extends string | number, CustomBlocks extends Record<string, ReactNode>> = BaseTableProps<TRow, TTabValue> & {
+    children?: BlocksOverride<typeof defaultBlocks, CustomBlocks>;
+};
+type BaseTableComponent = {
+    <TRow extends Record<string, unknown>, TTabValue extends string | number = string, CustomBlocks extends Record<string, ReactNode> = {}>(props: BaseTableWithChildrenProps<TRow, TTabValue, CustomBlocks>): ReactNode;
+    Header: typeof BaseTableHeader & {
+        Title: typeof BaseTableHeaderTitle;
+        Actions: typeof BaseTableHeaderActions;
+    };
+    Tabs: typeof BaseTableTabs;
+    SearchChips: typeof BaseTableSearchChips;
+    Content: typeof BaseTableContent & {
+        Loader: typeof BaseTableContentLoader;
+        EmptyState: typeof BaseTableContentEmptyState;
+        Grid: typeof BaseTableContentGrid & {
+            Table: typeof BaseTableContentGridTable;
+            Head: typeof BaseTableContentGridHead & {
+                Row: typeof BaseTableContentGridHeadRow;
+                Cell: typeof BaseTableContentGridHeadCell;
+                ActionCell: typeof BaseTableContentGridHeadActionCell;
+            };
+            Body: typeof BaseTableContentGridBody & {
+                Row: typeof BaseTableContentGridBodyRow;
+                Cell: typeof BaseTableContentGridBodyCell;
+                ActionCell: typeof BaseTableContentGridBodyActionCell;
+            };
+            RowMenu: typeof BaseTableContentGridRowMenu;
+        };
+    };
+    Pagination: typeof BaseTablePagination;
+};
+declare const BaseTable: BaseTableComponent;
+
+interface ListOrganizationsRowData extends Record<string, unknown> {
+    id: string;
+    createdAt: string;
+    name: string;
+    joinDate: string;
+    status: string;
+}
+type ListOrganizationsRowActionType = 'activate' | 'deactivate';
+type ListOrganizationsStatusMatch = {
+    active: string;
+    inactive: string;
+};
+type TabData = {
+    key: string;
+    label: string;
+    isDisabled?: boolean;
+    subtitle?: string;
+};
+interface PaginationProps {
+    /** Custom class to give the html component */
+    className?: string;
+    /** Currently selected page in the pagination. Pages are counted from 1. */
+    currentPage: number;
+    /** Callback when the page is changed */
+    onPageChange: (page: number) => void;
+    /** Total number of pages in the pagination. */
+    totalPages: number;
+}
+type ListOrganizationsLabels = {
+    emptyStateMessage: string;
+    searchFieldPlaceholder: string;
+    rowActions?: {
+        activate: string;
+        deactivate: string;
+    };
+    headerRow: {
+        createdAt: string;
+        name: string;
+        joinDate: string;
+        status: string;
+    };
+    cellData: {
+        statusActive: string;
+        statusInactive: string;
+    };
+};
+type ListOrganizationsValue<TTabs extends TabData[] = TabData[]> = {
+    isLoading?: boolean;
+    labels: ListOrganizationsLabels;
+    searchValue?: string;
+    onSearchFieldChange?: (value: string) => void;
+    onSearchSubmit?: () => void;
+    onNavigate?: (to: string) => void;
+    onItemActivate?: (rowId: ListOrganizationsRowData['id']) => void;
+    onItemDeactivate?: (rowId: ListOrganizationsRowData['id']) => void;
+    shouldShowDropdownMenu?: (row: ListOrganizationsRowData) => boolean;
+    resolveRowAction?: (row: ListOrganizationsRowData) => ListOrganizationsRowActionType[] | undefined;
+    statusMatch?: ListOrganizationsStatusMatch;
+    pagination?: PaginationProps;
+    data: ListOrganizationsRowData[];
+    rowHref?: (row: ListOrganizationsRowData) => string;
+    tabs?: TTabs;
+    currentTab?: TTabs[number]['key'];
+    onTabChange?: (tab: TTabs[number]['key']) => void;
+    searchChipsTitle?: ReactNode;
+    searchChips?: BaseTableSearchChip[];
+    onSearchChipDelete?: (chip: BaseTableSearchChip, index: number, event: SyntheticEvent) => void;
+    listOrganizationsTitle: ReactNode;
+    columns?: BaseTableColumn<ListOrganizationsRowData>[];
+    rowActions?: (row: ListOrganizationsRowData) => BaseTableRowAction<ListOrganizationsRowData>[];
+    actionColumn?: BaseTableActionColumn;
+    onRowClick?: (row: ListOrganizationsRowData) => void;
+};
+type ListOrganizationsDefaultBlocks = {
+    title: ReactNode;
+    action: ReactNode;
+    header: ReactNode;
+    loader: ReactNode;
+    content: ReactNode;
+    tabs: ReactNode;
+    searchChips: ReactNode;
+    table: ReactNode;
+    pagination: ReactNode;
+};
+type ListOrganizationsRootPassthroughProps = Omit<StackProps, 'children'>;
+type ListOrganizationsProps<TTabs extends TabData[] = TabData[], CustomBlocks extends Record<string, ReactNode> = {}> = ListOrganizationsRootPassthroughProps & Required<Pick<ListOrganizationsValue<TTabs>, 'labels' | 'data' | 'listOrganizationsTitle'>> & Partial<Pick<ListOrganizationsValue<TTabs>, 'isLoading' | 'searchValue' | 'onSearchFieldChange' | 'onSearchSubmit' | 'onNavigate' | 'onItemActivate' | 'onItemDeactivate' | 'shouldShowDropdownMenu' | 'resolveRowAction' | 'statusMatch' | 'pagination' | 'rowHref' | 'tabs' | 'currentTab' | 'onTabChange' | 'searchChipsTitle' | 'searchChips' | 'onSearchChipDelete'>> & {
+    children?: BlocksOverride<ListOrganizationsDefaultBlocks, CustomBlocks>;
+};
+type ListOrganizationsTitleProps = ComponentProps<typeof BaseTable.Header.Title> & {
+    listOrganizationsTitle?: ReactNode;
+};
+type ListOrganizationsHeaderProps = ComponentProps<typeof BaseTable.Header>;
+type ListOrganizationsActionProps = ComponentProps<typeof BaseTable.Header.Actions> & Partial<Pick<ListOrganizationsValue, 'labels' | 'searchValue' | 'onSearchFieldChange' | 'onSearchSubmit'>>;
+type ListOrganizationsLoaderProps = ComponentProps<typeof BaseTable.Content.Loader>;
+type ListOrganizationsContentProps = ComponentProps<typeof BaseTable.Content>;
+type ListOrganizationsTabsProps = ComponentProps<typeof BaseTable.Tabs<ListOrganizationsRowData>>;
+type ListOrganizationsBaseTableGridProps = ComponentProps<typeof BaseTable.Content.Grid<ListOrganizationsRowData>>;
+/**
+ * Props for `ListOrganizations.Table`. `rows` and `noRowsOverlay` are managed internally;
+ * pass `columns`, `rowActions`, `actionColumn`, or `onRowClick` to override the defaults
+ * derived from `labels`. When those props are omitted the component falls back to the
+ * `labels`-based auto-generated values.
+ */
+type ListOrganizationsTableProps = Omit<ListOrganizationsBaseTableGridProps, 'rows' | 'noRowsOverlay'> & Partial<Pick<ListOrganizationsValue, 'labels' | 'data' | 'onItemActivate' | 'onItemDeactivate' | 'shouldShowDropdownMenu' | 'resolveRowAction' | 'statusMatch' | 'rowHref' | 'onNavigate' | 'columns' | 'rowActions' | 'actionColumn' | 'onRowClick'>>;
+type ListOrganizationsPaginationProps = Partial<Omit<ComponentProps<typeof BaseTable.Pagination>, 'pagination' | 'rows' | 'isLoading'>> & Partial<Pick<ListOrganizationsValue, 'pagination' | 'data' | 'isLoading'>>;
+type ListOrganizationsSearchChipsProps = Partial<ComponentProps<typeof BaseTable.SearchChips>>;
+type ListOrganizationsComponent = {
+    <TTabs extends TabData[] = TabData[], CustomBlocks extends Record<string, ReactNode> = {}>(props: ListOrganizationsProps<TTabs, CustomBlocks>): ReactNode;
+    Title: (props: ListOrganizationsTitleProps) => ReactNode;
+    Action: (props: ListOrganizationsActionProps) => ReactNode;
+    Header: (props: ListOrganizationsHeaderProps) => ReactNode;
+    Loader: (props: ListOrganizationsLoaderProps) => ReactNode;
+    Content: (props: ListOrganizationsContentProps) => ReactNode;
+    Tabs: (props: ListOrganizationsTabsProps) => ReactNode;
+    SearchChips: (props: ListOrganizationsSearchChipsProps) => ReactNode;
+    Table: (props: ListOrganizationsTableProps) => ReactNode;
+    Pagination: (props: ListOrganizationsPaginationProps) => ReactNode;
+};
+declare const ListOrganizations: ListOrganizationsComponent;
+
+export { ListOrganizations };
+export type { BaseTableSearchChip, ListOrganizationsRowData };