@lavalogic/scoria 0.0.1

package/dist/Components/Table/Body/Rows/Columns/ProgressCell.svelte

@@ -0,0 +1,161 @@
+<svelte:options runes />
+
+<script lang="ts" module>
+	import ProgressBubble from '../../../../ProgressBubble.svelte';
+	import type { ProgressBarTableCell } from '../../../Types/Columns/ProgressBarTableCell.js';
+	import { TableContext } from '../../../Types/Context/TableContext.svelte.js';
+	import { TableFocusDetails } from '../../../Types/Focus/TableFocusDetails.svelte.js';
+	import { ToastContext } from '../../../../../Contexts/ToastContext.svelte.js';
+	import { Validity } from '../../../../../Types/Internal/Validity.js';
+	import { getContext, tick, untrack } from 'svelte';
+
+	export interface ProgressCellProps<T extends object> {
+		cell: ProgressBarTableCell<T>;
+	}
+</script>
+
+<!-- TODO editable version of this should contain a multi select -->
+<script lang="ts" generics="T extends object">
+	const { cell }: ProgressCellProps<T> = $props();
+
+	const value: [number, number] = $derived(cell.getValue()) as [number, number];
+
+	const tableContext = getContext<TableContext<T>>(TableContext.identifier);
+	const { toast } = getContext<ToastContext>(ToastContext.identifier);
+
+	// const previousRowIndex: number | undefined = $state(undefined);
+
+	const focusDetails: TableFocusDetails<T> = $derived(
+		new TableFocusDetails(cell, tableContext, toast)
+	);
+
+	let previousValidity = $state(Validity.Valid);
+	let validity = $state(Validity.Valid);
+	$effect(() => {
+		focusDetails.validityTuple.then(([newValidity]) => {
+			untrack(() => {
+				tick().then(() => {
+					validity = newValidity;
+				});
+			});
+		});
+	});
+
+	$effect(() => {
+		if (validity != previousValidity) {
+			untrack(() => {
+				tick().then(() => {
+					if (validity === Validity.Invalid) {
+						tableContext.addInvalidValue(cell.row.original);
+					} else {
+						tableContext.removeInvalidValue(cell.row.original);
+					}
+					previousValidity = validity;
+				});
+			});
+		}
+	});
+
+	const colours = $derived(
+		cell.column.columnDef.getColour?.(cell.row.original, cell.row.index, value)
+	);
+</script>
+
+<!-- svelte-ignore a11y_mouse_events_have_key_events -->
+<td
+	id={`${tableContext.tableName}-cell-${cell.row.index}-${cell.column.id}`}
+	tabIndex={0}
+	class="focusable"
+	class:multifocus={focusDetails.isMultiFocused}
+	class:multifocus-start={focusDetails.isMultiFocusStart}
+	style={focusDetails.outline}
+	class:info={validity == Validity.Info}
+	class:success={validity == Validity.Valid}
+	class:warning={validity == Validity.Warning}
+	class:error={validity == Validity.Invalid}
+	onmousedown={(e) => {
+		// start focus only on left click
+		if (e.button === 0) {
+			if (e.shiftKey) {
+				e.preventDefault();
+				tableContext.setFocusEnd(focusDetails.coordinates);
+			} else {
+				tableContext.startFocus(focusDetails.coordinates);
+			}
+		}
+	}}
+	onmouseover={() => {
+		if (tableContext.isMousingDown) {
+			tableContext.setFocusEnd(focusDetails.coordinates);
+		}
+	}}
+	onmouseup={() => {
+		tableContext.endFocus(focusDetails.coordinates);
+	}}
+>
+	<div class="bubble-parent">
+		<ProgressBubble {value} {colours} />
+	</div>
+</td>
+
+<style>td {
+  transition: line-height 0.2s ease, height 0.2s ease;
+  --input-border: none;
+  --input-height: var(--height);
+  white-space: nowrap;
+  overflow-x: clip;
+  text-overflow: ellipsis;
+  position: relative;
+  padding-left: 0.75rem;
+  padding-right: 0.75rem;
+  border: solid 1px #cbd4da;
+  border-left: none;
+}
+
+td.multifocus {
+  background-color: var(--multifocus-colour, #e6f8fd);
+}
+td.multifocus.multifocus-start {
+  background-color: #ffffff;
+}
+
+td.focusable {
+  user-select: none;
+  cursor: default;
+  outline: none;
+}
+td.focusable.editable {
+  cursor: pointer;
+}
+
+td.info {
+  background-color: #1f81a0;
+}
+td.warning {
+  background-color: #f8eab8;
+}
+td.error {
+  background-color: #f9e9e9;
+}
+
+td {
+  max-height: var(--max-height);
+  height: var(--height);
+  box-sizing: content-box;
+  overflow-x: clip;
+  --td-padding-left: 0;
+  --td-padding-right: 0;
+}
+
+div.bubble-parent {
+  display: flex;
+  flex-flow: row wrap;
+  max-width: 100%;
+  box-sizing: border-box;
+  height: 100%;
+  overflow-x: clip;
+  justify-content: flex-start;
+  align-items: center;
+  gap: 0.75rem;
+  --line-height: 1;
+}</style>

package/dist/Components/Table/Body/Rows/Columns/ProgressCell.svelte.d.ts

@@ -0,0 +1,28 @@
+import type { ProgressBarTableCell } from '../../../Types/Columns/ProgressBarTableCell.js';
+export interface ProgressCellProps<T extends object> {
+    cell: ProgressBarTableCell<T>;
+}
+declare function $$render<T extends object>(): {
+    props: ProgressCellProps<T>;
+    exports: {};
+    bindings: "";
+    slots: {};
+    events: {};
+};
+declare class __sveltets_Render<T extends object> {
+    props(): ReturnType<typeof $$render<T>>['props'];
+    events(): ReturnType<typeof $$render<T>>['events'];
+    slots(): ReturnType<typeof $$render<T>>['slots'];
+    bindings(): "";
+    exports(): {};
+}
+interface $$IsomorphicComponent {
+    new <T extends object>(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 extends object>(internal: unknown, props: ReturnType<__sveltets_Render<T>['props']> & {}): ReturnType<__sveltets_Render<T>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
+}
+declare const ProgressCell: $$IsomorphicComponent;
+type ProgressCell<T extends object> = InstanceType<typeof ProgressCell<T>>;
+export default ProgressCell;

package/dist/Components/Table/Body/Rows/Columns/TableAction.svelte

@@ -0,0 +1,62 @@
+<svelte:options runes />
+
+<script lang="ts" module>
+	import Button from '../../../../Button.svelte';
+	import { ColourSet } from '../../../../../scss/colours.js';
+	import { Size } from '../../../../../Types/Internal/Size.js';
+	import type { ActionsDef } from '../../../Types/Columns/Definitions/Actions/ActionsDef.svelte.js';
+	import type { TableActionButton } from '../../../Types/Columns/TableActionButton.js';
+	import type { TableCell } from '../../../Types/Columns/TableCell.js';
+	import { getErrorMessage } from '../../../../../Helpers/Helpers.svelte.js';
+
+	export interface TableActionProps<T extends object> {
+		action: TableActionButton<T>;
+		cell: TableCell<T>;
+	}
+</script>
+
+<script lang="ts" generics="T extends object">
+	const { action, cell }: TableActionProps<T> = $props();
+
+	const isEnabledPromise: boolean | Promise<boolean> = $derived.by(() => {
+		if (action.isDisabled) {
+			return action.isDisabled(cell.row.original, cell.row.index);
+		} else if ((cell.column.columnDef as ActionsDef<T>).isEnabled) {
+			return (cell.column.columnDef as ActionsDef<T>).isEnabled!(
+				cell.row.original,
+				cell.row.index,
+				action
+			);
+		}
+
+		return Promise.resolve(true);
+	});
+
+	const labelPromise: Promise<string> = $derived.by(() => {
+		const result = action.getLabel(cell.row.original, cell.row.index);
+
+		if (typeof result == 'object') {
+			return result.then((it) => it);
+		} else {
+			return Promise.resolve(result);
+		}
+	});
+</script>
+
+{#await Promise.all([labelPromise, isEnabledPromise]) then [label, enabled]}
+	<Button
+		fullWidth
+		size={Size.Medium}
+		colourSet={(cell.column.columnDef as ActionsDef<T>).getColourSet?.(
+			cell.row.original,
+			cell.row.index,
+			action
+		) ?? ColourSet.Secondary}
+		disabled={!enabled}
+		onclick={() => {
+			action.callback(cell.row.original, cell.row.index);
+		}}>{label}</Button
+	>
+{:catch e}
+	Error Loading Button: {getErrorMessage(e)}
+{/await}

package/dist/Components/Table/Body/Rows/Columns/TableAction.svelte.d.ts

@@ -0,0 +1,30 @@
+import type { TableActionButton } from '../../../Types/Columns/TableActionButton.js';
+import type { TableCell } from '../../../Types/Columns/TableCell.js';
+export interface TableActionProps<T extends object> {
+    action: TableActionButton<T>;
+    cell: TableCell<T>;
+}
+declare function $$render<T extends object>(): {
+    props: TableActionProps<T>;
+    exports: {};
+    bindings: "";
+    slots: {};
+    events: {};
+};
+declare class __sveltets_Render<T extends object> {
+    props(): ReturnType<typeof $$render<T>>['props'];
+    events(): ReturnType<typeof $$render<T>>['events'];
+    slots(): ReturnType<typeof $$render<T>>['slots'];
+    bindings(): "";
+    exports(): {};
+}
+interface $$IsomorphicComponent {
+    new <T extends object>(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 extends object>(internal: unknown, props: ReturnType<__sveltets_Render<T>['props']> & {}): ReturnType<__sveltets_Render<T>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
+}
+declare const TableAction: $$IsomorphicComponent;
+type TableAction<T extends object> = InstanceType<typeof TableAction<T>>;
+export default TableAction;

package/dist/Components/Table/Body/Rows/Columns/TableCheckbox.svelte

@@ -0,0 +1,155 @@
+<svelte:options runes />
+
+<script lang="ts" module>
+	export interface TableCheckboxProps<T extends object> {
+		cell: TableCell<T>;
+
+		onchange?: ChangeEventHandler<HTMLInputElement>;
+	}
+</script>
+
+<script lang="ts" generics="T extends object">
+	import { dev } from '$app/environment';
+	import type { TableCell } from '../../../Types/Columns/TableCell.js';
+	import { TableContext } from '../../../Types/Context/TableContext.svelte.js';
+	import { TableFocusDetails } from '../../../Types/Focus/TableFocusDetails.svelte.js';
+	import { ToastContext } from '../../../../../Contexts/ToastContext.svelte.js';
+	import { getContext, tick } from 'svelte';
+
+	import type { ChangeEventHandler } from 'svelte/elements';
+
+	const { cell, onchange: parentOnchange }: TableCheckboxProps<T> = $props();
+
+	const value = $derived(!!cell.getValue());
+
+	$effect(() => {
+		if (dev && value != null && typeof value != 'boolean') {
+			console.warn(
+				`non-boolean value was passed: ${value}\nIf that is intentional, please use accessorFn() to parse it to a boolean value.`
+			);
+		}
+	});
+
+	const tableContext = getContext<TableContext<T>>(TableContext.identifier);
+	const toastContext = getContext<ToastContext>(ToastContext.identifier);
+
+	const focusDetails: TableFocusDetails<T> = $derived(
+		new TableFocusDetails(cell, tableContext, toastContext.toast)
+	);
+
+	let inputRef: HTMLInputElement | undefined = $state();
+
+	const onchange: ChangeEventHandler<HTMLInputElement> = (e) => {
+		tableContext.onEditCell(
+			cell.row.original,
+			focusDetails.coordinates,
+			(e.target as HTMLInputElement).checked
+		);
+		parentOnchange?.(e);
+
+		tick().then(() => {
+			if (inputRef && value != inputRef.checked) {
+				inputRef.checked = value;
+			}
+		});
+	};
+</script>
+
+<!-- svelte-ignore a11y_mouse_events_have_key_events -->
+<td
+	class="checkbox-cell"
+	onmousedown={(e) => {
+		// start focus only on left click
+		if (e.button === 0) {
+			if (e.shiftKey) {
+				e.preventDefault();
+				tableContext.setFocusEnd(focusDetails.coordinates);
+			} else {
+				tableContext.startFocus(focusDetails.coordinates);
+			}
+		}
+	}}
+	onkeyup={(e) => {
+		if (e.key === 'Enter') {
+			e.stopPropagation();
+			tableContext.onEditCell(cell.row.original, focusDetails.coordinates, !value);
+		}
+	}}
+	onkeydown={(e) => {
+		if (e.key == 'Enter' || e.key == 'F2') {
+			e.stopPropagation();
+		}
+	}}
+	onmouseover={() => {
+		if (tableContext.isMousingDown) {
+			tableContext.setFocusEnd(focusDetails.coordinates);
+		}
+	}}
+	onmouseup={() => {
+		tableContext.endFocus(focusDetails.coordinates);
+	}}
+>
+	<label
+		class:multifocus={focusDetails.isMultiFocused}
+		class:multifocus-start={focusDetails.isMultiFocusStart}
+		style={focusDetails.outline}
+	>
+		<input
+			bind:this={inputRef}
+			id={`${tableContext.tableName}-cell-${cell.row.index}-${cell.column.id}`}
+			{onchange}
+			type="checkbox"
+			checked={!!value || undefined}
+		/>
+	</label>
+</td>
+
+<style>td {
+  transition: line-height 0.2s ease, height 0.2s ease;
+  --input-border: none;
+  --input-height: var(--height);
+  white-space: nowrap;
+  overflow-x: clip;
+  text-overflow: ellipsis;
+  position: relative;
+  padding-left: 0.75rem;
+  padding-right: 0.75rem;
+  border: solid 1px #cbd4da;
+  border-left: none;
+}
+
+input[type=checkbox] {
+  height: var(--checkbox-height);
+  padding: 1rem;
+  box-sizing: border-box;
+  cursor: pointer;
+  accent-color: var(--colour, #259fc7);
+  flex-grow: 1;
+}
+input[type=checkbox]:focus, input[type=checkbox]:focus-visible, input[type=checkbox]:focus-within {
+  outline: none !important;
+}
+
+label {
+  display: flex;
+  flex-flow: row nowrap;
+  justify-content: center;
+  position: absolute;
+  top: 0;
+  bottom: 0;
+  left: 0;
+  right: 0;
+  display: flex;
+  align-items: center;
+}
+
+label {
+  cursor: pointer;
+}
+
+label.multifocus {
+  background-color: var(--multifocus-colour, #f4fbfd);
+}
+label.multifocus.multifocus-start {
+  background-color: #ffffff;
+}</style>

package/dist/Components/Table/Body/Rows/Columns/TableCheckbox.svelte.d.ts

@@ -0,0 +1,30 @@
+export interface TableCheckboxProps<T extends object> {
+    cell: TableCell<T>;
+    onchange?: ChangeEventHandler<HTMLInputElement>;
+}
+import type { TableCell } from '../../../Types/Columns/TableCell.js';
+import type { ChangeEventHandler } from 'svelte/elements';
+declare function $$render<T extends object>(): {
+    props: TableCheckboxProps<T>;
+    exports: {};
+    bindings: "";
+    slots: {};
+    events: {};
+};
+declare class __sveltets_Render<T extends object> {
+    props(): ReturnType<typeof $$render<T>>['props'];
+    events(): ReturnType<typeof $$render<T>>['events'];
+    slots(): ReturnType<typeof $$render<T>>['slots'];
+    bindings(): "";
+    exports(): {};
+}
+interface $$IsomorphicComponent {
+    new <T extends object>(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 extends object>(internal: unknown, props: ReturnType<__sveltets_Render<T>['props']> & {}): ReturnType<__sveltets_Render<T>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
+}
+declare const TableCheckbox: $$IsomorphicComponent;
+type TableCheckbox<T extends object> = InstanceType<typeof TableCheckbox<T>>;
+export default TableCheckbox;

package/dist/Components/Table/Body/Rows/Columns/TableColumn.svelte

@@ -0,0 +1,140 @@
+<svelte:options runes />
+
+<script lang="ts" module>
+	import { dev } from '$app/environment';
+	import FocusableImmutableCell from './FocusableImmutableCell.svelte';
+	import BubbleCell from './BubbleCell.svelte';
+	import ActionsCell from './ActionsCell.svelte';
+	import type { Component } from 'svelte';
+	import ExpandCell from './ExpandCell.svelte';
+	import { ExpandDef } from '../../../Types/Columns/Definitions/Expand/ExpandDef.svelte.js';
+	import type { ColumnDef } from '../../../Types/Columns/Definitions/ColumnDef.svelte.js';
+	import type { TableCell } from '../../../Types/Columns/TableCell.js';
+	import { getErrorMessage } from '../../../../../Helpers/Helpers.svelte.js';
+	import { DisplayType } from '../../../Types/Columns/DisplayType.js';
+	import TableNumberInput from './TableNumberInput.svelte';
+	import TableDatePicker from './TableDatePicker.svelte';
+	import TableSelect from './TableSelect.svelte';
+	import TableQuerySelect from './TableQuerySelect.svelte';
+	import TableCheckbox from './TableCheckbox.svelte';
+	import TableTextInput from './TableTextInput.svelte';
+	import { AccessorDef } from '../../../Types/Columns/Definitions/Accessors/AccessorDef.svelte.js';
+	import { ActionsDef } from '../../../Types/Columns/Definitions/Actions/ActionsDef.svelte.js';
+	import ValidityCell from './ValidityCell.svelte';
+	import TableRowSelectionCheckbox from './TableRowSelectionCheckbox.svelte';
+	import { AbstractDisplayDef } from '../../../Types/Columns/AbstractDisplayDef.svelte.js';
+	import ProgressCell from './ProgressCell.svelte';
+	import { ValidityDef } from '../../../Types/Columns/Definitions/Display/ValidityDef.svelte.js';
+	import { ColumnType } from '../../../Types/Columns/ColumnType.js';
+	import { ProgressBarDef } from '../../../Types/Columns/Definitions/Display/ProgressBarDef.svelte.js';
+	import type { ProgressBarTableCell } from '../../../Types/Columns/ProgressBarTableCell.js';
+	import { RowSelectionDef } from '../../../Types/Columns/Definitions/RowSelection/RowSelectionDef.svelte.js';
+	import type { ExpandTableCell } from '../../../Types/Columns/ExpandTableCell.js';
+
+	const cellTypes: Record<
+		'Number' | 'Date' | 'Select' | 'Checkbox' | 'Query' | 'Text',
+		// eslint-disable-next-line @typescript-eslint/no-explicit-any
+		Component<any>
+	> = {
+		Number: TableNumberInput,
+		Date: TableDatePicker,
+		Select: TableSelect,
+		Query: TableQuerySelect,
+		Checkbox: TableCheckbox,
+		Text: TableTextInput
+	} as const;
+
+	export interface TableColumnProps<T extends object> {
+		cell: TableCell<T>;
+		expandedColumnDef: ExpandDef<T, object> | undefined;
+		onExpandChange: (columnDef: ExpandDef<T, object>) => void;
+	}
+
+	function isProgressBarTableCell<T extends object>(
+		cell: TableCell<T>
+	): cell is ProgressBarTableCell<T> {
+		return cell.column.columnDef instanceof ProgressBarDef;
+	}
+</script>
+
+<script lang="ts" generics="T extends object">
+	let { cell, expandedColumnDef, onExpandChange }: TableColumnProps<T> = $props();
+
+	function valueOrComponentIsConstructor(
+		valueOrComponent: unknown
+		// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	): valueOrComponent is Component<any> {
+		return typeof valueOrComponent === 'function';
+	}
+
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	function getAppropriateAccessorDef(columnDef: ColumnDef<T>): Component<any> {
+		if (columnDef instanceof AccessorDef) {
+			return cellTypes[columnDef.accessorType];
+		}
+
+		return FocusableImmutableCell;
+	}
+
+	function isExpandTableCell(cell: TableCell<T>): cell is ExpandTableCell<T> {
+		return cell.column.columnDef instanceof ExpandDef;
+	}
+</script>
+
+{#if cell.column.getIsVisible()}
+	{@const columnDef = cell.column.columnDef}
+
+	{#if cell.column.columnDef instanceof ValidityDef}
+		<ValidityCell {cell} />
+	{:else if columnDef instanceof RowSelectionDef}
+		<TableRowSelectionCheckbox {cell} />
+	{:else if columnDef instanceof ActionsDef}
+		<ActionsCell {cell} />
+	{:else if isExpandTableCell(cell)}
+		<ExpandCell {cell} {expandedColumnDef} {onExpandChange} />
+	{:else if columnDef.columnType !== ColumnType.Display}
+		{@const CurrentComponent = getAppropriateAccessorDef(columnDef)}
+		<CurrentComponent {cell} />
+	{:else}
+		{@const valueOrComponentPromise =
+			cell.column.columnDef.accessorFn?.(cell.row.original, cell.row.index) ??
+			cell.row.original[cell.column.id as keyof typeof cell.row.original] ??
+			null}
+
+		{#if valueOrComponentPromise instanceof Promise}
+			{#await valueOrComponentPromise}
+				<FocusableImmutableCell value={valueOrComponentPromise} {cell} />
+			{:then value}
+				{@render ValueFallback(value)}
+			{:catch e}
+				<FocusableImmutableCell value={getErrorMessage(e)} {cell} />
+			{/await}
+		{:else}
+			{@render ValueFallback(valueOrComponentPromise)}
+		{/if}
+	{/if}
+{/if}
+
+{#snippet ValueFallback(Value: unknown)}
+	{#if cell.column.columnDef instanceof AbstractDisplayDef && Array.isArray(Value)}
+		{#if cell.column.columnDef.displayType === DisplayType.Bubbles}
+			<BubbleCell {cell} />
+		{:else if isProgressBarTableCell(cell)}
+			<ProgressCell {cell} />
+		{:else if dev}
+			<FocusableImmutableCell value="DEBUG: INVALID TYPE PASSED" {cell} />
+		{/if}
+	{:else if Value == null || typeof Value === 'string' || typeof Value == 'number'}
+		<FocusableImmutableCell value={Value} {cell} />
+	{:else if valueOrComponentIsConstructor(Value)}
+		<FocusableImmutableCell {cell}>
+			<Value {cell} />
+		</FocusableImmutableCell>
+	{:else if typeof Value === 'function'}
+		<FocusableImmutableCell {cell}>
+			{@render Value(cell)}
+		</FocusableImmutableCell>
+	{:else if dev}
+		<FocusableImmutableCell value="DEBUG: NO VALUE OR COMPONENT PASSED" {cell} />
+	{/if}
+{/snippet}

package/dist/Components/Table/Body/Rows/Columns/TableColumn.svelte.d.ts

@@ -0,0 +1,31 @@
+import { ExpandDef } from '../../../Types/Columns/Definitions/Expand/ExpandDef.svelte.js';
+import type { TableCell } from '../../../Types/Columns/TableCell.js';
+export interface TableColumnProps<T extends object> {
+    cell: TableCell<T>;
+    expandedColumnDef: ExpandDef<T, object> | undefined;
+    onExpandChange: (columnDef: ExpandDef<T, object>) => void;
+}
+declare function $$render<T extends object>(): {
+    props: TableColumnProps<T>;
+    exports: {};
+    bindings: "";
+    slots: {};
+    events: {};
+};
+declare class __sveltets_Render<T extends object> {
+    props(): ReturnType<typeof $$render<T>>['props'];
+    events(): ReturnType<typeof $$render<T>>['events'];
+    slots(): ReturnType<typeof $$render<T>>['slots'];
+    bindings(): "";
+    exports(): {};
+}
+interface $$IsomorphicComponent {
+    new <T extends object>(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 extends object>(internal: unknown, props: ReturnType<__sveltets_Render<T>['props']> & {}): ReturnType<__sveltets_Render<T>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
+}
+declare const TableColumn: $$IsomorphicComponent;
+type TableColumn<T extends object> = InstanceType<typeof TableColumn<T>>;
+export default TableColumn;