@ithinkdt/ui 4.0.0-6 → 4.0.0-601

package/esm/components.d.ts

@@ -0,0 +1,523 @@
+import {
+    AnchorProps, ButtonProps, ButtonSlots, CheckboxGroupProps, DataTableInst as NDataTableInst, DataTableProps as NDataTableProps,
+    FlexProps, 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 { DescriptionItem, FormItem, PageParams, PresetKeyField, SortParams, TableActionRenderParam, TableColumn, ValidationResults, _DataWithPresetKeyField } from '@ithinkdt/page'
+
+declare module '@ithinkdt/page' {
+
+    interface FormRenderExtraOptions {
+        showColon?: MaybeRef<boolean | undefined>
+        labelWidth?: MaybeRef<string | number | undefined>
+        labelAlign?: MaybeRef<'left' | 'right' | 'center' | undefined>
+        labelPlacement?: MaybeRef<'left' | 'top' | undefined>
+        showRequireMark?: MaybeRef<boolean | undefined>
+        requireMarkPlacement?: MaybeRef<'left' | 'right' | 'right-hanging' | undefined>
+        showFeedback?: 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 NStateButtonProps = ButtonProps & {
+    succeeded?: boolean | null | undefined
+    successText?: string | undefined
+    failureText?: string | undefined
+}
+
+export type NStateButtonEmits = {
+    (e: 'click', evt: MouseEvent): void
+}
+
+export type NStateButtonSlots = ButtonSlots & {
+    success?: () => VNodeChild
+    failure?: () => VNodeChild
+    successIcon?: () => VNodeChild
+    failureIcon?: () => VNodeChild
+}
+
+export declare function NStateButton(
+    props: NStateButtonProps & PublicProps,
+    ctx?: Pick<GenericCtx<NStateButtonProps, NStateButtonEmits, NStateButtonSlots>, 'attrs' | 'emit' | 'slots'>,
+    expose?: (exposed?: GenericExposed) => void,
+    setup?: GenericCtx<NStateButtonProps, NStateButtonEmits, NStateButtonSlots>,
+): GenericReturn<NStateButtonProps, NStateButtonEmits, NStateButtonSlots>
+
+export type DataFormActionsProps = Pick<FlexProps, 'align' | 'justify' | 'vertical' | 'reverse'> & {
+    size?: 'small' | 'medium' | 'large' | undefined
+    gap?: number | string | undefined
+    submitText?: VNodeChild | undefined
+    resetText?: VNodeChild | undefined
+    cancelText?: VNodeChild | undefined
+    showSubmitBtn?: boolean | undefined
+    showResetBtn?: boolean | undefined
+    showCancelBtn?: boolean | undefined
+    submitDisabled?: boolean | undefined
+    submitLoading?: boolean | undefined
+    succeeded?: boolean | undefined
+    successText?: VNodeChild | undefined
+    failureText?: VNodeChild | undefined
+    onSubmit?: MaybeArray<() => void> | undefined
+    onRest?: MaybeArray<() => void> | undefined
+    onCancel?: MaybeArray<() => void> | undefined
+    nativeButtonType?: boolean | undefined
+}
+
+export type DataFormActionsEmits = {
+    (e: 'submit'): void
+    (e: 'reset'): void
+    (e: 'cancel'): void
+}
+
+export type DataFormActionsSlots = {
+    prefix?: () => VNodeChild
+    suffix?: () => VNodeChild
+}
+
+export declare function DataFormActions(
+    props: DataFormActionsProps & PublicProps,
+    ctx?: Pick<GenericCtx<DataFormActionsProps, DataFormActionsEmits, DataFormActionsSlots>, 'attrs' | 'emit' | 'slots'>,
+    expose?: (exposed?: GenericExposed) => void,
+    setup?: GenericCtx<DataFormActionsProps, DataFormActionsEmits, DataFormActionsSlots>,
+): GenericReturn<DataFormActionsProps, DataFormActionsEmits, DataFormActionsSlots>
+
+export type DataFormProps<Data extends {}> = Omit<NFormProps, 'model' | 'rules' | 'onSubmit' | 'validateMessages'>
+    & Omit<DataFormActionsProps, 'onSubmit' | 'size' | 'gap' | 'justify' | 'direction' | 'submitloading'> & {
+        items: FormItem<Data>[]
+        model: Data
+        readonly?: boolean | undefined
+        grid?: boolean | NGridProps | undefined
+        validation?: { [k in keyof Data]?: ValidationResults } | undefined
+        showColon?: boolean | undefined
+        tooltipPlacement?: 'bottom' | 'icon' | undefined
+        loading?: boolean | undefined
+        showAction?: boolean | NGridItemProps & AllowedComponentProps | undefined
+        actionJustify?: DataFormActionsProps['justify']
+        actionAlign?: DataFormActionsProps['align']
+        actionGap?: DataFormActionsProps['gap']
+        onSubmit?: MaybeArray<(model: Data) => void> | undefined
+    }
+
+export type DataFormEmits<Data extends {}> = {
+    (e: 'submit', model: Data): void
+    (e: 'reset'): void
+    (e: 'cancel'): void
+}
+
+export type DataFormSlots<_Data extends {}> = {
+    action?: (params: { cols: number, spans: number, overflow: boolean }) => VNodeChild
+    actionPrefix?: () => VNodeChild
+    actionSuffix?: () => 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
+        highlight?: boolean | 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
+    (e: 'highlight', rowKey: Data[KeyField]): void
+    (e: 'custom', params: { key: string, width: number }): 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
+    size?: number | undefined
+    type?: 'primary' | 'default' | 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
+    'mode'?: 'dialog' | 'list' | undefined
+    'defaultExpanded'?: boolean | 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 {
+    id?: string | undefined
+    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']
+    'valueField'?: 'id' | 'username' | 'code' | undefined
+    'users'?: { id?: string | undefined, 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 function 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, {}, {}>
+
+export interface DataDescriptionsProps<Data extends object> {
+    cols?: number
+    data: Data | undefined | null
+    items: DescriptionItem<Data>[]
+    title?: VNodeChild | ((data: Data | undefined) => VNodeChild)
+    anchor?: boolean | AnchorProps & AllowedComponentProps | undefined
+}
+
+export interface DataDescriptionsEmits {
+}
+
+export declare function DataDescriptions<Data extends {}>(
+    props: DataDescriptionsProps<Data> & PublicProps,
+    ctx?: Pick<GenericCtx<DataDescriptionsProps<Data>, DataDescriptionsEmits>, 'attrs' | 'emit' | 'slots'>,
+    expose?: (exposed?: GenericExposed<{}>) => void,
+    setup?: GenericCtx<DataDescriptionsProps<Data>, DataDescriptionsEmits, {}, {}>,
+): GenericReturn<DataDescriptionsProps<Data>, DataDescriptionsEmits, {}, {}>

package/esm/components.js

@@ -0,0 +1 @@
+export * from '../dist/components.js'