@oiij/naive-ui 0.0.4 → 0.0.5

package/dist/components/bubble/Bubble.vue.d.ts

@@ -1,4 +1,4 @@
-import { BubbleProps } from './index';
+import { BubbleProps } from '.';
 declare function __VLS_template(): {
     attrs: Partial<{}>;
     slots: {

package/dist/components/config-providers/ConfigProviders.vue.d.ts

@@ -1,4 +1,4 @@
-import { ConfigProvidersProps } from './index';
+import { ConfigProvidersProps } from '.';
 declare function __VLS_template(): {
     attrs: Partial<{}>;
     slots: {

package/dist/components/copy-button/CopyButton.vue.d.ts

@@ -1,4 +1,4 @@
-import { CopyButtonProps } from './index';
+import { CopyButtonProps } from '.';
 declare function __VLS_template(): {
     attrs: Partial<{}>;
     slots: {

package/dist/components/data-table-plus/DataTablePlus.vue.d.ts

@@ -1,16 +1,18 @@
-import { DataTableBaseColumn, DataTableColumns, DataTableFilterState, DataTableInst, DataTableProps, DataTableSortState, DropdownOption, PaginationProps } from 'naive-ui';
+import { DataTableBaseColumn, DataTableColumns, DataTableFilterState, DataTableProps, DataTableSortState, DropdownOption, GridProps, PaginationProps } from 'naive-ui';
 import { CSSProperties } from 'vue';
 import { UseRequestOptions, UseRequestPlugin } from 'vue-hooks-plus/es/useRequest/types';
-import { ClickRowType, ContextMenuSelectType, DataTableFilterOptions } from './index';
+import { ContextMenuSelectType, DataTablePlusClickRowType, DataTablePlusExposeActions, DataTablePlusExposeRefs, DataTablePlusFields, DataTablePlusFilterOptions } from '.';
 declare const _default: <P extends Record<string, any>, D extends Record<string, any>, R extends Record<string, any>>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
     props: __VLS_PrettifyLocal<any & {
         api: (params: P) => Promise<D>;
         defaultParams?: P;
+        manual?: boolean;
         columns?: DataTableColumns<R>;
-        filterOptions?: DataTableFilterOptions<P, D>;
+        filterOptions?: DataTablePlusFilterOptions<P, D, R>;
+        filterGridProps?: GridProps;
         contextMenuOptions?: DropdownOption[];
-        fields?: Record<"page" | "pageSize" | "filter" | "sorter" | "list" | "count" | "rowKey", string>;
-        pagination?: Omit<PaginationProps, "page" | "pageSize">;
+        fields?: DataTablePlusFields;
+        pagination?: Omit<PaginationProps, "page" | "pageSize"> | boolean;
         dataTableProps?: DataTableProps;
         requestOptions?: UseRequestOptions<D, P[]>;
         requestPlugins?: UseRequestPlugin<D, P[]>[];
@@ -18,50 +20,32 @@ declare const _default: <P extends Record<string, any>, D extends Record<string,
         customClass?: string;
     } & Partial<{}>> & import('vue').PublicProps;
     expose(exposed: import('vue').ShallowUnwrapRef<{
-        data: Readonly<import('vue').Ref<D | undefined, D | undefined>>;
-        params: Readonly<import('vue').Ref<[] | P[], [] | P[]>>;
-        error: Readonly<import('vue').Ref<Error | undefined, Error | undefined>>;
-        actions: {
-            run: (_params: Partial<P>) => void;
-            runAsync: (_params: Partial<P>) => Promise<D>;
-            refresh: () => void;
-            refreshAsync: () => Promise<D>;
-            cancel: () => void;
-            mutate: (data?: D | ((oldData?: D | undefined) => D | undefined) | undefined) => void;
-            setParams: (_params: Partial<P>) => void;
-        };
-        dataTableRef: Readonly<import('vue').ShallowRef<DataTableInst | null>>;
+        refs: DataTablePlusExposeRefs<P, D, R>;
+        actions: DataTablePlusExposeActions<P, D>;
     }>): void;
     attrs: any;
     slots: {
         filter?(_: {
-            params: P;
-            data: D | undefined;
-            actions: {
-                run: (_params: Partial<P>) => void;
-                runAsync: (_params: Partial<P>) => Promise<D>;
-                refresh: () => void;
-                refreshAsync: () => Promise<D>;
-                cancel: () => void;
-                mutate: (data?: D | ((oldData?: D | undefined) => D | undefined) | undefined) => void;
-                setParams: (_params: Partial<P>) => void;
-            };
-            dataTableRef: DataTableInst | null;
+            refs: DataTablePlusExposeRefs<P, D, R>;
+            actions: DataTablePlusExposeActions<P, D>;
         }): any;
     };
     emit: {
-        (e: "loaded", data: D): void;
-        (e: "clickRow", data: ClickRowType<R>): void;
-        (e: "contextMenuRow", data: ClickRowType<R>): void;
+        (e: "before", params: P[]): void;
+        (e: "success", data: D, params: P[]): void;
+        (e: "error", err: Error, params: P[]): void;
+        (e: "finally", params: P[], data?: D, err?: Error): void;
+        (e: "clickRow", data: DataTablePlusClickRowType<R>): void;
+        (e: "contextMenuRow", data: DataTablePlusClickRowType<R>): void;
         (e: "contextMenuSelect", data: ContextMenuSelectType<R>): void;
-        (e: "load", rowData: object): Promise<void>;
+        (e: "load", row: R): Promise<void>;
         (e: "scroll", ev: Event): void;
-        (e: "update:checkedRowKeys", keys: (number | string)[], rows: object[], meta: {
-            row: object | undefined;
+        (e: "update:checkedRowKeys", keys: keyof R_1[], rows: R[], meta: {
+            row: R | undefined;
             action: "check" | "uncheck" | "checkAll" | "uncheckAll";
         }): void;
-        (e: "update:expandedRowKeys", keys: (number | string)[]): void;
-        (e: "update:filters", filters: DataTableFilterState, initiatorColumn: DataTableBaseColumn): void;
+        (e: "update:expandedRowKeys", keys: R[]): void;
+        (e: "update:filters", filterState: DataTableFilterState, sourceColumn: DataTableBaseColumn<import('naive-ui/es/data-table/src/interface').InternalRowData>): void;
         (e: "update:sorter", options: DataTableSortState | DataTableSortState[] | null): void;
         (e: "update:page", page: number): void;
         (e: "update:pageSize", pageSize: number): void;

package/dist/components/data-table-plus/index.d.ts

@@ -1,47 +1,38 @@
-import { DataTableInst, DatePickerProps, DropdownOption, FormItemProps, InputProps, SelectProps, SwitchProps, TimePickerProps } from 'naive-ui';
-import { CSSProperties, VNode } from 'vue';
-import { SearchInputProps } from '../index';
+import { DataTableInst, DropdownOption, GridItemProps } from 'naive-ui';
+import { ComputedRef, Ref, ShallowRef, VNode } from 'vue';
+import { useRequestResult } from 'vue-hooks-plus/es/useRequest/types';
+import { PresetInputOptions } from '../preset-input';
 export { default as NDataTablePlus } from './DataTablePlus.vue';
-interface FilterTypeProps {
-    'date-picker': DatePickerProps;
-    'input': InputProps;
-    'search': SearchInputProps;
-    'select': SelectProps;
-    'switch': SwitchProps;
-    'time-picker': TimePickerProps;
-}
-interface Actions<P extends Record<string, any>, D extends Record<string, any>> {
+export interface DataTablePlusExposeActions<P extends Record<string, any>, D extends Record<string, any>> {
     run: (params: P) => void;
     runAsync: (params: P) => Promise<D>;
     refresh: () => void;
     refreshAsync: () => Promise<D>;
     cancel: () => void;
     mutate: (data?: D | ((oldData?: D | undefined) => D | undefined) | undefined) => void;
-    setParams: (params: P) => void;
+    setParam: (params: Partial<P>) => void;
+    runParam: (params: Partial<P>) => void;
+    runParamAsync: (params: Partial<P>) => Promise<D>;
+}
+export interface DataTablePlusPagination {
+    page: number;
+    pageSize: number;
+    itemCount: number;
 }
-export type DataTableFilterOptions<P extends Record<string, any>, D extends Record<string, any>> = {
-    [K in keyof FilterTypeProps]: {
-        key?: keyof P;
-        title?: string;
-        type?: K;
-        collapsed?: boolean;
-        props?: FilterTypeProps[K] & {
-            style?: CSSProperties;
-            class?: string;
-        };
-        labelProps?: FormItemProps & {
-            style?: CSSProperties;
-            class?: string;
-        };
-        render?: (opt: {
-            params: P;
-            data?: D;
-            actions: Actions<P, D>;
-            dataTableRef: DataTableInst | null;
-        }) => VNode;
-    };
-}[keyof FilterTypeProps][];
-export interface ClickRowType<R extends Record<string, any>> {
+export type DataTablePlusExposeRefsBase<P extends Record<string, any>, D extends Record<string, any>, R extends Record<string, any>> = Pick<useRequestResult<D, P[], false, false>, 'loading' | 'data' | 'error' | 'params'> & {
+    pagination: Readonly<Ref<DataTablePlusPagination, DataTablePlusPagination>>;
+    rawList: ComputedRef<R[]>;
+};
+export type DataTablePlusExposeRefs<P extends Record<string, any>, D extends Record<string, any>, R extends Record<string, any>> = DataTablePlusExposeRefsBase<P, D, R> & {
+    dataTableRef: Readonly<ShallowRef<DataTableInst | null>>;
+};
+export type DataTablePlusFilterOptions<P extends Record<string, any>, D extends Record<string, any>, R extends Record<string, any>> = (PresetInputOptions & {
+    key?: keyof P;
+    collapsed?: boolean;
+    gridItemProps?: GridItemProps;
+    render?: (refs: DataTablePlusExposeRefs<P, D, R>, actions: DataTablePlusExposeActions<P, D>) => VNode;
+})[];
+export interface DataTablePlusClickRowType<R extends Record<string, any>> {
     row: R;
     index: number;
     event: MouseEvent;
@@ -51,3 +42,9 @@ export interface ContextMenuSelectType<R extends Record<string, any>> {
     option: DropdownOption;
     row?: R;
 }
+export type DataTablePlusFields = Partial<Record<'page' | 'pageSize' | 'filter' | 'sorter' | 'list' | 'count' | 'rowKey', string>>;
+export type OnUpdateCheckedRowKeysParams<R extends Record<string, any>> = (keys: keyof R[], rows: R[], meta: {
+    row: R | undefined;
+    action: 'check' | 'uncheck' | 'checkAll' | 'uncheckAll';
+}) => void;
+export type OnUpdateExpandedRowKeysParams<R extends Record<string, any>> = (keys: R[]) => void;

package/dist/components/index.d.ts

@@ -2,6 +2,10 @@ export * from './bubble';
 export * from './config-providers';
 export * from './copy-button';
 export * from './data-table-plus';
+export * from './preset-form';
+export * from './preset-input';
+export * from './preset-select';
+export * from './remote-request';
 export * from './search-input';
 export * from './toggle-editor';
 export * from './tooltip-button';

package/dist/components/preset-form/PresetForm.vue.d.ts

@@ -0,0 +1,68 @@
+import { FormProps, GridProps } from 'naive-ui';
+import { PresetFormOptions } from '.';
+import { NaiveFormRules } from '../../composables';
+declare const _default: <V extends Record<string, any>>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly onValidated?: ((val: V) => any) | undefined;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onValidated"> & {
+        options?: PresetFormOptions<V>;
+        values?: V;
+        rules: NaiveFormRules<V>;
+        formProps?: FormProps;
+        gridProps?: GridProps;
+    } & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{
+        refs: {
+            formRef: import('vue').Ref<import('naive-ui').FormInst | undefined, import('naive-ui').FormInst | undefined>;
+            formValue: import('vue').Ref<V, V>;
+            formRules: Partial<Record<keyof V, import('naive-ui').FormItemRule | import('naive-ui').FormRules | import('naive-ui').FormItemRule[]>> | undefined;
+            formProps: {
+                ref: import('vue').Ref<import('naive-ui').FormInst | undefined, import('naive-ui').FormInst | undefined>;
+                model: import('vue').Reactive<V>;
+                rules: Partial<Record<keyof V, import('naive-ui').FormItemRule | import('naive-ui').FormRules | import('naive-ui').FormItemRule[]>> | undefined;
+            };
+        };
+        actions: {
+            validate: () => Promise<unknown[]> | undefined;
+            resetValidation: () => void;
+            resetForm: () => void;
+            reset: () => void;
+            clear: () => void;
+            onValidated: import('@vueuse/core').EventHookOn<[V]>;
+            setValue: (value: Partial<V>) => void;
+        };
+    }>): void;
+    attrs: any;
+    slots: {
+        header?(_: {}): any;
+        default?(_: {
+            refs: {
+                formRef: import('vue').Ref<import('naive-ui').FormInst | undefined, import('naive-ui').FormInst | undefined>;
+                formValue: import('vue').Ref<V, V>;
+                formRules: Partial<Record<keyof V, import('naive-ui').FormItemRule | import('naive-ui').FormRules | import('naive-ui').FormItemRule[]>> | undefined;
+                formProps: {
+                    ref: import('vue').Ref<import('naive-ui').FormInst | undefined, import('naive-ui').FormInst | undefined>;
+                    model: import('vue').Reactive<V>;
+                    rules: Partial<Record<keyof V, import('naive-ui').FormItemRule | import('naive-ui').FormRules | import('naive-ui').FormItemRule[]>> | undefined;
+                };
+            };
+            actions: {
+                validate: () => Promise<unknown[]> | undefined;
+                resetValidation: () => void;
+                resetForm: () => void;
+                reset: () => void;
+                clear: () => void;
+                onValidated: import('@vueuse/core').EventHookOn<[V]>;
+                setValue: (value: Partial<V>) => void;
+            };
+        }): any;
+        footer?(_: {}): any;
+    };
+    emit: (e: "validated", val: V) => void;
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/components/preset-form/index.d.ts

@@ -0,0 +1,15 @@
+import { GridItemProps } from 'naive-ui';
+import { VNode } from 'vue';
+import { NaiveFormReturns } from '../../composables';
+import { PresetInputOptions } from '../preset-input';
+export type { NaiveFormRules } from '../../composables';
+export { default as NPresetForm } from './PresetForm.vue';
+export type PresetFormExposeRefs<V extends Record<string, any>> = Pick<NaiveFormReturns<V>, 'formValue' | 'formRef' | 'formRules' | 'formProps'> & {};
+export type PresetFormExposeActions<V extends Record<string, any>> = Pick<NaiveFormReturns<V>, 'validate' | 'resetValidation' | 'resetForm' | 'reset' | 'clear' | 'onValidated'> & {
+    setValue: (value: Partial<V>) => void;
+};
+export type PresetFormOptions<V extends Record<string, any>> = (PresetInputOptions & {
+    key?: keyof V;
+    gridItemProps?: GridItemProps;
+    render?: (refs: PresetFormExposeRefs<V>, actions: PresetFormExposeActions<V>) => VNode;
+})[];

package/dist/components/preset-input/PresetInput.vue.d.ts

@@ -0,0 +1,20 @@
+import { PresetInputOptions } from '.';
+declare const _default: <V extends any>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly "onUpdate:value"?: ((val?: V | undefined) => any) | undefined;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onUpdate:value"> & {
+        value?: V;
+        path?: string;
+        options?: PresetInputOptions;
+    } & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: {};
+    emit: (e: "update:value", val?: V) => void;
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/components/preset-input/index.d.ts

@@ -0,0 +1,26 @@
+import { ButtonProps, DatePickerProps, FormItemProps, InputProps, SelectProps, SwitchProps, TimePickerProps } from 'naive-ui';
+import { CSSProperties } from 'vue';
+import { SearchInputProps } from '..';
+export { default as NPresetInput } from './PresetInput.vue';
+interface PresetInputType {
+    'date-picker': DatePickerProps;
+    'input': InputProps;
+    'search': SearchInputProps;
+    'select': SelectProps;
+    'switch': SwitchProps;
+    'time-picker': TimePickerProps;
+    'button': ButtonProps;
+}
+export type PresetInputOptions = {
+    [K in keyof PresetInputType]: {
+        type?: K;
+        label?: string | boolean | (FormItemProps & {
+            style?: CSSProperties;
+            class?: string;
+        });
+        props?: PresetInputType[K] & {
+            style?: CSSProperties;
+            class?: string;
+        };
+    };
+}[keyof PresetInputType];

package/dist/components/preset-select/PresetSelect.vue.d.ts

@@ -0,0 +1,51 @@
+import { PaginationProps, SelectOption, SelectProps } from 'naive-ui';
+import { UseRequestOptions, UseRequestPlugin } from 'vue-hooks-plus/es/useRequest/types';
+import { OptionFormat, PresetSelectExposeActions, PresetSelectExposeRefs, PresetSelectFields, PresetSelectValue } from '.';
+declare const _default: <P extends Record<string, any>, D extends Record<string, any>, R extends Record<string, any>>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly onError?: ((err: Error, params: P[]) => any) | undefined;
+        readonly onSuccess?: ((data: D, params: P[]) => any) | undefined;
+        readonly "onUpdate:value"?: ((val: string | number | (string | number)[] | null, option: SelectOption | SelectOption[] | null, raw: R | R[] | null) => any) | undefined;
+        readonly onBefore?: ((params: P[]) => any) | undefined;
+        readonly "onUpdate:page"?: ((page: number) => any) | undefined;
+        readonly "onUpdate:pageSize"?: ((pageSize: number) => any) | undefined;
+        readonly onFinally?: ((params: P[], data?: D | undefined, err?: Error | undefined) => any) | undefined;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onError" | "onUpdate:value" | "onUpdate:page" | "onUpdate:pageSize" | "onBefore" | "onSuccess" | "onFinally"> & {
+        api: (params: P) => Promise<D>;
+        value?: PresetSelectValue;
+        fallbackLabel?: string;
+        defaultParams?: P;
+        manual?: boolean;
+        multiple?: boolean;
+        disabled?: boolean;
+        optionFormat?: OptionFormat<R>;
+        fields?: PresetSelectFields;
+        selectProps?: SelectProps;
+        pagination?: Omit<PaginationProps, "page" | "pageSize"> | boolean;
+        requestOptions?: UseRequestOptions<D, P[]>;
+        requestPlugins?: UseRequestPlugin<D, P[]>[];
+    } & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{
+        refs: PresetSelectExposeRefs<P, D, R>;
+        actions: PresetSelectExposeActions<P, D>;
+    }>): void;
+    attrs: any;
+    slots: {
+        action?(_: {}): any;
+    };
+    emit: {
+        (e: "before", params: P[]): void;
+        (e: "success", data: D, params: P[]): void;
+        (e: "error", err: Error, params: P[]): void;
+        (e: "finally", params: P[], data?: D, err?: Error): void;
+        (e: "update:value", val: string | number | (string | number)[] | null, option: SelectOption | SelectOption[] | null, raw: R | R[] | null): void;
+        (e: "update:page", page: number): void;
+        (e: "update:pageSize", pageSize: number): void;
+    };
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

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

@@ -0,0 +1,17 @@
+import { SelectGroupOption, SelectInst, SelectOption } from 'naive-ui';
+import { ShallowRef } from 'vue';
+import { DataTablePlusExposeActions, DataTablePlusExposeRefsBase } from '../data-table-plus';
+export { default as NPresetSelect } from './PresetSelect.vue';
+export type OptionFormat<R extends Record<string, any>> = (row: R) => SelectOption | SelectGroupOption;
+export type PresetSelectValue = string | number | (string | number)[] | null;
+export type PresetSelectUpdateValue<R extends Record<string, any>> = (val: string | number | (string | number)[] | null, option: SelectOption | SelectOption[] | null, raw: R | R[] | null) => void;
+export type PresetSelectFields = Partial<Record<'page' | 'pageSize' | 'search' | 'list' | 'count' | 'rowKey' | 'label' | 'value' | 'children', string>>;
+export interface PresetSelectPagination {
+    page: number;
+    pageSize: number;
+    itemCount: number;
+}
+export type PresetSelectExposeRefs<P extends Record<string, any>, D extends Record<string, any>, R extends Record<string, any>> = DataTablePlusExposeRefsBase<P, D, R> & {
+    selectRef: Readonly<ShallowRef<SelectInst | null>>;
+};
+export type PresetSelectExposeActions<P extends Record<string, any>, D extends Record<string, any>> = DataTablePlusExposeActions<P, D>;

package/dist/components/remote-request/RemoteRequest.vue.d.ts

@@ -0,0 +1,70 @@
+import { UseRequestOptions, UseRequestPlugin } from 'vue-hooks-plus/es/useRequest/types';
+import { RemoteRequestFields } from '.';
+declare const _default: <P extends Record<string, any>, D extends Record<string, any>>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly onError?: ((err: Error, params: P[]) => any) | undefined;
+        readonly onSuccess?: ((data: D, params: P[]) => any) | undefined;
+        readonly onBefore?: ((params: P[]) => any) | undefined;
+        readonly onFinally?: ((params: P[], data?: D | undefined, err?: Error | undefined) => any) | undefined;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onError" | "onBefore" | "onSuccess" | "onFinally"> & {
+        api: (params: P) => Promise<D>;
+        defaultParams?: P;
+        manual?: boolean;
+        fields?: RemoteRequestFields;
+        requestOptions?: UseRequestOptions<D, P[]>;
+        requestPlugins?: UseRequestPlugin<D, P[]>[];
+    } & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{
+        refs: {
+            loading: Readonly<import('vue').Ref<boolean, boolean>>;
+            data: Readonly<import('vue').Ref<D | undefined, D | undefined>>;
+            error: Readonly<import('vue').Ref<Error | undefined, Error | undefined>>;
+            params: Readonly<import('vue').Ref<[] | P[], [] | P[]>>;
+        };
+        actions: {
+            run: (...params: P[]) => void;
+            runAsync: (...params: P[]) => Promise<D>;
+            refresh: () => void;
+            refreshAsync: () => Promise<D>;
+            cancel: () => void;
+            mutate: (data?: D | ((oldData?: D | undefined) => D | undefined) | undefined) => void;
+            setParam: (_params: Partial<P>) => void;
+            runParam: (_params: Partial<P>) => void;
+            runParamAsync: (_params: Partial<P>) => Promise<D>;
+        };
+    }>): void;
+    attrs: any;
+    slots: {
+        default?(_: {
+            refs: {
+                loading: Readonly<import('vue').Ref<boolean, boolean>>;
+                data: Readonly<import('vue').Ref<D | undefined, D | undefined>>;
+                error: Readonly<import('vue').Ref<Error | undefined, Error | undefined>>;
+                params: Readonly<import('vue').Ref<[] | P[], [] | P[]>>;
+            };
+            actions: {
+                run: (...params: P[]) => void;
+                runAsync: (...params: P[]) => Promise<D>;
+                refresh: () => void;
+                refreshAsync: () => Promise<D>;
+                cancel: () => void;
+                mutate: (data?: D | ((oldData?: D | undefined) => D | undefined) | undefined) => void;
+                setParam: (_params: Partial<P>) => void;
+                runParam: (_params: Partial<P>) => void;
+                runParamAsync: (_params: Partial<P>) => Promise<D>;
+            };
+        }): any;
+    };
+    emit: {
+        (e: "before", params: P[]): void;
+        (e: "success", data: D, params: P[]): void;
+        (e: "error", err: Error, params: P[]): void;
+        (e: "finally", params: P[], data?: D, err?: Error): void;
+    };
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/components/remote-request/index.d.ts

@@ -0,0 +1,2 @@
+export { default as NRemoteRequest } from './RemoteRequest.vue';
+export type RemoteRequestFields = Partial<Record<string, string>>;

package/dist/components/search-input/SearchInput.vue.d.ts

@@ -1,4 +1,4 @@
-import { SearchInputProps } from './index';
+import { SearchInputProps } from '.';
 declare function __VLS_template(): {
     attrs: Partial<{}>;
     slots: {

package/dist/components/tooltip-button/TooltipButton.vue.d.ts

@@ -1,4 +1,4 @@
-import { TooltipButtonProps } from './index';
+import { TooltipButtonProps } from '.';
 declare function __VLS_template(): {
     attrs: Partial<{}>;
     slots: {

package/dist/components/type-writer/TypeWriter.vue.d.ts

@@ -1,4 +1,4 @@
-import { TypeWriterProps } from './index';
+import { TypeWriterProps } from '.';
 declare const _default: import('vue').DefineComponent<TypeWriterProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
     start: () => any;
     update: (v: {