@haoyulong1112/jh-ui 0.1.0

package/dist/components/radio/src/props.d.ts

@@ -0,0 +1,25 @@
+import type { ExtractPropTypes, PropType } from 'vue';
+import type { RadioValue } from './types';
+export declare const radioProps: {
+    readonly modelValue: PropType<RadioValue>;
+    readonly value: {
+        readonly type: PropType<RadioValue>;
+        readonly required: true;
+    };
+    readonly label: StringConstructor;
+    readonly disabled: BooleanConstructor;
+};
+export declare const radioGroupProps: {
+    readonly modelValue: PropType<RadioValue>;
+    readonly disabled: BooleanConstructor;
+};
+export declare const radioEmits: {
+    'update:modelValue': (_value: RadioValue) => boolean;
+    change: (_value: RadioValue) => boolean;
+};
+export declare const radioGroupEmits: {
+    'update:modelValue': (_value: RadioValue) => boolean;
+    change: (_value: RadioValue) => boolean;
+};
+export type RadioProps = ExtractPropTypes<typeof radioProps>;
+export type RadioGroupProps = ExtractPropTypes<typeof radioGroupProps>;

package/dist/components/radio/src/radio-group.vue.d.ts

@@ -0,0 +1,27 @@
+import { type RadioValue } from './types';
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    readonly modelValue: import("vue").PropType<RadioValue>;
+    readonly disabled: BooleanConstructor;
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    change: (_value: RadioValue) => void;
+    "update:modelValue": (_value: RadioValue) => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly modelValue: import("vue").PropType<RadioValue>;
+    readonly disabled: BooleanConstructor;
+}>> & Readonly<{
+    onChange?: ((_value: RadioValue) => any) | undefined;
+    "onUpdate:modelValue"?: ((_value: RadioValue) => any) | undefined;
+}>, {
+    readonly disabled: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, 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/components/radio/src/radio.vue.d.ts

@@ -0,0 +1,36 @@
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    readonly modelValue: import("vue").PropType<import("./types").RadioValue>;
+    readonly value: {
+        readonly type: import("vue").PropType<import("./types").RadioValue>;
+        readonly required: true;
+    };
+    readonly label: StringConstructor;
+    readonly disabled: BooleanConstructor;
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    change: (_value: import("./types").RadioValue) => void;
+    "update:modelValue": (_value: import("./types").RadioValue) => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly modelValue: import("vue").PropType<import("./types").RadioValue>;
+    readonly value: {
+        readonly type: import("vue").PropType<import("./types").RadioValue>;
+        readonly required: true;
+    };
+    readonly label: StringConstructor;
+    readonly disabled: BooleanConstructor;
+}>> & Readonly<{
+    onChange?: ((_value: import("./types").RadioValue) => any) | undefined;
+    "onUpdate:modelValue"?: ((_value: import("./types").RadioValue) => any) | undefined;
+}>, {
+    readonly disabled: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, 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/components/radio/src/types.d.ts

@@ -0,0 +1,8 @@
+import type { InjectionKey } from 'vue';
+export type RadioValue = string | number | boolean;
+export interface RadioGroupContext {
+    modelValue: () => RadioValue | undefined;
+    disabled: () => boolean;
+    changeValue: (value: RadioValue) => void;
+}
+export declare const radioGroupKey: InjectionKey<RadioGroupContext>;

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

@@ -0,0 +1,60 @@
+export declare const JhScrollbar: import("../../utils/src/index").SFCWithInstall<{
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+        readonly height: import("vue").PropType<string | number>;
+        readonly maxHeight: import("vue").PropType<string | number>;
+        readonly always: BooleanConstructor;
+        readonly native: BooleanConstructor;
+        readonly wrapClass: StringConstructor;
+        readonly viewClass: StringConstructor;
+    }>> & Readonly<{
+        onScroll?: ((_payload: import("./index.js").ScrollbarScrollPayload) => any) | undefined;
+    }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        scroll: (_payload: import("./index.js").ScrollbarScrollPayload) => void;
+    }, import("vue").PublicProps, {
+        readonly always: boolean;
+        readonly native: boolean;
+    }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("vue").ExtractPropTypes<{
+        readonly height: import("vue").PropType<string | number>;
+        readonly maxHeight: import("vue").PropType<string | number>;
+        readonly always: BooleanConstructor;
+        readonly native: BooleanConstructor;
+        readonly wrapClass: StringConstructor;
+        readonly viewClass: StringConstructor;
+    }>> & Readonly<{
+        onScroll?: ((_payload: import("./index.js").ScrollbarScrollPayload) => any) | undefined;
+    }>, {}, {}, {}, {}, {
+        readonly always: boolean;
+        readonly native: boolean;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+    readonly height: import("vue").PropType<string | number>;
+    readonly maxHeight: import("vue").PropType<string | number>;
+    readonly always: BooleanConstructor;
+    readonly native: BooleanConstructor;
+    readonly wrapClass: StringConstructor;
+    readonly viewClass: StringConstructor;
+}>> & Readonly<{
+    onScroll?: ((_payload: import("./index.js").ScrollbarScrollPayload) => any) | undefined;
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    scroll: (_payload: import("./index.js").ScrollbarScrollPayload) => void;
+}, string, {
+    readonly always: boolean;
+    readonly native: boolean;
+}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+    $slots: {
+        default?: (props: {}) => any;
+    };
+})>;
+export default JhScrollbar;
+export * from './src/props';
+export * from './src/types';

package/dist/components/scrollbar/src/props.d.ts

@@ -0,0 +1,14 @@
+import type { ExtractPropTypes, PropType } from 'vue';
+import type { ScrollbarScrollPayload } from './types';
+export declare const scrollbarProps: {
+    readonly height: PropType<string | number>;
+    readonly maxHeight: PropType<string | number>;
+    readonly always: BooleanConstructor;
+    readonly native: BooleanConstructor;
+    readonly wrapClass: StringConstructor;
+    readonly viewClass: StringConstructor;
+};
+export declare const scrollbarEmits: {
+    scroll: (_payload: ScrollbarScrollPayload) => boolean;
+};
+export type ScrollbarProps = ExtractPropTypes<typeof scrollbarProps>;

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

@@ -0,0 +1,33 @@
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    readonly height: import("vue").PropType<string | number>;
+    readonly maxHeight: import("vue").PropType<string | number>;
+    readonly always: BooleanConstructor;
+    readonly native: BooleanConstructor;
+    readonly wrapClass: StringConstructor;
+    readonly viewClass: StringConstructor;
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    scroll: (_payload: import("./types").ScrollbarScrollPayload) => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly height: import("vue").PropType<string | number>;
+    readonly maxHeight: import("vue").PropType<string | number>;
+    readonly always: BooleanConstructor;
+    readonly native: BooleanConstructor;
+    readonly wrapClass: StringConstructor;
+    readonly viewClass: StringConstructor;
+}>> & Readonly<{
+    onScroll?: ((_payload: import("./types").ScrollbarScrollPayload) => any) | undefined;
+}>, {
+    readonly always: boolean;
+    readonly native: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, 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/components/scrollbar/src/types.d.ts

@@ -0,0 +1,4 @@
+export interface ScrollbarScrollPayload {
+    scrollTop: number;
+    scrollLeft: number;
+}

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

@@ -0,0 +1,43 @@
+export declare const JhSelect: import("../../utils/src/index").SFCWithInstall<import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    readonly modelValue: import("vue").PropType<import("./index.js").SelectValue>;
+    readonly options: {
+        readonly type: import("vue").PropType<import("./index.js").SelectOption[]>;
+        readonly default: () => never[];
+    };
+    readonly placeholder: {
+        readonly type: StringConstructor;
+        readonly default: "Please select";
+    };
+    readonly disabled: BooleanConstructor;
+    readonly clearable: BooleanConstructor;
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    clear: () => void;
+    change: (_value: import("./index.js").SelectValue | undefined, _option?: import("./index.js").SelectOption | undefined) => void;
+    "update:modelValue": (_value: import("./index.js").SelectValue | undefined) => void;
+    "visible-change": (_visible: boolean) => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly modelValue: import("vue").PropType<import("./index.js").SelectValue>;
+    readonly options: {
+        readonly type: import("vue").PropType<import("./index.js").SelectOption[]>;
+        readonly default: () => never[];
+    };
+    readonly placeholder: {
+        readonly type: StringConstructor;
+        readonly default: "Please select";
+    };
+    readonly disabled: BooleanConstructor;
+    readonly clearable: BooleanConstructor;
+}>> & Readonly<{
+    onClear?: (() => any) | undefined;
+    onChange?: ((_value: import("./index.js").SelectValue | undefined, _option?: import("./index.js").SelectOption | undefined) => any) | undefined;
+    "onUpdate:modelValue"?: ((_value: import("./index.js").SelectValue | undefined) => any) | undefined;
+    "onVisible-change"?: ((_visible: boolean) => any) | undefined;
+}>, {
+    readonly placeholder: string;
+    readonly disabled: boolean;
+    readonly options: import("./index.js").SelectOption[];
+    readonly clearable: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>>;
+export default JhSelect;
+export * from './src/props';
+export * from './src/types';

package/dist/components/select/src/props.d.ts

@@ -0,0 +1,22 @@
+import type { ExtractPropTypes, PropType } from 'vue';
+import type { SelectOption, SelectValue } from './types';
+export declare const selectProps: {
+    readonly modelValue: PropType<SelectValue>;
+    readonly options: {
+        readonly type: PropType<SelectOption[]>;
+        readonly default: () => never[];
+    };
+    readonly placeholder: {
+        readonly type: StringConstructor;
+        readonly default: "Please select";
+    };
+    readonly disabled: BooleanConstructor;
+    readonly clearable: BooleanConstructor;
+};
+export declare const selectEmits: {
+    'update:modelValue': (_value: SelectValue | undefined) => boolean;
+    change: (_value: SelectValue | undefined, _option?: SelectOption) => boolean;
+    'visible-change': (_visible: boolean) => boolean;
+    clear: () => boolean;
+};
+export type SelectProps = ExtractPropTypes<typeof selectProps>;

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

@@ -0,0 +1,42 @@
+import type { SelectOption } from './types';
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    readonly modelValue: import("vue").PropType<import("./types").SelectValue>;
+    readonly options: {
+        readonly type: import("vue").PropType<SelectOption[]>;
+        readonly default: () => never[];
+    };
+    readonly placeholder: {
+        readonly type: StringConstructor;
+        readonly default: "Please select";
+    };
+    readonly disabled: BooleanConstructor;
+    readonly clearable: BooleanConstructor;
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    clear: () => void;
+    change: (_value: import("./types").SelectValue | undefined, _option?: SelectOption | undefined) => void;
+    "update:modelValue": (_value: import("./types").SelectValue | undefined) => void;
+    "visible-change": (_visible: boolean) => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly modelValue: import("vue").PropType<import("./types").SelectValue>;
+    readonly options: {
+        readonly type: import("vue").PropType<SelectOption[]>;
+        readonly default: () => never[];
+    };
+    readonly placeholder: {
+        readonly type: StringConstructor;
+        readonly default: "Please select";
+    };
+    readonly disabled: BooleanConstructor;
+    readonly clearable: BooleanConstructor;
+}>> & Readonly<{
+    onClear?: (() => any) | undefined;
+    onChange?: ((_value: import("./types").SelectValue | undefined, _option?: SelectOption | undefined) => any) | undefined;
+    "onUpdate:modelValue"?: ((_value: import("./types").SelectValue | undefined) => any) | undefined;
+    "onVisible-change"?: ((_visible: boolean) => any) | undefined;
+}>, {
+    readonly placeholder: string;
+    readonly disabled: boolean;
+    readonly options: SelectOption[];
+    readonly clearable: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

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

@@ -0,0 +1,6 @@
+export type SelectValue = string | number;
+export interface SelectOption {
+    label: string;
+    value: SelectValue;
+    disabled?: boolean;
+}

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

@@ -0,0 +1,147 @@
+export declare const JhTable: import("../../utils/src/index").SFCWithInstall<{
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+        readonly data: {
+            readonly type: import("vue").PropType<import("./index.js").TableRow[]>;
+            readonly default: () => never[];
+        };
+        readonly columns: {
+            readonly type: import("vue").PropType<import("./index.js").TableColumn[]>;
+            readonly default: () => never[];
+        };
+        readonly loading: BooleanConstructor;
+        readonly border: BooleanConstructor;
+        readonly stripe: BooleanConstructor;
+        readonly selection: BooleanConstructor;
+        readonly rowKey: {
+            readonly type: import("vue").PropType<import("./index.js").TableRowKeyGetter>;
+            readonly default: undefined;
+        };
+        readonly selectable: import("vue").PropType<import("./index.js").TableSelectable>;
+        readonly emptyText: {
+            readonly type: StringConstructor;
+            readonly default: "No Data";
+        };
+    }>> & Readonly<{
+        onSelect?: ((_selection: import("./index.js").TableRow[], _row: import("./index.js").TableRow) => any) | undefined;
+        "onSelect-all"?: ((_selection: import("./index.js").TableRow[]) => any) | undefined;
+        "onSelection-change"?: ((_selection: import("./index.js").TableRow[]) => any) | undefined;
+    }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        select: (_selection: import("./index.js").TableRow[], _row: import("./index.js").TableRow) => void;
+        "select-all": (_selection: import("./index.js").TableRow[]) => void;
+        "selection-change": (_selection: import("./index.js").TableRow[]) => void;
+    }, import("vue").PublicProps, {
+        readonly loading: boolean;
+        readonly data: import("./index.js").TableRow[];
+        readonly columns: import("./index.js").TableColumn<import("./index.js").TableRow>[];
+        readonly border: boolean;
+        readonly stripe: boolean;
+        readonly selection: boolean;
+        readonly rowKey: import("./index.js").TableRowKeyGetter;
+        readonly emptyText: string;
+    }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("vue").ExtractPropTypes<{
+        readonly data: {
+            readonly type: import("vue").PropType<import("./index.js").TableRow[]>;
+            readonly default: () => never[];
+        };
+        readonly columns: {
+            readonly type: import("vue").PropType<import("./index.js").TableColumn[]>;
+            readonly default: () => never[];
+        };
+        readonly loading: BooleanConstructor;
+        readonly border: BooleanConstructor;
+        readonly stripe: BooleanConstructor;
+        readonly selection: BooleanConstructor;
+        readonly rowKey: {
+            readonly type: import("vue").PropType<import("./index.js").TableRowKeyGetter>;
+            readonly default: undefined;
+        };
+        readonly selectable: import("vue").PropType<import("./index.js").TableSelectable>;
+        readonly emptyText: {
+            readonly type: StringConstructor;
+            readonly default: "No Data";
+        };
+    }>> & Readonly<{
+        onSelect?: ((_selection: import("./index.js").TableRow[], _row: import("./index.js").TableRow) => any) | undefined;
+        "onSelect-all"?: ((_selection: import("./index.js").TableRow[]) => any) | undefined;
+        "onSelection-change"?: ((_selection: import("./index.js").TableRow[]) => any) | undefined;
+    }>, {}, {}, {}, {}, {
+        readonly loading: boolean;
+        readonly data: import("./index.js").TableRow[];
+        readonly columns: import("./index.js").TableColumn<import("./index.js").TableRow>[];
+        readonly border: boolean;
+        readonly stripe: boolean;
+        readonly selection: boolean;
+        readonly rowKey: import("./index.js").TableRowKeyGetter;
+        readonly emptyText: string;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+    readonly data: {
+        readonly type: import("vue").PropType<import("./index.js").TableRow[]>;
+        readonly default: () => never[];
+    };
+    readonly columns: {
+        readonly type: import("vue").PropType<import("./index.js").TableColumn[]>;
+        readonly default: () => never[];
+    };
+    readonly loading: BooleanConstructor;
+    readonly border: BooleanConstructor;
+    readonly stripe: BooleanConstructor;
+    readonly selection: BooleanConstructor;
+    readonly rowKey: {
+        readonly type: import("vue").PropType<import("./index.js").TableRowKeyGetter>;
+        readonly default: undefined;
+    };
+    readonly selectable: import("vue").PropType<import("./index.js").TableSelectable>;
+    readonly emptyText: {
+        readonly type: StringConstructor;
+        readonly default: "No Data";
+    };
+}>> & Readonly<{
+    onSelect?: ((_selection: import("./index.js").TableRow[], _row: import("./index.js").TableRow) => any) | undefined;
+    "onSelect-all"?: ((_selection: import("./index.js").TableRow[]) => any) | undefined;
+    "onSelection-change"?: ((_selection: import("./index.js").TableRow[]) => any) | undefined;
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    select: (_selection: import("./index.js").TableRow[], _row: import("./index.js").TableRow) => void;
+    "select-all": (_selection: import("./index.js").TableRow[]) => void;
+    "selection-change": (_selection: import("./index.js").TableRow[]) => void;
+}, string, {
+    readonly loading: boolean;
+    readonly data: import("./index.js").TableRow[];
+    readonly columns: import("./index.js").TableColumn<import("./index.js").TableRow>[];
+    readonly border: boolean;
+    readonly stripe: boolean;
+    readonly selection: boolean;
+    readonly rowKey: import("./index.js").TableRowKeyGetter;
+    readonly emptyText: string;
+}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+    $slots: {
+        [x: string]: ((props: {
+            row: import("./index.js").TableRow;
+            column: import("./index.js").TableColumn<import("./index.js").TableRow>;
+            index: number;
+            value: unknown;
+        }) => any) | undefined;
+    } & {
+        cell?: (props: {
+            row: import("./index.js").TableRow;
+            column: import("./index.js").TableColumn<import("./index.js").TableRow>;
+            index: number;
+            value: unknown;
+        }) => any;
+    } & {
+        empty?: (props: {}) => any;
+    };
+})>;
+export default JhTable;
+export * from './src/props';
+export * from './src/types';

package/dist/components/table/src/props.d.ts

@@ -0,0 +1,31 @@
+import type { ExtractPropTypes, PropType } from 'vue';
+import type { TableColumn, TableRow, TableRowKeyGetter, TableSelectable } from './types';
+export declare const tableProps: {
+    readonly data: {
+        readonly type: PropType<TableRow[]>;
+        readonly default: () => never[];
+    };
+    readonly columns: {
+        readonly type: PropType<TableColumn[]>;
+        readonly default: () => never[];
+    };
+    readonly loading: BooleanConstructor;
+    readonly border: BooleanConstructor;
+    readonly stripe: BooleanConstructor;
+    readonly selection: BooleanConstructor;
+    readonly rowKey: {
+        readonly type: PropType<TableRowKeyGetter>;
+        readonly default: undefined;
+    };
+    readonly selectable: PropType<TableSelectable>;
+    readonly emptyText: {
+        readonly type: StringConstructor;
+        readonly default: "No Data";
+    };
+};
+export declare const tableEmits: {
+    select: (_selection: TableRow[], _row: TableRow) => boolean;
+    'select-all': (_selection: TableRow[]) => boolean;
+    'selection-change': (_selection: TableRow[]) => boolean;
+};
+export type TableProps = ExtractPropTypes<typeof tableProps>;

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

@@ -0,0 +1,88 @@
+import type { TableColumn, TableRow } from './types';
+declare var __VLS_2: string, __VLS_3: {
+    row: TableRow;
+    column: TableColumn<TableRow>;
+    index: number;
+    value: unknown;
+}, __VLS_5: {
+    row: TableRow;
+    column: TableColumn<TableRow>;
+    index: number;
+    value: unknown;
+}, __VLS_7: {};
+type __VLS_Slots = {} & {
+    [K in NonNullable<typeof __VLS_2>]?: (props: typeof __VLS_3) => any;
+} & {
+    cell?: (props: typeof __VLS_5) => any;
+} & {
+    empty?: (props: typeof __VLS_7) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    readonly data: {
+        readonly type: import("vue").PropType<TableRow[]>;
+        readonly default: () => never[];
+    };
+    readonly columns: {
+        readonly type: import("vue").PropType<TableColumn[]>;
+        readonly default: () => never[];
+    };
+    readonly loading: BooleanConstructor;
+    readonly border: BooleanConstructor;
+    readonly stripe: BooleanConstructor;
+    readonly selection: BooleanConstructor;
+    readonly rowKey: {
+        readonly type: import("vue").PropType<import("./types").TableRowKeyGetter>;
+        readonly default: undefined;
+    };
+    readonly selectable: import("vue").PropType<import("./types").TableSelectable>;
+    readonly emptyText: {
+        readonly type: StringConstructor;
+        readonly default: "No Data";
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    select: (_selection: TableRow[], _row: TableRow) => void;
+    "select-all": (_selection: TableRow[]) => void;
+    "selection-change": (_selection: TableRow[]) => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly data: {
+        readonly type: import("vue").PropType<TableRow[]>;
+        readonly default: () => never[];
+    };
+    readonly columns: {
+        readonly type: import("vue").PropType<TableColumn[]>;
+        readonly default: () => never[];
+    };
+    readonly loading: BooleanConstructor;
+    readonly border: BooleanConstructor;
+    readonly stripe: BooleanConstructor;
+    readonly selection: BooleanConstructor;
+    readonly rowKey: {
+        readonly type: import("vue").PropType<import("./types").TableRowKeyGetter>;
+        readonly default: undefined;
+    };
+    readonly selectable: import("vue").PropType<import("./types").TableSelectable>;
+    readonly emptyText: {
+        readonly type: StringConstructor;
+        readonly default: "No Data";
+    };
+}>> & Readonly<{
+    onSelect?: ((_selection: TableRow[], _row: TableRow) => any) | undefined;
+    "onSelect-all"?: ((_selection: TableRow[]) => any) | undefined;
+    "onSelection-change"?: ((_selection: TableRow[]) => any) | undefined;
+}>, {
+    readonly loading: boolean;
+    readonly data: TableRow[];
+    readonly columns: TableColumn<TableRow>[];
+    readonly border: boolean;
+    readonly stripe: boolean;
+    readonly selection: boolean;
+    readonly rowKey: import("./types").TableRowKeyGetter;
+    readonly emptyText: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, 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/components/table/src/types.d.ts

@@ -0,0 +1,11 @@
+export type TableRow = Record<string, unknown>;
+export type TableRowKey = string | number;
+export type TableRowKeyGetter<T extends TableRow = TableRow> = (keyof T & string) | ((row: T) => TableRowKey);
+export type TableSelectable<T extends TableRow = TableRow> = (row: T, index: number) => boolean;
+export interface TableColumn<T extends TableRow = TableRow> {
+    prop: keyof T & string;
+    label: string;
+    width?: string | number;
+    align?: 'left' | 'center' | 'right';
+    slot?: string;
+}