@modufolio/panel 0.1.0

package/dist/Components/Table/TableEmptyState.vue.d.ts

@@ -0,0 +1,24 @@
+declare const __VLS_export: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    title: {
+        type: StringConstructor;
+        default: string;
+    };
+    description: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    title: {
+        type: StringConstructor;
+        default: string;
+    };
+    description: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{}>, {
+    title: string;
+    description: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/Components/Table/TablePagination.vue.d.ts

@@ -0,0 +1,71 @@
+import { PropType } from 'vue';
+declare const __VLS_export: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    currentPage: {
+        type: NumberConstructor;
+        required: true;
+    };
+    lastPage: {
+        type: NumberConstructor;
+        required: true;
+    };
+    total: {
+        type: NumberConstructor;
+        required: true;
+    };
+    perPage: {
+        type: NumberConstructor;
+        default: number;
+    };
+    from: {
+        type: NumberConstructor;
+        required: true;
+    };
+    to: {
+        type: NumberConstructor;
+        required: true;
+    };
+    perPageOptions: {
+        type: PropType<number[]>;
+        default: () => number[];
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    goto: (...args: any[]) => void;
+    "update:perPage": (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    currentPage: {
+        type: NumberConstructor;
+        required: true;
+    };
+    lastPage: {
+        type: NumberConstructor;
+        required: true;
+    };
+    total: {
+        type: NumberConstructor;
+        required: true;
+    };
+    perPage: {
+        type: NumberConstructor;
+        default: number;
+    };
+    from: {
+        type: NumberConstructor;
+        required: true;
+    };
+    to: {
+        type: NumberConstructor;
+        required: true;
+    };
+    perPageOptions: {
+        type: PropType<number[]>;
+        default: () => number[];
+    };
+}>> & Readonly<{
+    onGoto?: ((...args: any[]) => any) | undefined;
+    "onUpdate:perPage"?: ((...args: any[]) => any) | undefined;
+}>, {
+    perPage: number;
+    perPageOptions: number[];
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/Components/Table/TableSkeletonRows.vue.d.ts

@@ -0,0 +1,52 @@
+import { PropType } from 'vue';
+import { TableColumn } from './tableTypes';
+declare const __VLS_export: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    rows: {
+        type: NumberConstructor;
+        default: number;
+    };
+    columns: {
+        type: PropType<TableColumn[]>;
+        required: true;
+    };
+    expandable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    selectable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    hasActions: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    rows: {
+        type: NumberConstructor;
+        default: number;
+    };
+    columns: {
+        type: PropType<TableColumn[]>;
+        required: true;
+    };
+    expandable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    selectable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    hasActions: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{}>, {
+    rows: number;
+    expandable: boolean;
+    selectable: boolean;
+    hasActions: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/Components/Table/TableSortButton.vue.d.ts

@@ -0,0 +1,38 @@
+import { PropType } from 'vue';
+import { TableColumn } from './tableTypes';
+declare const __VLS_export: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    column: {
+        type: PropType<TableColumn>;
+        required: true;
+    };
+    sortColumn: {
+        type: StringConstructor;
+        default: null;
+    };
+    sortDirection: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    sort: (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    column: {
+        type: PropType<TableColumn>;
+        required: true;
+    };
+    sortColumn: {
+        type: StringConstructor;
+        default: null;
+    };
+    sortDirection: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{
+    onSort?: ((...args: any[]) => any) | undefined;
+}>, {
+    sortColumn: string;
+    sortDirection: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/Components/Table/TableToolbar.vue.d.ts

@@ -0,0 +1,62 @@
+declare var __VLS_1: {}, __VLS_3: {}, __VLS_5: {};
+type __VLS_Slots = {} & {
+    header?: (props: typeof __VLS_1) => any;
+} & {
+    filters?: (props: typeof __VLS_3) => any;
+} & {
+    headerActions?: (props: typeof __VLS_5) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    searchable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    search: {
+        type: StringConstructor;
+        default: string;
+    };
+    showTreeToggle: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    allTreeCollapsed: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:search": (...args: any[]) => void;
+    toggleTree: (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    searchable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    search: {
+        type: StringConstructor;
+        default: string;
+    };
+    showTreeToggle: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    allTreeCollapsed: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{
+    "onUpdate:search"?: ((...args: any[]) => any) | undefined;
+    onToggleTree?: ((...args: any[]) => any) | undefined;
+}>, {
+    search: string;
+    searchable: boolean;
+    showTreeToggle: boolean;
+    allTreeCollapsed: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/Components/Table/schemaLinks.d.ts

@@ -0,0 +1,16 @@
+import { SchemaColumn } from './tableSchema';
+/**
+ * The cell's displayed value, honouring `valueKey` so a column can render a
+ * nested field while staying keyed on its own name.
+ *
+ * Resolved here rather than using Table.vue's `value` slot prop, which always
+ * reads the bare column key — that returns the relation object, not its name.
+ */
+export declare function cellValue(column: SchemaColumn, record: Record<string, any>): unknown;
+/** Where a cell links to, or null when it renders as plain content. */
+export declare function cellLink(column: SchemaColumn, record: Record<string, any>, recordUrl: string | null | undefined): string | null;
+/**
+ * A drill-down into a *related* record gets the accented style with an arrow;
+ * a link to the row's own drawer stays muted and inline.
+ */
+export declare function cellLinkProps(column: SchemaColumn, record: Record<string, any>, recordUrl: string | null | undefined, queryParams: Record<string, any>): Record<string, any>;

package/dist/Components/Table/tableSchema.d.ts

@@ -0,0 +1,243 @@
+/**
+ * Client-side shape of a server-authored table schema.
+ *
+ * Mirrors App\Table\TableSchema / App\Table\Column. Declared in a .ts file
+ * rather than inside the SFC so pages can import the types (`<script setup>`
+ * cannot export type declarations).
+ */
+export type SchemaColumnType = 'text' | 'select' | 'money' | 'numeric' | 'badge' | 'date' | 'boolean' | 'image' | 'icon' | 'color';
+/**
+ * An action button rendered inside every cell of a column.
+ *
+ * Mirrors App\Table\ColumnAction. Either navigates (`urlTemplate`) or calls the
+ * handler the page registered under `name` in `cellActionHandlers`.
+ */
+export interface SchemaColumnAction {
+    /** Key into the page's `cellActionHandlers` map. */
+    name: string;
+    /** Accessible name and tooltip. */
+    label: string;
+    icon?: string;
+    color?: string;
+    /** Render as a link. Dot-path placeholders, like `Column.urlTemplate`. */
+    urlTemplate?: string;
+    /** Render inert when this field on the row is truthy. */
+    disabledWhen?: string;
+    /** Omit entirely when this field on the row is truthy. */
+    hiddenWhen?: string;
+    confirm?: boolean;
+    confirmMessage?: string;
+}
+export interface SchemaColumn {
+    /** Field on the record, and the `#cell-{key}` slot name for overrides. */
+    key: string;
+    /** Duplicate of `key`; Table.vue reads either. */
+    name: string;
+    label: string;
+    type: SchemaColumnType | (string & {});
+    /** Resolved server-side against the list query — never declared by hand. */
+    sortable: boolean;
+    toggleable?: boolean;
+    hiddenByDefault?: boolean;
+    /** Link the cell to the record using the schema's `recordUrl`. */
+    linksToRecord?: boolean;
+    /** Read the displayed value from another field; dot-paths supported. */
+    valueKey?: string;
+    /** Per-column link target, overriding `recordUrl`. Dot-path placeholders. */
+    urlTemplate?: string;
+    /** Accented drill-down style with a trailing arrow. */
+    showArrow?: boolean;
+    /** Rendered when the row's value is null or empty. */
+    placeholder?: string;
+    /** Field holding a secondary line of text, computed by the presenter. */
+    descriptionKey?: string;
+    width?: string;
+    /** Date format, for `type: 'date'`. */
+    format?: string;
+    relative?: boolean;
+    /** Value → colour map, for `type: 'badge'` and read-only selects. */
+    colors?: Record<string, string>;
+    /** Choices for `type: 'select'`. */
+    options?: Array<{
+        label: string;
+        value: string;
+        class?: string;
+    }>;
+    /** Editable in place — the page supplies the save handler via `cellHandlers`. */
+    editable?: boolean;
+    /** Render the control inert when this field on the row is truthy. */
+    disabledWhen?: string;
+    /** Drop the control for a static badge when this field on the row is truthy. */
+    readOnlyWhen?: string;
+    /** Action buttons rendered inside every cell, after the value. */
+    actions?: SchemaColumnAction[];
+    /** Font emphasis: 'medium' | 'bold'. */
+    weight?: string;
+    /** Cell alignment: 'left' | 'center' | 'right'. */
+    align?: string;
+    /** Static text colour token. */
+    color?: string;
+    /** Registered icon name rendered before the value. */
+    icon?: string;
+    /** Truncate after N characters, keeping the full value in the title. */
+    limit?: number;
+    /** Offer click-to-copy on the cell. */
+    copyable?: boolean;
+    /** Thumbnail size, for `type: 'image'`: 'sm' | 'md' | 'lg' | 'xl'. */
+    size?: string;
+    /** Corner rounding, for `type: 'image'`: 'none' | 'sm' | 'md' | 'lg' | 'full'. */
+    rounded?: string;
+    /** ISO currency code, for `type: 'money'`. */
+    currency?: string;
+    /** Decimal places, for `type: 'numeric'`. */
+    decimals?: number;
+}
+/** Emphasis / alignment / colour → utility classes for a text cell. */
+export declare function cellClasses(column: SchemaColumn): string;
+/** Truncate for display; the untruncated value is kept as a title attribute. */
+export declare function truncate(value: string, limit?: number): string;
+/**
+ * Format a cell value for display.
+ *
+ * Kept client-side so re-sorting or a partial reload doesn't need the server
+ * to re-render text it already has.
+ */
+export declare function formatValue(column: SchemaColumn, value: unknown): string;
+export type SchemaFilterType = 'select' | 'multiSelect' | 'ternary' | 'trashed' | 'dateRange';
+export interface SchemaFilter {
+    /** Query-param name and the key its value lives under in the filter form. */
+    key: string;
+    type: SchemaFilterType | (string & {});
+    label: string;
+    placeholder?: string;
+    options?: Array<{
+        label: string;
+        value: string;
+    }>;
+    /**
+     * The server capped the option list — only sent when it did. The control
+     * shows this rather than ending the list silently, so a value that exists
+     * but is unreachable from the dropdown is never mistaken for absent.
+     */
+    optionsTruncated?: boolean;
+    trueLabel?: string;
+    falseLabel?: string;
+    trueValue?: string;
+    falseValue?: string;
+}
+export interface SchemaConstraintOperator {
+    value: string;
+    label: string;
+    /** Number of value inputs the operator needs: 0, 1 or 2. */
+    values: number;
+}
+export interface SchemaConstraint {
+    key: string;
+    type: 'text' | 'number' | 'boolean' | 'date' | (string & {});
+    label: string;
+    icon?: string;
+    operators: SchemaConstraintOperator[];
+}
+/** One user-composed condition. */
+export interface QueryCondition {
+    key: string;
+    operator: string;
+    value?: string;
+    value2?: string;
+}
+export interface TableSchema {
+    columns: SchemaColumn[];
+    filters?: SchemaFilter[];
+    /** Groupings the user can switch between, as select options. */
+    groups?: Array<{
+        value: string;
+        label: string;
+    }>;
+    /** Fields the user may build ad-hoc conditions against. */
+    constraints?: SchemaConstraint[];
+    /** URL template with an `{id}` placeholder, e.g. `/panel/organizations/{id}`. */
+    recordUrl?: string | null;
+    emptyStateTitle?: string | null;
+    emptyStateDescription?: string | null;
+    searchable?: boolean;
+    /** Row selection enabled — the checkbox column. */
+    bulkActions?: boolean;
+    /** Actions offered on each row; the page's `#actions` slot still wins. */
+    actions?: SchemaRowAction[];
+    /** Actions offered on a selection; the page's `#bulkActions` slot wins. */
+    bulkActionItems?: SchemaBulkAction[];
+    stickyHeader?: boolean;
+}
+/**
+ * Read a possibly-nested field, e.g. `getPath(row, 'organization.name')`.
+ *
+ * Returns undefined rather than throwing when any segment is missing, so a
+ * null relation renders the column's placeholder instead of blowing up.
+ */
+export declare function getPath(record: Record<string, any>, path: string): unknown;
+/**
+ * The cell actions that apply to one row, after `hiddenWhen` is resolved
+ * against it. Dot-paths are supported, matching every other field reference.
+ */
+/** One action offered on a row, from `schema.actions`. */
+export interface SchemaRowAction {
+    name: string;
+    /** 'drawer' | 'visit' | 'delete' | 'handler' — what the table does with it. */
+    behaviour: string;
+    label: string;
+    icon?: string;
+    color?: string;
+    urlTemplate?: string;
+    /** Where to ask what deleting would do; `delete` behaviour only. */
+    previewUrl?: string;
+    /** The delete is reversible, so the dialog must not say "cannot be undone". */
+    soft?: boolean;
+    hiddenWhen?: string;
+    visibleWhen?: string;
+    confirm?: boolean;
+    confirmMessage?: string;
+}
+/** One action offered on a selection, from `schema.bulkActionItems`. */
+export interface SchemaBulkAction {
+    name: string;
+    /** 'post' | 'handler'. */
+    behaviour: string;
+    label: string;
+    icon?: string;
+    color?: string;
+    variant?: string;
+    url?: string;
+    confirm?: boolean;
+    confirmMessage?: string;
+}
+/** The actions this row offers, after its own visibility fields are read. */
+export declare function visibleRowActions(actions: SchemaRowAction[] | undefined, record: Record<string, any>): SchemaRowAction[];
+export declare function visibleCellActions(column: SchemaColumn, record: Record<string, any>): SchemaColumnAction[];
+/**
+ * Fill a URL template from a record: `/panel/contacts/{id}/organization/{organization.id}`.
+ *
+ * Returns null when a placeholder cannot be resolved — a link containing a
+ * literal `{organization.id}` would 404, so no link is the better answer.
+ */
+export declare function resolveRecordUrl(template: string | null | undefined, record: Record<string, any>): string | null;
+/**
+ * Empty form value per filter type — the shape useListFilters needs so it can
+ * tell "unset" from "set", and so reset() restores the right type.
+ */
+export declare function emptyFilterValue(filter: SchemaFilter): unknown;
+/**
+ * Build the `defaults` map useListFilters expects, straight from the schema.
+ *
+ * Keeps the page from restating filter keys the server already declared.
+ */
+export declare function filterDefaults(schema: TableSchema | undefined): Record<string, unknown>;
+/**
+ * Which columns a listing starts with visible.
+ *
+ * Every key except the ones the schema marks `hiddenByDefault` — the flag was
+ * declarable server-side but nothing acted on it, because Table only filters
+ * against the list a page hands it.
+ */
+export declare function visibleColumnDefaults(schema: TableSchema | undefined): string[];
+/** Treat null, undefined and '' as "no value" so the placeholder shows. */
+export declare function isEmptyValue(value: unknown): boolean;

package/dist/Components/Table/tableTypes.d.ts

@@ -0,0 +1,13 @@
+/** One column of a plain (non-schema) table. */
+export interface TableColumn {
+    key?: string;
+    name?: string;
+    label?: string;
+    sortable?: boolean;
+    width?: string;
+    headerClass?: string;
+    cellClass?: string;
+}
+export type TableRecord = Record<string, any>;
+/** Columns carry either `key` or `name`; every lookup goes through this. */
+export declare function columnName(column: TableColumn): string | undefined;

package/dist/Components/Table/useSchemaActions.d.ts

@@ -0,0 +1,82 @@
+import { SchemaRowAction, SchemaBulkAction, TableSchema } from './tableSchema';
+type Row = Record<string, any>;
+interface ActionOptions {
+    schema: () => TableSchema;
+    /** Appended to record links so a drawer preserves the current list state. */
+    queryParams: () => Record<string, any>;
+    /** The resource's own word for one record ('movie'), for the delete dialog. */
+    recordLabel: () => string | undefined;
+    /** Row actions the schema declares but the table cannot service itself. */
+    rowActionHandlers: () => Record<string, (record: Row, action: SchemaRowAction) => unknown>;
+    bulkActionHandlers: () => Record<string, (records: Row[], action: SchemaBulkAction) => unknown>;
+}
+/**
+ * Runs the actions a schema declares, and owns the confirmations they need.
+ *
+ * The dialogs live here rather than on each page: an action that says
+ * `confirm` should not require the page to remember to render one for it.
+ */
+export declare function useSchemaActions(options: ActionOptions): {
+    rowActionsFor: (record: Row) => SchemaRowAction[];
+    runRowAction: (action: SchemaRowAction, record: Row) => void;
+    deletion: import('vue').ComputedRef<{
+        state: {
+            open: boolean;
+            record: Row | null;
+            plan: {
+                blocked: boolean;
+                protected?: string[] | undefined;
+                nested?: {
+                    label: string;
+                    type?: string | undefined;
+                    children?: any[] | undefined;
+                }[] | undefined;
+                counts?: Record<string, number> | undefined;
+                linkCounts?: Record<string, number> | undefined;
+                soft?: boolean | undefined;
+            } | null;
+            loading: boolean;
+            deleting: boolean;
+            error: string | null;
+        };
+        request: (record: Row) => Promise<void>;
+        confirm: () => Promise<void>;
+        close: () => void;
+        message: ((record: Row) => string) | undefined;
+    }>;
+    deleteLabel: import('vue').ComputedRef<string>;
+    runBulkAction: (action: SchemaBulkAction, records: Row[]) => void;
+    pendingBulk: import('vue').Ref<{
+        action: {
+            name: string;
+            behaviour: string;
+            label: string;
+            icon?: string | undefined;
+            color?: string | undefined;
+            variant?: string | undefined;
+            url?: string | undefined;
+            confirm?: boolean | undefined;
+            confirmMessage?: string | undefined;
+        };
+        records: Row[];
+    } | null, {
+        action: SchemaBulkAction;
+        records: Row[];
+    } | {
+        action: {
+            name: string;
+            behaviour: string;
+            label: string;
+            icon?: string | undefined;
+            color?: string | undefined;
+            variant?: string | undefined;
+            url?: string | undefined;
+            confirm?: boolean | undefined;
+            confirmMessage?: string | undefined;
+        };
+        records: Row[];
+    } | null>;
+    bulkMessage: import('vue').ComputedRef<string>;
+    confirmBulk: () => void;
+};
+export {};

package/dist/Components/Table/useSchemaFilters.d.ts

@@ -0,0 +1,28 @@
+import { FilterIndicator } from '../Filters/FilterIndicators.vue';
+import { SchemaFilter, TableSchema } from './tableSchema';
+interface FilterOptions {
+    schema: () => TableSchema;
+    /** Current filter form values, keyed by filter key. */
+    values: () => Record<string, unknown>;
+    /** Reports a filter change; the page owns the state and the request. */
+    onChange: (key: string, value: unknown) => void;
+    /** Fired once after every filter has been cleared. */
+    onReset: () => void;
+}
+/**
+ * The state behind the schema's filter controls: what counts as active, what
+ * the chips above the table say, and how a filter is cleared.
+ *
+ * Grouping and ad-hoc conditions are filter-shaped here too — they are set,
+ * counted and cleared through the same plumbing as a declared filter.
+ */
+export declare function useSchemaFilters({ schema, values, onChange, onReset }: FilterOptions): {
+    schemaFilters: import('vue').ComputedRef<SchemaFilter[]>;
+    activeGroupField: import('vue').ComputedRef<string>;
+    hasFilterControls: import('vue').ComputedRef<boolean>;
+    activeFilterCount: import('vue').ComputedRef<number>;
+    filterIndicators: import('vue').ComputedRef<FilterIndicator[]>;
+    clearFilter: (key: string) => void;
+    resetFilters: () => void;
+};
+export {};

package/dist/Components/Table/useTableExport.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Composable for exporting table data to various formats
+ */
+export interface TableColumn {
+    key?: string;
+    name?: string;
+    label: string;
+    exportable?: boolean;
+}
+export declare function useTableExport(): {
+    exportToCSV: (data: Record<string, unknown>[], columns: TableColumn[], filename?: string) => void;
+    exportToExcel: (data: Record<string, unknown>[], columns: TableColumn[], filename?: string) => void;
+    exportToJSON: (data: Record<string, unknown>[], columns: TableColumn[], filename?: string) => void;
+    exportView: (data: Record<string, unknown>[], columns: TableColumn[], format?: string, filename?: string) => void;
+    printTable: (data: Record<string, unknown>[], columns: TableColumn[], title?: string) => void;
+};

package/dist/Components/Table/useTableGrouping.d.ts

@@ -0,0 +1,9 @@
+import { TableRecord } from './tableTypes';
+/**
+ * Group headings for rows the server already ordered by the grouped field.
+ * The client only draws the break where the value changes.
+ */
+export declare function useTableGrouping(groupBy: () => string, visibleRecords: () => TableRecord[]): {
+    isGroupStart: (index: number) => boolean;
+    groupHeading: (record: TableRecord) => string;
+};