@aplus-frontend/ui 0.0.1-beta.3 → 0.0.1-beta.30

package/es/src/ap-field/interface.d.ts

@@ -1,16 +1,25 @@
-import { InputProps, CheckboxGroupProps, DatePickerProps } from 'ant-design-vue';
+import { InputProps, CheckboxGroupProps, DatePickerProps, InputNumberProps, RadioGroupProps, SwitchProps, TextAreaProps, SelectProps, PopconfirmProps } from 'ant-design-vue';
 import { InputFocusOptions } from 'ant-design-vue/es/vc-input/utils/commonUtils';
+import { ApFormatPresetType } from './date/interface';
+import { RangeValue } from 'ant-design-vue/es/vc-picker/interface';
+import { RangePickerProps } from 'ant-design-vue/es/date-picker/dayjs';
+import { LiteralUnion } from '../type';
 
 export type FieldMode = 'read' | 'edit';
 export type BasicApFieldProps<FieldPropsType = any> = {
     mode?: FieldMode;
 } & FieldPropsType;
+export type ApFieldComposedProps<FieldPropsType = any> = {
+    mode?: FieldMode;
+    fieldProps?: FieldPropsType;
+};
 export type ApFieldTextProps = BasicApFieldProps<InputProps> & {
     emptyText?: string;
 };
 export type ApFieldTextExpose = {
     focus: (options?: InputFocusOptions) => void;
     blur: () => void;
+    input: any;
     setSelectionRange: (start: number, end: number, direction?: 'forward' | 'backward' | 'none') => void;
     select: () => void;
 };
@@ -18,12 +27,66 @@ export type ApFieldCheckboxProps = BasicApFieldProps<CheckboxGroupProps> & {
     emptyText?: string;
     request?: () => Promise<CheckboxGroupProps['options']>;
 };
-export type ApFormatPresetType = 'Y' | 'Y-M' | 'Y-D' | 'Y-h' | 'Y-m' | 'Y-s';
-export type ApFieldDateProps = BasicApFieldProps<Omit<DatePickerProps, 'value' | 'onChange' | 'mode' | 'defaultValue' | 'format'>> & {
+export type ApFieldDateProps = ApFieldComposedProps<Omit<DatePickerProps, 'mode' | 'value' | 'defaultValue' | 'onChange' | 'onOk' | 'format' | 'onUpdate:value'>> & {
     emptyText?: string;
     value?: number | null;
-    defaultValue?: number | null;
+    defaultValue?: number;
     onChange?: (ts: number | null, dayStr: string) => void;
-    'update:value': (ts: number) => void;
-    format: ApFormatPresetType;
+    onOk?: (ts: number | null) => void;
+    format?: LiteralUnion<ApFormatPresetType, string>;
+};
+export type ApFieldNumberProps = BasicApFieldProps<InputNumberProps> & {
+    emptyText?: string;
+    /**
+     * 是否展示千分位，只读模式可用
+     */
+    thousands?: boolean;
+    /**
+     * 强制保留指定的小数位，只读模式可用，只有在设置了`precision`才生效
+     */
+    limitDecimalsRetain?: boolean;
+};
+export type ApiFieldNumberExpose = {
+    focus: () => void;
+    blur: () => void;
+};
+export type ApFieldRadioProps = BasicApFieldProps<RadioGroupProps> & {
+    emptyText?: string;
+    request?: () => Promise<RadioGroupProps['options']>;
+};
+export type ApiFieldRadioExpose = {
+    focus: () => void;
+    blur: () => void;
+};
+export type ApFieldSwitchProps = BasicApFieldProps<Omit<SwitchProps, 'onClick'>> & {
+    emptyText?: string;
+    onAction?: (checked: string | boolean | number, e?: Event) => boolean | Promise<boolean>;
+    confirm?: Pick<PopconfirmProps, 'title' | 'okText' | 'cancelText' | 'description' | 'showCancel' | 'icon' | 'okType' | 'onCancel'>;
+};
+export type ApFieldTextAreaProps = BasicApFieldProps<TextAreaProps> & {
+    emptyText?: string;
+};
+export type ApFieldTextAreaExpose = {
+    focus: (options?: InputFocusOptions) => void;
+    blur: () => void;
+    resizableTextArea: any;
+};
+export type ApFieldDateRangeProps = ApFieldComposedProps<Omit<RangePickerProps, 'value' | 'onChange' | 'onPanelChange' | 'defaultValue' | 'onOk' | 'renderExtraFooter' | 'onUpdate:value'>> & {
+    emptyText?: string;
+    value?: RangeValue<number>;
+    defaultValue?: RangeValue<number>;
+    onChange?: (ts: RangeValue<number>, dayStr: [string, string]) => void;
+    onOk?: (ts: RangeValue<number>) => void;
+    format?: LiteralUnion<ApFormatPresetType, string>;
+};
+export type ApFieldSelectProps = ApFieldComposedProps<Omit<SelectProps, 'mode' | 'value' | 'onUpdate:value' | 'onSearch'>> & {
+    emptyText?: string;
+    request?: (value?: string) => Promise<SelectProps['options']>;
+    multiple?: boolean;
+    value?: SelectProps['value'];
+    'onUpdate:value'?: SelectProps['onUpdate:value'];
+};
+export type ApFieldSelectSlots = {
+    focus: () => void;
+    blur: () => void;
 };

package/es/src/ap-field/interface.mjs

@@ -0,0 +1 @@
+

package/es/src/ap-field/number/helper.d.ts

@@ -0,0 +1 @@
+export declare function addZeroToDecimalPlaces(numStr: string, precision?: number): string;

package/es/src/ap-field/number/helper.mjs

@@ -0,0 +1,14 @@
+import { isNil as i } from "lodash-unified";
+function a(t, r) {
+  if (i(r))
+    return t;
+  let [f, e = ""] = t.split(".");
+  if (e.length >= r)
+    return t;
+  for (let l = e.length; l < r; l++)
+    e += "0";
+  return f + "." + e;
+}
+export {
+  a as addZeroToDecimalPlaces
+};

package/es/src/ap-field/number/index.vue.d.ts

@@ -0,0 +1,72 @@
+import { ApFieldNumberProps } from '../interface';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ExtractPropTypes, PropType } from 'vue';
+import { ValueType } from 'ant-design-vue/es/input-number/src/utils/MiniDecimal';
+
+type ApFieldNumberSlots = {
+    addonBefore?: any;
+    addonAfter?: any;
+    prefix?: any;
+    default?: any;
+    upIcon?: any;
+    downIcon?: any;
+};
+declare function focus(): void;
+declare function blur(): void;
+declare const _default: __VLS_WithTemplateSlots< DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<ApFieldNumberProps>, {
+    emptyText: string;
+    thousands: boolean;
+    bordered: boolean;
+    controls: boolean;
+    keyboard: boolean;
+    max: number;
+    min: number;
+    step: number;
+}>, {
+    focus: typeof focus;
+    blur: typeof blur;
+}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    "update:value": (...args: any[]) => void;
+}, string, PublicProps, Readonly< ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<ApFieldNumberProps>, {
+    emptyText: string;
+    thousands: boolean;
+    bordered: boolean;
+    controls: boolean;
+    keyboard: boolean;
+    max: number;
+    min: number;
+    step: number;
+}>>> & {
+    "onUpdate:value"?: ((...args: any[]) => any) | undefined;
+}, {
+    keyboard: boolean;
+    bordered: boolean;
+    min: ValueType;
+    max: ValueType;
+    step: ValueType;
+    controls: boolean;
+    emptyText: string;
+    thousands: boolean;
+}, {}>, Readonly<ApFieldNumberSlots> & ApFieldNumberSlots>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/es/src/ap-field/number/index.vue.mjs

@@ -0,0 +1,106 @@
+import { defineComponent as h, ref as C, computed as x, unref as o, openBlock as r, createElementBlock as n, Fragment as N, normalizeClass as d, renderSlot as s, createCommentVNode as m, createElementVNode as V, toDisplayString as $, createBlock as D, mergeProps as P, createSlots as R, renderList as A, withCtx as I, normalizeProps as U, guardReactiveProps as z } from "vue";
+import { InputNumber as E } from "ant-design-vue";
+import "../../hooks/index.mjs";
+import { isNil as F, omit as M } from "lodash-unified";
+import { toDecimalMark as T } from "@fruits-chain/utils";
+import { addZeroToDecimalPlaces as _ } from "./helper.mjs";
+import "../../config-provider/index.mjs";
+import "./style.css";
+import { useNamespace as w } from "../../config-provider/hooks/use-namespace.mjs";
+import { useControllableValue as L } from "../../hooks/useControllableValue.mjs";
+const Y = /* @__PURE__ */ h({
+  name: "ApFieldNumber",
+  __name: "index",
+  props: {
+    mode: {},
+    size: {},
+    bordered: { type: Boolean, default: !0 },
+    placeholder: {},
+    name: {},
+    id: {},
+    type: {},
+    addonBefore: {},
+    addonAfter: {},
+    prefix: {},
+    "onUpdate:value": {},
+    valueModifiers: {},
+    status: {},
+    stringMode: { type: Boolean },
+    defaultValue: {},
+    value: {},
+    prefixCls: {},
+    min: { default: -1 / 0 },
+    max: { default: 1 / 0 },
+    step: { default: 1 },
+    tabindex: {},
+    controls: { type: Boolean, default: !0 },
+    readonly: { type: Boolean },
+    disabled: { type: Boolean },
+    autofocus: { type: Boolean },
+    keyboard: { type: Boolean, default: !0 },
+    parser: {},
+    formatter: {},
+    precision: {},
+    decimalSeparator: {},
+    onInput: {},
+    onChange: {},
+    onPressEnter: {},
+    onStep: {},
+    onBlur: {},
+    onFocus: {},
+    emptyText: { default: "-" },
+    thousands: { type: Boolean, default: !1 },
+    limitDecimalsRetain: { type: Boolean }
+  },
+  emits: ["update:value"],
+  setup(f, { expose: c, emit: y }) {
+    const v = y, { b: i } = w("field-number"), t = f, l = C(), { value: u, updateValue: B } = L(
+      t,
+      v
+    ), b = x(() => {
+      let e = o(u);
+      if (F(e))
+        return t.emptyText;
+      let a = t.thousands ? T(e, t.precision) : String(e);
+      return t.precision && t.limitDecimalsRetain && (a = _(a, t.precision)), a;
+    });
+    function k() {
+      var e;
+      (e = l.value) == null || e.focus();
+    }
+    function g() {
+      var e;
+      (e = l.value) == null || e.blur();
+    }
+    return c({ focus: k, blur: g }), (e, a) => e.mode === "read" ? (r(), n(N, { key: 0 }, [
+      e.$slots.prefix ? (r(), n("span", {
+        key: 0,
+        class: d(o(i)("label-left"))
+      }, [
+        s(e.$slots, "prefix")
+      ], 2)) : m("", !0),
+      V("span", null, $(b.value), 1),
+      e.$slots.addonAfter ? (r(), n("span", {
+        key: 1,
+        class: d(o(i)("label-right"))
+      }, [
+        s(e.$slots, "addonAfter")
+      ], 2)) : m("", !0)
+    ], 64)) : (r(), D(o(E), P({ key: 1 }, o(M)(t, ["value", "onUpdate:value"]), {
+      value: o(u),
+      "onUpdate:value": o(B),
+      ref_key: "inputRef",
+      ref: l
+    }), R({ _: 2 }, [
+      A(e.$slots, (Z, p) => ({
+        name: p,
+        fn: I((S) => [
+          s(e.$slots, p, U(z(S || {})))
+        ])
+      }))
+    ]), 1040, ["value", "onUpdate:value"]));
+  }
+});
+export {
+  Y as default
+};

package/es/src/ap-field/number/index.vue2.mjs

@@ -0,0 +1,4 @@
+import f from "./index.vue.mjs";
+export {
+  f as default
+};

package/es/src/ap-field/number/style.css

@@ -0,0 +1,6 @@
+.aplus-field-number-label-left {
+  padding-right: 4px;
+}
+.aplus-field-number-label-right {
+  padding-left: 4px;
+}

package/es/src/ap-field/radio/helper.d.ts

@@ -0,0 +1,4 @@
+import { RadioGroupChildOption } from 'ant-design-vue/es/radio/Group';
+
+export declare const getOptionValue: (v: RadioGroupChildOption | string | number) => any;
+export declare const getOptionLabel: (v: RadioGroupChildOption | string | number) => any;

package/es/src/ap-field/radio/helper.mjs

@@ -0,0 +1,5 @@
+const t = (e) => typeof e == "object" ? e.value : e, o = (e) => typeof e == "object" ? e.label : e;
+export {
+  o as getOptionLabel,
+  t as getOptionValue
+};

package/es/src/ap-field/radio/index.vue.d.ts

@@ -0,0 +1,40 @@
+import { ApFieldRadioProps, FieldMode } from '../interface';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ExtractPropTypes, PropType } from 'vue';
+
+declare function focus(): void;
+declare function blur(): void;
+declare const _default: DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<ApFieldRadioProps>, {
+    emptyText: string;
+    mode: string;
+}>, {
+    focus: typeof focus;
+    blur: typeof blur;
+}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    "update:value": (...args: any[]) => void;
+}, string, PublicProps, Readonly< ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<ApFieldRadioProps>, {
+    emptyText: string;
+    mode: string;
+}>>> & {
+    "onUpdate:value"?: ((...args: any[]) => any) | undefined;
+}, {
+    mode: FieldMode;
+    emptyText: string;
+}, {}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/es/src/ap-field/radio/index.vue.mjs

@@ -0,0 +1,74 @@
+import { defineComponent as V, ref as i, onMounted as q, computed as B, unref as o, openBlock as n, createElementBlock as m, Fragment as d, createTextVNode as C, toDisplayString as R, createBlock as f, mergeProps as U } from "vue";
+import { Spin as h, RadioGroup as G } from "ant-design-vue";
+import "../../hooks/index.mjs";
+import { isNil as S, omit as z } from "lodash-unified";
+import { getOptionValue as F, getOptionLabel as N } from "./helper.mjs";
+import { useControllableValue as O } from "../../hooks/useControllableValue.mjs";
+const j = /* @__PURE__ */ V({
+  name: "ApFieldRadio",
+  __name: "index",
+  props: {
+    mode: { default: "edit" },
+    prefixCls: {},
+    value: {},
+    size: {},
+    options: {},
+    disabled: { type: Boolean },
+    name: {},
+    buttonStyle: {},
+    id: {},
+    optionType: {},
+    onChange: {},
+    "onUpdate:value": {},
+    emptyText: { default: "-" },
+    request: {}
+  },
+  emits: ["update:value"],
+  setup(c, { expose: v, emit: y }) {
+    const t = c, g = y, u = i(), l = i((t == null ? void 0 : t.options) || []), { value: s, updateValue: x } = O(t, g), r = i(!1);
+    q(() => {
+      var e;
+      t.request && (r.value = !0, (e = t.request) == null || e.call(t).then((a) => l.value = a).finally(() => {
+        r.value = !1;
+      }));
+    });
+    const k = B(() => {
+      var p;
+      const e = o(s);
+      if (S(e))
+        return t.emptyText;
+      const a = (p = l.value) == null ? void 0 : p.find(
+        (_) => e === F(_)
+      );
+      return N(a) || t.emptyText;
+    });
+    function b() {
+      var e;
+      (e = u.value) == null || e.focus();
+    }
+    function T() {
+      var e;
+      (e = u.value) == null || e.blur();
+    }
+    return v({
+      focus: b,
+      blur: T
+    }), (e, a) => e.mode === "read" ? (n(), m(d, { key: 0 }, [
+      C(R(k.value), 1)
+    ], 64)) : (n(), m(d, { key: 1 }, [
+      r.value ? (n(), f(o(h), {
+        key: 0,
+        size: "small"
+      })) : (n(), f(o(G), U({ key: 1 }, o(z)(t, ["value", "onUpdate:value", "options", "request"]), {
+        value: o(s),
+        "onUpdate:value": o(x),
+        options: l.value,
+        ref_key: "radioGroupRef",
+        ref: u
+      }), null, 16, ["value", "onUpdate:value", "options"]))
+    ], 64));
+  }
+});
+export {
+  j as default
+};

package/es/src/ap-field/radio/index.vue2.mjs

@@ -0,0 +1,4 @@
+import f from "./index.vue.mjs";
+export {
+  f as default
+};

package/es/src/ap-field/select/index.vue.d.ts

@@ -0,0 +1,235 @@
+import { DefaultOptionType, SelectValue, LabeledValue } from 'ant-design-vue/es/select';
+import { ApFieldSelectProps, FieldMode } from '../interface';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ExtractPropTypes, PropType, CSSProperties } from 'vue';
+import { VueTypeValidableDef } from '../../../node_modules/vue-types';
+import { ButtonSize } from 'ant-design-vue/es/button';
+import { VueNode } from 'ant-design-vue/es/_util/type';
+import { SelectHandler, FieldNames, FilterFunc } from 'ant-design-vue/es/vc-select/Select';
+import { RenderDOMFunc, DropdownRender, CustomTagProps } from 'ant-design-vue/es/vc-select/BaseSelect';
+import { AlignType } from 'ant-design-vue/es/vc-trigger/interface';
+
+type ApFieldSelectSlots = {
+    notFoundContent: any;
+    suffixIcon: any;
+    itemIcon: any;
+    removeIcon: any;
+    clearIcon: any;
+    dropdownRender: any;
+    option: any;
+    placeholder: any;
+    tagRender: any;
+    maxTagPlaceholder: any;
+    optionLabel: any;
+    default: any;
+};
+declare function focus(): void;
+declare function blur(): void;
+declare const _default: __VLS_WithTemplateSlots< DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<ApFieldSelectProps>, {
+    fieldProps: () => {};
+    emptyText: string;
+    mode: string;
+}>, {
+    focus: typeof focus;
+    blur: typeof blur;
+}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    "update:value": (...args: any[]) => void;
+}, string, PublicProps, Readonly< ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<ApFieldSelectProps>, {
+    fieldProps: () => {};
+    emptyText: string;
+    mode: string;
+}>>> & {
+    "onUpdate:value"?: ((...args: any[]) => any) | undefined;
+}, {
+    mode: FieldMode;
+    emptyText: string;
+    fieldProps: Omit<Partial< ExtractPropTypes<{
+        value: {
+            type: PropType<SelectValue>;
+            default: SelectValue;
+        };
+        defaultValue: {
+            type: PropType<SelectValue>;
+            default: SelectValue;
+        };
+        notFoundContent: VueTypeValidableDef<any>;
+        suffixIcon: VueTypeValidableDef<any>;
+        itemIcon: VueTypeValidableDef<any>;
+        size: {
+            type: PropType<ButtonSize>;
+            default: ButtonSize;
+        };
+        mode: {
+            type: PropType<"multiple" | "tags" | "SECRET_COMBOBOX_MODE_DO_NOT_USE">;
+            default: "multiple" | "tags" | "SECRET_COMBOBOX_MODE_DO_NOT_USE";
+        };
+        bordered: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        transitionName: StringConstructor;
+        choiceTransitionName: {
+            type: PropType<"">;
+            default: "";
+        };
+        popupClassName: StringConstructor;
+        dropdownClassName: StringConstructor;
+        placement: {
+            type: PropType<"bottomLeft" | "bottomRight" | "topLeft" | "topRight">;
+            default: "bottomLeft" | "bottomRight" | "topLeft" | "topRight";
+        };
+        status: {
+            type: PropType<"" | "error" | "warning">;
+            default: "" | "error" | "warning";
+        };
+        'onUpdate:value': {
+            type: PropType<(val: SelectValue) => void>;
+            default: (val: SelectValue) => void;
+        };
+        children: PropType< VueNode[]>;
+        listHeight: NumberConstructor;
+        onMouseenter: PropType<(e: MouseEvent) => void>;
+        onMouseleave: PropType<(e: MouseEvent) => void>;
+        tabindex: NumberConstructor;
+        onClick: PropType<(e: MouseEvent) => void>;
+        onFocus: {
+            type: PropType<(e: FocusEvent) => void>;
+        };
+        onBlur: {
+            type: PropType<(e: FocusEvent) => void>;
+        };
+        onChange: PropType<(value: SelectValue, option: DefaultOptionType | DefaultOptionType[]) => void>;
+        onKeydown: PropType<(e: KeyboardEvent) => void>;
+        onKeyup: PropType<(e: KeyboardEvent) => void>;
+        onMousedown: PropType<(e: MouseEvent) => void>;
+        onSelect: PropType<SelectHandler<(string | number) | LabeledValue, DefaultOptionType>>;
+        open: {
+            type: BooleanConstructor;
+            default: any;
+        };
+        animation: StringConstructor;
+        direction: {
+            type: PropType<"ltr" | "rtl">;
+        };
+        disabled: {
+            type: BooleanConstructor;
+            default: any;
+        };
+        prefixCls: StringConstructor;
+        id: StringConstructor;
+        autofocus: BooleanConstructor;
+        getPopupContainer: {
+            type: PropType<RenderDOMFunc>;
+        };
+        virtual: {
+            type: BooleanConstructor;
+            default: any;
+        };
+        dropdownMatchSelectWidth: {
+            type: PropType<number | boolean>;
+            default: any;
+        };
+        options: PropType<DefaultOptionType[]>;
+        showAction: {
+            type: PropType<("click" | "focus")[]>;
+        };
+        placeholder: VueTypeValidableDef<any>;
+        onDeselect: PropType<SelectHandler<(string | number) | LabeledValue, DefaultOptionType>>;
+        loading: {
+            type: BooleanConstructor;
+            default: any;
+        };
+        clearIcon: VueTypeValidableDef<any>;
+        allowClear: {
+            type: BooleanConstructor;
+            default: any;
+        };
+        onSearch: PropType<(value: string) => void>;
+        fieldNames: PropType<FieldNames>;
+        dropdownStyle: {
+            type: PropType<CSSProperties>;
+        };
+        dropdownRender: {
+            type: PropType<DropdownRender>;
+        };
+        dropdownAlign: PropType<AlignType>;
+        showSearch: {
+            type: BooleanConstructor;
+            default: any;
+        };
+        searchValue: StringConstructor;
+        onInputKeyDown: PropType<(e: KeyboardEvent) => void>;
+        removeIcon: VueTypeValidableDef<any>;
+        maxTagCount: {
+            type: PropType<number | "responsive">;
+        };
+        maxTagTextLength: NumberConstructor;
+        maxTagPlaceholder: VueTypeValidableDef<any>;
+        tokenSeparators: {
+            type: PropType<string[]>;
+        };
+        tagRender: {
+            type: PropType<(props: CustomTagProps) => any>;
+        };
+        optionLabelRender: {
+            type: PropType<(option: Record<string, any>) => any>;
+        };
+        onClear: PropType<() => void>;
+        defaultOpen: {
+            type: BooleanConstructor;
+            default: any;
+        };
+        onDropdownVisibleChange: {
+            type: PropType<(open: boolean) => void>;
+        };
+        showArrow: {
+            type: BooleanConstructor;
+            default: any;
+        };
+        onPopupScroll: PropType<(e: UIEvent) => void>;
+        menuItemSelectedIcon: VueTypeValidableDef<any>;
+        listItemHeight: NumberConstructor;
+        inputValue: StringConstructor;
+        autoClearSearchValue: {
+            type: BooleanConstructor;
+            default: any;
+        };
+        filterOption: {
+            type: PropType<boolean | FilterFunc<DefaultOptionType>>;
+            default: any;
+        };
+        filterSort: PropType<(optionA: DefaultOptionType, optionB: DefaultOptionType) => number>;
+        optionFilterProp: StringConstructor;
+        optionLabelProp: StringConstructor;
+        defaultActiveFirstOption: {
+            type: BooleanConstructor;
+            default: any;
+        };
+        labelInValue: {
+            type: BooleanConstructor;
+            default: any;
+        };
+    }>>, "mode" | "value" | "onUpdate:value" | "onSearch">;
+}, {}>, Readonly<ApFieldSelectSlots> & ApFieldSelectSlots>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};