@kayord/ui 3.0.11 → 4.0.0

package/dist/components/custom/data-table/DataTableHeader.svelte

@@ -1,33 +1,47 @@
-<script lang="ts" generics="T">
+<script lang="ts" generics="T extends RowData">
 	import { Table } from "../../..";
-	import { FlexRender } from "../../../data-table";
-	import { type Header, type Table as TypeType } from "@tanstack/table-core";
+	import { FlexRender } from "../../ui/data-table";
+	import type { Header, RowData } from "@tanstack/svelte-table";
 	import { ArrowUpDownIcon, ArrowDownIcon, ArrowUpIcon } from "@lucide/svelte";
+	import type { DataTableFeatures } from "./features";
 
-	interface Props<T> {
-		header: Header<T, unknown>;
-		table: TypeType<T>;
+	interface Props<T extends RowData> {
+		header: Header<DataTableFeatures, T, unknown>;
 		disableUISorting?: boolean;
 	}
 
-	let { header, table, disableUISorting = false }: Props<T> = $props();
+	let { header, disableUISorting = false }: Props<T> = $props();
 
-	const isSortingEnabled = $derived(table.options.getSortedRowModel !== undefined && disableUISorting !== true);
+	function headerSizeStyle(width: number, min?: number, max?: number) {
+		const styles = [`width: ${width}px`];
+		if (min !== undefined) styles.push(`min-width: ${min}px`);
+		if (max !== undefined) styles.push(`max-width: ${max}px`);
+		return styles.join("; ");
+	}
+
+	const isSortingEnabled = $derived(disableUISorting !== true);
+	const sorted = $derived(header.column.getIsSorted());
+	const ariaSort = $derived(sorted === "asc" ? "ascending" : sorted === "desc" ? "descending" : undefined);
 </script>
 
 <Table.Head
 	colspan={header.colSpan}
+	aria-sort={ariaSort}
 	class="bg-muted/20"
-	style={`width: ${header.getSize()}px; min-width:${header.column.columnDef.minSize}px; max-width:${header.column.columnDef.maxSize}px`}
+	style={headerSizeStyle(header.getSize(), header.column.columnDef.minSize, header.column.columnDef.maxSize)}
 >
 	{#if !header.isPlaceholder}
 		<div class="flex items-center gap-1">
-			<FlexRender content={header.column.columnDef.header} context={header.getContext()} />
+			<FlexRender {header} />
 			{#if isSortingEnabled && header.column.getCanSort()}
-				<button onclick={header.column.getToggleSortingHandler()}>
-					{#if header.column.getIsSorted() == "asc"}
+				<button
+					aria-label={`Sort by ${header.column.id}`}
+					class="cursor-pointer"
+					onclick={header.column.getToggleSortingHandler()}
+				>
+					{#if sorted == "asc"}
 						<ArrowDownIcon class="size-4" />
-					{:else if header.column.getIsSorted() == "desc"}
+					{:else if sorted == "desc"}
 						<ArrowUpIcon class="size-4" />
 					{:else}
 						<ArrowUpDownIcon class="text-muted size-4" />

package/dist/components/custom/data-table/DataTableHeader.svelte.d.ts

@@ -1,17 +1,17 @@
-import { type Header, type Table as TypeType } from "@tanstack/table-core";
-interface Props<T> {
-    header: Header<T, unknown>;
-    table: TypeType<T>;
+import type { Header, RowData } from "@tanstack/svelte-table";
+import type { DataTableFeatures } from "./features";
+interface Props<T extends RowData> {
+    header: Header<DataTableFeatures, T, unknown>;
     disableUISorting?: boolean;
 }
-declare function $$render<T>(): {
+declare function $$render<T extends RowData>(): {
     props: Props<T>;
     exports: {};
     bindings: "";
     slots: {};
     events: {};
 };
-declare class __sveltets_Render<T> {
+declare class __sveltets_Render<T extends RowData> {
     props(): ReturnType<typeof $$render<T>>['props'];
     events(): ReturnType<typeof $$render<T>>['events'];
     slots(): ReturnType<typeof $$render<T>>['slots'];
@@ -19,12 +19,12 @@ declare class __sveltets_Render<T> {
     exports(): {};
 }
 interface $$IsomorphicComponent {
-    new <T>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<T>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<T>['props']>, ReturnType<__sveltets_Render<T>['events']>, ReturnType<__sveltets_Render<T>['slots']>> & {
+    new <T extends RowData>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<T>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<T>['props']>, ReturnType<__sveltets_Render<T>['events']>, ReturnType<__sveltets_Render<T>['slots']>> & {
         $$bindings?: ReturnType<__sveltets_Render<T>['bindings']>;
     } & ReturnType<__sveltets_Render<T>['exports']>;
-    <T>(internal: unknown, props: ReturnType<__sveltets_Render<T>['props']> & {}): ReturnType<__sveltets_Render<T>['exports']>;
+    <T extends RowData>(internal: unknown, props: ReturnType<__sveltets_Render<T>['props']> & {}): ReturnType<__sveltets_Render<T>['exports']>;
     z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
 }
 declare const DataTableHeader: $$IsomorphicComponent;
-type DataTableHeader<T> = InstanceType<typeof DataTableHeader<T>>;
+type DataTableHeader<T extends RowData> = InstanceType<typeof DataTableHeader<T>>;
 export default DataTableHeader;

package/dist/components/custom/data-table/DataTableView.svelte

@@ -1,5 +1,5 @@
-<script lang="ts" generics="TData">
-	import type { Table } from "@tanstack/table-core";
+<script lang="ts" generics="TData extends RowData">
+	import type { RowData, Table } from "@tanstack/svelte-table";
 	import { cn } from "../../../utils.js";
 	import { Button } from "../../ui/button";
 	import { Popover, PopoverContent, PopoverTrigger } from "../../ui/popover";
@@ -11,26 +11,27 @@
 		CommandItem,
 		CommandList,
 	} from "../../ui/command/index.js";
+	import type { DataTableFeatures } from "./features";
 
 	// Icons
 	import Settings2 from "@lucide/svelte/icons/settings-2";
 	import Check from "@lucide/svelte/icons/check";
 
 	interface Props {
-		table: Table<TData>;
+		table: Table<DataTableFeatures, TData>;
 		align?: "start" | "center" | "end";
 		class?: string;
 	}
 
 	let { table, align = "start", class: className }: Props = $props();
 
-	// Get columns - table.getAllColumns() is reactive via our wrapper
+	// Get columns - table.getAllColumns() is rune-reactive in v9
 	const columns = $derived(
 		table.getAllColumns().filter((column) => typeof column.accessorFn !== "undefined" && column.getCanHide())
 	);
 
-	// Get visibility state reactively
-	const columnVisibility = $derived(table.getState().columnVisibility);
+	// Get visibility state reactively via the v9 atoms API
+	const columnVisibility = $derived(table.atoms.columnVisibility.get());
 
 	// Helper to check if column is visible - reads from reactive state
 	function isColumnVisible(columnId: string): boolean {

package/dist/components/custom/data-table/DataTableView.svelte.d.ts

@@ -1,7 +1,8 @@
-import type { Table } from "@tanstack/table-core";
-declare function $$render<TData>(): {
+import type { RowData, Table } from "@tanstack/svelte-table";
+import type { DataTableFeatures } from "./features";
+declare function $$render<TData extends RowData>(): {
     props: {
-        table: Table<TData>;
+        table: Table<DataTableFeatures, TData>;
         align?: "start" | "center" | "end";
         class?: string;
     };
@@ -10,7 +11,7 @@ declare function $$render<TData>(): {
     slots: {};
     events: {};
 };
-declare class __sveltets_Render<TData> {
+declare class __sveltets_Render<TData extends RowData> {
     props(): ReturnType<typeof $$render<TData>>['props'];
     events(): ReturnType<typeof $$render<TData>>['events'];
     slots(): ReturnType<typeof $$render<TData>>['slots'];
@@ -18,12 +19,12 @@ declare class __sveltets_Render<TData> {
     exports(): {};
 }
 interface $$IsomorphicComponent {
-    new <TData>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<TData>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<TData>['props']>, ReturnType<__sveltets_Render<TData>['events']>, ReturnType<__sveltets_Render<TData>['slots']>> & {
+    new <TData extends RowData>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<TData>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<TData>['props']>, ReturnType<__sveltets_Render<TData>['events']>, ReturnType<__sveltets_Render<TData>['slots']>> & {
         $$bindings?: ReturnType<__sveltets_Render<TData>['bindings']>;
     } & ReturnType<__sveltets_Render<TData>['exports']>;
-    <TData>(internal: unknown, props: ReturnType<__sveltets_Render<TData>['props']> & {}): ReturnType<__sveltets_Render<TData>['exports']>;
+    <TData extends RowData>(internal: unknown, props: ReturnType<__sveltets_Render<TData>['props']> & {}): ReturnType<__sveltets_Render<TData>['exports']>;
     z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
 }
 declare const DataTableView: $$IsomorphicComponent;
-type DataTableView<TData> = InstanceType<typeof DataTableView<TData>>;
+type DataTableView<TData extends RowData> = InstanceType<typeof DataTableView<TData>>;
 export default DataTableView;

package/dist/components/custom/data-table/FullscreenModeToggle.svelte

@@ -9,18 +9,23 @@
 
 	let { isFullscreen = $bindable(), end }: Props = $props();
 
-	$effect.pre(() => {
+	let previous = isFullscreen;
+
+	$effect(() => {
+		if (isFullscreen === previous) return;
+		previous = isFullscreen;
+
 		if (isFullscreen) {
 			document.body.classList.add("overflow-hidden");
 			document.body.scrollIntoView({ behavior: "smooth", block: "start" });
 		} else {
-			if (!end) {
-				document.body.classList.remove("overflow-hidden");
-				return;
-			}
-			end.scrollIntoView({ behavior: "smooth", block: "start" });
 			document.body.classList.remove("overflow-hidden");
+			end?.scrollIntoView({ behavior: "smooth", block: "start" });
 		}
+
+		return () => {
+			document.body.classList.remove("overflow-hidden");
+		};
 	});
 </script>
 

package/dist/components/custom/data-table/Pagination.svelte

@@ -1,86 +1,102 @@
-<script lang="ts" generics="T">
-	import type { Table } from "@tanstack/table-core";
+<script lang="ts" generics="T extends RowData">
+	import type { RowData, Table } from "@tanstack/svelte-table";
 	import ChevronLeft from "@lucide/svelte/icons/chevron-left";
 	import ChevronRight from "@lucide/svelte/icons/chevron-right";
-	import DoubleArrowLeft from "@lucide/svelte/icons/arrow-left";
-	import DoubleArrowRight from "@lucide/svelte/icons/arrow-right";
+	import ChevronsLeft from "@lucide/svelte/icons/chevrons-left";
+	import ChevronsRight from "@lucide/svelte/icons/chevrons-right";
 	import { Select, Button } from "../../..";
+	import type { DataTableFeatures } from "./features";
 
-	interface Props<T> {
-		table: Table<T>;
+	interface Props<T extends RowData> {
+		table: Table<DataTableFeatures, T>;
 		canChangePageSize?: boolean;
 	}
 
-	let { table, canChangePageSize = false }: Props<T> = $props();
+	let { table, canChangePageSize = true }: Props<T> = $props();
 
-	// svelte-ignore state_referenced_locally
-	let value = $state(table.getState().pagination.pageSize.toString());
+	const pagination = $derived(table.atoms.pagination.get());
 </script>
 
-<div class="flex items-center justify-between py-2">
+<div class="flex items-center justify-between gap-4 px-2 py-4">
 	<div class="text-muted-foreground flex-1 text-sm">
 		{#if table.options.enableRowSelection}
-			{table.getFilteredSelectedRowModel().rows.length} of
-			{table.getFilteredRowModel().rows.length} row(s) selected.
+			<p>
+				{table.getFilteredSelectedRowModel().rows.length} of
+				{table.getFilteredRowModel().rows.length} row(s) selected.
+			</p>
 		{/if}
+		<p>
+			{#if !table.options.manualPagination}
+				{table.getPrePaginatedRowModel().rows.length.toLocaleString()}
+				of {table.options.data.length.toLocaleString()} rows
+			{/if}
+		</p>
 	</div>
-	<div class="flex items-center space-x-6 lg:space-x-8">
-		<div class="flex items-center space-x-2">
-			{#if canChangePageSize}
+	<div class="flex items-center gap-6 lg:gap-8">
+		{#if canChangePageSize}
+			<div class="flex items-center gap-2">
 				<p class="text-sm font-medium">Rows per page</p>
+				<!-- bits-ui's Select has no SelectValue part — the trigger renders the
+					selected value directly as its children. -->
 				<Select.Root
 					type="single"
-					bind:value
-					onValueChange={(value) => {
-						table.setPageSize(Number(value));
-					}}
+					value={`${pagination.pageSize}`}
+					onValueChange={(value) => table.setPageSize(Number(value))}
 				>
-					<Select.Trigger class="h-8 w-[70px]">Select page size</Select.Trigger>
+					<Select.Trigger size="sm" class="w-[70px]">
+						{pagination.pageSize === Infinity ? "All" : pagination.pageSize}
+					</Select.Trigger>
 					<Select.Content side="top">
-						{#each [10, 20, 30, 40, 50] as pageSize}
-							<Select.Item value={pageSize.toString()}>
-								{pageSize}
-							</Select.Item>
+						{#each [10, 20, 30, 40, 50, Infinity] as pageSize (pageSize)}
+							<Select.Item value={`${pageSize}`} label={pageSize === Infinity ? "All" : `${pageSize}`} />
 						{/each}
 					</Select.Content>
 				</Select.Root>
-			{/if}
-		</div>
+			</div>
+		{/if}
 		<div class="flex w-[100px] items-center justify-center text-sm font-medium">
-			Page {table.getState().pagination.pageIndex + 1} of
-			{table.getPageCount()}
+			Page {pagination.pageIndex + 1} of {Math.max(1, table.getPageCount())}
 		</div>
-		<div class="flex items-center space-x-2">
+		<div class="flex items-center gap-2">
 			<Button
 				variant="outline"
-				class="hidden size-8 p-0 lg:flex"
-				onclick={() => table.setPageIndex(0)}
+				size="icon"
+				class="hidden size-8 lg:flex"
 				disabled={!table.getCanPreviousPage()}
+				onclick={() => table.firstPage()}
 			>
 				<span class="sr-only">Go to first page</span>
-				<DoubleArrowLeft class="size-4" />
+				<ChevronsLeft />
 			</Button>
 			<Button
 				variant="outline"
-				class="size-8 p-0"
-				onclick={() => table.previousPage()}
+				size="icon"
+				class="size-8"
 				disabled={!table.getCanPreviousPage()}
+				onclick={() => table.previousPage()}
 			>
 				<span class="sr-only">Go to previous page</span>
-				<ChevronLeft class="size-4" />
+				<ChevronLeft />
 			</Button>
-			<Button variant="outline" class="size-8 p-0" onclick={() => table.nextPage()} disabled={!table.getCanNextPage()}>
+			<Button
+				variant="outline"
+				size="icon"
+				class="size-8"
+				disabled={!table.getCanNextPage()}
+				onclick={() => table.nextPage()}
+			>
 				<span class="sr-only">Go to next page</span>
-				<ChevronRight class="size-4" />
+				<ChevronRight />
 			</Button>
 			<Button
 				variant="outline"
-				class="hidden size-8 p-0 lg:flex"
-				onclick={() => table.setPageIndex(table.getPageCount() - 1)}
-				disabled={!table.getCanNextPage()}
+				size="icon"
+				class="hidden size-8 lg:flex"
+				disabled={!table.getCanLastPage()}
+				onclick={() => table.lastPage()}
 			>
 				<span class="sr-only">Go to last page</span>
-				<DoubleArrowRight class="size-4" />
+				<ChevronsRight />
 			</Button>
 		</div>
 	</div>

package/dist/components/custom/data-table/Pagination.svelte.d.ts

@@ -1,16 +1,17 @@
-import type { Table } from "@tanstack/table-core";
-interface Props<T> {
-    table: Table<T>;
+import type { RowData, Table } from "@tanstack/svelte-table";
+import type { DataTableFeatures } from "./features";
+interface Props<T extends RowData> {
+    table: Table<DataTableFeatures, T>;
     canChangePageSize?: boolean;
 }
-declare function $$render<T>(): {
+declare function $$render<T extends RowData>(): {
     props: Props<T>;
     exports: {};
     bindings: "";
     slots: {};
     events: {};
 };
-declare class __sveltets_Render<T> {
+declare class __sveltets_Render<T extends RowData> {
     props(): ReturnType<typeof $$render<T>>['props'];
     events(): ReturnType<typeof $$render<T>>['events'];
     slots(): ReturnType<typeof $$render<T>>['slots'];
@@ -18,12 +19,12 @@ declare class __sveltets_Render<T> {
     exports(): {};
 }
 interface $$IsomorphicComponent {
-    new <T>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<T>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<T>['props']>, ReturnType<__sveltets_Render<T>['events']>, ReturnType<__sveltets_Render<T>['slots']>> & {
+    new <T extends RowData>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<T>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<T>['props']>, ReturnType<__sveltets_Render<T>['events']>, ReturnType<__sveltets_Render<T>['slots']>> & {
         $$bindings?: ReturnType<__sveltets_Render<T>['bindings']>;
     } & ReturnType<__sveltets_Render<T>['exports']>;
-    <T>(internal: unknown, props: ReturnType<__sveltets_Render<T>['props']> & {}): ReturnType<__sveltets_Render<T>['exports']>;
+    <T extends RowData>(internal: unknown, props: ReturnType<__sveltets_Render<T>['props']> & {}): ReturnType<__sveltets_Render<T>['exports']>;
     z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
 }
 declare const Pagination: $$IsomorphicComponent;
-type Pagination<T> = InstanceType<typeof Pagination<T>>;
+type Pagination<T extends RowData> = InstanceType<typeof Pagination<T>>;
 export default Pagination;

package/dist/components/custom/data-table/data-table-utils.d.ts

@@ -2,7 +2,7 @@ export declare const sum: <T>(data: T[], columnId: keyof T) => number;
 export declare const min: <T>(data: T[], columnId: keyof T) => number | undefined;
 export declare const max: <T>(data: T[], columnId: keyof T) => number | undefined;
 export declare const uniqueCount: <T>(data: T[], columnId: keyof T) => number;
-export declare const count: <T>(data: T[], columnId: keyof T) => number;
+export declare const count: <T>(data: T[], _columnId: keyof T) => number;
 export declare const mean: <T>(data: T[], columnId: keyof T) => number | undefined;
 export declare const aggregationFns: {
     sum: <T>(data: T[], columnId: keyof T) => number;
@@ -10,5 +10,5 @@ export declare const aggregationFns: {
     max: <T>(data: T[], columnId: keyof T) => number | undefined;
     mean: <T>(data: T[], columnId: keyof T) => number | undefined;
     uniqueCount: <T>(data: T[], columnId: keyof T) => number;
-    count: <T>(data: T[], columnId: keyof T) => number;
+    count: <T>(data: T[], _columnId: keyof T) => number;
 };

package/dist/components/custom/data-table/data-table-utils.js

@@ -1,47 +1,46 @@
 export const sum = (data, columnId) => {
-    return data.reduce((sum, next) => {
-        const nextValue = next[columnId];
-        return sum + (typeof nextValue === "number" ? nextValue : 0);
+    return data.reduce((total, row) => {
+        const value = row[columnId];
+        return total + (typeof value === "number" && Number.isFinite(value) ? value : 0);
     }, 0);
 };
 export const min = (data, columnId) => {
     let min;
-    data.forEach((row) => {
-        const value = Number(row[columnId]);
-        if (value != null && (min > value || (min === undefined && value >= value))) {
+    for (const row of data) {
+        const value = row[columnId];
+        if (typeof value === "number" && Number.isFinite(value) && (min === undefined || value < min)) {
             min = value;
         }
-    });
+    }
     return min;
 };
 export const max = (data, columnId) => {
     let max;
-    data.forEach((row) => {
-        const value = Number(row[columnId]);
-        if (value != null && (max < value || (max === undefined && value >= value))) {
+    for (const row of data) {
+        const value = row[columnId];
+        if (typeof value === "number" && Number.isFinite(value) && (max === undefined || value > max)) {
             max = value;
         }
-    });
+    }
     return max;
 };
 export const uniqueCount = (data, columnId) => {
     return new Set(data.map((d) => d[columnId])).size;
 };
-export const count = (data, columnId) => {
+export const count = (data, _columnId) => {
     return data.length;
 };
 export const mean = (data, columnId) => {
     let count = 0;
-    let sum = 0;
-    data.forEach((row) => {
-        let value = Number(row[columnId]);
-        if (value != null && (value = +value) >= value) {
-            (++count, (sum += value));
+    let total = 0;
+    for (const row of data) {
+        const value = row[columnId];
+        if (typeof value === "number" && Number.isFinite(value)) {
+            count += 1;
+            total += value;
         }
-    });
-    if (count)
-        return sum / count;
-    return;
+    }
+    return count > 0 ? total / count : undefined;
 };
 export const aggregationFns = {
     sum,

package/dist/components/custom/data-table/features.d.ts

@@ -0,0 +1,157 @@
+import { type RowData } from "@tanstack/svelte-table";
+import type { CustomColumnMeta, CustomOptions } from "./types";
+/** Feature set type used by {@link createShadTable}. */
+export type DataTableFeatures = typeof features;
+/**
+ * The static feature set shared by every {@link createShadTable} table.
+ *
+ * Includes:
+ * - all stock **feature modules** (so the `Table` / `ColumnDef` API surface and
+ *   every `table.atoms.<slice>` is always available and consistently typed)
+ * - the **row models** (sorted / filtered / paginated) — runtime-only, but
+ *   cheap to wire unconditionally: an unused pipeline simply falls through to
+ *   the previous stage (matching the TanStack examples)
+ * - the built-in **`filterFns` / `sortFns` / `aggregationFns` registries**, so
+ *   any string fn (including the default `"auto"`) resolves instead of silently
+ *   no-op'ing, and those strings typecheck in column defs
+ * - the per-table **`columnMeta` / `tableMeta`** slots (`meta.className`)
+ */
+export declare const features: {
+    sortedRowModel: (table: import("@tanstack/svelte-table").Table<any, any>) => () => import("@tanstack/svelte-table").RowModel<any, any>;
+    paginatedRowModel: (table: import("@tanstack/svelte-table").Table<any, any>) => () => import("@tanstack/svelte-table").RowModel<any, any>;
+    filteredRowModel: (table: import("@tanstack/svelte-table").Table<any, any>) => () => import("@tanstack/svelte-table").RowModel<any, any>;
+    filterFns: {
+        arrIncludes: import("@tanstack/svelte-table").CreatedFilterFn<any, any>;
+        arrIncludesAll: import("@tanstack/svelte-table").CreatedFilterFn<any, any>;
+        arrHas: import("@tanstack/svelte-table").CreatedFilterFn<any, any>;
+        arrIncludesSome: import("@tanstack/svelte-table").CreatedFilterFn<any, any>;
+        between: import("@tanstack/svelte-table").CreatedFilterFn<any, any>;
+        betweenInclusive: import("@tanstack/svelte-table").CreatedFilterFn<any, any>;
+        empty: import("@tanstack/svelte-table").CreatedFilterFn<any, any>;
+        endsWith: import("@tanstack/svelte-table").CreatedFilterFn<any, any>;
+        equals: import("@tanstack/svelte-table").CreatedFilterFn<any, any>;
+        equalsString: import("@tanstack/svelte-table").CreatedFilterFn<any, any>;
+        equalsStringSensitive: import("@tanstack/svelte-table").CreatedFilterFn<any, any>;
+        inDateRange: import("@tanstack/svelte-table").CreatedFilterFn<any, any>;
+        inNumberRange: import("@tanstack/svelte-table").CreatedFilterFn<any, any>;
+        includesString: import("@tanstack/svelte-table").CreatedFilterFn<any, any>;
+        includesStringSensitive: import("@tanstack/svelte-table").CreatedFilterFn<any, any>;
+        notEmpty: import("@tanstack/svelte-table").CreatedFilterFn<any, any>;
+        startsWith: import("@tanstack/svelte-table").CreatedFilterFn<any, any>;
+        weakEquals: import("@tanstack/svelte-table").CreatedFilterFn<any, any>;
+    };
+    sortFns: {
+        alphanumeric: import("@tanstack/svelte-table").CreatedSortFn<any, any>;
+        alphanumericCaseSensitive: import("@tanstack/svelte-table").CreatedSortFn<any, any>;
+        basic: import("@tanstack/svelte-table").CreatedSortFn<any, any>;
+        datetime: import("@tanstack/svelte-table").CreatedSortFn<any, any>;
+        text: import("@tanstack/svelte-table").CreatedSortFn<any, any>;
+        textCaseSensitive: import("@tanstack/svelte-table").CreatedSortFn<any, any>;
+    };
+    aggregationFns: {
+        sum: import("@tanstack/svelte-table").AggregationFnDef<any, any, unknown, number>;
+        min: import("@tanstack/svelte-table").AggregationFnDef<any, any, unknown, (number | Date) | undefined>;
+        max: import("@tanstack/svelte-table").AggregationFnDef<any, any, unknown, (number | Date) | undefined>;
+        extent: import("@tanstack/svelte-table").AggregationFnDef<any, any, unknown, [(number | Date) | undefined, (number | Date) | undefined]>;
+        mean: import("@tanstack/svelte-table").AggregationFnDef<any, any, unknown, number | undefined>;
+        median: import("@tanstack/svelte-table").AggregationFnDef<any, any, unknown, number | undefined>;
+        unique: import("@tanstack/svelte-table").AggregationFnDef<any, any, unknown, unknown[]>;
+        uniqueCount: import("@tanstack/svelte-table").AggregationFnDef<any, any, unknown, number>;
+        count: import("@tanstack/svelte-table").AggregationFnDef<any, any, unknown, number>;
+        first: import("@tanstack/svelte-table").AggregationFnDef<any, any, unknown, unknown>;
+        last: import("@tanstack/svelte-table").AggregationFnDef<any, any, unknown, unknown>;
+    };
+    columnMeta: CustomColumnMeta;
+    tableMeta: CustomOptions;
+    cellSelectionFeature: import("@tanstack/svelte-table").TableFeature;
+    cellSpanningFeature: import("@tanstack/svelte-table").TableFeature;
+    columnFacetingFeature: import("@tanstack/svelte-table").TableFeature;
+    columnFilteringFeature: import("@tanstack/svelte-table").TableFeature;
+    columnGroupingFeature: import("@tanstack/svelte-table").TableFeature;
+    columnOrderingFeature: import("@tanstack/svelte-table").TableFeature;
+    columnPinningFeature: import("@tanstack/svelte-table").TableFeature;
+    columnResizingFeature: import("@tanstack/svelte-table").TableFeature;
+    columnSizingFeature: import("@tanstack/svelte-table").TableFeature;
+    columnVisibilityFeature: import("@tanstack/svelte-table").TableFeature;
+    globalFilteringFeature: import("@tanstack/svelte-table").TableFeature;
+    rowAggregationFeature: import("@tanstack/svelte-table").TableFeature;
+    rowExpandingFeature: import("@tanstack/svelte-table").TableFeature;
+    rowPaginationFeature: import("@tanstack/svelte-table").TableFeature;
+    rowPinningFeature: import("@tanstack/svelte-table").TableFeature;
+    rowSelectionFeature: import("@tanstack/svelte-table").TableFeature;
+    rowSortingFeature: import("@tanstack/svelte-table").TableFeature;
+};
+/**
+ * Creates a `ColumnHelper` bound to the library's feature set, so consumers
+ * get the same typed API as the TanStack examples:
+ *
+ * ```ts
+ * const helper = createColumnHelper<Person>();
+ * const columns = helper.columns([helper.accessor("name", { header: "Name" })]);
+ * ```
+ */
+export declare const createColumnHelperFor: <TData extends RowData>() => import("@tanstack/svelte-table").ColumnHelper<{
+    sortedRowModel: (table: import("@tanstack/svelte-table").Table<any, any>) => () => import("@tanstack/svelte-table").RowModel<any, any>;
+    paginatedRowModel: (table: import("@tanstack/svelte-table").Table<any, any>) => () => import("@tanstack/svelte-table").RowModel<any, any>;
+    filteredRowModel: (table: import("@tanstack/svelte-table").Table<any, any>) => () => import("@tanstack/svelte-table").RowModel<any, any>;
+    filterFns: {
+        arrIncludes: import("@tanstack/svelte-table").CreatedFilterFn<any, any>;
+        arrIncludesAll: import("@tanstack/svelte-table").CreatedFilterFn<any, any>;
+        arrHas: import("@tanstack/svelte-table").CreatedFilterFn<any, any>;
+        arrIncludesSome: import("@tanstack/svelte-table").CreatedFilterFn<any, any>;
+        between: import("@tanstack/svelte-table").CreatedFilterFn<any, any>;
+        betweenInclusive: import("@tanstack/svelte-table").CreatedFilterFn<any, any>;
+        empty: import("@tanstack/svelte-table").CreatedFilterFn<any, any>;
+        endsWith: import("@tanstack/svelte-table").CreatedFilterFn<any, any>;
+        equals: import("@tanstack/svelte-table").CreatedFilterFn<any, any>;
+        equalsString: import("@tanstack/svelte-table").CreatedFilterFn<any, any>;
+        equalsStringSensitive: import("@tanstack/svelte-table").CreatedFilterFn<any, any>;
+        inDateRange: import("@tanstack/svelte-table").CreatedFilterFn<any, any>;
+        inNumberRange: import("@tanstack/svelte-table").CreatedFilterFn<any, any>;
+        includesString: import("@tanstack/svelte-table").CreatedFilterFn<any, any>;
+        includesStringSensitive: import("@tanstack/svelte-table").CreatedFilterFn<any, any>;
+        notEmpty: import("@tanstack/svelte-table").CreatedFilterFn<any, any>;
+        startsWith: import("@tanstack/svelte-table").CreatedFilterFn<any, any>;
+        weakEquals: import("@tanstack/svelte-table").CreatedFilterFn<any, any>;
+    };
+    sortFns: {
+        alphanumeric: import("@tanstack/svelte-table").CreatedSortFn<any, any>;
+        alphanumericCaseSensitive: import("@tanstack/svelte-table").CreatedSortFn<any, any>;
+        basic: import("@tanstack/svelte-table").CreatedSortFn<any, any>;
+        datetime: import("@tanstack/svelte-table").CreatedSortFn<any, any>;
+        text: import("@tanstack/svelte-table").CreatedSortFn<any, any>;
+        textCaseSensitive: import("@tanstack/svelte-table").CreatedSortFn<any, any>;
+    };
+    aggregationFns: {
+        sum: import("@tanstack/svelte-table").AggregationFnDef<any, any, unknown, number>;
+        min: import("@tanstack/svelte-table").AggregationFnDef<any, any, unknown, (number | Date) | undefined>;
+        max: import("@tanstack/svelte-table").AggregationFnDef<any, any, unknown, (number | Date) | undefined>;
+        extent: import("@tanstack/svelte-table").AggregationFnDef<any, any, unknown, [(number | Date) | undefined, (number | Date) | undefined]>;
+        mean: import("@tanstack/svelte-table").AggregationFnDef<any, any, unknown, number | undefined>;
+        median: import("@tanstack/svelte-table").AggregationFnDef<any, any, unknown, number | undefined>;
+        unique: import("@tanstack/svelte-table").AggregationFnDef<any, any, unknown, unknown[]>;
+        uniqueCount: import("@tanstack/svelte-table").AggregationFnDef<any, any, unknown, number>;
+        count: import("@tanstack/svelte-table").AggregationFnDef<any, any, unknown, number>;
+        first: import("@tanstack/svelte-table").AggregationFnDef<any, any, unknown, unknown>;
+        last: import("@tanstack/svelte-table").AggregationFnDef<any, any, unknown, unknown>;
+    };
+    columnMeta: CustomColumnMeta;
+    tableMeta: CustomOptions;
+    cellSelectionFeature: import("@tanstack/svelte-table").TableFeature;
+    cellSpanningFeature: import("@tanstack/svelte-table").TableFeature;
+    columnFacetingFeature: import("@tanstack/svelte-table").TableFeature;
+    columnFilteringFeature: import("@tanstack/svelte-table").TableFeature;
+    columnGroupingFeature: import("@tanstack/svelte-table").TableFeature;
+    columnOrderingFeature: import("@tanstack/svelte-table").TableFeature;
+    columnPinningFeature: import("@tanstack/svelte-table").TableFeature;
+    columnResizingFeature: import("@tanstack/svelte-table").TableFeature;
+    columnSizingFeature: import("@tanstack/svelte-table").TableFeature;
+    columnVisibilityFeature: import("@tanstack/svelte-table").TableFeature;
+    globalFilteringFeature: import("@tanstack/svelte-table").TableFeature;
+    rowAggregationFeature: import("@tanstack/svelte-table").TableFeature;
+    rowExpandingFeature: import("@tanstack/svelte-table").TableFeature;
+    rowPaginationFeature: import("@tanstack/svelte-table").TableFeature;
+    rowPinningFeature: import("@tanstack/svelte-table").TableFeature;
+    rowSelectionFeature: import("@tanstack/svelte-table").TableFeature;
+    rowSortingFeature: import("@tanstack/svelte-table").TableFeature;
+}, TData>;