@ithinkdt/ui 4.0.0-10

package/README.md

@@ -0,0 +1 @@
+# @ithinkdt/ui

package/auto-imports.d.ts

@@ -0,0 +1,15 @@
+export declare const UIDirectives: {
+    type: 'directive'
+    resolve: (name: string) => string | undefined
+}[]
+
+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

@@ -0,0 +1,34 @@
+export const UIDirectives = [
+    {
+        type: 'directive',
+        resolve(name) {
+            return ['Spin', 'Tooltip'].includes(name)
+                ? { name: `v${name}`, from: '@ithinkdt/ui/directives' }
+                : undefined
+        },
+    },
+]
+
+export const UIComponents = [
+    {
+        type: 'component',
+        resolve(name) {
+            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/locale.d.ts

@@ -0,0 +1,74 @@
+export interface UILocale {
+    all: string
+    back: string
+    layout: {
+        sider: {
+            collapse: string
+            expand: string
+        }
+        screen: {
+            full: string
+            exitfull: string
+        }
+        mode: {
+            auto: string
+            light: string
+            dark: string
+        }
+        tabs: {
+            exitFullTab: string
+            fullTab: string
+            reloadTab: string
+            openTabBlank: string
+            closeAllTabs: string
+            closeLeftTabs: string
+            closeRightTabs: string
+            closeOtherTabs: string
+        }
+    }
+    account: {
+        logout: string
+        changePwd: string
+    }
+    notification: {
+        tip: (params: { count?: number | null }) => string
+        title: string
+        all: string
+        unread: (params: { count: string }) => string
+        markPageRead: string
+        markRead: string
+        markDelete: string
+        time: string
+    }
+    timeago: (params: { time: string | number | Date }) => string
+    page: {
+        selection: {
+            countText: (params: { count: number }) => string
+            back: string
+            view: string
+            clear: string
+        }
+        pagination: {
+            prefix: (params: { total: number }) => string
+            suffix: string
+        }
+        custom: {
+            tooltip: string
+            reset: string
+        }
+        form: {
+            submitText: string
+            resetText: string
+            cancelText: string
+            selectFileText: string
+        }
+        filter: {
+            submitText: string
+            expand: string
+            collapse: string
+        }
+    }
+}
+
+declare const locale: UILocale
+export default locale

package/package.json

@@ -0,0 +1,99 @@
+{
+  "name": "@ithinkdt/ui",
+  "version": "4.0.0-10",
+  "type": "module",
+  "license": "MIT",
+  "description": "iThinkDT UI",
+  "keywords": [
+    "ithinkdt",
+    "vue",
+    "ui"
+  ],
+  "files": [
+    "src",
+    "auto-imports.*",
+    "locale.*",
+    "unocss.*"
+  ],
+  "main": "./src/index.js",
+  "module": "./src/index.js",
+  "types": "./src/index.d.ts",
+  "exports": {
+    ".": {
+      "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"
+    },
+    "./auto-imports": {
+      "types": "./auto-imports.d.ts",
+      "default": "./auto-imports.js"
+    },
+    "./unocss": {
+      "types": "./unocss.d.ts",
+      "default": "./unocss.js"
+    }
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "sideEffects": false,
+  "dependencies": {
+    "@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-10"
+  },
+  "peerDependencies": {
+    "@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": {
+    "@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-10"
+  },
+  "scripts": {
+    "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, {}, {}>