@starasia/admin 8.2.8 → 8.3.0

package/dist/components/FilterBar/components/MobileFilterBar.d.ts

@@ -0,0 +1,52 @@
+import { default as React } from 'react';
+import { FilterFieldConfig, SavedView } from '../types';
+import { OrderedColumn } from '../hooks/useColumnPrefs';
+import { Pagination as PaginationMeta } from '../../TableSection/types';
+
+interface MobileFilterBarProps {
+    withPadding: boolean;
+    configs: FilterFieldConfig[];
+    activeKeys: string[];
+    configByKey: Record<string, FilterFieldConfig>;
+    hasActiveFilter: boolean;
+    toggleFilter: (key: string) => void;
+    removeFilter: (key: string) => void;
+    getValue: (field: FilterFieldConfig) => unknown;
+    setValue: (field: FilterFieldConfig, value: unknown) => void;
+    clearValue: (key: string) => void;
+    onReset: () => void;
+    searchable: boolean;
+    searchKey: string;
+    filterKey: string;
+    pageKey: string;
+    searchPlaceholder: string;
+    searchShortcut: string;
+    pagination?: PaginationMeta;
+    perPageKey: string;
+    pageSizeOptions: number[];
+    defaultPerPage: number;
+    showPagination: boolean;
+    showResultCount: boolean;
+    showPageSize: boolean;
+    hasColumns: boolean;
+    orderedColumns: OrderedColumn[];
+    allVisible: boolean;
+    onToggleVisibility: (key: string) => void;
+    onReorder: (from: number, to: number) => void;
+    onSetAllHidden: (hidden: boolean) => void;
+    showSavedViews: boolean;
+    savedViews: SavedView[];
+    onApplyView: (view: SavedView) => void;
+    onDeleteView: (id: string) => void;
+    onSaveView: (name: string) => void;
+}
+/**
+ * Mobile (<768px) variant of FilterBar. Replaces the horizontal toolbar with a
+ * two-row layout: a tight toolbar (search icon-toggle + "Filter (N)" trigger +
+ * saved views + columns + more) and a compact pagination row below.
+ *
+ * The filter pills + add-filter catalog move into a bottom `Drawer` opened by
+ * the Filter button. Page-size selection moves into the "More" overflow menu.
+ */
+export declare const MobileFilterBar: React.FC<MobileFilterBarProps>;
+export {};

package/dist/components/FilterBar/components/MobileFilterDrawer.d.ts

@@ -0,0 +1,25 @@
+import { default as React } from 'react';
+import { FilterFieldConfig } from '../types';
+
+interface MobileFilterDrawerProps {
+    isOpen: boolean;
+    onClose: () => void;
+    configs: FilterFieldConfig[];
+    activeKeys: string[];
+    configByKey: Record<string, FilterFieldConfig>;
+    hasActiveFilter: boolean;
+    onToggle: (key: string) => void;
+    onReset: () => void;
+    getValue: (field: FilterFieldConfig) => unknown;
+    setValue: (field: FilterFieldConfig, value: unknown) => void;
+    clearValue: (key: string) => void;
+    removeFilter: (key: string) => void;
+}
+/**
+ * Bottom drawer that consolidates the filter UX for mobile: active pills
+ * (stacked vertically) at the top, followed by the full filter catalog as a
+ * toggleable list. Reuses `FilterPills` so each pill keeps its native editor
+ * popover — the popover floats over the drawer when tapped.
+ */
+export declare const MobileFilterDrawer: React.FC<MobileFilterDrawerProps>;
+export {};

package/dist/components/FilterBar/components/MobileMoreMenu.d.ts

@@ -0,0 +1,16 @@
+import { default as React } from 'react';
+
+interface MobileMoreMenuProps {
+    perPageKey: string;
+    pageKey: string;
+    pageSizeOptions: number[];
+    defaultPerPage?: number;
+    showPageSize: boolean;
+}
+/**
+ * Mobile-only "More" menu — overflow surface for the secondary toolbar
+ * affordances that don't fit on a narrow screen. For now this is just the
+ * page-size selector; saved-views / columns stay as their own icon buttons.
+ */
+export declare const MobileMoreMenu: React.FC<MobileMoreMenuProps>;
+export {};

package/dist/components/FilterBar/hooks/useColumnPrefs.d.ts

@@ -5,6 +5,8 @@ interface UseColumnPrefsOptions {
     scopeId?: string;
     storage: FilterStorageAdapter;
     onColumnsChange?: (state: ColumnPrefState) => void;
+    /** Controlled external state (mis. hide/freeze dari menu kolom tabel). */
+    value?: Partial<ColumnPrefState>;
 }
 export interface OrderedColumn extends ColumnConfig {
     visible: boolean;
@@ -15,7 +17,7 @@ export interface OrderedColumn extends ColumnConfig {
  * consumer via `onColumnsChange` so it can apply the result to its table.
  * Without a `scopeId` the state is session-only (still fully functional).
  */
-export declare function useColumnPrefs({ columns, scopeId, storage, onColumnsChange }: UseColumnPrefsOptions): {
+export declare function useColumnPrefs({ columns, scopeId, storage, onColumnsChange, value }: UseColumnPrefsOptions): {
     state: ColumnPrefState;
     orderedColumns: OrderedColumn[];
     allVisible: boolean;

package/dist/components/FilterBar/hooks/useFilterBarApiParams.d.ts

@@ -0,0 +1,52 @@
+import { FilterFieldConfig } from '../types';
+
+export interface UseFilterBarApiParamsOptions {
+    /** Same catalog passed to `<FilterBar>`. */
+    filterConfigs: FilterFieldConfig[];
+    /** Mirror FilterBar URL keys. */
+    filterKey?: string;
+    activeFilterKey?: string;
+    pageKey?: string;
+    perPageKey?: string;
+    searchKey?: string;
+    /** Fallback when `?page` is absent. Default 1. */
+    defaultPage?: number;
+    /** Fallback when `?perPage` is absent. Default 10. */
+    defaultPerPage?: number;
+    /**
+     * Rename output keys. Covers built-ins (`page`, `perPage`, `search`) and
+     * individual filter field keys. Example:
+     *   `{ perPage: 'limit', status: 'statusId' }`
+     */
+    paramKeys?: Record<string, string>;
+    /**
+     * Per-field custom serializer. Receives the **decoded** value
+     * (`string | string[] | Date | DateCompactValue | undefined`) and returns
+     * whatever shape the API expects. Return `undefined` to omit the key.
+     * Keyed by the filter field key (before any `paramKeys` remap).
+     */
+    serialize?: Record<string, (value: unknown) => unknown>;
+}
+export interface FilterBarApiParams {
+    /** Memoized, flat object ready to spread into a service call. */
+    params: Record<string, unknown>;
+    /** True when any filter (incl. search) is set. */
+    hasActiveFilter: boolean;
+    /** Decoded but pre-flattening values, keyed by field key — useful if a
+     *  consumer wants the `{label, value}` pairs back for display. */
+    raw: Record<string, unknown>;
+}
+/**
+ * Read FilterBar's URL state and produce a flat, API-ready params object that
+ * consumer service functions can accept directly. Drop-in for the
+ * `useQuery({ queryKey: [scope, params], queryFn: () => service.list(params) })`
+ * pattern documented in the `starasia-tanstack-query` skill.
+ *
+ * - `page` / `perPage` always present (coerced, with defaults)
+ * - `search` only when non-empty
+ * - Filter values flattened per type (single → value, multi → value[],
+ *   date → ISO string, date-compact stays raw — pair with `expandDateCompact`)
+ * - Cleared filters are omitted (no `null`, no empty array)
+ * - `paramKeys` renames output keys; `serialize` overrides default flattening
+ */
+export declare const useFilterBarApiParams: (options: UseFilterBarApiParamsOptions) => FilterBarApiParams;

package/dist/components/FilterBar/hooks/useFilterBarControls.d.ts

@@ -0,0 +1,39 @@
+import { FilterFieldConfig } from '../types';
+
+export interface UseFilterBarControlsOptions {
+    /** Katalog filter yang SAMA dengan yang dipakai `<FilterBar>`. */
+    filterConfigs: FilterFieldConfig[];
+    /** Mirror key URL FilterBar (default sama dgn FilterBar). */
+    filterKey?: string;
+    activeFilterKey?: string;
+    pageKey?: string;
+    searchKey?: string;
+}
+export interface FilterBarControls {
+    /** Set nilai filter (replace). Array kosong / `[]` → hapus filter. */
+    set: (key: string, value: string | string[]) => void;
+    /** Tambah/lepas satu nilai (cocok untuk klik kartu shortcut). */
+    toggle: (key: string, value: string) => void;
+    /** Hapus filter ini sepenuhnya (nilai + pill). */
+    clear: (key: string) => void;
+    /** Reset semua filter + search. */
+    clearAll: () => void;
+    /** Apakah `value` sedang aktif pada filter `key` (untuk styling kartu aktif). */
+    isActive: (key: string, value: string) => boolean;
+    /** Nilai-nilai aktif sekarang pada filter `key`. */
+    values: (key: string) => string[];
+    /** Ada filter aktif (apa pun). */
+    hasActiveFilter: boolean;
+}
+/**
+ * Kontrol filter dari LUAR `<FilterBar>` — untuk shortcut/quick-filter
+ * (mis. summary card status yang saat diklik memfilter tabel).
+ *
+ * Sumber kebenaran sama dengan FilterBar: URL. Jadi begitu helper ini menulis,
+ * pill FilterBar, tabel, dan `useFilterBarApiParams` ikut otomatis — tanpa
+ * lifting state. Companion arah-tulis dari `useFilterBarApiParams` (arah-baca).
+ *
+ * Khusus untuk filter select-type (`dropdown` / `dropdown-multiple` /
+ * `checkbox-multiple` / `radio`). Field lain (date) diabaikan.
+ */
+export declare const useFilterBarControls: ({ filterConfigs, filterKey, activeFilterKey, pageKey, searchKey }: UseFilterBarControlsOptions) => FilterBarControls;

package/dist/components/FilterBar/hooks/useLastFilterState.d.ts

@@ -3,7 +3,7 @@ import { FilterStorageAdapter } from '../types';
 interface UseLastFilterStateOptions {
     scopeId?: string;
     storage: FilterStorageAdapter;
-    /** URL params to snapshot (e.g. [activeFilterKey, filterKey, perPageKey]). */
+    /** URL params to snapshot (e.g. [activeFilterKey, filterKey, pageKey]). */
     snapshotKeys: string[];
     /** Opt-out toggle (default true when scopeId is provided). */
     enabled?: boolean;
@@ -11,17 +11,20 @@ interface UseLastFilterStateOptions {
 /**
  * Persists the latest filter URL params per scope, so link-based back
  * navigation (which drops the query string) still restores the previous
- * filters on remount. URL always wins — restoration only kicks in when the
- * URL has none of the snapshot keys.
+ * filters. URL always wins.
  *
- * - **Autosave**: writes to `localStorage[filterbar:last:{scopeId}]` on every
- *   `searchParams` change.
- * - **Autorestore**: on mount, hydrates the URL from storage if empty.
- * - **`clear()`**: removes the snapshot; call this from Reset so the user's
- *   explicit reset isn't undone on the next navigation back.
+ * NOTE: restore-ke-URL TIDAK dilakukan di sini — dikoordinasikan oleh
+ * `useUrlHydration` (satu `setSearchParams` gabungan) supaya tidak bentrok
+ * dengan restore perPage. Hook ini hanya autosave + expose `read()` + `clear()`.
+ *
+ * - **Autosave**: writes to `filterbar:last:{scopeId}` on every URL change.
+ *   Snapshot KOSONG tidak ditulis (agar tidak menghapus snapshot saat URL
+ *   kosong transient / pindah route).
+ * - **`clear()`**: removes the snapshot (dipanggil dari Reset).
  */
 export declare function useLastFilterState({ scopeId, storage, snapshotKeys, enabled }: UseLastFilterStateOptions): {
     enabled: boolean;
+    read: () => Record<string, string> | null;
     clear: () => void;
 };
 export {};

package/dist/components/FilterBar/hooks/usePerPagePref.d.ts

@@ -0,0 +1,23 @@
+import { FilterStorageAdapter } from '../types';
+
+interface UsePerPagePrefOptions {
+    scopeId?: string;
+    storage: FilterStorageAdapter;
+    perPageKey: string;
+    /** When provided, the restored value is validated against this list. */
+    pageSizeOptions?: number[];
+    /** Opt-out toggle (default true when scopeId is provided). */
+    enabled?: boolean;
+}
+/**
+ * Persists the rows-per-page choice independently of the filter snapshot.
+ *
+ * UI preference — NOT wiped by Reset. Restore-ke-URL dikoordinasikan oleh
+ * `useUrlHydration`; hook ini hanya autosave + expose `read()` + `clear()`.
+ */
+export declare function usePerPagePref({ scopeId, storage, perPageKey, pageSizeOptions, enabled }: UsePerPagePrefOptions): {
+    enabled: boolean;
+    read: () => string | null;
+    clear: () => void;
+};
+export {};

package/dist/components/FilterBar/hooks/useUrlHydration.d.ts

@@ -0,0 +1,23 @@
+interface UseUrlHydrationOptions {
+    enabled: boolean;
+    /** Keys yang dianggap "filter snapshot" (mis. [filters, filter, page]). */
+    snapshotKeys: string[];
+    perPageKey: string;
+    /** Snapshot filter tersimpan (atau null). */
+    readSnapshot: () => Record<string, string> | null;
+    /** Page size tersimpan (string) atau null. */
+    readPerPage: () => string | null;
+}
+/**
+ * Hidrasi URL dari preferensi tersimpan. Restore filter-snapshot & perPage
+ * digabung lewat micro-batcher → tidak saling menimpa, dan tahan banting untuk
+ * >1 FilterBar dalam satu halaman.
+ *
+ * Jalan saat "tiba" di halaman: mount ATAU `location.pathname` berubah (navigasi
+ * balik), jadi halaman yang di-keep-alive router tetap ter-restore tanpa hard
+ * refresh. Di-gate ke perubahan pathname agar TIDAK loop saat user mengubah
+ * filter di halaman yang sama. URL selalu menang (key yang sudah ada di URL
+ * tidak ditimpa).
+ */
+export declare function useUrlHydration({ enabled, snapshotKeys, perPageKey, readSnapshot, readPerPage }: UseUrlHydrationOptions): void;
+export {};

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

@@ -1,3 +1,6 @@
 export { FilterBar } from './FilterBar';
+export { useFilterBarApiParams, type UseFilterBarApiParamsOptions, type FilterBarApiParams } from './hooks/useFilterBarApiParams';
+export { useFilterBarControls, type UseFilterBarControlsOptions, type FilterBarControls } from './hooks/useFilterBarControls';
+export { expandDateCompact, type ExpandDateCompactOptions } from './utils/expand-date-compact';
 export { localStorageAdapter, storageKeys } from './utils/storage-adapter';
 export type { FilterBarProps, FilterFieldConfig, FilterFieldType, SelectFilterField, CheckboxMultipleFilterField, DateFilterField, DateCompactFilterField, DateCompactOp, DateCompactValue, RelativeDirection, RelativePeriod, ColumnConfig, ColumnPrefState, SavedView, FilterStorageAdapter } from './types';

package/dist/components/FilterBar/types.d.ts

@@ -132,6 +132,12 @@ export interface FilterBarProps {
     perPageKey?: string;
     /** Page-size choices. Default `[10, 25, 50, 100]`. */
     pageSizeOptions?: number[];
+    /**
+     * Initial page size used when the URL (and the persisted preference under
+     * `savedViews.scopeId`) is empty. Defaults to `pageSizeOptions[0]`, so
+     * `pageSizeOptions={[25, 50, 100]}` naturally defaults to 25.
+     */
+    defaultPerPage?: number;
     showPagination?: boolean;
     showResultCount?: boolean;
     /** Show the rows-per-page selector. Default `true`. */
@@ -140,15 +146,30 @@ export interface FilterBarProps {
     columns?: ColumnConfig[];
     /** Emitted when visibility/order changes — consumer applies to its table. */
     onColumnsChange?: (state: ColumnPrefState) => void;
-    /** Enable named saved views. `scopeId` namespaces persisted data per table. */
+    /**
+     * Controlled column state. Saat diisi, panel Customize Column ikut state ini
+     * (mis. hide/freeze dari menu kolom TableLayout) — sinkron dua arah dgn
+     * `onColumnsChange`. `frozenKey` & field lain di luar order/hidden diabaikan.
+     */
+    columnsState?: Partial<ColumnPrefState>;
+    /**
+     * Namespace persistensi per tabel — dipakai untuk column prefs, last-filter
+     * snapshot, perPage, & saved views. WAJIB diisi agar fitur persist aktif.
+     * Boleh juga lewat `savedViews.scopeId` (kompatibilitas lama); kalau dua-duanya
+     * ada, prop top-level ini menang.
+     */
+    scopeId?: string;
+    /**
+     * Saved views. `enabled` mengontrol tampil/sembunyinya tombol Saved Views.
+     * `scopeId` di sini opsional & deprecated — pakai prop `scopeId` top-level.
+     */
     savedViews?: {
         enabled?: boolean;
-        scopeId: string;
+        scopeId?: string;
     };
     /**
      * Auto-restore the last applied filter state when the URL has no filter
-     * params (e.g. link-based back navigation). Requires `savedViews.scopeId`.
-     * Default `true`.
+     * params (e.g. link-based back navigation). Requires `scopeId`. Default `true`.
      */
     persistLastState?: boolean;
     /** Persistence adapter (default: localStorage via @starasia/storage). */

package/dist/components/FilterBar/utils/expand-date-compact.d.ts

@@ -0,0 +1,33 @@
+import { DateCompactValue } from '../types';
+
+export interface ExpandDateCompactOptions {
+    /** Param key for the start / single date. */
+    fromKey: string;
+    /** Param key for the end of a range (only used by `is-between` and
+     *  `is-relative-to-today`). */
+    toKey: string;
+    /**
+     * Optional separate key carrying the operator. When provided:
+     * - is-empty / is-not-empty → `{ [opKey]: 'empty' | 'not-empty' }`
+     * - single-date ops (is / is-before / …) → also emits `{ [opKey]: op }`
+     *   so the API can branch on direction.
+     * When omitted, those ops produce `{}` (single-date ops still emit
+     * `{ [fromKey]: ISO }`).
+     */
+    opKey?: string;
+}
+/**
+ * Expand a `DateCompactValue` (operator + payload, as stored by the
+ * `date-compact` filter type) into a flat `Record<string, string>` ready to
+ * spread into an API params object.
+ *
+ * - `is` / `is-before` / `is-after` / `is-on-or-before` / `is-on-or-after`
+ *     → `{ [fromKey]: ISO }` (+ `{ [opKey]: op }` when `opKey` is set)
+ * - `is-between` → `{ [fromKey]: ISO, [toKey]: ISO }`
+ * - `is-relative-to-today` → resolved to absolute ISO via `computeRelativeRange`
+ *   → `{ [fromKey]: ISO, [toKey]: ISO }`
+ * - `is-empty` / `is-not-empty` → `{ [opKey]: 'empty' | 'not-empty' }` when
+ *   `opKey` is set, otherwise `{}` (caller's choice how to encode)
+ * - `undefined` value → `{}`
+ */
+export declare const expandDateCompact: (value: DateCompactValue | undefined, options: ExpandDateCompactOptions) => Record<string, string>;

package/dist/components/FilterBar/utils/relative-date.d.ts

@@ -0,0 +1,17 @@
+import { RelativeDirection, RelativePeriod } from '../types';
+
+export declare const startOfDay: (d: Date) => Date;
+export declare const shiftPeriod: (d: Date, n: number, p: RelativePeriod) => Date;
+/**
+ * Resolve a relative spec (Past 2 weeks / Next 1 month / This year …) to a
+ * concrete date range anchored at today. Shared between DatePill (preview
+ * calendar) and expandDateCompact (API param expansion).
+ */
+export declare const computeRelativeRange: (rel: {
+    direction: RelativeDirection;
+    count?: number;
+    period: RelativePeriod;
+}) => {
+    from: Date;
+    to: Date;
+};

package/dist/components/FilterBar/utils/storage-adapter.d.ts

@@ -13,4 +13,6 @@ export declare const storageKeys: {
     columns: (scopeId: string) => string;
     savedViews: (scopeId: string) => string;
     lastState: (scopeId: string) => string;
+    perPage: (scopeId: string) => string;
+    tableSort: (scopeId: string) => string;
 };

package/dist/components/TableLayout/ColumnMenu.d.ts

@@ -0,0 +1,15 @@
+import { default as React } from 'react';
+
+export interface ColumnMenuProps {
+    /** trigger tetap terlihat (mis. sedang di-sort / di-freeze) walau tidak hover */
+    active: boolean;
+    canSort: boolean;
+    canHide: boolean;
+    sortDir: 'asc' | 'desc' | null;
+    frozen: boolean;
+    onSort: (dir: 'asc' | 'desc') => void;
+    onClearSort: () => void;
+    onToggleFreeze: () => void;
+    onHide: () => void;
+}
+export declare const ColumnMenu: ({ active, canSort, canHide, sortDir, frozen, onSort, onClearSort, onToggleFreeze, onHide }: ColumnMenuProps) => React.JSX.Element;

package/dist/components/TableLayout/TableLayout.d.ts

@@ -0,0 +1,4 @@
+import { default as React } from 'react';
+import { TableLayoutProps } from './types';
+
+export declare const TableLayout: <T>({ columns, data, getRowKey, size, resizable, widthStorageKey, columnState, onColumnStateChange, columnMenu, sort, defaultSort, onSortChange, height, mobileLayout, mobileBreakpoint, groupSeparator, summary, emptyState, rowActions, }: TableLayoutProps<T>) => React.JSX.Element;

package/dist/components/TableLayout/hooks/useTableSortApiParams.d.ts

@@ -0,0 +1,64 @@
+import { FilterStorageAdapter } from '../../FilterBar/types';
+import { TableLayoutSort } from '../types';
+
+export interface UseTableSortApiParamsOptions {
+    /** URL param holding the sort key. Default `'sortBy'`. */
+    sortKeyParam?: string;
+    /** URL param holding the sort direction. Default `'sortOrder'`. */
+    sortOrderParam?: string;
+    /** URL param for pagination — auto-reset to 1 on sort change. Default `'page'`. */
+    pageKey?: string;
+    /** Sort used when URL has no sort (and no persisted snapshot). Default `null`. */
+    defaultSort?: TableLayoutSort | null;
+    /**
+     * Rename output param keys (in `params`) without changing URL keys.
+     * Example: `{ sortBy: 'orderBy', sortOrder: 'orderDir' }` for a backend
+     * with different names. Defaults to the same names as the URL.
+     */
+    paramKeys?: {
+        sortBy?: string;
+        sortOrder?: string;
+    };
+    /**
+     * Namespace for persistence. When provided, sort is saved to storage and
+     * auto-restored when the user navigates away and comes back to a URL with
+     * no sort params (URL always wins on direct visits). Conventionally matches
+     * `FilterBar.savedViews.scopeId` so list state stays consistent.
+     */
+    scopeId?: string;
+    /**
+     * Pluggable persistence (default `localStorageAdapter`). Only used when
+     * `scopeId` is set. Same shape as `FilterBar`'s `storage` prop.
+     */
+    storage?: FilterStorageAdapter;
+}
+export interface TableSortApiParams {
+    /** Current sort, decoded from URL (or `defaultSort` when URL is empty). */
+    sort: TableLayoutSort | null;
+    /** Update sort + write to URL. Pass `null` to clear. Resets `?page` to 1
+     *  so the user lands on the first page of the newly-sorted result. */
+    setSort: (next: TableLayoutSort | null) => void;
+    /**
+     * Flat API params, ready to spread into a service call.
+     * `{ sortBy: 'createdAt', sortOrder: 'desc' }` when sort active, `{}`
+     * when not. Memoized — stable reference for tanstack `queryKey`.
+     */
+    params: Record<string, string>;
+}
+/**
+ * Persist `<TableLayout>` sort state in the URL (`?sortBy=…&sortOrder=…`) and
+ * surface a flat `{ sortBy, sortOrder }` object ready to spread into a service
+ * call — companion to `useFilterBarApiParams`.
+ *
+ * Passing the returned `onSortChange` to `<TableLayout>` flips it into
+ * **server mode** (it won't sort the data itself, it just emits — perfect
+ * when the API does the sorting). The hook resets `?page` to 1 on every
+ * sort change so the user always lands on the first page of the new order.
+ *
+ * **Persistence** (opt-in via `scopeId`): mirrors `FilterBar.useLastFilterState`.
+ * Sort is autosaved to storage on every change, and auto-restored on mount
+ * when the URL has no sort params. URL always wins on direct visits.
+ * `setSort(null)` clears both URL and storage so explicit resets aren't
+ * undone by the next back-navigation.
+ */
+export declare const useTableSortApiParams: (options?: UseTableSortApiParamsOptions) => TableSortApiParams;

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

@@ -0,0 +1,4 @@
+export { TableLayout } from './TableLayout';
+export { ColumnMenu } from './ColumnMenu';
+export { useTableSortApiParams, type UseTableSortApiParamsOptions, type TableSortApiParams } from './hooks/useTableSortApiParams';
+export type { TableLayoutProps, TableLayoutColumn, TableLayoutAlign, TableLayoutColumnState, TableLayoutCellProps, TableLayoutSort, TableLayoutSortDirection, TableLayoutRowAction } from './types';