@ithinkdt/ui 4.0.0-5 → 4.0.0-9

package/auto-imports.d.ts

@@ -1,10 +1,15 @@
-export declare const UI: {
-    from: string
-    imports: (string | { name: string; type: boolean })[]
+export declare const UIDirectives: {
+    type: 'directive'
+    resolve: (name: string) => string | undefined
 }[]
-export default UI
 
-export declare const UIDirectives: {
-    type: 'component' | 'directive'
+export declare const UIComponents: {
+    type: 'component'
     resolve: (name: string) => string | undefined
 }[]
+
+export declare const UI: {
+    from: string
+    imports: (string | { name: string, type: boolean })[]
+}[]
+export default UI

package/auto-imports.js

@@ -1,19 +1,34 @@
-export const UI = [
+export const UIDirectives = [
     {
-        from: '@ithinkdt/ui',
-        imports: ['vSpin', 'vTooltip'],
+        type: 'directive',
+        resolve(name) {
+            return ['Spin', 'Tooltip'].includes(name)
+                ? { name: `v${name}`, from: '@ithinkdt/ui/directives' }
+                : undefined
+        },
     },
 ]
 
-export default UI
-
-export const UIDirectives = [
+export const UIComponents = [
     {
-        type: 'directive',
+        type: 'component',
         resolve(name) {
-            return ['Spin', 'Tooltip'].includes(name)
-                ? { name: `v${name}`, from: '@ithinkdt/ui' }
+            return ['DataTable', 'DataForm', 'DataCustom', 'DataFilter', 'DataSelection', 'DataPagination'].includes(name)
+                ? { name, from: '@ithinkdt/ui/components' }
                 : undefined
         },
     },
 ]
+
+export const UI = [
+    {
+        from: '@ithinkdt/ui/directives',
+        imports: ['vSpin', 'vTooltip'],
+    },
+    {
+        from: '@ithinkdt/ui/components',
+        imports: ['DataTable', 'DataForm', 'DataCustom', 'DataFilter', 'DataSelection', 'DataPagination'],
+    },
+]
+
+export default UI

package/package.json

@@ -1,13 +1,21 @@
 {
   "name": "@ithinkdt/ui",
-  "version": "4.0.0-5",
+  "version": "4.0.0-9",
   "type": "module",
   "license": "MIT",
   "description": "iThinkDT UI",
   "keywords": [
+    "ithinkdt",
     "vue",
-    "ithinkdt"
+    "ui"
   ],
+  "files": [
+    "src",
+    "auto-imports.*",
+    "shims.*",
+    "unocss.*"
+  ],
+  "main": "./src/index.js",
   "module": "./src/index.js",
   "types": "./src/index.d.ts",
   "exports": {
@@ -15,6 +23,22 @@
       "types": "./src/index.d.ts",
       "default": "./src/index.js"
     },
+    "./directives": {
+      "types": "./src/directives.d.ts",
+      "default": "./src/directives/index.js"
+    },
+    "./components": {
+      "types": "./src/components.d.ts",
+      "default": "./src/components/index.js"
+    },
+    "./use-style": {
+      "types": "./src/use-style.d.ts",
+      "default": "./src/use-style.js"
+    },
+    "./page": {
+      "types": "./src/page.d.ts",
+      "default": "./src/page.jsx"
+    },
     "./package.json": {
       "default": "./package.json"
     },
@@ -25,10 +49,6 @@
     "./unocss": {
       "types": "./unocss.d.ts",
       "default": "./unocss.js"
-    },
-    "./design": {
-      "types": "./design/index.d.ts",
-      "default": "./design/index.js"
     }
   },
   "publishConfig": {
@@ -37,25 +57,43 @@
   },
   "sideEffects": false,
   "dependencies": {
-    "@unocss/preset-uno": ">=0.62.3",
-    "@vueuse/core": "^11.0.3",
-    "@ithinkdt/common": "^4.0.0-5"
+    "@vueuse/core": "^13.9.0",
+    "date-fns": "^4.1.0",
+    "vueuc": "^0.4.65",
+    "sortablejs": "^1.15.6",
+    "@types/sortablejs": "^1.15.8",
+    "nanoid": "^5.1.6",
+    "@ithinkdt/common": "^4.0.0-9"
   },
   "peerDependencies": {
-    "@ithinkdt/core": ">=4.0",
-    "vue": ">=3.4",
-    "vue-router": ">=4.4",
-    "ithinkdt-ui": ">=1.4"
+    "@ithinkdt/page": ">=4.0",
+    "vue": ">=3.5",
+    "vue-router": ">=4.5",
+    "ithinkdt-ui": ">=1.5",
+    "unocss": ">=66"
+  },
+  "peerDependenciesMeta": {
+    "@ithinkdt/page": {
+      "optional": true
+    },
+    "unocss": {
+      "optional": true
+    }
   },
   "devDependencies": {
-    "ithinkdt-ui": "^1.4.5",
-    "typescript": "~5.5.4",
-    "vue": "^3.4.38",
-    "vue-router": "^4.4.3",
-    "@ithinkdt/core": "^4.0.0-5"
+    "@vitejs/plugin-vue-jsx": "^5.1.1",
+    "ithinkdt-ui": "^1.7.3",
+    "typescript": "~5.9.3",
+    "unocss": ">=66.5.2",
+    "vite": "npm:rolldown-vite@^7.1.16",
+    "vue": "^3.5.22",
+    "vue-router": "^4.5.1",
+    "@ithinkdt/page": "^4.0.0-9"
   },
   "scripts": {
-    "format": "prettier --write \"./{src,tests}/**/*.{js,vue,ts,jsx,tsx}\"",
-    "release": "pnpm publish --no-git-checks"
+    "build": " vite build && cp -r ./_src/*.d.ts ./src",
+    "prerelease": "cp -r ./src ./_src && pnpm run build",
+    "release": "pnpm publish --no-git-checks",
+    "postrelease": "rm -rf ./src && cp -r ./_src ./src && rm -rf ./_src"
   }
 }

package/src/components.d.ts

@@ -0,0 +1,435 @@
+import {
+    CheckboxGroupProps, DataTableInst as NDataTableInst, DataTableProps as NDataTableProps,
+    FormItemGiProps as NFormItemGiProps, FormProps as NFormProps, GridItemProps as NGridItemProps, GridProps as NGridProps,
+    PopoverProps,
+    RadioGroupProps, TransferProps,
+} from 'ithinkdt-ui'
+import Sortable from 'sortablejs'
+import { AllowedComponentProps, MaybeRef, MaybeRefOrGetter, VNodeChild } from 'vue'
+import type { CSSProperties, HTMLAttributes, TemplateRef } from 'vue'
+
+import { GenericCtx, GenericExposed, GenericReturn, MaybeArray, MaybePromise, PublicProps } from '@ithinkdt/common'
+import { DictItem } from '@ithinkdt/common/dict'
+import { FormItem, PageParams, PresetKeyField, SortParams, TableActionRenderParam, TableColumn, ValidationResults, _DataWithPresetKeyField } from '@ithinkdt/page'
+
+declare module '@ithinkdt/page' {
+
+    interface FormRenderExtraOptions {
+        showColon?: MaybeRef<boolean | undefined>
+    }
+
+    type FormItemOptionKeys = 'size' | 'showLabel' | 'labelWidth' | 'labelStyle' | 'labelAlign' | 'labelPlacement' | 'labelProps'
+        | 'showRequireMark' | 'requireMarkPlacement' | 'showFeedback' | 'feedbackClass' | 'feedbackStyle' | 'span' | 'offset'
+
+    type FormItemOptionExtra = {
+        [K in FormItemOptionKeys]?: MaybeRef<NFormItemGiProps[K]>
+    }
+
+    // eslint-disable-next-line ts/no-unused-vars
+    interface FormItemOptions<Model extends {}> extends FormItemOptionExtra {
+        showColon?: MaybeRef<boolean | undefined>
+        rowSpan?: MaybeRef<number | undefined>
+        tooltip?: MaybeRefOrGetter<VNodeChild | undefined>
+        tooltipPlacement?: MaybeRef<'bottom' | 'icon' | undefined>
+        showTooltipWhenReadonly?: MaybeRef<boolean | undefined>
+    }
+    // eslint-disable-next-line ts/no-unused-vars
+    interface FormItem<Model extends {}> extends Pick<NFormItemGiProps, FormItemOptionKeys> {
+        showColon?: boolean | undefined
+        rowSpan?: number | undefined
+        tooltip?: VNodeChild | (() => VNodeChild) | undefined
+        tooltipPlacement?: 'bottom' | 'icon' | undefined
+        showTooltipWhenReadonly?: boolean | undefined
+    }
+
+    interface FormItemRenderExtraParams {
+        size?: 'small' | 'medium' | 'large' | undefined
+    }
+
+}
+
+export type DataFormProps<Data extends {}> = Omit<NFormProps, 'model' | 'rules' | 'onSubmit' | 'validateMessages'> & {
+    items: FormItem<Data>[]
+    model: Data
+    readonly?: boolean | undefined
+    grid?: boolean | NGridProps | undefined
+    validation?: { [k in keyof Data]?: ValidationResults } | undefined
+    showColon?: boolean | undefined
+    loading?: boolean | undefined
+    showAction?: boolean | NGridItemProps & AllowedComponentProps | undefined
+    actionAlign?: 'start' | 'center' | 'end'
+    submitText?: VNodeChild | undefined
+    resetText?: VNodeChild | undefined
+    cancelText?: VNodeChild | undefined
+    showSubmitBtn?: boolean | undefined
+    showResetBtn?: boolean | undefined
+    showCancelBtn?: boolean | undefined
+    submitDisabled?: boolean | undefined
+    succeeded?: boolean | undefined
+    successText?: VNodeChild | undefined
+
+    tooltipPlacement?: 'bottom' | 'icon' | undefined
+    onSubmit?: MaybeArray<(model: Data) => void> | undefined
+    onRest?: MaybeArray<() => void> | undefined
+}
+
+export type DataFormEmits<Data extends {}> = {
+    (e: 'submit', model: Data): void
+    (e: 'reset'): void
+}
+
+export type DataFormSlots<_Data extends {}> = {
+    action?: (params: { cols: number, spans: number, overflow: boolean }) => VNodeChild
+}
+
+export type DataFormInst = {
+}
+
+export declare function DataForm<Data extends {}>(
+    props: DataFormProps<Data> & PublicProps,
+    ctx?: Pick<GenericCtx<DataFormProps<Data>, DataFormEmits<Data>, DataFormSlots<Data>, DataFormInst>, 'attrs' | 'emit' | 'slots'>,
+    expose?: (exposed?: GenericExposed<DataFormInst>) => void,
+    setup?: GenericCtx<DataFormProps<Data>, DataFormEmits<Data>, DataFormSlots<Data>, DataFormInst>,
+): GenericReturn<DataFormProps<Data>, DataFormEmits<Data>, DataFormSlots<Data>, DataFormInst>
+
+export type DataFilterProps<Data extends {}> = Omit<NFormProps, 'model' | 'rules' | 'onSubmit' | 'validateMessages'> & {
+    items: FormItem<Data>[]
+    model: Data
+    loading?: boolean | undefined
+    filterOnReset?: boolean | undefined
+    filterText?: VNodeChild | undefined
+    resetText?: VNodeChild | undefined
+    grid?: boolean | Omit<NGridProps, 'collapsed' | 'collapsedRows'> | undefined
+    collapsible?: boolean | undefined
+    defaultCollapsed?: boolean | undefined
+    collapsedRows?: number | undefined
+    showColon?: boolean | undefined
+    tooltipPlacement?: 'bottom' | 'icon' | undefined
+    customizable?: boolean | undefined
+    onFilter?: MaybeArray<(model: Data) => void> | undefined
+    onRest?: MaybeArray<() => void> | undefined
+    onCustom?: MaybeArray<
+            ((reset: true) => void)
+            | ((sort: string[]) => void)
+            | ((modify: {
+                key: string
+                hidden: boolean
+            }) => void)
+    >
+    | undefined
+    onCollapse?: MaybeArray<(collapsed: boolean) => void> | undefined
+}
+
+export type DataFilterEmits<Data extends {}> = {
+    (e: 'filter', model: Data): void
+    (e: 'reset'): void
+    (e: 'custom', param: true | string[] | { key: string, hidden?: boolean }): void
+    (e: 'custom', sort: string[]): void
+    (e: 'custom', modify: {
+        key: string
+        hidden?: boolean
+    }): void
+    (e: 'collpase', collapsed: boolean): void
+}
+
+export type DataFilterInst = {
+    collapse(this: void, collapsed: boolean): void
+}
+
+export declare function DataFilter<Data extends {}>(
+    props: DataFilterProps<Data> & PublicProps,
+    ctx?: Pick<GenericCtx<DataFilterProps<Data>, DataFilterEmits<Data>, {}, DataFilterInst>, 'attrs' | 'emit' | 'slots'>,
+    expose?: (exposed?: GenericExposed<DataFilterInst>) => void,
+    setup?: GenericCtx<DataFilterProps<Data>, DataFilterEmits<Data>, {}, DataFilterInst>,
+): GenericReturn<DataFilterProps<Data>, DataFilterEmits<Data>, {}, DataFilterInst>
+
+export type DataTableProps<Data extends {}, KeyField extends keyof Data>
+    = Omit<NDataTableProps, 'columns' | 'rowKey' | 'data' | 'checkedRowKeys' | 'defaultCheckedRowKeys' | 'onUpdate:checkedRowKeys' | 'onUpdateCheckedRowKeys'> & {
+        columns?: TableColumn<Data>[] | undefined
+        data?: Data[] | undefined
+        keyField?: KeyField | undefined
+        selectedKeys?: Data[KeyField][] | undefined
+        sorter?: SortParams<Data> | undefined
+        onSort?: MaybeArray<(param: SortParams<Data>) => void> | undefined
+        onSelect?: MaybeArray<(param: NonNullable<Data[KeyField]>[]) => void> | undefined
+    }
+
+export type DataTableEmits<Data extends {}, KeyField extends keyof Data> = {
+    (e: 'sort', param: SortParams<Data>): void
+    (e: 'select', param: Data[KeyField][]): void
+}
+
+export type DataTableInst<Data extends {}, KeyField extends keyof Data> = NDataTableInst & {
+    scrollToView(rowKey: Data[KeyField]): void
+}
+
+export declare function DataTable<Data extends _DataWithPresetKeyField>(
+    props: DataTableProps<Data, PresetKeyField> & PublicProps,
+    ctx?: Pick<GenericCtx<DataTableProps<Data, PresetKeyField>, DataTableEmits<Data, PresetKeyField>, {}, DataTableInst<Data, PresetKeyField>>, 'attrs' | 'emit' | 'slots'>,
+    expose?: (exposed?: GenericExposed<DataTableInst<Data, PresetKeyField>>) => void,
+    setup?: GenericCtx<DataTableProps<Data, PresetKeyField>, DataTableEmits<Data, PresetKeyField>, {}, DataTableInst<Data, PresetKeyField>>,
+): GenericReturn<DataTableProps<Data, PresetKeyField>, DataTableEmits<Data, PresetKeyField>, {}, DataTableInst<Data, PresetKeyField>>
+
+export declare function DataTable<Data extends {}, KeyField extends keyof Data>(
+    props: DataTableProps<Data, KeyField> & PublicProps,
+    ctx?: Pick<GenericCtx<DataTableProps<Data, KeyField>, DataTableEmits<Data, KeyField>, {}, DataTableInst<Data, KeyField>>, 'attrs' | 'emit' | 'slots'>,
+    expose?: (exposed?: GenericExposed<DataTableInst<Data, KeyField>>) => void,
+    setup?: GenericCtx<DataTableProps<Data, KeyField>, DataTableEmits<Data, KeyField>, {}, DataTableInst<Data, KeyField>>,
+): GenericReturn<DataTableProps<Data, KeyField>, DataTableEmits<Data, KeyField>, {}, DataTableInst<Data, KeyField>>
+
+export declare function useDataTableDrag<T>(
+    tableRef: TemplateRef<HTMLElement>,
+    { data, onSort, ...options }: {
+        data: MaybeRef<T[]>
+        onSort: (info: { from: number, to: number }) => void
+    } & Omit<Sortable.Options, 'onSort'>
+): void
+
+export type DataPaginationProps = (PageParams | { page: PageParams }) & {
+    simple?: boolean | undefined
+    total: number
+    pageSizes?: number[] | undefined
+    onChange?: MaybeArray<(value: PageParams) => void> | undefined
+}
+
+export type DataPaginationEmits = {
+    (e: 'change', value: PageParams): void
+}
+
+export declare function DataPagination(
+    props: DataPaginationProps & PublicProps,
+    ctx?: Pick<GenericCtx<DataPaginationProps, DataPaginationEmits, {}, {}>, 'attrs' | 'emit' | 'slots'>,
+    expose?: (exposed?: GenericExposed<{}>) => void,
+    setup?: GenericCtx<DataPaginationProps, DataPaginationEmits, {}, {}>,
+): GenericReturn<DataPaginationProps, DataPaginationEmits, {}, {}>
+
+export type DataSelectionProps = {
+    'count': number
+    'modelValue': 'all' | 'selection'
+    'onClear'?: MaybeArray<() => void> | undefined
+    'onUpdate:modelValue'?: MaybeArray<(value: DataSelectionProps['modelValue']) => void> | undefined
+}
+
+export type DataSelectionEmits = {
+    (e: 'clear'): void
+    (e: 'update:modelValue', v: DataSelectionProps['modelValue']): void
+}
+
+export declare function DataSelection(
+    props: DataSelectionProps & PublicProps,
+    ctx?: Pick<GenericCtx<DataSelectionProps, DataSelectionEmits, {}, {}>, 'attrs' | 'emit' | 'slots'>,
+    expose?: (exposed?: GenericExposed<{}>) => void,
+    setup?: GenericCtx<DataSelectionProps, DataSelectionEmits, {}, {}>,
+): GenericReturn<DataSelectionProps, DataSelectionEmits, {}, {}>
+
+export type DataCustomProps<Data extends {}> = {
+    data: Data[]
+    hiddenField?: keyof Data | undefined
+    fixedField?: keyof Data | undefined
+    labelField?: keyof Data | undefined
+    keyField?: keyof Data | undefined
+    showFixed?: boolean | undefined
+    disabledField?: keyof Data | undefined
+    visiblityField?: keyof Data | undefined
+    labelTitle?: VNodeChild | undefined
+    onCustom?: MaybeArray<
+        ((reset: true) => void)
+        | ((sort: string[]) => void)
+        | ((modify: {
+            key: string
+            hidden?: boolean | undefined
+            fixed?: 'left' | 'right' | false | undefined
+        }) => void)>
+        | undefined
+}
+
+export type DataCustomEmits = {
+    (e: 'custom', reset: true): void
+    (e: 'custom', sort: string[]): void
+    (e: 'custom', modify: {
+        key: string
+        hidden?: boolean | undefined
+        fixed?: 'left' | 'right' | false | undefined
+    }): void
+}
+
+export declare function DataCustom<Data extends {}>(
+    props: DataCustomProps<Data> & PublicProps,
+    ctx?: Pick<GenericCtx<DataCustomProps<Data>, DataCustomEmits, {}, {}>, 'attrs' | 'emit' | 'slots'>,
+    expose?: (exposed?: GenericExposed<{}>) => void,
+    setup?: GenericCtx<DataCustomProps<Data>, DataCustomEmits, {}, {}>,
+): GenericReturn<DataCustomProps<Data>, DataCustomEmits, {}, {}>
+
+export type DataActionsProps = {
+    options?: TableActionRenderParam[] | undefined
+}
+
+export type DataActionsEmits = {}
+
+export declare function DataActions(
+    props: DataActionsProps & PublicProps,
+    ctx?: Pick<GenericCtx<DataActionsProps, DataActionsEmits, { default?: () => VNodeChild }, {}>, 'attrs' | 'emit' | 'slots'>,
+    expose?: (exposed?: GenericExposed<{}>) => void,
+    setup?: GenericCtx<DataActionsProps, DataActionsEmits, { default?: () => VNodeChild }, {}>,
+): GenericReturn<DataActionsProps, DataActionsEmits, { default?: () => VNodeChild }, {}>
+
+export type DataLocaleInputProps = {
+    'label'?: VNodeChild | (() => VNodeChild) | undefined
+    'modelValue'?: Record<string, string | undefined> | null | undefined
+    'supports'?: { label: string, value: string }[] | undefined
+    'defaultLang'?: string | undefined
+    'showLang'?: string | undefined
+    'disabled'?: boolean | undefined
+    'defaultRows'?: number | undefined
+    'onUpdate:modelValue'?: MaybeArray<(modelValue: Record<string, string | undefined> | null) => void> | undefined
+    'onUpdateModelValue'?: MaybeArray<(modelValue: Record<string, string | undefined> | null) => void> | undefined
+}
+
+export type DataLocaleInputEmits = {
+    (e: 'update:modelValue', modelValue: Record<string, string | undefined> | null | undefined): void
+    (e: 'updateModelValue', modelValue: Record<string, string | undefined> | null | undefined): void
+}
+
+export declare function DataLocaleInput(
+    props: DataLocaleInputProps & PublicProps,
+    ctx?: Pick<GenericCtx<DataLocaleInputProps, DataLocaleInputEmits, {}, {}>, 'attrs' | 'emit' | 'slots'>,
+    expose?: (exposed?: GenericExposed<{}>) => void,
+    setup?: GenericCtx<DataLocaleInputProps, DataLocaleInputEmits, {}, {}>,
+): GenericReturn<DataLocaleInputProps, DataLocaleInputEmits, {}, {}>
+
+export declare function useLocaleEdit(
+    title: VNodeChild | (() => VNodeChild),
+    onSubmit: (data: Record<string, string | undefined>) => void,
+    defaultRows?: MaybeRef<number | undefined>
+): {
+    open(this: void, data: MaybePromise<Record<string, string | undefined>>, readonly?: boolean): PromiseLike<Record<string, string | undefined>>
+    setSupports(this: void, supports: { label: string, value: string, required?: boolean }[]): void
+}
+
+export interface CheckboxesProps extends Omit<CheckboxGroupProps, 'value' | 'onUpdate:value' | 'defaultValue'> {
+    'options'?: DictItem[] | Record<string, unknown>[] | undefined
+    'vertical'?: boolean | undefined
+    'default'?: boolean | string | DictItem | undefined
+    'labelPadding'?: CSSProperties['padding']
+    'labelField'?: string | undefined
+    'valueField'?: string | undefined
+    'disabledField'?: string | undefined
+    'modelValue'?: string[] | number[] | null | undefined
+    'onUpdate:modelValue'?: MaybeArray<(modelValue: string[] | number[] | null) => void> | undefined
+    'onUpdateModelValue'?: MaybeArray<(modelValue: string[] | number[] | null) => void> | undefined
+}
+
+export interface CheckboxesEmits {
+    (e: 'update:modelValue', modelValue: string[] | number[] | null): void
+    (e: 'updateModelValue', modelValue: string[] | number[] | null): void
+}
+
+export declare function NCheckboxes(
+    props: CheckboxesProps & PublicProps,
+    ctx?: Pick<GenericCtx<CheckboxesProps, CheckboxesEmits, {}, {}>, 'attrs' | 'emit' | 'slots'>,
+    expose?: (exposed?: GenericExposed<{}>) => void,
+    setup?: GenericCtx<CheckboxesProps, CheckboxesEmits, {}, {}>,
+): GenericReturn<CheckboxesProps, CheckboxesEmits, {}, {}>
+
+export interface RadiosProps extends Omit<RadioGroupProps, 'value' | 'onUpdate:value' | 'defaultValue'> {
+    'options'?: DictItem[] | Record<string, unknown>[] | undefined
+    'type'?: 'radio' | 'button' | 'button-primary' | undefined
+    'vertical'?: boolean | undefined
+    'default'?: boolean | string | DictItem | undefined
+    'padding'?: CSSProperties['padding']
+    'labelField'?: string | undefined
+    'valueField'?: string | undefined
+    'disabledField'?: string | undefined
+    'modelValue'?: string | number | boolean | null | undefined
+    'onUpdate:modelValue'?: MaybeArray<(modelValue: string | number | boolean | null) => void> | undefined
+    'onUpdateModelValue'?: MaybeArray<(modelValue: string | number | boolean | null) => void> | undefined
+}
+
+export interface RadiosEmits {
+    (e: 'update:modelValue', modelValue: string | number | boolean | null): void
+    (e: 'updateModelValue', modelValue: string | number | boolean | null): void
+}
+
+export declare function NRadios(
+    props: RadiosProps & PublicProps,
+    ctx?: Pick<GenericCtx<RadiosProps, RadiosEmits, {}, {}>, 'attrs' | 'emit' | 'slots'>,
+    expose?: (exposed?: GenericExposed<{}>) => void,
+    setup?: GenericCtx<RadiosProps, RadiosEmits, {}, {}>,
+): GenericReturn<RadiosProps, RadiosEmits, {}, {}>
+
+export interface UserGroupOption {
+    code: string
+    name: string
+}
+export interface DeptOption {
+    code: string
+    name: string
+    children?: DeptOption[]
+}
+
+interface UserDeptProps<Multiple extends boolean> {
+    'type'?: 'user' | 'dept' | undefined
+    'selectType'?: 'dropdown' | 'dialog' | 'transfer' | undefined
+    'placeholder'?: string | undefined
+    'menuProps'?: HTMLAttributes | undefined
+    'multiple'?: Multiple | undefined
+    'defaultExpandAll'?: boolean | undefined
+    'filterable'?: boolean | undefined
+    'disabled'?: boolean | undefined
+    'size'?: TransferProps['size'] | undefined
+    'users'?: { username: string, nickname: string }[] | undefined
+    'groups'?: UserGroupOption[] | undefined
+    'depts'?: DeptOption[] | undefined
+    'getUsersByGroup'?: ((code: string) => Promise<{ username: string, nickname: string }[]>) | undefined
+    'getUsersByDept'?: ((code: string) => Promise<{ username: string, nickname: string }[]>) | undefined
+    'modelValue'?: Multiple extends true ? (string[] | null | undefined) : (string | null | undefined)
+    'onUpdate:modelValue'?: MaybeArray<(value: Multiple extends true ? string[] : string) => void> | undefined
+    'onUpdateModelValue'?: MaybeArray<(value: Multiple extends true ? string[] : string) => void> | undefined
+}
+
+interface UserDeptEmits<Multiple extends boolean> {
+    (e: 'update:modelValue', value: Multiple extends true ? string[] : string): void
+    (e: 'updateModelValue', value: Multiple extends true ? string[] : string): void
+}
+
+export declare const DtUserDept: <Multiple extends boolean>(
+    props: UserDeptProps<Multiple> & PublicProps,
+    ctx?: Pick<GenericCtx<UserDeptProps<Multiple>, UserDeptEmits<Multiple>>, 'attrs' | 'emit' | 'slots'>,
+    expose?: (exposed?: GenericExposed<{}>) => void,
+    setup?: GenericCtx<UserDeptProps<Multiple>, UserDeptEmits<Multiple>, {}, {}>,
+) => GenericReturn<UserDeptProps<Multiple>, UserDeptEmits<Multiple>, {}, {}>
+
+interface UserRenderProps {
+    value?: string | string[] | null | undefined
+    multiple?: boolean | undefined
+    max?: number | undefined
+    size?: number | undefined
+    placement?: PopoverProps['placement']
+    getUsersByUsername?: ((usernames: string[]) => Promise<{ username: string, nickname: string }[]>) | undefined
+}
+
+interface UserRenderEmits {
+}
+
+export declare const DtUserRender: (
+    props: UserRenderProps & PublicProps,
+    ctx?: Pick<GenericCtx<UserRenderProps, UserRenderEmits>, 'attrs' | 'emit' | 'slots'>,
+    expose?: (exposed?: GenericExposed<{}>) => void,
+    setup?: GenericCtx<UserRenderProps, UserRenderEmits, {}, {}>,
+) => GenericReturn<UserRenderProps, UserRenderEmits, {}, {}>
+
+interface DeptRenderProps {
+    value?: string | string[] | null | undefined
+    multiple?: boolean | undefined
+    getDeptsByCode?: (codes: string[]) => Promise<DeptOption[]>
+}
+
+interface DeptRenderEmits {
+}
+
+export declare const DtDeptRender: (
+    props: DeptRenderProps & PublicProps,
+    ctx?: Pick<GenericCtx<DeptRenderProps, DeptRenderEmits>, 'attrs' | 'emit' | 'slots'>,
+    expose?: (exposed?: GenericExposed<{}>) => void,
+    setup?: GenericCtx<DeptRenderProps, DeptRenderEmits, {}, {}>,
+) => GenericReturn<DeptRenderProps, DeptRenderEmits, {}, {}>