@una-ui/nuxt 0.67.2 → 0.67.4

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

@@ -0,0 +1,184 @@
+import type { ColumnFiltersState, ColumnOrderState, ColumnPinningState, ExpandedState, GroupingState, Header, PaginationState, Row, RowSelectionState, SortingState, VisibilityState } from '@tanstack/vue-table';
+import type { NTableProps } from '../../../types/index.js';
+declare const _default: <TData, TValue>(__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 onSelect?: ((row: TData) => any) | undefined;
+        readonly onRow?: ((event: Event, row: TData) => any) | undefined;
+        readonly "onUpdate:rowSelection"?: ((value: RowSelectionState | undefined) => any) | undefined;
+        readonly "onUpdate:sorting"?: ((value: SortingState | undefined) => any) | undefined;
+        readonly "onUpdate:columnVisibility"?: ((value: VisibilityState | undefined) => any) | undefined;
+        readonly "onUpdate:columnFilters"?: ((value: ColumnFiltersState | undefined) => any) | undefined;
+        readonly "onUpdate:globalFilter"?: ((value: string | undefined) => any) | undefined;
+        readonly "onUpdate:columnOrder"?: ((value: ColumnOrderState | undefined) => any) | undefined;
+        readonly "onUpdate:columnPinning"?: ((value: ColumnPinningState | undefined) => any) | undefined;
+        readonly "onUpdate:expanded"?: ((value: ExpandedState | undefined) => any) | undefined;
+        readonly "onUpdate:grouping"?: ((value: GroupingState | undefined) => any) | undefined;
+        readonly "onUpdate:pagination"?: ((value: PaginationState) => any) | undefined;
+        readonly onSelectAll?: ((rows: TData[]) => any) | undefined;
+        readonly onExpand?: ((row: TData) => any) | undefined;
+    } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, "onSelect" | "onRow" | "onUpdate:rowSelection" | "onUpdate:sorting" | "onUpdate:columnVisibility" | "onUpdate:columnFilters" | "onUpdate:globalFilter" | "onUpdate:columnOrder" | "onUpdate:columnPinning" | "onUpdate:expanded" | "onUpdate:grouping" | "onUpdate:pagination" | "onSelectAll" | "onExpand"> & (NTableProps<TData, TValue> & {
+        rowSelection?: RowSelectionState;
+        sorting?: SortingState;
+        columnVisibility?: VisibilityState;
+        columnFilters?: ColumnFiltersState;
+        globalFilter?: string;
+        columnOrder?: ColumnOrderState;
+        columnPinning?: ColumnPinningState;
+        expanded?: ExpandedState;
+        grouping?: GroupingState;
+        pagination?: PaginationState;
+    }) & Partial<{}>> & import("vue").PublicProps;
+    expose(exposed: import("vue").ShallowUnwrapRef<{
+        _features: readonly import("@tanstack/vue-table").TableFeature[];
+        _getAllFlatColumnsById: () => Record<string, import("@tanstack/vue-table").Column<any, unknown>>;
+        _getColumnDefs: () => import("@tanstack/vue-table").ColumnDef<any, unknown>[];
+        _getCoreRowModel?: (() => import("@tanstack/vue-table").RowModel<any>) | undefined;
+        _getDefaultColumnDef: () => Partial<import("@tanstack/vue-table").ColumnDef<any, unknown>>;
+        _getRowId: (_: any, index: number, parent?: Row<any> | undefined) => string;
+        _queue: (cb: () => void) => void;
+        getAllColumns: () => import("@tanstack/vue-table").Column<any, unknown>[];
+        getAllFlatColumns: () => import("@tanstack/vue-table").Column<any, unknown>[];
+        getAllLeafColumns: () => import("@tanstack/vue-table").Column<any, unknown>[];
+        getColumn: (columnId: string) => import("@tanstack/vue-table").Column<any, unknown> | undefined;
+        getCoreRowModel: () => import("@tanstack/vue-table").RowModel<any>;
+        getRow: (id: string, searchAll?: boolean) => Row<any>;
+        getRowModel: () => import("@tanstack/vue-table").RowModel<any>;
+        getState: () => import("@tanstack/vue-table").TableState;
+        initialState: import("@tanstack/vue-table").TableState;
+        options: import("@tanstack/vue-table").RequiredKeys<import("@tanstack/vue-table").TableOptionsResolved<any>, "state">;
+        reset: () => void;
+        setOptions: (newOptions: import("@tanstack/vue-table").Updater<import("@tanstack/vue-table").TableOptionsResolved<any>>) => void;
+        setState: (updater: import("@tanstack/vue-table").Updater<import("@tanstack/vue-table").TableState>) => void;
+        getHeaderGroups: () => import("@tanstack/vue-table").HeaderGroup<any>[];
+        getLeftHeaderGroups: () => import("@tanstack/vue-table").HeaderGroup<any>[];
+        getCenterHeaderGroups: () => import("@tanstack/vue-table").HeaderGroup<any>[];
+        getRightHeaderGroups: () => import("@tanstack/vue-table").HeaderGroup<any>[];
+        getFooterGroups: () => import("@tanstack/vue-table").HeaderGroup<any>[];
+        getLeftFooterGroups: () => import("@tanstack/vue-table").HeaderGroup<any>[];
+        getCenterFooterGroups: () => import("@tanstack/vue-table").HeaderGroup<any>[];
+        getRightFooterGroups: () => import("@tanstack/vue-table").HeaderGroup<any>[];
+        getFlatHeaders: () => Header<any, unknown>[];
+        getLeftFlatHeaders: () => Header<any, unknown>[];
+        getCenterFlatHeaders: () => Header<any, unknown>[];
+        getRightFlatHeaders: () => Header<any, unknown>[];
+        getLeafHeaders: () => Header<any, unknown>[];
+        getLeftLeafHeaders: () => Header<any, unknown>[];
+        getCenterLeafHeaders: () => Header<any, unknown>[];
+        getRightLeafHeaders: () => Header<any, unknown>[];
+        getCenterVisibleLeafColumns: () => import("@tanstack/vue-table").Column<any, unknown>[];
+        getIsAllColumnsVisible: () => boolean;
+        getIsSomeColumnsVisible: () => boolean;
+        getLeftVisibleLeafColumns: () => import("@tanstack/vue-table").Column<any, unknown>[];
+        getRightVisibleLeafColumns: () => import("@tanstack/vue-table").Column<any, unknown>[];
+        getToggleAllColumnsVisibilityHandler: () => (event: unknown) => void;
+        getVisibleFlatColumns: () => import("@tanstack/vue-table").Column<any, unknown>[];
+        getVisibleLeafColumns: () => import("@tanstack/vue-table").Column<any, unknown>[];
+        resetColumnVisibility: (defaultState?: boolean) => void;
+        setColumnVisibility: (updater: import("@tanstack/vue-table").Updater<VisibilityState>) => void;
+        toggleAllColumnsVisible: (value?: boolean) => void;
+        _getOrderColumnsFn: () => (columns: import("@tanstack/vue-table").Column<any, unknown>[]) => import("@tanstack/vue-table").Column<any, unknown>[];
+        resetColumnOrder: (defaultState?: boolean) => void;
+        setColumnOrder: (updater: import("@tanstack/vue-table").Updater<ColumnOrderState>) => void;
+        getCenterLeafColumns: () => import("@tanstack/vue-table").Column<any, unknown>[];
+        getIsSomeColumnsPinned: (position?: import("@tanstack/vue-table").ColumnPinningPosition) => boolean;
+        getLeftLeafColumns: () => import("@tanstack/vue-table").Column<any, unknown>[];
+        getRightLeafColumns: () => import("@tanstack/vue-table").Column<any, unknown>[];
+        resetColumnPinning: (defaultState?: boolean) => void;
+        setColumnPinning: (updater: import("@tanstack/vue-table").Updater<ColumnPinningState>) => void;
+        _getPinnedRows: (visiblePinnedRows: Row<any>[], pinnedRowIds: Array<string> | undefined, position: "top" | "bottom") => Row<any>[];
+        getBottomRows: () => Row<any>[];
+        getCenterRows: () => Row<any>[];
+        getIsSomeRowsPinned: (position?: import("@tanstack/vue-table").RowPinningPosition) => boolean;
+        getTopRows: () => Row<any>[];
+        resetRowPinning: (defaultState?: boolean) => void;
+        setRowPinning: (updater: import("@tanstack/vue-table").Updater<import("@tanstack/vue-table").RowPinningState>) => void;
+        _getFilteredRowModel?: (() => import("@tanstack/vue-table").RowModel<any>) | undefined;
+        getFilteredRowModel: () => import("@tanstack/vue-table").RowModel<any>;
+        getPreFilteredRowModel: () => import("@tanstack/vue-table").RowModel<any>;
+        resetColumnFilters: (defaultState?: boolean) => void;
+        resetGlobalFilter: (defaultState?: boolean) => void;
+        setColumnFilters: (updater: import("@tanstack/vue-table").Updater<ColumnFiltersState>) => void;
+        setGlobalFilter: (updater: import("@tanstack/vue-table").Updater<any>) => void;
+        getGlobalAutoFilterFn: () => import("@tanstack/vue-table").FilterFn<any> | undefined;
+        getGlobalFilterFn: () => import("@tanstack/vue-table").FilterFn<any> | undefined;
+        _getGlobalFacetedMinMaxValues?: () => undefined | [number, number];
+        _getGlobalFacetedRowModel?: (() => import("@tanstack/vue-table").RowModel<any>) | undefined;
+        _getGlobalFacetedUniqueValues?: () => Map<any, number>;
+        getGlobalFacetedMinMaxValues: () => undefined | [number, number];
+        getGlobalFacetedRowModel: () => import("@tanstack/vue-table").RowModel<any>;
+        getGlobalFacetedUniqueValues: () => Map<any, number>;
+        _getSortedRowModel?: (() => import("@tanstack/vue-table").RowModel<any>) | undefined;
+        getPreSortedRowModel: () => import("@tanstack/vue-table").RowModel<any>;
+        getSortedRowModel: () => import("@tanstack/vue-table").RowModel<any>;
+        resetSorting: (defaultState?: boolean) => void;
+        setSorting: (updater: import("@tanstack/vue-table").Updater<SortingState>) => void;
+        _getGroupedRowModel?: (() => import("@tanstack/vue-table").RowModel<any>) | undefined;
+        getGroupedRowModel: () => import("@tanstack/vue-table").RowModel<any>;
+        getPreGroupedRowModel: () => import("@tanstack/vue-table").RowModel<any>;
+        resetGrouping: (defaultState?: boolean) => void;
+        setGrouping: (updater: import("@tanstack/vue-table").Updater<GroupingState>) => void;
+        getCenterTotalSize: () => number;
+        getLeftTotalSize: () => number;
+        getRightTotalSize: () => number;
+        getTotalSize: () => number;
+        resetColumnSizing: (defaultState?: boolean) => void;
+        resetHeaderSizeInfo: (defaultState?: boolean) => void;
+        setColumnSizing: (updater: import("@tanstack/vue-table").Updater<import("@tanstack/vue-table").ColumnSizingState>) => void;
+        setColumnSizingInfo: (updater: import("@tanstack/vue-table").Updater<import("@tanstack/vue-table").ColumnSizingInfoState>) => void;
+        _autoResetExpanded: () => void;
+        _getExpandedRowModel?: (() => import("@tanstack/vue-table").RowModel<any>) | undefined;
+        getCanSomeRowsExpand: () => boolean;
+        getExpandedDepth: () => number;
+        getExpandedRowModel: () => import("@tanstack/vue-table").RowModel<any>;
+        getIsAllRowsExpanded: () => boolean;
+        getIsSomeRowsExpanded: () => boolean;
+        getPreExpandedRowModel: () => import("@tanstack/vue-table").RowModel<any>;
+        getToggleAllRowsExpandedHandler: () => (event: unknown) => void;
+        resetExpanded: (defaultState?: boolean) => void;
+        setExpanded: (updater: import("@tanstack/vue-table").Updater<ExpandedState>) => void;
+        toggleAllRowsExpanded: (expanded?: boolean) => void;
+        _autoResetPageIndex: () => void;
+        _getPaginationRowModel?: (() => import("@tanstack/vue-table").RowModel<any>) | undefined;
+        getCanNextPage: () => boolean;
+        getCanPreviousPage: () => boolean;
+        getPageCount: () => number;
+        getRowCount: () => number;
+        getPageOptions: () => number[];
+        getPaginationRowModel: () => import("@tanstack/vue-table").RowModel<any>;
+        getPrePaginationRowModel: () => import("@tanstack/vue-table").RowModel<any>;
+        nextPage: () => void;
+        previousPage: () => void;
+        firstPage: () => void;
+        lastPage: () => void;
+        resetPageIndex: (defaultState?: boolean) => void;
+        resetPageSize: (defaultState?: boolean) => void;
+        resetPagination: (defaultState?: boolean) => void;
+        setPageCount: (updater: import("@tanstack/vue-table").Updater<number>) => void;
+        setPageIndex: (updater: import("@tanstack/vue-table").Updater<number>) => void;
+        setPageSize: (updater: import("@tanstack/vue-table").Updater<number>) => void;
+        setPagination: (updater: import("@tanstack/vue-table").Updater<PaginationState>) => void;
+        getFilteredSelectedRowModel: () => import("@tanstack/vue-table").RowModel<any>;
+        getGroupedSelectedRowModel: () => import("@tanstack/vue-table").RowModel<any>;
+        getIsAllPageRowsSelected: () => boolean;
+        getIsAllRowsSelected: () => boolean;
+        getIsSomePageRowsSelected: () => boolean;
+        getIsSomeRowsSelected: () => boolean;
+        getPreSelectedRowModel: () => import("@tanstack/vue-table").RowModel<any>;
+        getSelectedRowModel: () => import("@tanstack/vue-table").RowModel<any>;
+        getToggleAllPageRowsSelectedHandler: () => (event: unknown) => void;
+        getToggleAllRowsSelectedHandler: () => (event: unknown) => void;
+        resetRowSelection: (defaultState?: boolean) => void;
+        setRowSelection: (updater: import("@tanstack/vue-table").Updater<RowSelectionState>) => void;
+        toggleAllPageRowsSelected: (value?: boolean) => void;
+        toggleAllRowsSelected: (value?: boolean) => void;
+    }>): void;
+    attrs: any;
+    slots: __VLS_Slots;
+    emit: (((evt: "select", row: TData) => void) & ((evt: "row", event: Event, row: TData) => void) & ((evt: "selectAll", rows: TData[]) => void) & ((evt: "expand", row: TData) => void)) & (((evt: "update:rowSelection", value: RowSelectionState | undefined) => void) & ((evt: "update:sorting", value: SortingState | undefined) => void) & ((evt: "update:columnVisibility", value: VisibilityState | undefined) => void) & ((evt: "update:columnFilters", value: ColumnFiltersState | undefined) => void) & ((evt: "update:globalFilter", value: string | undefined) => void) & ((evt: "update:columnOrder", value: ColumnOrderState | undefined) => void) & ((evt: "update:columnPinning", value: ColumnPinningState | undefined) => void) & ((evt: "update:expanded", value: ExpandedState | undefined) => void) & ((evt: "update:grouping", value: GroupingState | undefined) => 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]: T[K];
+} & {};

package/dist/runtime/components/data/table/TableBody.d.vue.ts

@@ -0,0 +1,34 @@
+import type { NTableBodyProps } from '../../../types/index.js';
+declare var __VLS_6: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_6) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<NTableBodyProps>, {
+    as: string;
+}>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<NTableBodyProps>, {
+    as: string;
+}>>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_PrettifyLocal<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/runtime/components/data/table/TableCaption.d.vue.ts

@@ -0,0 +1,34 @@
+import type { NTableCaptionProps } from '../../../types/index.js';
+declare var __VLS_6: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_6) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<NTableCaptionProps>, {
+    as: string;
+}>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<NTableCaptionProps>, {
+    as: string;
+}>>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_PrettifyLocal<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/runtime/components/data/table/TableCell.d.vue.ts

@@ -0,0 +1,34 @@
+import type { NTableCellProps } from '../../../types/index.js';
+declare var __VLS_6: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_6) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<NTableCellProps>, {
+    as: string;
+}>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<NTableCellProps>, {
+    as: string;
+}>>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_PrettifyLocal<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/runtime/components/data/table/TableEmpty.d.vue.ts

@@ -0,0 +1,38 @@
+import type { NTableEmptyProps } from '../../../types/index.js';
+declare var __VLS_8: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_8) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<NTableEmptyProps>, {
+    colspan: number;
+    emptyText: string;
+    emptyIcon: string;
+}>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<NTableEmptyProps>, {
+    colspan: number;
+    emptyText: string;
+    emptyIcon: string;
+}>>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_PrettifyLocal<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/runtime/components/data/table/TableFooter.d.vue.ts

@@ -0,0 +1,34 @@
+import type { NTableFooterProps } from '../../../types/index.js';
+declare var __VLS_6: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_6) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<NTableFooterProps>, {
+    as: string;
+}>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<NTableFooterProps>, {
+    as: string;
+}>>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_PrettifyLocal<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/runtime/components/data/table/TableHead.d.vue.ts

@@ -0,0 +1,34 @@
+import type { NTableHeadProps } from '../../../types/index.js';
+declare var __VLS_6: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_6) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<NTableHeadProps>, {
+    as: string;
+}>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<NTableHeadProps>, {
+    as: string;
+}>>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_PrettifyLocal<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/runtime/components/data/table/TableHeader.d.vue.ts

@@ -0,0 +1,34 @@
+import type { NTableHeaderProps } from '../../../types/index.js';
+declare var __VLS_6: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_6) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<NTableHeaderProps>, {
+    as: string;
+}>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<NTableHeaderProps>, {
+    as: string;
+}>>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_PrettifyLocal<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/runtime/components/data/table/TableLoading.d.vue.ts

@@ -0,0 +1,34 @@
+import type { NTableLoadingProps } from '../../../types/index.js';
+declare var __VLS_5: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_5) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<NTableLoadingProps>, {
+    size: string;
+}>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<NTableLoadingProps>, {
+    size: string;
+}>>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_PrettifyLocal<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/runtime/components/data/table/TableRow.d.vue.ts

@@ -0,0 +1,34 @@
+import type { NTableRowProps } from '../../../types/index.js';
+declare var __VLS_6: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_6) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<NTableRowProps>, {
+    as: string;
+}>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<NTableRowProps>, {
+    as: string;
+}>>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_PrettifyLocal<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/runtime/components/drawer/Drawer.d.vue.ts

@@ -0,0 +1,47 @@
+import type { NDrawerProps } from '../../types/index.js';
+declare var __VLS_6: {}, __VLS_11: {
+    open: any;
+}, __VLS_26: {}, __VLS_31: {}, __VLS_36: {}, __VLS_41: {}, __VLS_43: {}, __VLS_48: {}, __VLS_53: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_6) => any;
+} & {
+    trigger?: (props: typeof __VLS_11) => any;
+} & {
+    content?: (props: typeof __VLS_26) => any;
+} & {
+    header?: (props: typeof __VLS_31) => any;
+} & {
+    title?: (props: typeof __VLS_36) => any;
+} & {
+    description?: (props: typeof __VLS_41) => any;
+} & {
+    body?: (props: typeof __VLS_43) => any;
+} & {
+    footer?: (props: typeof __VLS_48) => any;
+} & {
+    close?: (props: typeof __VLS_53) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<NDrawerProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    close: () => any;
+    drag: (percentageDragged: number) => any;
+    "update:open": (open: boolean) => any;
+    animationEnd: (open: boolean) => any;
+    release: (open: boolean) => any;
+    "update:activeSnapPoint": (val: string | number) => any;
+}, string, import("vue").PublicProps, Readonly<NDrawerProps> & Readonly<{
+    onClose?: (() => any) | undefined;
+    onDrag?: ((percentageDragged: number) => any) | undefined;
+    "onUpdate:open"?: ((open: boolean) => any) | undefined;
+    onAnimationEnd?: ((open: boolean) => any) | undefined;
+    onRelease?: ((open: boolean) => any) | undefined;
+    "onUpdate:activeSnapPoint"?: ((val: string | number) => any) | undefined;
+}>, {
+    shouldScaleBackground: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/drawer/DrawerClose.d.vue.ts

@@ -0,0 +1,13 @@
+import type { NDrawerCloseProps } from '../../types/index.js';
+declare var __VLS_6: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_6) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<NDrawerCloseProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<NDrawerCloseProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/drawer/DrawerContent.d.vue.ts

@@ -0,0 +1,29 @@
+import type { NDrawerContentProps } from '../../types/index.js';
+declare var __VLS_13: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_13) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<NDrawerContentProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    escapeKeyDown: (event: KeyboardEvent) => any;
+    pointerDownOutside: (event: import("reka-ui").PointerDownOutsideEvent) => any;
+    focusOutside: (event: import("reka-ui").FocusOutsideEvent) => any;
+    interactOutside: (event: import("reka-ui").PointerDownOutsideEvent | import("reka-ui").FocusOutsideEvent) => any;
+    openAutoFocus: (event: Event) => any;
+    closeAutoFocus: (event: Event) => any;
+}, string, import("vue").PublicProps, Readonly<NDrawerContentProps> & Readonly<{
+    onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
+    onPointerDownOutside?: ((event: import("reka-ui").PointerDownOutsideEvent) => any) | undefined;
+    onFocusOutside?: ((event: import("reka-ui").FocusOutsideEvent) => any) | undefined;
+    onInteractOutside?: ((event: import("reka-ui").PointerDownOutsideEvent | import("reka-ui").FocusOutsideEvent) => any) | undefined;
+    onOpenAutoFocus?: ((event: Event) => any) | undefined;
+    onCloseAutoFocus?: ((event: Event) => any) | undefined;
+}>, {
+    overlay: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/drawer/DrawerDescription.d.vue.ts

@@ -0,0 +1,13 @@
+import type { NDrawerDescriptionProps } from '../../types/index.js';
+declare var __VLS_6: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_6) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<NDrawerDescriptionProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<NDrawerDescriptionProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/drawer/DrawerFooter.d.vue.ts

@@ -0,0 +1,13 @@
+import type { NDrawerFooterProps } from '../../types/index.js';
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<NDrawerFooterProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<NDrawerFooterProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/drawer/DrawerHeader.d.vue.ts

@@ -0,0 +1,13 @@
+import type { NDrawerHeaderProps } from '../../types/index.js';
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<NDrawerHeaderProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<NDrawerHeaderProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};