@casinogate/ui 0.0.4 → 1.0.1

package/dist/components/data-table/components/data-table.body.svelte

@@ -0,0 +1,33 @@
+<script lang="ts" module>
+  type DataTableBodyPropsWithoutHTML = WithElementRef<WithChildren<{}>>;
+
+  export type DataTableBodyProps = DataTableBodyPropsWithoutHTML &
+    Without<PrimitiveDivAttributes, DataTableBodyPropsWithoutHTML>;
+</script>
+
+<script lang="ts">
+  import type { PrimitiveDivAttributes } from '../../../internal/types/html-attributes.js';
+  import { cn } from '../../../internal/utils/common.js';
+  import { useId, type WithChildren } from 'bits-ui';
+  import { box, mergeProps, type WithElementRef, type Without } from 'svelte-toolbelt';
+  import { DataTableStylesContext } from '../styles.js';
+  import { DataTableBodyState } from './data-table.svelte.js';
+
+  let { ref = $bindable(null), id = useId(), children, class: className, ...restProps }: DataTableBodyProps = $props();
+
+  const bodyState = DataTableBodyState.create({
+    ref: box.with(
+      () => ref,
+      (v) => (ref = v)
+    ),
+    id: box.with(() => id),
+  });
+
+  const styles = DataTableStylesContext.get();
+
+  const mergedProps = $derived(mergeProps(restProps, bodyState.props));
+</script>
+
+<tbody class={cn(styles.current.body(), className)} {...mergedProps}>
+  {@render children?.()}
+</tbody>

package/dist/components/data-table/components/data-table.body.svelte.d.ts

@@ -0,0 +1,8 @@
+type DataTableBodyPropsWithoutHTML = WithElementRef<WithChildren<{}>>;
+export type DataTableBodyProps = DataTableBodyPropsWithoutHTML & Without<PrimitiveDivAttributes, DataTableBodyPropsWithoutHTML>;
+import type { PrimitiveDivAttributes } from '../../../internal/types/html-attributes.js';
+import { type WithChildren } from 'bits-ui';
+import { type WithElementRef, type Without } from 'svelte-toolbelt';
+declare const DataTable: import("svelte").Component<DataTableBodyProps, {}, "ref">;
+type DataTable = ReturnType<typeof DataTable>;
+export default DataTable;

package/dist/components/data-table/components/data-table.cell.svelte

@@ -0,0 +1,48 @@
+<script lang="ts" module>
+  type DataTableCellPropsWithoutHTML = WithElementRef<
+    WithChildren<{
+      cell: Cell<any, unknown> | null;
+    }>
+  >;
+
+  export type DataTableCellProps = DataTableCellPropsWithoutHTML &
+    Without<PrimitiveTdAttributes, DataTableCellPropsWithoutHTML>;
+</script>
+
+<script lang="ts">
+  import { DataTableStylesContext } from '../styles.js';
+
+  import { DataTableCellState } from './data-table.svelte.js';
+
+  import type { PrimitiveTdAttributes } from '../../../internal/types/html-attributes.js';
+  import { cn } from '../../../internal/utils/common.js';
+  import type { Cell } from '@tanstack/table-core';
+  import { useId } from 'bits-ui';
+  import { box, mergeProps, type WithChildren, type WithElementRef, type Without } from 'svelte-toolbelt';
+
+  let {
+    ref = $bindable(null),
+    id = useId(),
+    children,
+    class: className,
+    cell,
+    ...restProps
+  }: DataTableCellProps = $props();
+
+  const cellState = DataTableCellState.create({
+    ref: box.with(
+      () => ref,
+      (v) => (ref = v)
+    ),
+    id: box.with(() => id),
+    cell: box.with(() => cell),
+  });
+
+  const styles = DataTableStylesContext.get();
+
+  const mergedProps = $derived(mergeProps(restProps, cellState.props));
+</script>
+
+<td class={cn(styles.current.cell(), className)} {...mergedProps}>
+  {@render children?.()}
+</td>

package/dist/components/data-table/components/data-table.cell.svelte.d.ts

@@ -0,0 +1,10 @@
+type DataTableCellPropsWithoutHTML = WithElementRef<WithChildren<{
+    cell: Cell<any, unknown> | null;
+}>>;
+export type DataTableCellProps = DataTableCellPropsWithoutHTML & Without<PrimitiveTdAttributes, DataTableCellPropsWithoutHTML>;
+import type { PrimitiveTdAttributes } from '../../../internal/types/html-attributes.js';
+import type { Cell } from '@tanstack/table-core';
+import { type WithChildren, type WithElementRef, type Without } from 'svelte-toolbelt';
+declare const DataTable: import("svelte").Component<DataTableCellProps, {}, "ref">;
+type DataTable = ReturnType<typeof DataTable>;
+export default DataTable;

package/dist/components/data-table/components/data-table.head.svelte

@@ -0,0 +1,48 @@
+<script lang="ts" module>
+  type DataTableHeadPropsWithoutHTML = WithElementRef<
+    WithChildren<{
+      header: Header<any, unknown>;
+    }>
+  >;
+
+  export type DataTableHeadProps = DataTableHeadPropsWithoutHTML &
+    Without<PrimitiveDivAttributes, DataTableHeadPropsWithoutHTML>;
+</script>
+
+<script lang="ts">
+  import { DataTableStylesContext } from '../styles.js';
+
+  import { DataTableHeadState } from './data-table.svelte.js';
+
+  import type { PrimitiveDivAttributes } from '../../../internal/types/html-attributes.js';
+  import { cn } from '../../../internal/utils/common.js';
+  import type { Header } from '@tanstack/table-core';
+  import { useId } from 'bits-ui';
+  import { box, mergeProps, type WithChildren, type WithElementRef, type Without } from 'svelte-toolbelt';
+
+  let {
+    ref = $bindable(null),
+    id = useId(),
+    children,
+    class: className,
+    header,
+    ...restProps
+  }: DataTableHeadProps = $props();
+
+  const headState = DataTableHeadState.create({
+    ref: box.with(
+      () => ref,
+      (v) => (ref = v)
+    ),
+    id: box.with(() => id),
+    header: box.with(() => header),
+  });
+
+  const styles = DataTableStylesContext.get();
+
+  const mergedProps = $derived(mergeProps(restProps, headState.props));
+</script>
+
+<th class={cn(styles.current.head(), className)} {...mergedProps}>
+  {@render children?.()}
+</th>

package/dist/components/data-table/components/data-table.head.svelte.d.ts

@@ -0,0 +1,10 @@
+type DataTableHeadPropsWithoutHTML = WithElementRef<WithChildren<{
+    header: Header<any, unknown>;
+}>>;
+export type DataTableHeadProps = DataTableHeadPropsWithoutHTML & Without<PrimitiveDivAttributes, DataTableHeadPropsWithoutHTML>;
+import type { PrimitiveDivAttributes } from '../../../internal/types/html-attributes.js';
+import type { Header } from '@tanstack/table-core';
+import { type WithChildren, type WithElementRef, type Without } from 'svelte-toolbelt';
+declare const DataTable: import("svelte").Component<DataTableHeadProps, {}, "ref">;
+type DataTable = ReturnType<typeof DataTable>;
+export default DataTable;

package/dist/components/data-table/components/data-table.header.svelte

@@ -0,0 +1,41 @@
+<script lang="ts" module>
+  type DataTableHeaderPropsWithoutHTML = WithElementRef<WithChildren<{}>>;
+
+  export type DataTableHeaderProps = DataTableHeaderPropsWithoutHTML &
+    Without<PrimitiveDivAttributes, DataTableHeaderPropsWithoutHTML>;
+</script>
+
+<script lang="ts">
+  import { DataTableHeaderState } from './data-table.svelte.js';
+
+  import { DataTableStylesContext } from '../styles.js';
+
+  import type { PrimitiveDivAttributes } from '../../../internal/types/html-attributes.js';
+  import { cn } from '../../../internal/utils/common.js';
+  import { useId } from 'bits-ui';
+  import { box, mergeProps, type WithChildren, type WithElementRef, type Without } from 'svelte-toolbelt';
+
+  let {
+    ref = $bindable(null),
+    children,
+    class: className,
+    id = useId(),
+    ...restProps
+  }: DataTableHeaderProps = $props();
+
+  const headerState = DataTableHeaderState.create({
+    ref: box.with(
+      () => ref,
+      (v) => (ref = v)
+    ),
+    id: box.with(() => id),
+  });
+
+  const styles = DataTableStylesContext.get();
+
+  const mergedProps = $derived(mergeProps(restProps, headerState.props));
+</script>
+
+<thead class={cn(styles.current.header(), className)} {...mergedProps}>
+  {@render children?.()}
+</thead>

package/dist/components/data-table/components/data-table.header.svelte.d.ts

@@ -0,0 +1,7 @@
+type DataTableHeaderPropsWithoutHTML = WithElementRef<WithChildren<{}>>;
+export type DataTableHeaderProps = DataTableHeaderPropsWithoutHTML & Without<PrimitiveDivAttributes, DataTableHeaderPropsWithoutHTML>;
+import type { PrimitiveDivAttributes } from '../../../internal/types/html-attributes.js';
+import { type WithChildren, type WithElementRef, type Without } from 'svelte-toolbelt';
+declare const DataTable: import("svelte").Component<DataTableHeaderProps, {}, "ref">;
+type DataTable = ReturnType<typeof DataTable>;
+export default DataTable;

package/dist/components/data-table/components/data-table.resize-handler.svelte

@@ -0,0 +1,31 @@
+<script lang="ts" module>
+  type DataTableResizeHandlerPropsWithoutHTML = WithElementRef<{}>;
+
+  export type DataTableResizeHandlerProps = DataTableResizeHandlerPropsWithoutHTML &
+    Without<PrimitiveDivAttributes, DataTableResizeHandlerPropsWithoutHTML>;
+</script>
+
+<script lang="ts">
+  import type { PrimitiveDivAttributes } from '../../../internal/types/html-attributes.js';
+  import { cn } from '../../../internal/utils/common.js';
+  import { useId } from 'bits-ui';
+  import { box, mergeProps, type WithElementRef, type Without } from 'svelte-toolbelt';
+  import { DataTableStylesContext } from '../styles.js';
+  import { DataTableResizeHandlerState } from './data-table.svelte.js';
+
+  let { ref = $bindable(null), id = useId(), class: className, ...restProps }: DataTableResizeHandlerProps = $props();
+
+  const resizeHandlerState = DataTableResizeHandlerState.create({
+    ref: box.with(
+      () => ref,
+      (v) => (ref = v)
+    ),
+    id: box.with(() => id),
+  });
+
+  const styles = DataTableStylesContext.get();
+
+  const mergedProps = $derived(mergeProps(restProps, resizeHandlerState.props));
+</script>
+
+<div class={cn(styles.current.resizeHandler(), className)} {...mergedProps}></div>

package/dist/components/data-table/components/data-table.resize-handler.svelte.d.ts

@@ -0,0 +1,7 @@
+type DataTableResizeHandlerPropsWithoutHTML = WithElementRef<{}>;
+export type DataTableResizeHandlerProps = DataTableResizeHandlerPropsWithoutHTML & Without<PrimitiveDivAttributes, DataTableResizeHandlerPropsWithoutHTML>;
+import type { PrimitiveDivAttributes } from '../../../internal/types/html-attributes.js';
+import { type WithElementRef, type Without } from 'svelte-toolbelt';
+declare const DataTable: import("svelte").Component<DataTableResizeHandlerProps, {}, "ref">;
+type DataTable = ReturnType<typeof DataTable>;
+export default DataTable;

package/dist/components/data-table/components/data-table.root.svelte

@@ -0,0 +1,55 @@
+<script lang="ts" module>
+  type DataTableRootPropsWithoutHTML<TData extends RowData> = WithElementRef<
+    WithChildren<{
+      table: CreateTableReturn<TData>;
+    }>
+  > &
+    DataTableVariantsProps;
+
+  export type DataTableRootProps<TData extends RowData> = DataTableRootPropsWithoutHTML<TData> &
+    Without<PrimitiveDivAttributes, DataTableRootPropsWithoutHTML<TData>>;
+</script>
+
+<script lang="ts" generics="TData extends RowData">
+  import type { CreateTableReturn } from '../models/create-table.svelte.js';
+  import type { PrimitiveDivAttributes } from '../../../internal/types/html-attributes.js';
+  import { cn } from '../../../internal/utils/common.js';
+  import type { RowData } from '@tanstack/table-core';
+  import { useId, type Without } from 'bits-ui';
+  import { box, mergeProps, type WithChildren, type WithElementRef } from 'svelte-toolbelt';
+  import { DataTableStylesContext, dataTableVariants, type DataTableVariantsProps } from '../styles.js';
+  import { DataTableRootState } from './data-table.svelte.js';
+
+  let {
+    table,
+    ref = $bindable(null),
+    id = useId(),
+    class: className,
+    variant = 'primary',
+    stripped = true,
+    align = 'start',
+    rounded = 'sm',
+    resizable = false,
+    children,
+    ...restProps
+  }: DataTableRootProps<TData> = $props();
+
+  const rootState = DataTableRootState.create({
+    table: box.with(() => table),
+    id: box.with(() => id),
+    ref: box.with(
+      () => ref,
+      (v) => (ref = v)
+    ),
+  });
+
+  const variants = $derived(dataTableVariants({ variant, stripped, align, rounded, resizable }));
+
+  DataTableStylesContext.set(box.with(() => variants));
+
+  const mergedProps = $derived(mergeProps(restProps, rootState.props));
+</script>
+
+<div class={cn(variants.root(), className)} {...mergedProps}>
+  {@render children?.()}
+</div>

package/dist/components/data-table/components/data-table.root.svelte.d.ts

@@ -0,0 +1,34 @@
+type DataTableRootPropsWithoutHTML<TData extends RowData> = WithElementRef<WithChildren<{
+    table: CreateTableReturn<TData>;
+}>> & DataTableVariantsProps;
+export type DataTableRootProps<TData extends RowData> = DataTableRootPropsWithoutHTML<TData> & Without<PrimitiveDivAttributes, DataTableRootPropsWithoutHTML<TData>>;
+import type { CreateTableReturn } from '../models/create-table.svelte.js';
+import type { PrimitiveDivAttributes } from '../../../internal/types/html-attributes.js';
+import type { RowData } from '@tanstack/table-core';
+import { type Without } from 'bits-ui';
+import { type WithChildren, type WithElementRef } from 'svelte-toolbelt';
+import { type DataTableVariantsProps } from '../styles.js';
+declare function $$render<TData extends RowData>(): {
+    props: DataTableRootProps<TData>;
+    exports: {};
+    bindings: "ref";
+    slots: {};
+    events: {};
+};
+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'];
+    bindings(): "ref";
+    exports(): {};
+}
+interface $$IsomorphicComponent {
+    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 extends RowData>(internal: unknown, props: ReturnType<__sveltets_Render<TData>['props']> & {}): ReturnType<__sveltets_Render<TData>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
+}
+declare const DataTable: $$IsomorphicComponent;
+type DataTable<TData extends RowData> = InstanceType<typeof DataTable<TData>>;
+export default DataTable;

package/dist/components/data-table/components/data-table.row.svelte

@@ -0,0 +1,35 @@
+<script lang="ts" module>
+  type DataTableRowPropsWithoutHTML = WithElementRef<WithChildren<{}>>;
+
+  export type DataTableRowProps = DataTableRowPropsWithoutHTML &
+    Without<PrimitiveDivAttributes, DataTableRowPropsWithoutHTML>;
+</script>
+
+<script lang="ts">
+  import { DataTableStylesContext } from '../styles.js';
+
+  import { DataTableRowState } from './data-table.svelte.js';
+
+  import type { PrimitiveDivAttributes } from '../../../internal/types/html-attributes.js';
+  import { cn } from '../../../internal/utils/common.js';
+  import { useId } from 'bits-ui';
+  import { box, mergeProps, type WithChildren, type WithElementRef, type Without } from 'svelte-toolbelt';
+
+  let { ref = $bindable(null), id = useId(), children, class: className, ...restProps }: DataTableRowProps = $props();
+
+  const rowState = DataTableRowState.create({
+    ref: box.with(
+      () => ref,
+      (v) => (ref = v)
+    ),
+    id: box.with(() => id),
+  });
+
+  const styles = DataTableStylesContext.get();
+
+  const mergedProps = $derived(mergeProps(restProps, rowState.props));
+</script>
+
+<tr class={cn(styles.current.row(), className)} {...mergedProps}>
+  {@render children?.()}
+</tr>

package/dist/components/data-table/components/data-table.row.svelte.d.ts

@@ -0,0 +1,7 @@
+type DataTableRowPropsWithoutHTML = WithElementRef<WithChildren<{}>>;
+export type DataTableRowProps = DataTableRowPropsWithoutHTML & Without<PrimitiveDivAttributes, DataTableRowPropsWithoutHTML>;
+import type { PrimitiveDivAttributes } from '../../../internal/types/html-attributes.js';
+import { type WithChildren, type WithElementRef, type Without } from 'svelte-toolbelt';
+declare const DataTable: import("svelte").Component<DataTableRowProps, {}, "ref">;
+type DataTable = ReturnType<typeof DataTable>;
+export default DataTable;

package/dist/components/data-table/components/data-table.sort-button.svelte

@@ -0,0 +1,51 @@
+<script lang="ts" module>
+  type DataTableSortButtonPropsWithoutHTML = WithElementRef<WithChild<{}>>;
+
+  export type DataTableSortButtonProps = DataTableSortButtonPropsWithoutHTML &
+    Without<PrimitiveButtonAttributes, DataTableSortButtonPropsWithoutHTML>;
+</script>
+
+<script lang="ts">
+  import { SortIcon } from '../../icons/index.js';
+  import type { PrimitiveButtonAttributes } from '../../../internal/types/html-attributes.js';
+  import { cn } from '../../../internal/utils/common.js';
+  import { useId } from 'bits-ui';
+  import { box, mergeProps, type WithChild, type WithElementRef, type Without } from 'svelte-toolbelt';
+  import { DataTableStylesContext } from '../styles.js';
+  import { DataTableSortButtonState } from './data-table.svelte.js';
+
+  let {
+    ref = $bindable(null),
+    id = useId(),
+    class: className,
+    children,
+    child,
+    ...restProps
+  }: DataTableSortButtonProps = $props();
+
+  const sortButtonState = DataTableSortButtonState.create({
+    ref: box.with(
+      () => ref,
+      (v) => (ref = v)
+    ),
+    id: box.with(() => id),
+  });
+
+  const styles = DataTableStylesContext.get();
+
+  const mergedProps = $derived(
+    mergeProps(restProps, sortButtonState.props, { class: cn(styles.current.sortButton(), className) })
+  );
+</script>
+
+{#if child}
+  {@render child?.({ props: mergedProps })}
+{:else}
+  <button {...mergedProps}>
+    {#if children}
+      {@render children?.()}
+    {:else}
+      <SortIcon />
+    {/if}
+  </button>
+{/if}

package/dist/components/data-table/components/data-table.sort-button.svelte.d.ts

@@ -0,0 +1,7 @@
+type DataTableSortButtonPropsWithoutHTML = WithElementRef<WithChild<{}>>;
+export type DataTableSortButtonProps = DataTableSortButtonPropsWithoutHTML & Without<PrimitiveButtonAttributes, DataTableSortButtonPropsWithoutHTML>;
+import type { PrimitiveButtonAttributes } from '../../../internal/types/html-attributes.js';
+import { type WithChild, type WithElementRef, type Without } from 'svelte-toolbelt';
+declare const DataTable: import("svelte").Component<DataTableSortButtonProps, {}, "ref">;
+type DataTable = ReturnType<typeof DataTable>;
+export default DataTable;

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

@@ -0,0 +1,139 @@
+import type { CreateTableReturn } from '../models/create-table.svelte.js';
+import type { RefAttachment } from '../../../internal/types/common.js';
+import type { Cell, Header, RowData } from '@tanstack/table-core';
+import { type ReadableBoxedValues, type WithRefProps } from 'svelte-toolbelt';
+type DataTableRootOpts<TData extends RowData> = WithRefProps<ReadableBoxedValues<{
+    table: CreateTableReturn<TData>;
+}>>;
+export declare class DataTableRootState<TData extends RowData> {
+    static create<TData extends RowData>(opts: DataTableRootOpts<TData>): DataTableRootState<any>;
+    readonly opts: DataTableRootOpts<TData>;
+    readonly attachment: RefAttachment;
+    observedRow: HTMLElement | null;
+    columnSizingVars: {
+        [key: string]: number;
+    };
+    constructor(opts: DataTableRootOpts<TData>);
+    onLastRowReached: () => void;
+    readonly props: {
+        readonly id: string;
+        readonly "data-slot": "root";
+        readonly style: {
+            readonly [key: string]: number;
+        };
+    };
+}
+type DataTableTableOpts = WithRefProps<{}>;
+export declare class DataTableTableState {
+    static create(opts: DataTableTableOpts): DataTableTableState;
+    readonly opts: DataTableTableOpts;
+    readonly attachment: RefAttachment;
+    constructor(opts: DataTableTableOpts);
+    readonly props: {
+        readonly id: string;
+        readonly "data-slot": "table";
+    };
+}
+type DataTableHeaderOpts = WithRefProps<{}>;
+export declare class DataTableHeaderState {
+    static create(opts: DataTableHeaderOpts): DataTableHeaderState;
+    readonly opts: DataTableHeaderOpts;
+    readonly attachment: RefAttachment;
+    constructor(opts: DataTableHeaderOpts);
+    readonly props: {
+        readonly id: string;
+        readonly "data-slot": "header";
+    };
+}
+type DataTableRowOpts = WithRefProps<{}>;
+export declare class DataTableRowState {
+    static create(opts: DataTableRowOpts): DataTableRowState;
+    readonly opts: DataTableRowOpts;
+    readonly attachment: RefAttachment;
+    readonly rootState: DataTableRootState<any>;
+    constructor(opts: DataTableRowOpts, root: DataTableRootState<any>);
+    readonly props: {
+        readonly id: string;
+        readonly "data-slot": "row";
+    };
+}
+type DataTableBodyOpts = WithRefProps<{}>;
+export declare class DataTableBodyState {
+    #private;
+    static create(opts: DataTableBodyOpts): DataTableBodyState;
+    readonly opts: DataTableBodyOpts;
+    readonly attachment: RefAttachment;
+    readonly rootState: DataTableRootState<any>;
+    constructor(opts: DataTableBodyOpts, root: DataTableRootState<any>);
+    readonly props: {
+        readonly id: string;
+        readonly "data-slot": "body";
+    };
+}
+type DataTableHeadOpts = WithRefProps<ReadableBoxedValues<{
+    header: Header<any, unknown>;
+}>>;
+export declare class DataTableHeadState {
+    #private;
+    static create(opts: DataTableHeadOpts): DataTableHeadState;
+    readonly opts: DataTableHeadOpts;
+    readonly attachment: RefAttachment;
+    readonly rootState: DataTableRootState<any>;
+    constructor(opts: DataTableHeadOpts, root: DataTableRootState<any>);
+    readonly props: {
+        readonly id: string;
+        readonly "data-slot": "head";
+        readonly 'data-id': string;
+        readonly style: {
+            readonly width: `calc(${number} * 1px)`;
+        };
+        readonly colspan: number;
+    };
+}
+type DataTableCellOpts = WithRefProps<ReadableBoxedValues<{
+    cell: Cell<any, unknown> | null;
+}>>;
+export declare class DataTableCellState {
+    #private;
+    static create(opts: DataTableCellOpts): DataTableCellState;
+    readonly opts: DataTableCellOpts;
+    readonly attachment: RefAttachment;
+    readonly rootState: DataTableRootState<any>;
+    constructor(opts: DataTableCellOpts, root: DataTableRootState<any>);
+    readonly props: {
+        readonly id: string;
+        readonly "data-slot": "cell";
+        readonly style: {
+            readonly width: `calc(${number} * 1px)`;
+        };
+    };
+}
+type DataTableSortButtonOpts = WithRefProps<{}>;
+export declare class DataTableSortButtonState {
+    static create(opts: DataTableSortButtonOpts): DataTableSortButtonState;
+    readonly opts: DataTableSortButtonOpts;
+    readonly attachment: RefAttachment;
+    readonly headState: DataTableHeadState;
+    constructor(opts: DataTableSortButtonOpts, head: DataTableHeadState);
+    readonly props: {
+        readonly "data-slot": "sort-button";
+        readonly id: string;
+    };
+}
+type DataTableResizeHandlerOpts = WithRefProps<{}>;
+export declare class DataTableResizeHandlerState {
+    #private;
+    static create(opts: DataTableResizeHandlerOpts): DataTableResizeHandlerState;
+    readonly opts: DataTableResizeHandlerOpts;
+    readonly attachment: RefAttachment;
+    readonly headState: DataTableHeadState;
+    constructor(opts: DataTableResizeHandlerOpts, head: DataTableHeadState);
+    readonly props: {
+        readonly id: string;
+        readonly "data-slot": "resize-handler";
+        readonly ondblclick: () => void;
+        readonly onmousedown: (event: unknown) => void;
+        readonly ontouchstart: (event: unknown) => void;
+    };
+}
+export {};