@pantograph/pattern-vue 0.0.3 → 0.0.4

package/dist/components/DataTable/DataTable.d.ts

@@ -0,0 +1,99 @@
+import { InsertBetweenState } from './types/context';
+import { DataTableContext, DataTableProps, DataTableSlotProps, DataTableSlots, GetTableRowProps, TableCol, TableColExtra, TableColumn } from './types';
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<DataTableProps, {
+    props: DataTableProps;
+    emit: ((evt: "sort", column: TableColumn, order: false | "desc" | "asc", sorting: import('./types').SortItem[]) => void) & ((evt: "drop", params: import('./types').DataTableRowDropParams) => void) & ((evt: "resize", value: Record<string, number | undefined>) => void) & ((evt: "fetch", getIsVisible: () => Promise<boolean>) => void) & ((evt: "expand", id: string, value: boolean) => void) & ((evt: "update:filteredColumns", value: string[]) => void) & ((evt: "update:columnVisibility", value?: Record<string, boolean> | undefined) => void) & ((evt: "update:expanded", value?: true | Record<string, boolean> | undefined) => void) & ((evt: "update:columnOrder", value: string[]) => void) & ((evt: "reorder", value: string[]) => void) & ((evt: "rowClick", row: object, event: Event) => void) & ((evt: "insertBetweenRows", row: GetTableRowProps & {
+        position: "before" | "after";
+    }) => void) & ((evt: "columnWrap", wrapped: boolean, column: TableColumn) => void) & ((evt: "update:fixedColumn", value?: string | undefined) => void) & ((evt: "init", value?: DataTableContext | undefined) => void);
+    slots: DataTableSlots;
+    table: import('@tanstack/vue-table').Table<unknown>;
+    getRowProps: (params: GetTableRowProps) => Record<string, any>;
+    selectionId: string;
+    cell: import('./utils').CellActions;
+    selectState: import('./utils').SelectionState;
+    col: import('./utils').ColActions;
+    sort: import('./utils').SortActions;
+    getSlotProps: import('vue').ComputedRef<DataTableSlotProps>;
+    getTableLayout: import('vue').ComputedRef<"fixed" | "auto" | undefined>;
+    tableSelect: import('./utils').SelectionActions;
+    colWrap: import('./utils').ColumnWrapActions;
+    filter: import('./utils').FilterActions;
+    size: import('./utils').ColumnSizeActions;
+    fix: import('./utils').ColumnFixActions;
+    colOrder: import('./utils').ColumnOrderActions;
+    colPopover: import('./utils').ColumnPopoverActions;
+    row: import('./utils').RowActions;
+    getColDefByExtra: (col: TableCol) => TableColExtra & Omit<import('./types').TableCustomCellReturn, "rowSpan"> & import('./types').TableColumnBase<any> & {
+        customCell?: import('./types').TableCustomCell<any>;
+    } & {
+        [key: string]: unknown;
+    };
+    hasFooter: import('vue').Ref<boolean, boolean>;
+    onScroll: (e: Event) => void;
+    insertBetweenState: import('vue').Ref<InsertBetweenState, InsertBetweenState>;
+    hideShadowHeader: import('vue').Ref<boolean, boolean>;
+    hideShadowColumn: import('vue').Ref<boolean, boolean>;
+    headerRowCount: import('vue').Ref<number, number>;
+    tableRootRef: import('vue').Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    tableHeaderRef: import('vue').Ref<any, any>;
+    tableBodyRef: import('vue').Ref<any, any>;
+    getDragging: () => import('@pantograph/vue').ConfigProviderDraggingState;
+    setDragging: (value: import('@pantograph/vue').ConfigProviderDraggingState) => void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    sort: (column: TableColumn, order: false | "desc" | "asc", sorting: import('./types').SortItem[]) => any;
+    drop: (params: import('./types').DataTableRowDropParams) => any;
+    resize: (value: Record<string, number | undefined>) => any;
+    fetch: (getIsVisible: () => Promise<boolean>) => any;
+    expand: (id: string, value: boolean) => any;
+    "update:filteredColumns": (value: string[]) => any;
+    "update:columnVisibility": (value?: Record<string, boolean> | undefined) => any;
+    "update:expanded": (value?: true | Record<string, boolean> | undefined) => any;
+    "update:columnOrder": (value: string[]) => any;
+    reorder: (value: string[]) => any;
+    rowClick: (row: object, event: Event) => any;
+    insertBetweenRows: (row: GetTableRowProps & {
+        position: "before" | "after";
+    }) => any;
+    columnWrap: (wrapped: boolean, column: TableColumn) => any;
+    "update:fixedColumn": (value?: string | undefined) => any;
+    init: (value?: DataTableContext | undefined) => any;
+}, string, import('vue').PublicProps, Readonly<DataTableProps> & Readonly<{
+    onSort?: ((column: TableColumn, order: false | "desc" | "asc", sorting: import('./types').SortItem[]) => any) | undefined;
+    onDrop?: ((params: import('./types').DataTableRowDropParams) => any) | undefined;
+    onResize?: ((value: Record<string, number | undefined>) => any) | undefined;
+    onFetch?: ((getIsVisible: () => Promise<boolean>) => any) | undefined;
+    onExpand?: ((id: string, value: boolean) => any) | undefined;
+    "onUpdate:filteredColumns"?: ((value: string[]) => any) | undefined;
+    "onUpdate:columnVisibility"?: ((value?: Record<string, boolean> | undefined) => any) | undefined;
+    "onUpdate:expanded"?: ((value?: true | Record<string, boolean> | undefined) => any) | undefined;
+    "onUpdate:columnOrder"?: ((value: string[]) => any) | undefined;
+    onReorder?: ((value: string[]) => any) | undefined;
+    onRowClick?: ((row: object, event: Event) => any) | undefined;
+    onInsertBetweenRows?: ((row: GetTableRowProps & {
+        position: "before" | "after";
+    }) => any) | undefined;
+    onColumnWrap?: ((wrapped: boolean, column: TableColumn) => any) | undefined;
+    "onUpdate:fixedColumn"?: ((value?: string | undefined) => any) | undefined;
+    onInit?: ((value?: DataTableContext | undefined) => any) | undefined;
+}>, {
+    zebra: boolean;
+    bordered: boolean;
+    loadingRowCount: number;
+    minVisibleAreaOnFixColumns: string | number;
+    childrenRowName: string | ((row: Record<string, any>) => any);
+    childrenColumnName: string | ((row: any) => any);
+    rowKey: string | ((row: Record<string, any>, index: number) => string);
+    batchActionsTitle: string;
+    paginateExpandedRows: boolean;
+    tableLayout: "fixed" | "auto";
+    overflowScroll: string | boolean;
+    hideDataOnLoading: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    tableRootRef: HTMLDivElement;
+}, HTMLDivElement>, Readonly<DataTableSlots> & DataTableSlots>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/DataTable/components/DataTableBatchActions.d.ts

@@ -0,0 +1,9 @@
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/DataTable/components/DataTableBatchActionsContent.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+export default _default;

package/dist/components/DataTable/components/DataTableColGroup.d.ts

@@ -0,0 +1,6 @@
+import { DataTableContext } from '../types';
+type __VLS_Props = {
+    getContext?: () => DataTableContext;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLTableColElement>;
+export default _default;

package/dist/components/DataTable/components/DataTableContent.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/components/DataTable/components/DataTableEmpty.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLTableRowElement>;
+export default _default;

package/dist/components/DataTable/components/DataTableFooter.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/components/DataTable/components/DataTableHeader.d.ts

@@ -0,0 +1,57 @@
+declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    containers: ({
+        $: import('vue').ComponentInternalInstance;
+        $data: {};
+        $props: {
+            readonly class?: import('clsx').ClassValue;
+            readonly zebra?: boolean | undefined;
+            readonly empty?: boolean | undefined;
+            readonly checked?: boolean | undefined;
+            readonly lazyLoadObserver?: boolean | undefined;
+            readonly onClick?: ((event: MouseEvent) => void) | undefined;
+            readonly onDblclick?: ((event: MouseEvent) => void) | undefined;
+            readonly onContextmenu?: ((event: MouseEvent) => void) | undefined;
+            readonly onMouseenter?: ((event: MouseEvent) => void) | undefined;
+            readonly onMouseleave?: ((event: MouseEvent) => void) | undefined;
+        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import('vue').Slot<any> | undefined;
+        }>;
+        $root: import('vue').ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import('vue').ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}, {}, {}, string, import('vue').ComponentProvideOptions>, {}, {}, "", {}, any> | null;
+        $parent: import('vue').ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import('vue').ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}, {}, {}, string, import('vue').ComponentProvideOptions>, {}, {}, "", {}, any> | null;
+        $host: Element | null;
+        $emit: (event: string, ...args: any[]) => void;
+        $el: HTMLTableRowElement;
+        $options: import('vue').ComponentOptionsBase<Readonly<import('@pantograph/vue').TrProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+            beforeCreate?: ((() => void) | (() => void)[]) | undefined;
+            created?: ((() => void) | (() => void)[]) | undefined;
+            beforeMount?: ((() => void) | (() => void)[]) | undefined;
+            mounted?: ((() => void) | (() => void)[]) | undefined;
+            beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
+            updated?: ((() => void) | (() => void)[]) | undefined;
+            activated?: ((() => void) | (() => void)[]) | undefined;
+            deactivated?: ((() => void) | (() => void)[]) | undefined;
+            beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
+            beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
+            destroyed?: ((() => void) | (() => void)[]) | undefined;
+            unmounted?: ((() => void) | (() => void)[]) | undefined;
+            renderTracked?: (((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[]) | undefined;
+            renderTriggered?: (((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[]) | undefined;
+            errorCaptured?: (((err: unknown, instance: import('vue').ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import('vue').ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}, {}, {}, string, import('vue').ComponentProvideOptions>, {}, {}, "", {}, any> | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import('vue').ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}, {}, {}, string, import('vue').ComponentProvideOptions>, {}, {}, "", {}, any> | null, info: string) => boolean | void)[]) | undefined;
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof import('vue').nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R, args_2: import('@vue/reactivity').OnCleanup) => any : (args_0: any, args_1: any, args_2: import('@vue/reactivity').OnCleanup) => any, options?: import('vue').WatchOptions<boolean> | undefined): import('vue').WatchStopHandle;
+    } & Readonly<{}> & Omit<Readonly<import('@pantograph/vue').TrProps> & Readonly<{}>, never> & import('vue').ShallowUnwrapRef<{}> & {} & import('vue').ComponentCustomProperties & {} & {
+        $slots: {
+            default?(_: {}): any;
+        };
+    }) | null;
+}, any>;
+export default _default;

package/dist/components/DataTable/components/DataTableHeaderCell.d.ts

@@ -0,0 +1,243 @@
+import { Header } from '@tanstack/table-core';
+type __VLS_Props = {
+    header: Header<unknown, unknown>;
+    cellProps: any;
+    draggable: boolean;
+};
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    filterRef: ({
+        $: import('vue').ComponentInternalInstance;
+        $data: {};
+        $props: {
+            readonly hover?: boolean | undefined;
+            readonly as?: ("svg" | "input" | "a" | "button" | "div" | "form" | "h2" | "h3" | "img" | "label" | "li" | "nav" | "ol" | "p" | "span" | "template" | "ul" | ({} & string)) | import('vue').Component | undefined;
+            readonly disabled?: boolean | undefined;
+            readonly class?: import('clsx').ClassValue;
+            readonly active?: boolean | undefined;
+            readonly badgeText?: string | undefined;
+            readonly badgeIcon?: string | undefined;
+            readonly icon?: string | undefined;
+            readonly flipOnDir?: import('@pantograph/vue').FlipOnDir | undefined;
+            readonly badgeIconFlipOnDir?: import('@pantograph/vue').FlipOnDir | undefined;
+            readonly dir?: import('@pantograph/vue').Direction | undefined;
+            readonly text?: string | number | undefined;
+            readonly size?: "md" | "sm" | "lg" | undefined;
+            readonly noRing?: boolean | undefined;
+            readonly loading?: boolean | undefined;
+            readonly preIcon?: string | undefined;
+            readonly postIcon?: string | undefined;
+            readonly customStroke?: boolean | undefined;
+            readonly preIconCustomStroke?: boolean | undefined;
+            readonly postIconCustomStroke?: boolean | undefined;
+            readonly preIconFlipOnDir?: import('@pantograph/vue').FlipOnDir | undefined;
+            readonly postIconFlipOnDir?: import('@pantograph/vue').FlipOnDir | undefined;
+            readonly htmlType?: "reset" | "submit" | "button" | undefined;
+            readonly block?: boolean | undefined;
+            readonly href?: string | undefined;
+            readonly target?: string | undefined;
+            readonly type?: "ghost" | "outline" | undefined;
+            readonly variant?: "icon" | "simple" | undefined;
+        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        } & {
+            buttonRef: ({
+                $: import('vue').ComponentInternalInstance;
+                $data: {};
+                $props: {
+                    readonly dir?: import('@pantograph/vue').Direction | undefined;
+                    readonly as?: ("svg" | "input" | "a" | "button" | "div" | "form" | "h2" | "h3" | "img" | "label" | "li" | "nav" | "ol" | "p" | "span" | "template" | "ul" | ({} & string)) | import('vue').Component | undefined;
+                    readonly class?: import('clsx').ClassValue;
+                    readonly text?: string | number | undefined;
+                    readonly size?: "md" | "sm" | "lg" | undefined;
+                    readonly color?: "neutral" | "primary" | "danger" | "success" | "warning" | "red" | "orange" | "amber" | "yellow" | "lime" | "green" | "teal" | "cyan" | "sky" | "blue" | "ocean" | "violet" | "amethyst" | "fuchsia" | "pink" | "mallard" | "gray" | undefined;
+                    readonly noRing?: boolean | undefined;
+                    readonly type?: "ghost" | "fill" | "outline" | undefined;
+                    readonly variant?: "icon" | "simple" | "float" | undefined;
+                    readonly loading?: boolean | undefined;
+                    readonly action?: boolean | undefined;
+                    readonly active?: boolean | undefined;
+                    readonly badgeText?: string | undefined;
+                    readonly badgeIcon?: string | undefined;
+                    readonly icon?: string | undefined;
+                    readonly preIcon?: string | undefined;
+                    readonly postIcon?: string | undefined;
+                    readonly customStroke?: boolean | undefined;
+                    readonly preIconCustomStroke?: boolean | undefined;
+                    readonly postIconCustomStroke?: boolean | undefined;
+                    readonly flipOnDir?: import('@pantograph/vue').FlipOnDir | undefined;
+                    readonly preIconFlipOnDir?: import('@pantograph/vue').FlipOnDir | undefined;
+                    readonly postIconFlipOnDir?: import('@pantograph/vue').FlipOnDir | undefined;
+                    readonly badgeIconFlipOnDir?: import('@pantograph/vue').FlipOnDir | undefined;
+                    readonly htmlType?: "reset" | "submit" | "button" | undefined;
+                    readonly block?: boolean | undefined;
+                    readonly disabled?: boolean | undefined;
+                    readonly hover?: boolean | undefined;
+                    readonly href?: string | undefined;
+                    readonly target?: string | undefined;
+                    readonly onClick?: ((...args: any[]) => any) | undefined;
+                } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+                $attrs: {
+                    [x: string]: unknown;
+                };
+                $refs: {
+                    [x: string]: unknown;
+                } & {
+                    buttonRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
+                        asChild: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        as: {
+                            type: import('vue').PropType<("svg" | "input" | "a" | "button" | "div" | "form" | "h2" | "h3" | "img" | "label" | "li" | "nav" | "ol" | "p" | "span" | "template" | "ul" | ({} & string)) | import('vue').Component>;
+                            default: string;
+                        };
+                    }>> & Readonly<{}>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+                        [key: string]: any;
+                    }>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {
+                        asChild: boolean;
+                        as: ("svg" | "input" | "a" | "button" | "div" | "form" | "h2" | "h3" | "img" | "label" | "li" | "nav" | "ol" | "p" | "span" | "template" | "ul" | ({} & string)) | import('vue').Component;
+                    }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                        P: {};
+                        B: {};
+                        D: {};
+                        C: {};
+                        M: {};
+                        Defaults: {};
+                    }, Readonly<import('vue').ExtractPropTypes<{
+                        asChild: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        as: {
+                            type: import('vue').PropType<("svg" | "input" | "a" | "button" | "div" | "form" | "h2" | "h3" | "img" | "label" | "li" | "nav" | "ol" | "p" | "span" | "template" | "ul" | ({} & string)) | import('vue').Component>;
+                            default: string;
+                        };
+                    }>> & Readonly<{}>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+                        [key: string]: any;
+                    }>, {}, {}, {}, {
+                        asChild: boolean;
+                        as: ("svg" | "input" | "a" | "button" | "div" | "form" | "h2" | "h3" | "img" | "label" | "li" | "nav" | "ol" | "p" | "span" | "template" | "ul" | ({} & string)) | import('vue').Component;
+                    }> | null;
+                };
+                $slots: Readonly<{
+                    [name: string]: import('vue').Slot<any> | undefined;
+                }>;
+                $root: import('vue').ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import('vue').ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}, {}, {}, string, import('vue').ComponentProvideOptions>, {}, {}, "", {}, any> | null;
+                $parent: import('vue').ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import('vue').ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}, {}, {}, string, import('vue').ComponentProvideOptions>, {}, {}, "", {}, any> | null;
+                $host: Element | null;
+                $emit: (event: "click", ...args: any[]) => void;
+                $el: any;
+                $options: import('vue').ComponentOptionsBase<Readonly<import('@pantograph/vue').BaseButtonProps> & Readonly<{
+                    onClick?: ((...args: any[]) => any) | undefined;
+                }>, {
+                    isFocused(): boolean;
+                    focus(): void;
+                    blur(): void;
+                }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                    click: (...args: any[]) => void;
+                }, string, {
+                    type: "ghost" | "fill" | "outline";
+                    disabled: boolean;
+                    color: "neutral" | "primary" | "danger" | "success" | "warning" | "red" | "orange" | "amber" | "yellow" | "lime" | "green" | "teal" | "cyan" | "sky" | "blue" | "ocean" | "violet" | "amethyst" | "fuchsia" | "pink" | "mallard" | "gray";
+                    htmlType: "reset" | "submit" | "button";
+                }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+                    beforeCreate?: (() => void) | (() => void)[] | undefined;
+                    created?: (() => void) | (() => void)[] | undefined;
+                    beforeMount?: (() => void) | (() => void)[] | undefined;
+                    mounted?: (() => void) | (() => void)[] | undefined;
+                    beforeUpdate?: (() => void) | (() => void)[] | undefined;
+                    updated?: (() => void) | (() => void)[] | undefined;
+                    activated?: (() => void) | (() => void)[] | undefined;
+                    deactivated?: (() => void) | (() => void)[] | undefined;
+                    beforeDestroy?: (() => void) | (() => void)[] | undefined;
+                    beforeUnmount?: (() => void) | (() => void)[] | undefined;
+                    destroyed?: (() => void) | (() => void)[] | undefined;
+                    unmounted?: (() => void) | (() => void)[] | undefined;
+                    renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[] | undefined;
+                    renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[] | undefined;
+                    errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import('vue').ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}, {}, {}, string, import('vue').ComponentProvideOptions>, {}, {}, "", {}, any> | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import('vue').ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}, {}, {}, string, import('vue').ComponentProvideOptions>, {}, {}, "", {}, any> | null, info: string) => boolean | void)[] | undefined;
+                };
+                $forceUpdate: () => void;
+                $nextTick: nextTick;
+                $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R, args_2: import('@vue/reactivity').OnCleanup) => any : (args_0: any, args_1: any, args_2: import('@vue/reactivity').OnCleanup) => any, options?: import('vue').WatchOptions<boolean> | undefined): import('vue').WatchStopHandle;
+            } & Readonly<{
+                type: "ghost" | "fill" | "outline";
+                disabled: boolean;
+                color: "neutral" | "primary" | "danger" | "success" | "warning" | "red" | "orange" | "amber" | "yellow" | "lime" | "green" | "teal" | "cyan" | "sky" | "blue" | "ocean" | "violet" | "amethyst" | "fuchsia" | "pink" | "mallard" | "gray";
+                htmlType: "reset" | "submit" | "button";
+            }> & Omit<Readonly<import('@pantograph/vue').BaseButtonProps> & Readonly<{
+                onClick?: ((...args: any[]) => any) | undefined;
+            }>, "disabled" | "color" | "type" | "htmlType" | "blur" | "focus" | "isFocused"> & import('vue').ShallowUnwrapRef<{
+                isFocused(): boolean;
+                focus(): void;
+                blur(): void;
+            }> & import('vue').ComponentCustomProperties & {
+                $slots: Readonly<import('@pantograph/vue').BaseButtonSlots> & import('@pantograph/vue').BaseButtonSlots;
+            }) | null;
+        };
+        $slots: Readonly<{
+            [name: string]: import('vue').Slot<any> | undefined;
+        }>;
+        $root: import('vue').ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import('vue').ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}, {}, {}, string, import('vue').ComponentProvideOptions>, {}, {}, "", {}, any> | null;
+        $parent: import('vue').ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import('vue').ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}, {}, {}, string, import('vue').ComponentProvideOptions>, {}, {}, "", {}, any> | null;
+        $host: Element | null;
+        $emit: (event: string, ...args: any[]) => void;
+        $el: any;
+        $options: import('vue').ComponentOptionsBase<Readonly<import('@pantograph/vue').ActionButtonProps> & Readonly<{}>, {
+            isFocused(): void;
+            focus(): void;
+            blur(): void;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+            type: "ghost" | "outline";
+            disabled: boolean;
+            htmlType: "reset" | "submit" | "button";
+        }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+            beforeCreate?: ((() => void) | (() => void)[]) | undefined;
+            created?: ((() => void) | (() => void)[]) | undefined;
+            beforeMount?: ((() => void) | (() => void)[]) | undefined;
+            mounted?: ((() => void) | (() => void)[]) | undefined;
+            beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
+            updated?: ((() => void) | (() => void)[]) | undefined;
+            activated?: ((() => void) | (() => void)[]) | undefined;
+            deactivated?: ((() => void) | (() => void)[]) | undefined;
+            beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
+            beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
+            destroyed?: ((() => void) | (() => void)[]) | undefined;
+            unmounted?: ((() => void) | (() => void)[]) | undefined;
+            renderTracked?: (((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[]) | undefined;
+            renderTriggered?: (((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[]) | undefined;
+            errorCaptured?: (((err: unknown, instance: import('vue').ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import('vue').ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}, {}, {}, string, import('vue').ComponentProvideOptions>, {}, {}, "", {}, any> | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import('vue').ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}, {}, {}, string, import('vue').ComponentProvideOptions>, {}, {}, "", {}, any> | null, info: string) => boolean | void)[]) | undefined;
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof import('vue').nextTick;
+        $watch<T_1 extends string | ((...args: any) => any)>(source: T_1, cb: T_1 extends (...args: any) => infer R_1 ? (args_0: R_1, args_1: R_1, args_2: import('@vue/reactivity').OnCleanup) => any : (args_0: any, args_1: any, args_2: import('@vue/reactivity').OnCleanup) => any, options?: import('vue').WatchOptions<boolean> | undefined): import('vue').WatchStopHandle;
+    } & Readonly<{
+        type: "ghost" | "outline";
+        disabled: boolean;
+        htmlType: "reset" | "submit" | "button";
+    }> & Omit<Readonly<import('@pantograph/vue').ActionButtonProps> & Readonly<{}>, "disabled" | "type" | "htmlType" | "blur" | "focus" | "isFocused"> & import('vue').ShallowUnwrapRef<{
+        isFocused(): void;
+        focus(): void;
+        blur(): void;
+    }> & {} & import('vue').ComponentCustomProperties & {} & {
+        $slots: Readonly<import('@pantograph/vue').BaseButtonSlots> & import('@pantograph/vue').BaseButtonSlots;
+    }) | null;
+}, HTMLTableCellElement>, {
+    headerCell?(_: {
+        column: import('../types').TableColExtra & Omit<import('../types').TableCustomCellReturn, "rowSpan"> & import('../types').TableColumnBase<any> & {
+            customCell?: import('../types').TableCustomCell<any>;
+        } & {
+            [key: string]: unknown;
+        };
+    }): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/DataTable/components/DataTableHeaderCellActionsPopover.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/components/DataTable/components/DataTableInsertBetween.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/components/DataTable/components/DataTableLazyLoading.d.ts

@@ -0,0 +1,56 @@
+declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    target: ({
+        $: import('vue').ComponentInternalInstance;
+        $data: {};
+        $props: {
+            readonly class?: import('clsx').ClassValue;
+            readonly size?: "lg" | "xlg" | undefined;
+            readonly empty?: boolean | undefined;
+            readonly wrap?: boolean | undefined;
+            readonly noContainer?: boolean | undefined;
+            readonly noPy?: boolean | undefined;
+            readonly noPx?: boolean | undefined;
+            readonly lazyLoadObserver?: boolean | undefined;
+            readonly fixed?: boolean | undefined;
+            readonly afterShadow?: boolean | undefined;
+            readonly ellipseHFull?: boolean | undefined;
+        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import('vue').Slot<any> | undefined;
+        }>;
+        $root: import('vue').ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import('vue').ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}, {}, {}, string, import('vue').ComponentProvideOptions>, {}, {}, "", {}, any> | null;
+        $parent: import('vue').ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import('vue').ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}, {}, {}, string, import('vue').ComponentProvideOptions>, {}, {}, "", {}, any> | null;
+        $host: Element | null;
+        $emit: (event: string, ...args: any[]) => void;
+        $el: HTMLTableCellElement;
+        $options: import('vue').ComponentOptionsBase<Readonly<import('@pantograph/vue').TdProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+            beforeCreate?: ((() => void) | (() => void)[]) | undefined;
+            created?: ((() => void) | (() => void)[]) | undefined;
+            beforeMount?: ((() => void) | (() => void)[]) | undefined;
+            mounted?: ((() => void) | (() => void)[]) | undefined;
+            beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
+            updated?: ((() => void) | (() => void)[]) | undefined;
+            activated?: ((() => void) | (() => void)[]) | undefined;
+            deactivated?: ((() => void) | (() => void)[]) | undefined;
+            beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
+            beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
+            destroyed?: ((() => void) | (() => void)[]) | undefined;
+            unmounted?: ((() => void) | (() => void)[]) | undefined;
+            renderTracked?: (((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[]) | undefined;
+            renderTriggered?: (((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[]) | undefined;
+            errorCaptured?: (((err: unknown, instance: import('vue').ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import('vue').ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}, {}, {}, string, import('vue').ComponentProvideOptions>, {}, {}, "", {}, any> | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import('vue').ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}, {}, {}, string, import('vue').ComponentProvideOptions>, {}, {}, "", {}, any> | null, info: string) => boolean | void)[]) | undefined;
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof import('vue').nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R, args_2: import('@vue/reactivity').OnCleanup) => any : (args_0: any, args_1: any, args_2: import('@vue/reactivity').OnCleanup) => any, options?: import('vue').WatchOptions<boolean> | undefined): import('vue').WatchStopHandle;
+    } & Readonly<{}> & Omit<Readonly<import('@pantograph/vue').TdProps> & Readonly<{}>, never> & import('vue').ShallowUnwrapRef<{}> & {} & import('vue').ComponentCustomProperties & {} & {
+        $slots: Readonly<import('@pantograph/vue').TdSlots> & import('@pantograph/vue').TdSlots;
+    }) | null;
+}, any>;
+export default _default;

package/dist/components/DataTable/components/DataTableLoadingRow.d.ts

@@ -0,0 +1,18 @@
+import { TableColumn } from '../types';
+type __VLS_Props = {
+    index: number;
+    first: boolean;
+    last: boolean;
+};
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLTableRowElement>, {
+    skeleton?(_: {
+        index: number;
+        column: TableColumn;
+    }): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/DataTable/components/DataTableRow.d.ts

@@ -0,0 +1,15 @@
+import { Row } from '@tanstack/table-core';
+import { DataTableContext } from '../types';
+type __VLS_Props = {
+    row: Row<unknown> & {
+        fakeScroll?: boolean;
+        _dragging?: boolean;
+    };
+    first?: boolean;
+    last?: boolean;
+    hasSubRows: boolean;
+    collapseParent?: boolean;
+    getContext?: () => DataTableContext;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLTableRowElement>;
+export default _default;

package/dist/components/DataTable/components/ThDragGhost.d.ts

@@ -0,0 +1,16 @@
+import { ThProps } from '@pantograph/vue';
+type __VLS_Props = {
+    size?: ThProps['size'];
+    prefix: string;
+};
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    size: "lg" | "xlg";
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/DataTable/constant.d.ts

@@ -0,0 +1,20 @@
+export declare const dataTablePrefix: string;
+export declare const dataTableRowPrefix: string;
+export declare const dataTableDragHandleCls: string;
+/**
+ * Default props for the DataTable component
+ */
+export declare const DATA_TABLE_DEFAULT_PROPS: {
+    readonly childrenColumnName: "children";
+    readonly childrenRowName: "children";
+    readonly batchActionsTitle: "Records selected :";
+    readonly loadingRowCount: 5;
+    readonly tableLayout: "fixed";
+    readonly rowKey: "id";
+    readonly zebra: true;
+    readonly paginateExpandedRows: false;
+    readonly overflowScroll: true;
+    readonly bordered: true;
+    readonly hideDataOnLoading: false;
+    readonly minVisibleAreaOnFixColumns: 200;
+};

package/dist/components/DataTable/context.d.ts

@@ -0,0 +1,2 @@
+import { DataTableContext } from './types';
+export declare const injectDataTableContext: <T extends DataTableContext | null | undefined = DataTableContext>(fallback?: T | undefined) => T extends null ? DataTableContext | null : DataTableContext, provideDataTableContext: (contextValue: DataTableContext) => DataTableContext;

package/dist/components/DataTable/index.d.ts

@@ -0,0 +1,5 @@
+import { default as DataTable } from './DataTable';
+export { DataTable };
+export * from './types';
+export * from './constant';
+export * from './context';

package/dist/components/DataTable/types/cell.d.ts

@@ -0,0 +1,15 @@
+import { ClassValue } from 'clsx';
+import { TableGetFunctionsProps } from './index';
+export type TableCustomCellReturn = {
+    colSpan?: number;
+    rowSpan?: number;
+    class?: ClassValue;
+    wrap?: boolean;
+    editing?: boolean;
+    ellipseHFull?: boolean;
+    noContainer?: boolean;
+    noPy?: boolean;
+    noPx?: boolean;
+    enableResizing?: boolean;
+};
+export type TableCustomCell<T = any> = TableCustomCellReturn | ((props?: Partial<TableGetFunctionsProps<T>>) => TableCustomCellReturn | undefined) | undefined;