@nuxt/ui 4.0.0-alpha.1 → 4.0.0-alpha.2

package/dist/runtime/components/Separator.d.vue.ts

@@ -0,0 +1,54 @@
+import { Separator } from 'reka-ui';
+import type { SeparatorProps as _SeparatorProps } from 'reka-ui';
+import type { AppConfig } from '@nuxt/schema';
+import theme from '#build/ui/separator';
+import type { AvatarProps, IconProps } from '../types';
+import type { ComponentConfig } from '../types/tv';
+type Separator = ComponentConfig<typeof theme, AppConfig, 'separator'>;
+export interface SeparatorProps extends Pick<_SeparatorProps, 'decorative'> {
+    /**
+     * The element or component this component should render as.
+     * @defaultValue 'div'
+     */
+    as?: any;
+    /** Display a label in the middle. */
+    label?: string;
+    /**
+     * Display an icon in the middle.
+     * @IconifyIcon
+     */
+    icon?: IconProps['name'];
+    /** Display an avatar in the middle. */
+    avatar?: AvatarProps;
+    /**
+     * @defaultValue 'neutral'
+     */
+    color?: Separator['variants']['color'];
+    /**
+     * @defaultValue 'xs'
+     */
+    size?: Separator['variants']['size'];
+    /**
+     * @defaultValue 'solid'
+     */
+    type?: Separator['variants']['type'];
+    /**
+     * The orientation of the separator.
+     * @defaultValue 'horizontal'
+     */
+    orientation?: _SeparatorProps['orientation'];
+    class?: any;
+    ui?: Separator['slots'];
+}
+export interface SeparatorSlots {
+    default(props?: {}): any;
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<SeparatorProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<SeparatorProps> & Readonly<{}>, {
+    orientation: "horizontal" | "vertical";
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, SeparatorSlots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/Skeleton.d.vue.ts

@@ -0,0 +1,17 @@
+export interface SkeletonProps {
+    /**
+     * The element or component this component should render as.
+     * @defaultValue 'div'
+     */
+    as?: any;
+    class?: any;
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<SkeletonProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<SkeletonProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    default?: (props: {}) => any;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/Slideover.d.vue.ts

@@ -0,0 +1,108 @@
+import type { DialogRootProps, DialogRootEmits, DialogContentProps, DialogContentEmits } from 'reka-ui';
+import type { AppConfig } from '@nuxt/schema';
+import theme from '#build/ui/slideover';
+import type { ButtonProps, IconProps } from '../types';
+import type { EmitsToProps } from '../types/utils';
+import type { ComponentConfig } from '../types/tv';
+type Slideover = ComponentConfig<typeof theme, AppConfig, 'slideover'>;
+export interface SlideoverProps extends DialogRootProps {
+    title?: string;
+    description?: string;
+    /** The content of the slideover. */
+    content?: Omit<DialogContentProps, 'as' | 'asChild' | 'forceMount'> & Partial<EmitsToProps<DialogContentEmits>>;
+    /**
+     * Render an overlay behind the slideover.
+     * @defaultValue true
+     */
+    overlay?: boolean;
+    /**
+     * Animate the slideover when opening or closing.
+     * @defaultValue true
+     */
+    transition?: boolean;
+    /**
+     * The side of the slideover.
+     * @defaultValue 'right'
+     */
+    side?: Slideover['variants']['side'];
+    /**
+     * Render the slideover in a portal.
+     * @defaultValue true
+     */
+    portal?: boolean | string | HTMLElement;
+    /**
+     * Display a close button to dismiss the slideover.
+     * `{ size: 'md', color: 'neutral', variant: 'ghost' }`{lang="ts-type"}
+     * @defaultValue true
+     */
+    close?: boolean | Partial<ButtonProps>;
+    /**
+     * The icon displayed in the close button.
+     * @defaultValue appConfig.ui.icons.close
+     * @IconifyIcon
+     */
+    closeIcon?: IconProps['name'];
+    /**
+     * When `false`, the slideover will not close when clicking outside or pressing escape.
+     * @defaultValue true
+     */
+    dismissible?: boolean;
+    class?: any;
+    ui?: Slideover['slots'];
+}
+export interface SlideoverEmits extends DialogRootEmits {
+    'after:leave': [];
+    'after:enter': [];
+    'close:prevent': [];
+}
+export interface SlideoverSlots {
+    default(props: {
+        open: boolean;
+    }): any;
+    content(props: {
+        close: () => void;
+    }): any;
+    header(props: {
+        close: () => void;
+    }): any;
+    title(props?: {}): any;
+    description(props?: {}): any;
+    actions(props?: {}): any;
+    close(props: {
+        close: () => void;
+        ui: {
+            [K in keyof Required<Slideover['slots']>]: (props?: Record<string, any>) => string;
+        };
+    }): any;
+    body(props: {
+        close: () => void;
+    }): any;
+    footer(props: {
+        close: () => void;
+    }): any;
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<SlideoverProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:open": (value: boolean) => any;
+    "after:leave": () => any;
+    "after:enter": () => any;
+    "close:prevent": () => any;
+}, string, import("vue").PublicProps, Readonly<SlideoverProps> & Readonly<{
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+    "onAfter:leave"?: (() => any) | undefined;
+    "onAfter:enter"?: (() => any) | undefined;
+    "onClose:prevent"?: (() => any) | undefined;
+}>, {
+    close: boolean | Partial<ButtonProps>;
+    modal: boolean;
+    transition: boolean;
+    portal: boolean | string | HTMLElement;
+    overlay: boolean;
+    side: Slideover["variants"]["side"];
+    dismissible: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, SlideoverSlots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/Slider.d.vue.ts

@@ -0,0 +1,57 @@
+import type { SliderRootProps } from 'reka-ui';
+import type { AppConfig } from '@nuxt/schema';
+import theme from '#build/ui/slider';
+import type { TooltipProps } from '../types';
+import type { ComponentConfig } from '../types/tv';
+type Slider = ComponentConfig<typeof theme, AppConfig, 'slider'>;
+export interface SliderProps extends Pick<SliderRootProps, 'name' | 'disabled' | 'inverted' | 'min' | 'max' | 'step' | 'minStepsBetweenThumbs'> {
+    /**
+     * The element or component this component should render as.
+     * @defaultValue 'div'
+     */
+    as?: any;
+    /**
+     * @defaultValue 'md'
+     */
+    size?: Slider['variants']['size'];
+    /**
+     * @defaultValue 'primary'
+     */
+    color?: Slider['variants']['color'];
+    /**
+     * The orientation of the slider.
+     * @defaultValue 'horizontal'
+     */
+    orientation?: SliderRootProps['orientation'];
+    /**
+     * Display a tooltip around the slider thumbs with the current value.
+     * `{ disableClosingTrigger: true }`{lang="ts-type"}
+     * @defaultValue false
+     */
+    tooltip?: boolean | TooltipProps;
+    /** The value of the slider when initially rendered. Use when you do not need to control the state of the slider. */
+    defaultValue?: number | number[];
+    class?: any;
+    ui?: Slider['slots'];
+}
+export interface SliderEmits {
+    change: [event: Event];
+}
+declare const _default: <T extends number | number[]>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly onChange?: ((event: Event) => any) | undefined;
+        readonly "onUpdate:modelValue"?: ((value: T | undefined) => any) | undefined;
+    } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, "onChange" | "onUpdate:modelValue"> & (SliderProps & {
+        modelValue?: T;
+    }) & {}> & import("vue").PublicProps;
+    expose(exposed: import("vue").ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: {};
+    emit: ((evt: "change", event: Event) => void) & ((evt: "update:modelValue", value: T | undefined) => void);
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T as K]: T[K];
+} & {};

package/dist/runtime/components/Stepper.d.vue.ts

@@ -0,0 +1,87 @@
+import type { StepperRootProps, StepperRootEmits } from 'reka-ui';
+import type { AppConfig } from '@nuxt/schema';
+import theme from '#build/ui/stepper';
+import type { IconProps } from '../types';
+import type { DynamicSlots } from '../types/utils';
+import type { ComponentConfig } from '../types/tv';
+type Stepper = ComponentConfig<typeof theme, AppConfig, 'stepper'>;
+export interface StepperItem {
+    slot?: string;
+    value?: string | number;
+    title?: string;
+    description?: string;
+    /**
+     * @IconifyIcon
+     */
+    icon?: IconProps['name'];
+    content?: string;
+    disabled?: boolean;
+    class?: any;
+    ui?: Pick<Stepper['slots'], 'item' | 'container' | 'trigger' | 'indicator' | 'icon' | 'separator' | 'wrapper' | 'title' | 'description'>;
+    [key: string]: any;
+}
+export interface StepperProps<T extends StepperItem = StepperItem> extends Pick<StepperRootProps, 'linear'> {
+    /**
+     * The element or component this component should render as.
+     * @defaultValue 'div'
+     */
+    as?: any;
+    items: T[];
+    /**
+     * @defaultValue 'md'
+     */
+    size?: Stepper['variants']['size'];
+    /**
+     * @defaultValue 'primary'
+     */
+    color?: Stepper['variants']['color'];
+    /**
+     * The orientation of the stepper.
+     * @defaultValue 'horizontal'
+     */
+    orientation?: Stepper['variants']['orientation'];
+    /**
+     * The value of the step that should be active when initially rendered. Use when you do not need to control the state of the steps.
+     */
+    defaultValue?: string | number;
+    disabled?: boolean;
+    class?: any;
+    ui?: Stepper['slots'];
+}
+export type StepperEmits<T extends StepperItem = StepperItem> = Omit<StepperRootEmits, 'update:modelValue'> & {
+    next: [value: T];
+    prev: [value: T];
+};
+type SlotProps<T extends StepperItem> = (props: {
+    item: T;
+}) => any;
+export type StepperSlots<T extends StepperItem = StepperItem> = {
+    indicator: SlotProps<T>;
+    title: SlotProps<T>;
+    description: SlotProps<T>;
+    content: SlotProps<T>;
+} & DynamicSlots<T>;
+declare const _default: <T extends StepperItem>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly onNext?: ((value: T) => any) | undefined;
+        readonly onPrev?: ((value: T) => any) | undefined;
+        readonly "onUpdate:modelValue"?: ((value: string | number | undefined) => any) | undefined;
+    } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, "onUpdate:modelValue" | "onNext" | "onPrev"> & (StepperProps<T> & {
+        modelValue?: string | number;
+    }) & {}> & import("vue").PublicProps;
+    expose(exposed: import("vue").ShallowUnwrapRef<{
+        next(): void;
+        prev(): void;
+        hasNext: import("vue").ComputedRef<boolean>;
+        hasPrev: import("vue").ComputedRef<boolean>;
+    }>): void;
+    attrs: any;
+    slots: StepperSlots<T>;
+    emit: (((evt: "next", value: T) => void) & ((evt: "prev", value: T) => void)) & ((evt: "update:modelValue", value: string | number | undefined) => void);
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T as K]: T[K];
+} & {};

package/dist/runtime/components/Switch.d.vue.ts

@@ -0,0 +1,71 @@
+import type { SwitchRootProps } from 'reka-ui';
+import type { AppConfig } from '@nuxt/schema';
+import theme from '#build/ui/switch';
+import type { IconProps } from '../types';
+import type { ComponentConfig } from '../types/tv';
+type Switch = ComponentConfig<typeof theme, AppConfig, 'switch'>;
+export interface SwitchProps extends Pick<SwitchRootProps, 'disabled' | 'id' | 'name' | 'required' | 'value' | 'defaultValue'> {
+    /**
+     * The element or component this component should render as.
+     * @defaultValue 'div'
+     */
+    as?: any;
+    /**
+     * @defaultValue 'primary'
+     */
+    color?: Switch['variants']['color'];
+    /**
+     * @defaultValue 'md'
+     */
+    size?: Switch['variants']['size'];
+    /** When `true`, the loading icon will be displayed. */
+    loading?: boolean;
+    /**
+     * The icon when the `loading` prop is `true`.
+     * @defaultValue appConfig.ui.icons.loading
+     * @IconifyIcon
+     */
+    loadingIcon?: IconProps['name'];
+    /**
+     * Display an icon when the switch is checked.
+     * @IconifyIcon
+     */
+    checkedIcon?: IconProps['name'];
+    /**
+     * Display an icon when the switch is unchecked.
+     * @IconifyIcon
+     */
+    uncheckedIcon?: IconProps['name'];
+    label?: string;
+    description?: string;
+    class?: any;
+    ui?: Switch['slots'];
+}
+export type SwitchEmits = {
+    change: [event: Event];
+};
+export interface SwitchSlots {
+    label(props: {
+        label?: string;
+    }): any;
+    description(props: {
+        description?: string;
+    }): any;
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<SwitchProps & {
+    modelValue?: boolean;
+}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    change: (event: Event) => any;
+    "update:modelValue": (value: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<SwitchProps & {
+    modelValue?: boolean;
+}> & Readonly<{
+    onChange?: ((event: Event) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, SwitchSlots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/Table.d.vue.ts

@@ -0,0 +1,201 @@
+import type { Ref, WatchOptions } from 'vue';
+import type { AppConfig } from '@nuxt/schema';
+import type { Cell, Header, RowData, TableMeta } from '@tanstack/table-core';
+import type { CellContext, ColumnDef, ColumnFiltersOptions, ColumnFiltersState, ColumnOrderState, ColumnPinningOptions, ColumnPinningState, ColumnSizingInfoState, ColumnSizingOptions, ColumnSizingState, CoreOptions, ExpandedOptions, ExpandedState, FacetedOptions, GlobalFilterOptions, GroupingOptions, GroupingState, HeaderContext, PaginationOptions, PaginationState, Row, RowPinningOptions, RowPinningState, RowSelectionOptions, RowSelectionState, SortingOptions, SortingState, VisibilityOptions, VisibilityState } from '@tanstack/vue-table';
+import theme from '#build/ui/table';
+import type { ComponentConfig } from '../types/tv';
+declare module '@tanstack/table-core' {
+    interface ColumnMeta<TData extends RowData, TValue> {
+        class?: {
+            th?: string | ((cell: Header<TData, TValue>) => string);
+            td?: string | ((cell: Cell<TData, TValue>) => string);
+        };
+        style?: {
+            th?: string | Record<string, string> | ((cell: Header<TData, TValue>) => string | Record<string, string>);
+            td?: string | Record<string, string> | ((cell: Cell<TData, TValue>) => string | Record<string, string>);
+        };
+        colspan?: {
+            td?: string | ((cell: Cell<TData, TValue>) => string);
+        };
+        rowspan?: {
+            td?: string | ((cell: Cell<TData, TValue>) => string);
+        };
+    }
+    interface TableMeta<TData> {
+        class?: {
+            tr?: string | ((row: Row<TData>) => string);
+        };
+        style?: {
+            tr?: string | Record<string, string> | ((row: Row<TData>) => string | Record<string, string>);
+        };
+    }
+}
+type Table = ComponentConfig<typeof theme, AppConfig, 'table'>;
+export type TableRow<T> = Row<T>;
+export type TableData = RowData;
+export type TableColumn<T extends TableData, D = unknown> = ColumnDef<T, D>;
+export interface TableOptions<T extends TableData = TableData> extends Omit<CoreOptions<T>, 'data' | 'columns' | 'getCoreRowModel' | 'state' | 'onStateChange' | 'renderFallbackValue'> {
+    state?: CoreOptions<T>['state'];
+    onStateChange?: CoreOptions<T>['onStateChange'];
+    renderFallbackValue?: CoreOptions<T>['renderFallbackValue'];
+}
+export interface TableProps<T extends TableData = TableData> extends TableOptions<T> {
+    /**
+     * The element or component this component should render as.
+     * @defaultValue 'div'
+     */
+    as?: any;
+    data?: T[];
+    columns?: TableColumn<T>[];
+    caption?: string;
+    meta?: TableMeta<T>;
+    /**
+     * The text to display when the table is empty.
+     * @defaultValue t('table.noData')
+     */
+    empty?: string;
+    /**
+     * Whether the table should have a sticky header or footer. True for both, 'header' for header only, 'footer' for footer only.
+     * @defaultValue false
+     */
+    sticky?: boolean | 'header' | 'footer';
+    /** Whether the table should be in loading state. */
+    loading?: boolean;
+    /**
+     * @defaultValue 'primary'
+     */
+    loadingColor?: Table['variants']['loadingColor'];
+    /**
+     * @defaultValue 'carousel'
+     */
+    loadingAnimation?: Table['variants']['loadingAnimation'];
+    /**
+     * Use the `watchOptions` prop to customize reactivity (for ex: disable deep watching for changes in your data or limiting the max traversal depth). This can improve performance by reducing unnecessary re-renders, but it should be used with caution as it may lead to unexpected behavior if not managed properly.
+     * @see [API](https://vuejs.org/api/options-state.html#watch)
+     * @see [Guide](https://vuejs.org/guide/essentials/watchers.html)
+     * @defaultValue { deep: true }
+     */
+    watchOptions?: WatchOptions;
+    /**
+     * @see [API](https://tanstack.com/table/v8/docs/api/features/global-filtering#table-options)
+     * @see [Guide](https://tanstack.com/table/v8/docs/guide/global-filtering)
+     */
+    globalFilterOptions?: Omit<GlobalFilterOptions<T>, 'onGlobalFilterChange'>;
+    /**
+     * @see [API](https://tanstack.com/table/v8/docs/api/features/column-filtering#table-options)
+     * @see [Guide](https://tanstack.com/table/v8/docs/guide/column-filtering)
+     */
+    columnFiltersOptions?: Omit<ColumnFiltersOptions<T>, 'getFilteredRowModel' | 'onColumnFiltersChange'>;
+    /**
+     * @see [API](https://tanstack.com/table/v8/docs/api/features/column-pinning#table-options)
+     * @see [Guide](https://tanstack.com/table/v8/docs/guide/column-pinning)
+     */
+    columnPinningOptions?: Omit<ColumnPinningOptions, 'onColumnPinningChange'>;
+    /**
+     * @see [API](https://tanstack.com/table/v8/docs/api/features/column-sizing#table-options)
+     * @see [Guide](https://tanstack.com/table/v8/docs/guide/column-sizing)
+     */
+    columnSizingOptions?: Omit<ColumnSizingOptions, 'onColumnSizingChange' | 'onColumnSizingInfoChange'>;
+    /**
+     * @see [API](https://tanstack.com/table/v8/docs/api/features/column-visibility#table-options)
+     * @see [Guide](https://tanstack.com/table/v8/docs/guide/column-visibility)
+     */
+    visibilityOptions?: Omit<VisibilityOptions, 'onColumnVisibilityChange'>;
+    /**
+     * @see [API](https://tanstack.com/table/v8/docs/api/features/sorting#table-options)
+     * @see [Guide](https://tanstack.com/table/v8/docs/guide/sorting)
+     */
+    sortingOptions?: Omit<SortingOptions<T>, 'getSortedRowModel' | 'onSortingChange'>;
+    /**
+     * @see [API](https://tanstack.com/table/v8/docs/api/features/grouping#table-options)
+     * @see [Guide](https://tanstack.com/table/v8/docs/guide/grouping)
+     */
+    groupingOptions?: Omit<GroupingOptions, 'onGroupingChange'>;
+    /**
+     * @see [API](https://tanstack.com/table/v8/docs/api/features/expanding#table-options)
+     * @see [Guide](https://tanstack.com/table/v8/docs/guide/expanding)
+     */
+    expandedOptions?: Omit<ExpandedOptions<T>, 'getExpandedRowModel' | 'onExpandedChange'>;
+    /**
+     * @see [API](https://tanstack.com/table/v8/docs/api/features/row-selection#table-options)
+     * @see [Guide](https://tanstack.com/table/v8/docs/guide/row-selection)
+     */
+    rowSelectionOptions?: Omit<RowSelectionOptions<T>, 'onRowSelectionChange'>;
+    /**
+     * @see [API](https://tanstack.com/table/v8/docs/api/features/row-pinning#table-options)
+     * @see [Guide](https://tanstack.com/table/v8/docs/guide/row-pinning)
+     */
+    rowPinningOptions?: Omit<RowPinningOptions<T>, 'onRowPinningChange'>;
+    /**
+     * @see [API](https://tanstack.com/table/v8/docs/api/features/pagination#table-options)
+     * @see [Guide](https://tanstack.com/table/v8/docs/guide/pagination)
+     */
+    paginationOptions?: Omit<PaginationOptions, 'onPaginationChange'>;
+    /**
+     * @see [API](https://tanstack.com/table/v8/docs/api/features/column-faceting#table-options)
+     * @see [Guide](https://tanstack.com/table/v8/docs/guide/column-faceting)
+     */
+    facetedOptions?: FacetedOptions<T>;
+    onSelect?: (row: TableRow<T>, e?: Event) => void;
+    onHover?: (e: Event, row: TableRow<T> | null) => void;
+    onContextmenu?: ((e: Event, row: TableRow<T>) => void) | Array<((e: Event, row: TableRow<T>) => void)>;
+    class?: any;
+    ui?: Table['slots'];
+}
+type DynamicHeaderSlots<T, K = keyof T> = Record<string, (props: HeaderContext<T, unknown>) => any> & Record<`${K extends string ? K : never}-header`, (props: HeaderContext<T, unknown>) => any>;
+type DynamicFooterSlots<T, K = keyof T> = Record<string, (props: HeaderContext<T, unknown>) => any> & Record<`${K extends string ? K : never}-footer`, (props: HeaderContext<T, unknown>) => any>;
+type DynamicCellSlots<T, K = keyof T> = Record<string, (props: CellContext<T, unknown>) => any> & Record<`${K extends string ? K : never}-cell`, (props: CellContext<T, unknown>) => any>;
+export type TableSlots<T extends TableData = TableData> = {
+    'expanded': (props: {
+        row: Row<T>;
+    }) => any;
+    'empty': (props?: {}) => any;
+    'loading': (props?: {}) => any;
+    'caption': (props?: {}) => any;
+    'body-top': (props?: {}) => any;
+    'body-bottom': (props?: {}) => any;
+} & DynamicHeaderSlots<T> & DynamicFooterSlots<T> & DynamicCellSlots<T>;
+declare const _default: <T extends TableData>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly "onUpdate:globalFilter"?: ((value: string) => any) | undefined;
+        readonly "onUpdate:columnFilters"?: ((value: ColumnFiltersState) => any) | undefined;
+        readonly "onUpdate:columnOrder"?: ((value: ColumnOrderState) => any) | undefined;
+        readonly "onUpdate:columnVisibility"?: ((value: VisibilityState) => any) | undefined;
+        readonly "onUpdate:columnPinning"?: ((value: ColumnPinningState) => any) | undefined;
+        readonly "onUpdate:columnSizing"?: ((value: ColumnSizingState) => any) | undefined;
+        readonly "onUpdate:columnSizingInfo"?: ((value: ColumnSizingInfoState) => any) | undefined;
+        readonly "onUpdate:rowSelection"?: ((value: RowSelectionState) => any) | undefined;
+        readonly "onUpdate:rowPinning"?: ((value: RowPinningState) => any) | undefined;
+        readonly "onUpdate:sorting"?: ((value: SortingState) => any) | undefined;
+        readonly "onUpdate:grouping"?: ((value: GroupingState) => any) | undefined;
+        readonly "onUpdate:expanded"?: ((value: ExpandedState) => any) | undefined;
+        readonly "onUpdate:pagination"?: ((value: PaginationState) => any) | undefined;
+    } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, "onUpdate:globalFilter" | "onUpdate:columnFilters" | "onUpdate:columnOrder" | "onUpdate:columnVisibility" | "onUpdate:columnPinning" | "onUpdate:columnSizing" | "onUpdate:columnSizingInfo" | "onUpdate:rowSelection" | "onUpdate:rowPinning" | "onUpdate:sorting" | "onUpdate:grouping" | "onUpdate:expanded" | "onUpdate:pagination"> & (TableProps<T> & {
+        globalFilter?: string;
+        columnFilters?: ColumnFiltersState;
+        columnOrder?: ColumnOrderState;
+        columnVisibility?: VisibilityState;
+        columnPinning?: ColumnPinningState;
+        columnSizing?: ColumnSizingState;
+        columnSizingInfo?: ColumnSizingInfoState;
+        rowSelection?: RowSelectionState;
+        rowPinning?: RowPinningState;
+        sorting?: SortingState;
+        grouping?: GroupingState;
+        expanded?: ExpandedState;
+        pagination?: PaginationState;
+    }) & {}> & import("vue").PublicProps;
+    expose(exposed: import("vue").ShallowUnwrapRef<{
+        tableRef: Ref<HTMLTableElement | null, HTMLTableElement | null>;
+        tableApi: import("@tanstack/table-core").Table<T>;
+    }>): void;
+    attrs: any;
+    slots: TableSlots<T>;
+    emit: ((evt: "update:globalFilter", value: string) => void) & ((evt: "update:columnFilters", value: ColumnFiltersState) => void) & ((evt: "update:columnOrder", value: ColumnOrderState) => void) & ((evt: "update:columnVisibility", value: VisibilityState) => void) & ((evt: "update:columnPinning", value: ColumnPinningState) => void) & ((evt: "update:columnSizing", value: ColumnSizingState) => void) & ((evt: "update:columnSizingInfo", value: ColumnSizingInfoState) => void) & ((evt: "update:rowSelection", value: RowSelectionState) => void) & ((evt: "update:rowPinning", value: RowPinningState) => void) & ((evt: "update:sorting", value: SortingState) => void) & ((evt: "update:grouping", value: GroupingState) => void) & ((evt: "update:expanded", value: ExpandedState) => void) & ((evt: "update:pagination", value: PaginationState) => void);
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T as K]: T[K];
+} & {};