fuma 2.0.2 → 2.0.4

package/dist/ui/table/Table.svelte.d.ts

@@ -1,45 +1,37 @@
-import type { ComponentAndProps } from '../../utils/component.js';
-import { type TableField } from './index.js';
-declare class __sveltets_Render<Item extends {
-    id: string;
-}> {
-    props(): {
+import { type TableField, type ItemBase } from './index.js';
+import type { Snippet } from 'svelte';
+declare function $$render<Item extends ItemBase>(): {
+    props: {
         key?: string;
         fields: TableField<Item>[];
         items: Item[];
-        slotAction?: ((item: Item) => ComponentAndProps) | undefined;
+        actions?: Snippet<[item: Item]>;
         placholder?: string;
         class?: string;
         classRow?: string;
         hideBody?: boolean;
-        onCreateField?: (() => void) | undefined;
+        onCreateField?: () => void;
+        onclick?: (item?: Item) => void;
     };
-    events(): {
-        click: CustomEvent<{
-            id: string;
-        }>;
-    } & {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots(): {};
-    bindings(): string;
+    exports: {};
+    bindings: "";
+    slots: {};
+    events: {};
+};
+declare class __sveltets_Render<Item extends ItemBase> {
+    props(): ReturnType<typeof $$render<Item>>['props'];
+    events(): ReturnType<typeof $$render<Item>>['events'];
+    slots(): ReturnType<typeof $$render<Item>>['slots'];
+    bindings(): "";
     exports(): {};
 }
 interface $$IsomorphicComponent {
-    new <Item extends {
-        id: string;
-    }>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<Item>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<Item>['props']>, ReturnType<__sveltets_Render<Item>['events']>, ReturnType<__sveltets_Render<Item>['slots']>> & {
+    new <Item extends ItemBase>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<Item>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<Item>['props']>, ReturnType<__sveltets_Render<Item>['events']>, ReturnType<__sveltets_Render<Item>['slots']>> & {
         $$bindings?: ReturnType<__sveltets_Render<Item>['bindings']>;
     } & ReturnType<__sveltets_Render<Item>['exports']>;
-    <Item extends {
-        id: string;
-    }>(internal: unknown, props: ReturnType<__sveltets_Render<Item>['props']> & {
-        $$events?: ReturnType<__sveltets_Render<Item>['events']>;
-    }): ReturnType<__sveltets_Render<Item>['exports']>;
+    <Item extends ItemBase>(internal: unknown, props: ReturnType<__sveltets_Render<Item>['props']> & {}): ReturnType<__sveltets_Render<Item>['exports']>;
     z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
 }
 declare const Table: $$IsomorphicComponent;
-type Table<Item extends {
-    id: string;
-}> = InstanceType<typeof Table<Item>>;
+type Table<Item extends ItemBase> = InstanceType<typeof Table<Item>>;
 export default Table;

package/dist/ui/table/TableBody.svelte

@@ -1,33 +1,33 @@
-<script lang="ts" generics="Item extends {id: string}">
-	import { createEventDispatcher } from 'svelte'
+<script lang="ts" generics="Item extends ItemBase">
+	import { TableCell, type ItemBase, type TableField } from './index.js'
+	import type { Snippet } from 'svelte'
 
-	import { TableCell, type TableField } from './index.js'
-	import type { ComponentAndProps } from '../../utils/component.js'
+	let {
+		items,
+		fields,
+		actions,
+		classRow,
+		onclick
+	}: {
+		items: Item[]
+		fields: TableField<Item>[]
+		actions?: Snippet<[item: Item]>
+		classRow?: string
+		onclick?: (item?: Item) => void
+	} = $props()
 
-	export let items: Item[]
-	export let fields: TableField<Item>[]
-	export let action: ((item: Item) => ComponentAndProps) | undefined = undefined
-	export let classRow = ''
-
-	const dispatch = createEventDispatcher<{ click: Item }>()
-
-	$: _fields = fields.filter((f) => f.$visible)
-
-	function handleClickRow(event: MouseEvent, item: Item) {
-		dispatch('click', item)
-	}
+	let fieldsVisible = $derived(fields.filter((f) => f._visible))
 </script>
 
 <tbody>
 	{#each items as item (item.id)}
-		<tr class={classRow} on:click={(event) => handleClickRow(event, item)}>
-			{#each _fields as field (field.key)}
+		<tr class={classRow} onclick={() => onclick?.(item)}>
+			{#each fieldsVisible as field (field.key)}
 				<TableCell {item} {field} />
 			{/each}
 			<td align="right">
-				{#if action}
-					{@const { component, props } = action(item)}
-					<svelte:component this={component} {...props} />
+				{#if actions}
+					{@render actions(item)}
 				{/if}
 			</td>
 		</tr>

package/dist/ui/table/TableBody.svelte.d.ts

@@ -1,38 +1,32 @@
-import { type TableField } from './index.js';
-import type { ComponentAndProps } from '../../utils/component.js';
-declare class __sveltets_Render<Item extends {
-    id: string;
-}> {
-    props(): {
+import { type ItemBase, type TableField } from './index.js';
+import type { Snippet } from 'svelte';
+declare function $$render<Item extends ItemBase>(): {
+    props: {
         items: Item[];
         fields: TableField<Item>[];
-        action?: ((item: Item) => ComponentAndProps) | undefined;
+        actions?: Snippet<[item: Item]>;
         classRow?: string;
+        onclick?: (item?: Item) => void;
     };
-    events(): {
-        click: CustomEvent<Item>;
-    } & {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots(): {};
-    bindings(): string;
+    exports: {};
+    bindings: "";
+    slots: {};
+    events: {};
+};
+declare class __sveltets_Render<Item extends ItemBase> {
+    props(): ReturnType<typeof $$render<Item>>['props'];
+    events(): ReturnType<typeof $$render<Item>>['events'];
+    slots(): ReturnType<typeof $$render<Item>>['slots'];
+    bindings(): "";
     exports(): {};
 }
 interface $$IsomorphicComponent {
-    new <Item extends {
-        id: string;
-    }>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<Item>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<Item>['props']>, ReturnType<__sveltets_Render<Item>['events']>, ReturnType<__sveltets_Render<Item>['slots']>> & {
+    new <Item extends ItemBase>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<Item>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<Item>['props']>, ReturnType<__sveltets_Render<Item>['events']>, ReturnType<__sveltets_Render<Item>['slots']>> & {
         $$bindings?: ReturnType<__sveltets_Render<Item>['bindings']>;
     } & ReturnType<__sveltets_Render<Item>['exports']>;
-    <Item extends {
-        id: string;
-    }>(internal: unknown, props: ReturnType<__sveltets_Render<Item>['props']> & {
-        $$events?: ReturnType<__sveltets_Render<Item>['events']>;
-    }): ReturnType<__sveltets_Render<Item>['exports']>;
+    <Item extends ItemBase>(internal: unknown, props: ReturnType<__sveltets_Render<Item>['props']> & {}): ReturnType<__sveltets_Render<Item>['exports']>;
     z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
 }
 declare const TableBody: $$IsomorphicComponent;
-type TableBody<Item extends {
-    id: string;
-}> = InstanceType<typeof TableBody<Item>>;
+type TableBody<Item extends ItemBase> = InstanceType<typeof TableBody<Item>>;
 export default TableBody;

package/dist/ui/table/TableCell.svelte

@@ -1,30 +1,29 @@
-<script lang="ts" generics="Item extends {id: string}">
+<script lang="ts" generics="Item extends ItemBase">
 	import {
 		TableCellArray,
 		TableCellBoolean,
 		TableCellNumber,
 		TableCellString
 	} from './cell/index.js'
-	import type { TableField } from './index.js'
+	import type { ItemBase, TableField } from './index.js'
 
-	export let item: Item
-	export let field: TableField<Item>
+	let { item, field }: { item: Item; field: TableField<Item> } = $props()
 
-	$: value = field.getCell(item)
+	let cell = $derived(field.cell(item))
 </script>
 
-{#if Array.isArray(value)}
-	<TableCellArray {value} />
-{:else if typeof value === 'number'}
-	<TableCellNumber {value} />
-{:else if typeof value === 'boolean'}
-	<TableCellBoolean {value} />
-{:else if typeof value === 'string'}
-	<TableCellString {value} {field} />
-{:else if value === undefined || value === null}
+{#if Array.isArray(cell)}
+	<TableCellArray {cell} />
+{:else if typeof cell === 'number'}
+	<TableCellNumber {cell} />
+{:else if typeof cell === 'boolean'}
+	<TableCellBoolean {cell} />
+{:else if typeof cell === 'string'}
+	<TableCellString {cell} {field} />
+{:else if cell === undefined || cell === null}
 	<td>-</td>
 {:else}
 	<td>
-		<svelte:component this={value.component} {...value.props} />
+		{@render cell(item)}
 	</td>
 {/if}

package/dist/ui/table/TableCell.svelte.d.ts

@@ -1,33 +1,28 @@
-import type { TableField } from './index.js';
-declare class __sveltets_Render<Item extends {
-    id: string;
-}> {
-    props(): {
+import type { ItemBase, TableField } from './index.js';
+declare function $$render<Item extends ItemBase>(): {
+    props: {
         item: Item;
         field: TableField<Item>;
     };
-    events(): {} & {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots(): {};
-    bindings(): string;
+    exports: {};
+    bindings: "";
+    slots: {};
+    events: {};
+};
+declare class __sveltets_Render<Item extends ItemBase> {
+    props(): ReturnType<typeof $$render<Item>>['props'];
+    events(): ReturnType<typeof $$render<Item>>['events'];
+    slots(): ReturnType<typeof $$render<Item>>['slots'];
+    bindings(): "";
     exports(): {};
 }
 interface $$IsomorphicComponent {
-    new <Item extends {
-        id: string;
-    }>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<Item>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<Item>['props']>, ReturnType<__sveltets_Render<Item>['events']>, ReturnType<__sveltets_Render<Item>['slots']>> & {
+    new <Item extends ItemBase>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<Item>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<Item>['props']>, ReturnType<__sveltets_Render<Item>['events']>, ReturnType<__sveltets_Render<Item>['slots']>> & {
         $$bindings?: ReturnType<__sveltets_Render<Item>['bindings']>;
     } & ReturnType<__sveltets_Render<Item>['exports']>;
-    <Item extends {
-        id: string;
-    }>(internal: unknown, props: ReturnType<__sveltets_Render<Item>['props']> & {
-        $$events?: ReturnType<__sveltets_Render<Item>['events']>;
-    }): ReturnType<__sveltets_Render<Item>['exports']>;
+    <Item extends ItemBase>(internal: unknown, props: ReturnType<__sveltets_Render<Item>['props']> & {}): ReturnType<__sveltets_Render<Item>['exports']>;
     z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
 }
 declare const TableCell: $$IsomorphicComponent;
-type TableCell<Item extends {
-    id: string;
-}> = InstanceType<typeof TableCell<Item>>;
+type TableCell<Item extends ItemBase> = InstanceType<typeof TableCell<Item>>;
 export default TableCell;

package/dist/ui/table/TableFieldsEdition.svelte

@@ -26,7 +26,7 @@
 
 	const { KEY_FIELDS_VISIBLE, KEY_FIELDS_HIDDEN, KEY_FIELDS_ORDER } = context.get(key)
 
-	function getFieldHref(field: TableField) {
+	function getFieldHref(field: TableField<Item>) {
 		if (field.locked) return
 		const url = toggleParam(field.visible ? KEY_FIELDS_HIDDEN : KEY_FIELDS_VISIBLE, field.key)
 		if (url.searchParams.has(field.key)) {
@@ -106,7 +106,7 @@
 							<Icon path={mdiCheck} class="fill-base-content/50" size={21} />
 						{:else if $urlParam.has(field.key)}
 							<Icon path={mdiCheckCircleOutline} class="fill-primary" size={21} />
-						{:else if field.$visible}
+						{:else if field._visible}
 							<Icon path={mdiCheck} class="fill-success" size={21} />
 						{:else}
 							<Icon path={mdiCircleSmall} class="fill-base-content/50" size={21} />

package/dist/ui/table/TableHead.svelte

@@ -1,29 +1,41 @@
-<script lang="ts" generics="Item extends {id: string}">
-	import { component, type ComponentAndProps } from '../../utils/component.js'
+<script lang="ts">
 	import { type TableField, TableFieldsEdition } from './index.js'
-	import { tableHeadComponent } from './head/index.js'
-	import TableHeadDefault from './head/TableHeadDefault.svelte'
+	import {
+		TableHeadBoolean,
+		TableHeadDate,
+		TableHeadDefault,
+		TableHeadNumber,
+		TableHeadSelect,
+		TableHeadString
+	} from './head/index.js'
 
-	export let fields: TableField<Item>[]
-	export let key: string
-	export let onCreateField: (() => void) | undefined = undefined
-
-	function getComponent(field: TableField): ComponentAndProps {
-		if (field.type === 'select' || field.type === 'multiselect')
-			return tableHeadComponent(field.type, { options: field.options || [] })(field)
-		if (field.type) return tableHeadComponent(field.type, {})(field)
-		if (!field.head) return component(TableHeadDefault, { field })
-		if (typeof field.head === 'function') return field.head(field)
-		if (typeof field.head === 'string') return tableHeadComponent(field.head, {})(field)
-		return field.head
-	}
+	let {
+		fields,
+		key,
+		onCreateField
+	}: {
+		fields: TableField[]
+		key: string
+		onCreateField?: () => void
+	} = $props()
 </script>
 
 <thead>
 	<tr class="shadow">
-		{#each fields.filter((f) => f.$visible) as field (field.key)}
-			{@const { component, props } = getComponent(field)}
-			<svelte:component this={component} {...props} />
+		{#each fields.filter((f) => f._visible) as field (field.key)}
+			{#if !field.type}
+				<TableHeadDefault {field} />
+			{:else if field.type === 'string' || field.type === 'textarea'}
+				<TableHeadString {field} />
+			{:else if field.type === 'number'}
+				<TableHeadNumber {field} />
+			{:else if field.type === 'boolean'}
+				<TableHeadBoolean {field} />
+			{:else if field.type === 'date'}
+				<TableHeadDate {field} />
+			{:else if field.options}
+				<TableHeadSelect {field} options={field.options} />
+			{/if}
 		{/each}
 		<TableFieldsEdition {fields} {key} {onCreateField} />
 	</tr>

package/dist/ui/table/TableHead.svelte.d.ts

@@ -1,34 +1,9 @@
 import { type TableField } from './index.js';
-declare class __sveltets_Render<Item extends {
-    id: string;
-}> {
-    props(): {
-        fields: TableField<Item>[];
-        key: string;
-        onCreateField?: (() => void) | undefined;
-    };
-    events(): {} & {
-        [evt: string]: CustomEvent<any>;
-    };
-    slots(): {};
-    bindings(): string;
-    exports(): {};
-}
-interface $$IsomorphicComponent {
-    new <Item extends {
-        id: string;
-    }>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<Item>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<Item>['props']>, ReturnType<__sveltets_Render<Item>['events']>, ReturnType<__sveltets_Render<Item>['slots']>> & {
-        $$bindings?: ReturnType<__sveltets_Render<Item>['bindings']>;
-    } & ReturnType<__sveltets_Render<Item>['exports']>;
-    <Item extends {
-        id: string;
-    }>(internal: unknown, props: ReturnType<__sveltets_Render<Item>['props']> & {
-        $$events?: ReturnType<__sveltets_Render<Item>['events']>;
-    }): ReturnType<__sveltets_Render<Item>['exports']>;
-    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
-}
-declare const TableHead: $$IsomorphicComponent;
-type TableHead<Item extends {
-    id: string;
-}> = InstanceType<typeof TableHead<Item>>;
+type $$ComponentProps = {
+    fields: TableField[];
+    key: string;
+    onCreateField?: () => void;
+};
+declare const TableHead: import("svelte").Component<$$ComponentProps, {}, "">;
+type TableHead = ReturnType<typeof TableHead>;
 export default TableHead;

package/dist/ui/table/cell/TableCellArray.svelte

@@ -1,14 +1,11 @@
 <script lang="ts">
-	import { Badge } from '../../badge/index.js'
-	import { component, type ComponentAndProps } from '../../../utils/component.js'
-
-	export let value: (ComponentAndProps | string | number | boolean)[]
+	let { cell }: { cell: (string | number | boolean)[] } = $props()
 </script>
 
 <td>
-	{#each value as v}
-		{@const componentAndProps =
-			typeof v === 'object' ? v : component(Badge, { content: String(v) })}
-		<svelte:component this={componentAndProps.component} {...componentAndProps.props} />
+	{#each cell as content}
+		<span class="badge mr-1 whitespace-nowrap">
+			{content}
+		</span>
 	{/each}
 </td>

package/dist/ui/table/cell/TableCellArray.svelte.d.ts

@@ -1,21 +1,6 @@
-import { type ComponentAndProps } from '../../../utils/component.js';
-interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
-    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
-        $$bindings?: Bindings;
-    } & Exports;
-    (internal: unknown, props: Props & {
-        $$events?: Events;
-        $$slots?: Slots;
-    }): Exports & {
-        $set?: any;
-        $on?: any;
-    };
-    z_$$bindings?: Bindings;
-}
-declare const TableCellArray: $$__sveltets_2_IsomorphicComponent<{
-    value: (ComponentAndProps | string | number | boolean)[];
-}, {
-    [evt: string]: CustomEvent<any>;
-}, {}, {}, string>;
-type TableCellArray = InstanceType<typeof TableCellArray>;
+type $$ComponentProps = {
+    cell: (string | number | boolean)[];
+};
+declare const TableCellArray: import("svelte").Component<$$ComponentProps, {}, "">;
+type TableCellArray = ReturnType<typeof TableCellArray>;
 export default TableCellArray;

package/dist/ui/table/cell/TableCellBoolean.svelte

@@ -1,11 +1,12 @@
 <script lang="ts">
 	import { mdiCheck, mdiClose } from '@mdi/js'
 	import { Icon } from '../../icon/index.js'
-	export let value: boolean
+
+	let { cell }: { cell: boolean } = $props()
 </script>
 
 <td>
-	{#if value}
+	{#if cell}
 		<Icon path={mdiCheck} class="fill-success" />
 	{:else}
 		<Icon path={mdiClose} class="fill-error" />

package/dist/ui/table/cell/TableCellBoolean.svelte.d.ts

@@ -1,20 +1,6 @@
-interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
-    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
-        $$bindings?: Bindings;
-    } & Exports;
-    (internal: unknown, props: Props & {
-        $$events?: Events;
-        $$slots?: Slots;
-    }): Exports & {
-        $set?: any;
-        $on?: any;
-    };
-    z_$$bindings?: Bindings;
-}
-declare const TableCellBoolean: $$__sveltets_2_IsomorphicComponent<{
-    value: boolean;
-}, {
-    [evt: string]: CustomEvent<any>;
-}, {}, {}, string>;
-type TableCellBoolean = InstanceType<typeof TableCellBoolean>;
+type $$ComponentProps = {
+    cell: boolean;
+};
+declare const TableCellBoolean: import("svelte").Component<$$ComponentProps, {}, "">;
+type TableCellBoolean = ReturnType<typeof TableCellBoolean>;
 export default TableCellBoolean;

package/dist/ui/table/cell/TableCellNumber.svelte

@@ -1,7 +1,7 @@
 <script lang="ts">
-	export let value: number
+	let { cell }: { cell: number } = $props()
 </script>
 
 <td>
-	<span class="badge">{value}</span>
+	<span class="badge">{cell}</span>
 </td>

package/dist/ui/table/cell/TableCellNumber.svelte.d.ts

@@ -1,20 +1,6 @@
-interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
-    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
-        $$bindings?: Bindings;
-    } & Exports;
-    (internal: unknown, props: Props & {
-        $$events?: Events;
-        $$slots?: Slots;
-    }): Exports & {
-        $set?: any;
-        $on?: any;
-    };
-    z_$$bindings?: Bindings;
-}
-declare const TableCellNumber: $$__sveltets_2_IsomorphicComponent<{
-    value: number;
-}, {
-    [evt: string]: CustomEvent<any>;
-}, {}, {}, string>;
-type TableCellNumber = InstanceType<typeof TableCellNumber>;
+type $$ComponentProps = {
+    cell: number;
+};
+declare const TableCellNumber: import("svelte").Component<$$ComponentProps, {}, "">;
+type TableCellNumber = ReturnType<typeof TableCellNumber>;
 export default TableCellNumber;

package/dist/ui/table/cell/TableCellString.svelte

@@ -1,10 +1,10 @@
-<script lang="ts">
-	import type { TableField } from '../index.js'
+<script lang="ts" generics="Item extends ItemBase">
+	import type { ItemBase, TableField } from '../index.js'
 
-	export let value: string
-	export let field: TableField
+	let { cell, field }: { cell: string; field: TableField<Item> } = $props()
 </script>
 
 <td data-field-key={field.key} data-field-type={field.type === 'textarea' ? 'textarea' : 'string'}>
-	<span>{@html value}</span>
+	<!-- TODO: Sanitize -->
+	<span>{@html cell}</span>
 </td>

package/dist/ui/table/cell/TableCellString.svelte.d.ts

@@ -1,22 +1,28 @@
-import type { TableField } from '../index.js';
-interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
-    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
-        $$bindings?: Bindings;
-    } & Exports;
-    (internal: unknown, props: Props & {
-        $$events?: Events;
-        $$slots?: Slots;
-    }): Exports & {
-        $set?: any;
-        $on?: any;
+import type { ItemBase, TableField } from '../index.js';
+declare function $$render<Item extends ItemBase>(): {
+    props: {
+        cell: string;
+        field: TableField<Item>;
     };
-    z_$$bindings?: Bindings;
+    exports: {};
+    bindings: "";
+    slots: {};
+    events: {};
+};
+declare class __sveltets_Render<Item extends ItemBase> {
+    props(): ReturnType<typeof $$render<Item>>['props'];
+    events(): ReturnType<typeof $$render<Item>>['events'];
+    slots(): ReturnType<typeof $$render<Item>>['slots'];
+    bindings(): "";
+    exports(): {};
 }
-declare const TableCellString: $$__sveltets_2_IsomorphicComponent<{
-    value: string;
-    field: TableField;
-}, {
-    [evt: string]: CustomEvent<any>;
-}, {}, {}, string>;
-type TableCellString = InstanceType<typeof TableCellString>;
+interface $$IsomorphicComponent {
+    new <Item extends ItemBase>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<Item>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<Item>['props']>, ReturnType<__sveltets_Render<Item>['events']>, ReturnType<__sveltets_Render<Item>['slots']>> & {
+        $$bindings?: ReturnType<__sveltets_Render<Item>['bindings']>;
+    } & ReturnType<__sveltets_Render<Item>['exports']>;
+    <Item extends ItemBase>(internal: unknown, props: ReturnType<__sveltets_Render<Item>['props']> & {}): ReturnType<__sveltets_Render<Item>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
+}
+declare const TableCellString: $$IsomorphicComponent;
+type TableCellString<Item extends ItemBase> = InstanceType<typeof TableCellString<Item>>;
 export default TableCellString;