@milaboratories/uikit 1.2.3

package/dist/src/components/ContextProvider.vue.d.ts

@@ -0,0 +1,23 @@
+import { type InjectionKey } from 'vue';
+declare function __VLS_template(): {
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    attrs: Partial<{}>;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import("vue").DefineComponent<{
+    context: object;
+    contextKey: InjectionKey<unknown>;
+}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{
+    context: object;
+    contextKey: InjectionKey<unknown>;
+}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/src/components/DataTable/AddColumnBtn.vue.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/src/components/DataTable/BaseCellComponent.vue.d.ts

@@ -0,0 +1,15 @@
+import type { ValueType } from './types';
+declare const _default: import("vue").DefineComponent<{
+    modelValue: unknown;
+    valueType: ValueType | undefined;
+    editable?: boolean;
+}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (...args: any[]) => void;
+}, string, import("vue").PublicProps, Readonly<{
+    modelValue: unknown;
+    valueType: ValueType | undefined;
+    editable?: boolean;
+}> & Readonly<{
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/src/components/DataTable/ColumnCaret.vue.d.ts

@@ -0,0 +1,7 @@
+import type { ColumnSpecSettings } from './types';
+declare const _default: import("vue").DefineComponent<{
+    column: ColumnSpecSettings;
+}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{
+    column: ColumnSpecSettings;
+}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/src/components/DataTable/ColumnsCommandMenu.vue.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/src/components/DataTable/RowsCommandMenu.vue.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/src/components/DataTable/TScroll.vue.d.ts

@@ -0,0 +1,14 @@
+declare const _default: import("vue").DefineComponent<{
+    offset: number;
+    windowSize: number;
+    dataSize: number;
+}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    "change:offset": (value: number) => any;
+}, string, import("vue").PublicProps, Readonly<{
+    offset: number;
+    windowSize: number;
+    dataSize: number;
+}> & Readonly<{
+    "onChange:offset"?: ((value: number) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/src/components/DataTable/TableComponent.vue.d.ts

@@ -0,0 +1,14 @@
+import './assets/data-table-style.scss';
+import type { TableSettings, TableData } from './types';
+declare const _default: import("vue").DefineComponent<{
+    settings: Readonly<TableSettings>;
+}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    "change:sort": (value: unknown) => any;
+    "update:data": (value: TableData) => any;
+}, string, import("vue").PublicProps, Readonly<{
+    settings: Readonly<TableSettings>;
+}> & Readonly<{
+    "onChange:sort"?: ((value: unknown) => any) | undefined;
+    "onUpdate:data"?: ((value: TableData) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/src/components/DataTable/TdCell.vue.d.ts

@@ -0,0 +1,7 @@
+import type { TableCell } from './types';
+declare const _default: import("vue").DefineComponent<{
+    cell: TableCell;
+}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{
+    cell: TableCell;
+}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/src/components/DataTable/ThCell.vue.d.ts

@@ -0,0 +1,15 @@
+import type { ColumnSpecSettings } from './types';
+declare const _default: import("vue").DefineComponent<{
+    col: ColumnSpecSettings;
+}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "delete:column": (...args: any[]) => void;
+    "expand:column": (...args: any[]) => void;
+    "change:sort": (...args: any[]) => void;
+}, string, import("vue").PublicProps, Readonly<{
+    col: ColumnSpecSettings;
+}> & Readonly<{
+    "onDelete:column"?: ((...args: any[]) => any) | undefined;
+    "onExpand:column"?: ((...args: any[]) => any) | undefined;
+    "onChange:sort"?: ((...args: any[]) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/src/components/DataTable/TrBody.vue.d.ts

@@ -0,0 +1,23 @@
+import type { TableRow } from './types';
+declare function __VLS_template(): {
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {
+        trRef: HTMLDivElement;
+    };
+    attrs: Partial<{}>;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import("vue").DefineComponent<{
+    row: TableRow;
+}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{
+    row: TableRow;
+}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/src/components/DataTable/TrHead.vue.d.ts

@@ -0,0 +1,16 @@
+declare function __VLS_template(): {
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    attrs: Partial<{}>;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/src/components/DataTable/adapters/AsyncData.d.ts

@@ -0,0 +1,11 @@
+import type * as Types from '../types';
+import type { DataRow, Row } from '../types';
+export declare class AsyncData<D extends DataRow> implements Types.DataSource {
+    readonly api: Types.ExternalApi<D>;
+    readonly rowHeight: number;
+    readonly resolvePrimaryKey: Types.ResolvePrimaryKey;
+    constructor(api: Types.ExternalApi<D>, rowHeight: number, resolvePrimaryKey: Types.ResolvePrimaryKey);
+    get height(): number;
+    getHeight(): Promise<number>;
+    getRows(scrollTop: number, bodyHeight: number): Promise<Row[]>;
+}

package/dist/src/components/DataTable/adapters/RawData.d.ts

@@ -0,0 +1,12 @@
+import type * as Types from '../types';
+import type { DataRow, ResolvePrimaryKey, Row, ResolveRowHeight } from '../types';
+export declare class RawData<D extends DataRow = DataRow> implements Types.DataSource {
+    readonly datum: D[];
+    readonly resolveHeight: ResolveRowHeight<D>;
+    readonly resolvePrimaryKey: ResolvePrimaryKey<D>;
+    private dataHeight;
+    constructor(datum: D[], resolveHeight: ResolveRowHeight<D>, resolvePrimaryKey: ResolvePrimaryKey<D>);
+    get rows(): Row<D>[];
+    getHeight(): Promise<number>;
+    getRows(scrollTop: number, bodyHeight: number): Promise<Row<D>[]>;
+}

package/dist/src/components/DataTable/assets/TableIcon.vue.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/src/components/DataTable/composition/useColumn.d.ts

@@ -0,0 +1,10 @@
+export declare function useColumn(cb: (state: {
+    x: number;
+    width: number;
+    diff: number;
+}) => void, clear: () => void): {
+    start: (e: {
+        x: number;
+        width: number;
+    }) => void;
+};

package/dist/src/components/DataTable/composition/useMouseUp.d.ts

@@ -0,0 +1 @@
+export declare function useMouseUp(update: (ev: globalThis.MouseEvent) => void): void;

package/dist/src/components/DataTable/composition/useResize.d.ts

@@ -0,0 +1,9 @@
+import type { Ref } from 'vue';
+import type { ResizeTh } from '../types';
+import type { State } from '../state';
+type MaybeRef<T> = T | Ref<T>;
+export declare function getColumnPositions(tableRef: MaybeRef<HTMLElement | undefined>): ResizeTh[];
+export declare function useResize(state: State, tableRef: Ref<HTMLElement | undefined>): {
+    mouseDown: (e: MouseEvent) => void;
+};
+export {};

package/dist/src/components/DataTable/composition/useTableColumns.d.ts

@@ -0,0 +1,6 @@
+import type { TableSettings, TableColumn, TableData } from '../types';
+import type { ComputedRef } from 'vue';
+export declare function useTableColumns(state: {
+    data: TableData;
+    settings: ComputedRef<TableSettings>;
+}): ComputedRef<TableColumn[]>;

package/dist/src/components/DataTable/composition/useTableRows.d.ts

@@ -0,0 +1,3 @@
+import type { ComputedRef } from 'vue';
+import type { TableColumn, TableData, TableRow } from '../types';
+export declare function useTableRows(data: TableData, tableColumns: ComputedRef<TableColumn[]>): ComputedRef<TableRow[]>;

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

@@ -0,0 +1,5 @@
+export declare const GAP = 1;
+export declare const RESIZE_GAP = 10;
+export declare const MIN_COLUMN_WIDTH = 30;
+export declare const DEFAULT_ROW_HEIGHT = 40;
+export declare const WINDOW_DELTA = 60;

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

@@ -0,0 +1,11 @@
+export declare function toComparable(v: unknown): string | number;
+export declare function compareRecords(sorts: Record<string, 'ASC' | 'DESC'>, a: Record<string, unknown>, b: Record<string, unknown>): number;
+export declare const identity: <T>(v: T) => T;
+export declare function rotate<T>(v: T, lst: T[]): T;
+/**
+ * Returns a first contiguous copy of a section of an array where predicate is true
+ * @param arr
+ * @param predicate
+ * @returns
+ */
+export declare function sliceBy<T>(arr: readonly T[], predicate: (el: T, index: number) => boolean): T[];

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

@@ -0,0 +1,36 @@
+import type { TableSettings } from './types';
+import Component from './TableComponent.vue';
+import type * as Types from './types';
+import type { RawTableSettings } from './types';
+import type { ComputedRef } from 'vue';
+import type { MaybeRef } from '../../types';
+export { AsyncData } from './adapters/AsyncData';
+type AnyRef<T> = MaybeRef<T> | ComputedRef<T>;
+export declare function settings<D extends Types.DataRow>(tableSettings: TableSettings<D>): TableSettings;
+export declare function factory<const S extends TableSettings>(tableSettings: S): import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>;
+export { Component };
+export { Types };
+/*** Adapters ***/
+export declare function rawDataSettings<D extends Types.DataRow>(rows: D[], rawSettings: Types.RawTableSettings<D>): TableSettings;
+export declare function useRawData<D extends Types.DataRow>(rowsRef: AnyRef<D[]>, raw: MaybeRef<RawTableSettings<D>>): ComputedRef<Readonly<{
+    columns: Types.ColumnSpecSettings<string, unknown>[];
+    dataSource: Types.DataSource<Types.DataRow>;
+    gap?: number;
+    height: number;
+    addColumn?: () => Promise<void>;
+    controlColumn?: boolean;
+    onSelectedRows?: Types.SelectedRowsOperation<Types.DataRow>[] | undefined;
+    onSelectedColumns?: Types.SelectedColumnsOperation<Types.DataRow>[] | undefined;
+    onUpdatedRow?: ((row: Types.Row<Types.DataRow>) => void) | undefined;
+}>>;
+/**
+ * @deprecated
+ * @param rows
+ * @param raw
+ * @returns
+ */
+export declare function useRawDataComponent<D extends Types.DataRow>(rowsRef: AnyRef<D[]>, raw: MaybeRef<RawTableSettings<D>>): ComputedRef<import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>>;

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

@@ -0,0 +1,81 @@
+import { type InjectionKey, type ComputedRef } from 'vue';
+import type { TableSettings } from './types';
+import type { State } from './state';
+export declare const settingsKey: InjectionKey<ComputedRef<TableSettings>>;
+export declare const stateKey: InjectionKey<State>;
+export declare const injectState: () => {
+    data: {
+        rowIndex: number;
+        pendingLoads: number;
+        columns: readonly {
+            label: string;
+            id: string;
+            width: number;
+            justify?: ("center" | "start") | undefined;
+            sort?: {
+                direction: "DESC" | "ASC" | undefined;
+            } | undefined;
+            component?: (() => import("vue").Component) | undefined;
+            editable?: boolean | undefined;
+            valueType?: import("./types").ValueType | undefined;
+            frozen?: boolean | undefined;
+        }[];
+        rows: readonly {
+            dataRow: import("./types").DataRow;
+            index: number;
+            primaryKey: import("./types").PrimaryKey;
+            offset: number;
+            height: number;
+        }[];
+        currentWindow?: {
+            bodyHeight: number;
+            scrollTop: number;
+        } | undefined;
+        resize: boolean;
+        resizeTh?: {
+            colId: string;
+            width: number;
+            x: number;
+            right: number;
+        } | undefined;
+        dataHeight: number;
+        bodyHeight: number;
+        bodyWidth: number;
+        scrollTop: number;
+        scrollLeft: number;
+        selectedRows: Set<import("./types").PrimaryKey> & Omit<Set<import("./types").PrimaryKey>, keyof Set<any>>;
+        selectedColumns: Set<string> & Omit<Set<string>, keyof Set<any>>;
+        error?: unknown;
+    };
+    settings: ComputedRef<Readonly<{
+        columns: import("./types").ColumnSpecSettings<string, unknown>[];
+        dataSource: import("./types").DataSource<import("./types").DataRow>;
+        gap?: number;
+        height: number;
+        addColumn?: () => Promise<void>;
+        controlColumn?: boolean;
+        onSelectedRows?: import("./types").SelectedRowsOperation<import("./types").DataRow>[] | undefined;
+        onSelectedColumns?: import("./types").SelectedColumnsOperation<import("./types").DataRow>[] | undefined;
+        onUpdatedRow?: ((row: import("./types").Row<import("./types").DataRow>) => void) | undefined;
+    }>>;
+    tableColumns: ComputedRef<import("./types").TableColumn[]>;
+    tableRows: ComputedRef<import("./types").TableRow[]>;
+    adjustWidth: () => void;
+    updateOffsets(ev: {
+        deltaY: number;
+        deltaX: number;
+    }): void;
+    getSelectedRows(): import("./types").Row[];
+    getSelectedColumns(): import("./types").ColumnSpecSettings[];
+    selectRow(rowId: import("./types").PrimaryKey): void;
+    unselectRow(rowId: import("./types").PrimaryKey): void;
+    selectColumn(columnId: string): void;
+    unselectColumn(columnId: string): void;
+    updateScrollTop(scrollTop: number): void;
+    updateScrollLeft(scrollLeft: number): void;
+    updateBodyHeight(): void;
+    updateDimensions(rect: {
+        height: number;
+        width: number;
+    }): void;
+};

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

@@ -0,0 +1,78 @@
+import type { TableProps, PrimaryKey, Row, ColumnSpecSettings, DataSource } from './types';
+export declare function createState(props: TableProps): {
+    data: {
+        rowIndex: number;
+        pendingLoads: number;
+        columns: readonly {
+            label: string;
+            id: string;
+            width: number;
+            justify?: ("center" | "start") | undefined;
+            sort?: {
+                direction: "DESC" | "ASC" | undefined;
+            } | undefined;
+            component?: (() => import("vue").Component) | undefined;
+            editable?: boolean | undefined;
+            valueType?: import("./types").ValueType | undefined;
+            frozen?: boolean | undefined;
+        }[];
+        rows: readonly {
+            dataRow: import("./types").DataRow;
+            index: number;
+            primaryKey: PrimaryKey;
+            offset: number;
+            height: number;
+        }[];
+        currentWindow?: {
+            bodyHeight: number;
+            scrollTop: number;
+        } | undefined;
+        resize: boolean;
+        resizeTh?: {
+            colId: string;
+            width: number;
+            x: number;
+            right: number;
+        } | undefined;
+        dataHeight: number;
+        bodyHeight: number;
+        bodyWidth: number;
+        scrollTop: number;
+        scrollLeft: number;
+        selectedRows: Set<PrimaryKey> & Omit<Set<PrimaryKey>, keyof Set<any>>;
+        selectedColumns: Set<string> & Omit<Set<string>, keyof Set<any>>;
+        error?: unknown;
+    };
+    settings: import("vue").ComputedRef<Readonly<{
+        columns: ColumnSpecSettings<string, unknown>[];
+        dataSource: DataSource<import("./types").DataRow>;
+        gap?: number;
+        height: number;
+        addColumn?: () => Promise<void>;
+        controlColumn?: boolean;
+        onSelectedRows?: import("./types").SelectedRowsOperation<import("./types").DataRow>[] | undefined;
+        onSelectedColumns?: import("./types").SelectedColumnsOperation<import("./types").DataRow>[] | undefined;
+        onUpdatedRow?: ((row: Row<import("./types").DataRow>) => void) | undefined;
+    }>>;
+    tableColumns: import("vue").ComputedRef<import("./types").TableColumn[]>;
+    tableRows: import("vue").ComputedRef<import("./types").TableRow[]>;
+    adjustWidth: () => void;
+    updateOffsets(ev: {
+        deltaY: number;
+        deltaX: number;
+    }): void;
+    getSelectedRows(): Row[];
+    getSelectedColumns(): ColumnSpecSettings[];
+    selectRow(rowId: PrimaryKey): void;
+    unselectRow(rowId: PrimaryKey): void;
+    selectColumn(columnId: string): void;
+    unselectColumn(columnId: string): void;
+    updateScrollTop(scrollTop: number): void;
+    updateScrollLeft(scrollLeft: number): void;
+    updateBodyHeight(): void;
+    updateDimensions(rect: {
+        height: number;
+        width: number;
+    }): void;
+};
+export type State = ReturnType<typeof createState>;

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

@@ -0,0 +1,143 @@
+import type { Component } from 'vue';
+import type { Branded, Values } from '@milaboratories/helpers';
+type TypeMap = {
+    integer: number;
+    float: number;
+    string: string;
+    unknown: number | string;
+};
+export type ValueType = keyof TypeMap;
+export type TableProps = {
+    settings: TableSettings;
+};
+export type DataWindow = {
+    bodyHeight: number;
+    scrollTop: number;
+};
+export type TableData = {
+    rowIndex: number;
+    pendingLoads: number;
+    columns: readonly ColumnSpecSettings[];
+    rows: readonly Row[];
+    currentWindow?: DataWindow;
+    resize: boolean;
+    resizeTh?: ResizeTh;
+    dataHeight: number;
+    bodyHeight: number;
+    bodyWidth: number;
+    scrollTop: number;
+    scrollLeft: number;
+    selectedRows: Set<PrimaryKey>;
+    selectedColumns: Set<string>;
+    error?: unknown;
+};
+export type DataRow = Record<string, unknown>;
+export type PrimaryKey = Branded<string, 'PrimaryKey'>;
+export type ResolvePrimaryKey<D extends DataRow = DataRow> = (dataRow: D, index: number) => string;
+export type ResolveRowHeight<D extends DataRow = DataRow> = (dataRow: D, index: number) => number;
+export type SelectedRowsOperation<D extends DataRow = DataRow> = {
+    label: string;
+    cb: (rows: Row<D>[]) => Promise<void>;
+};
+export type SelectedColumnsOperation<D extends DataRow = DataRow> = {
+    label: string;
+    cb: (columns: ColumnSpec<D>[]) => Promise<void>;
+};
+export type TableSettings<D extends DataRow = DataRow> = Readonly<{
+    columns: ColumnSpec<D>[];
+    dataSource: DataSource<D>;
+    gap?: number;
+    height: number;
+    addColumn?: () => Promise<void>;
+    controlColumn?: boolean;
+    onSelectedRows?: SelectedRowsOperation<D>[];
+    onSelectedColumns?: SelectedColumnsOperation<D>[];
+    onUpdatedRow?: (row: Row<D>) => void;
+}>;
+export type ColumnSpecSettings<ID = string, _Value = unknown> = {
+    label: string;
+    id: ID;
+    width: number;
+    justify?: 'center' | 'start';
+    sort?: {
+        direction: 'DESC' | 'ASC' | undefined;
+    };
+    component?: () => Component;
+    editable?: boolean;
+    valueType?: ValueType;
+    frozen?: boolean;
+};
+export type ColumnSpec<D extends DataRow = DataRow> = Values<{
+    [P in keyof D]: ColumnSpecSettings<P, D[P]>;
+}>;
+export type TableCell<D extends DataRow = DataRow> = Values<{
+    [P in keyof D]: {
+        id: P;
+        column: ColumnSpecSettings<P, D[P]>;
+        row: Row<D>;
+        value: D[P];
+        class: string;
+        editable?: boolean;
+        width: number;
+        style: ColumnStyle;
+        control?: boolean;
+    };
+}>;
+export type Row<D extends DataRow = DataRow> = {
+    dataRow: D;
+    index: number;
+    primaryKey: PrimaryKey;
+    offset: number;
+    height: number;
+};
+export type TableRow = {
+    style: {
+        top: `${number}px`;
+        height: `${number}px`;
+    };
+    offset: number;
+    height: number;
+    cells: TableCell[];
+    primaryKey: PrimaryKey;
+    selected?: boolean;
+};
+export type ColumnStyle = {
+    left: string;
+    width: string;
+};
+export type TableColumn = ColumnSpecSettings & {
+    style: ColumnStyle;
+    offset: number;
+    control?: boolean;
+};
+export interface DataSource<D extends DataRow = DataRow> {
+    getHeight(): Promise<number>;
+    getRows(scrollTop: number, bodyHeight: number): Promise<Row<D>[]>;
+}
+export type ExternalApi<T extends DataRow> = {
+    query(options: {
+        offset: number;
+        limit: number;
+    }): Promise<T[]>;
+    count(): Promise<number>;
+};
+export type ResizeTh = {
+    colId: string;
+    width: number;
+    x: number;
+    right: number;
+};
+/*** Adapters ***/
+export type RawTableSettings<D extends DataRow = DataRow> = Readonly<{
+    columns: ColumnSpec<D>[];
+    gap?: number;
+    height: number;
+    addColumn?: () => Promise<void>;
+    controlColumn?: boolean;
+    onSelectedRows?: SelectedRowsOperation<D>[];
+    onSelectedColumns?: SelectedColumnsOperation<D>[];
+    resolvePrimaryKey: ResolvePrimaryKey<D>;
+    resolveRowHeight: ResolveRowHeight<D>;
+    onUpdatedRow?: (row: Row<D>) => void;
+}>;
+export {};

package/dist/src/components/DropdownListItem.vue.d.ts

@@ -0,0 +1,20 @@
+import type { ListOption } from '../types';
+declare const _default: import("vue").DefineComponent<{
+    option: ListOption;
+    isSelected: boolean;
+    size: "small" | "medium";
+    isHovered: boolean;
+    useCheckbox?: boolean;
+}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{
+    option: ListOption;
+    isSelected: boolean;
+    size: "small" | "medium";
+    isHovered: boolean;
+    useCheckbox?: boolean;
+}> & Readonly<{}>, {
+    size: "small" | "medium";
+    isSelected: boolean;
+    isHovered: boolean;
+    useCheckbox: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/src/components/GridTable/AddColumnBtn.vue.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/src/components/GridTable/TRow.vue.d.ts

@@ -0,0 +1,24 @@
+declare function __VLS_template(): {
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    attrs: Partial<{}>;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import("vue").DefineComponent<{
+    index: number;
+    visible: boolean;
+    height: number;
+}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{
+    index: number;
+    visible: boolean;
+    height: number;
+}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};