@aplus-frontend/ui 0.0.1-beta.5 → 0.0.1-beta.7

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

@@ -0,0 +1,108 @@
+import { defineComponent as C, ref as S, computed as N, unref as o, openBlock as r, createElementBlock as n, Fragment as V, normalizeClass as m, renderSlot as i, createCommentVNode as d, createElementVNode as $, toDisplayString as x, createBlock as A, mergeProps as D, createSlots as P, renderList as R, withCtx as I, normalizeProps as z, guardReactiveProps as E } from "vue";
+import { InputNumber as F } from "ant-design-vue";
+import "../../hooks/useMessage.mjs";
+import { useControllableValue as M } from "../../hooks/useControllableValue.mjs";
+import { isNil as T, omit as U } from "lodash-unified";
+import { toDecimalMark as w } from "@fruits-chain/utils";
+import { addZeroToDecimalPlaces as L } from "./helper.mjs";
+import "../../config-provider/index.mjs";
+import "./style.css";
+import { useNamespace as Z } from "../../config-provider/hooks/use-namespace.mjs";
+const Y = /* @__PURE__ */ C({
+  name: "ApFieldNumber",
+  inheritAttrs: !1,
+  __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: s } = Z("field-number"), t = f, l = S(), { value: p, updateValue: B } = M(
+      t,
+      v
+    ), b = N(() => {
+      let e = o(p);
+      if (T(e))
+        return t.emptyText;
+      let a = w(e, t.precision);
+      return t.precision && t.limitDecimalsRetain && (a = L(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(V, { key: 0 }, [
+      e.$slots.prefix ? (r(), n("span", {
+        key: 0,
+        class: m(o(s)("label-left"))
+      }, [
+        i(e.$slots, "prefix")
+      ], 2)) : d("", !0),
+      $("span", null, x(b.value), 1),
+      e.$slots.addonAfter ? (r(), n("span", {
+        key: 1,
+        class: m(o(s)("label-right"))
+      }, [
+        i(e.$slots, "addonAfter")
+      ], 2)) : d("", !0)
+    ], 64)) : (r(), A(o(F), D({ key: 1 }, o(U)(t, ["precision", "value", "update:value"]), {
+      value: o(p),
+      "onUpdate:value": o(B),
+      precision: e.precision,
+      ref_key: "inputRef",
+      ref: l
+    }), P({ _: 2 }, [
+      R(e.$slots, (_, u) => ({
+        name: u,
+        fn: I((h) => [
+          i(e.$slots, u, z(E(h || {})))
+        ])
+      }))
+    ]), 1040, ["value", "onUpdate:value", "precision"]));
+  }
+});
+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,68 @@
+import { defineComponent as b, ref as i, onMounted as k, computed as T, unref as o, openBlock as p, createElementBlock as _, Fragment as V, createTextVNode as h, toDisplayString as B, createBlock as C, mergeProps as R } from "vue";
+import { RadioGroup as G } from "ant-design-vue";
+import "../../hooks/useMessage.mjs";
+import { useControllableValue as U } from "../../hooks/useControllableValue.mjs";
+import { isNil as q, omit as A } from "lodash-unified";
+import { getOptionValue as F, getOptionLabel as N } from "./helper.mjs";
+const M = /* @__PURE__ */ b({
+  name: "ApFieldRadio",
+  inheritAttrs: !1,
+  __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(s, { expose: m, emit: d }) {
+    const t = s, f = d, n = i(), u = i((t == null ? void 0 : t.options) || []), { value: l, updateValue: c } = U(t, f);
+    k(() => {
+      var e;
+      (e = t.request) == null || e.call(t).then((a) => u.value = a);
+    });
+    const v = T(() => {
+      var r;
+      const e = o(l);
+      if (q(e))
+        return t.emptyText;
+      const a = (r = u.value) == null ? void 0 : r.find(
+        (g) => e === F(g)
+      );
+      return N(a) || t.emptyText;
+    });
+    function y() {
+      var e;
+      (e = n.value) == null || e.focus();
+    }
+    function x() {
+      var e;
+      (e = n.value) == null || e.blur();
+    }
+    return m({
+      focus: y,
+      blur: x
+    }), (e, a) => e.mode === "read" ? (p(), _(V, { key: 0 }, [
+      h(B(v.value), 1)
+    ], 64)) : (p(), C(o(G), R({ key: 1 }, o(A)(t, ["value", "update:value", "options"]), {
+      value: o(l),
+      "onUpdate:value": o(c),
+      options: u.value,
+      ref_key: "radioGroupRef",
+      ref: n
+    }), null, 16, ["value", "onUpdate:value", "options"]));
+  }
+});
+export {
+  M 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;
+    };
+};

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

@@ -0,0 +1,114 @@
+import { defineComponent as B, ref as d, onMounted as C, computed as v, unref as a, openBlock as h, createElementBlock as V, toDisplayString as T, createBlock as I, mergeProps as M, createSlots as R, renderList as U, withCtx as y, renderSlot as z, normalizeProps as N, guardReactiveProps as $, createVNode as j } from "vue";
+import { debounce as D, isFunction as P, isArray as E, isNil as L } from "lodash-unified";
+import { Select as G, Spin as H } from "ant-design-vue";
+import "../../hooks/useMessage.mjs";
+import { useControllableValue as J } from "../../hooks/useControllableValue.mjs";
+const K = { key: 0 }, ee = /* @__PURE__ */ B({
+  name: "ApFieldSelect",
+  __name: "index",
+  props: {
+    mode: { default: "edit" },
+    fieldProps: { default: () => ({}) },
+    emptyText: { default: "-" },
+    request: {},
+    multiple: { type: Boolean },
+    value: {},
+    "onUpdate:value": {}
+  },
+  emits: ["update:value"],
+  setup(S, { expose: g, emit: F }) {
+    var p, m;
+    let s = 0;
+    const b = (e, l) => typeof (l == null ? void 0 : l.label) == "string" && l.label.indexOf(e) > -1, w = D((e) => {
+      if (!P(t.request))
+        return;
+      s += 1;
+      const l = s;
+      u.value = [], n.value = !0, t.request(e).then((o) => {
+        s === l && (u.value = o);
+      }).finally(() => {
+        n.value = !1;
+      });
+    }, 300), t = S, u = d(((p = t.fieldProps) == null ? void 0 : p.options) || []), f = d(), n = d(((m = t.fieldProps) == null ? void 0 : m.loading) || !1), k = F;
+    C(() => {
+      if (P(t.request)) {
+        n.value = !0, s += 1;
+        const e = s;
+        t.request().then((l) => {
+          e === s && (u.value = l);
+        }).finally(() => {
+          n.value = !1;
+        });
+      }
+    });
+    const { value: c, updateValue: _ } = J(t, k), x = v(() => {
+      const e = a(c);
+      if (!e)
+        return t.emptyText;
+      if (E(e))
+        return e.map(
+          (o) => {
+            var r;
+            return (r = a(u).find((i) => i.value === o)) == null ? void 0 : r.label;
+          }
+        ).filter(Boolean).join("、") || t.emptyText;
+      const l = a(u).find((o) => o.value === e);
+      return (l == null ? void 0 : l.label) || t.emptyText;
+    }), O = v(() => {
+      var o, r, i;
+      const l = !!((o = t.fieldProps) != null && o.showSearch) ? {
+        showArrow: !1,
+        defaultActiveFirstOption: !1,
+        onSearch: w,
+        notFoundContent: n.value ? void 0 : null
+      } : {
+        showArrow: !0
+      };
+      return {
+        ...t.fieldProps,
+        ...l,
+        filterOption: t.fieldProps.showSearch ? !1 : L((r = t.fieldProps) == null ? void 0 : r.filterOption) ? b : (i = t.fieldProps) == null ? void 0 : i.filterOption
+      };
+    });
+    function q() {
+      var e;
+      (e = f.value) == null || e.focus();
+    }
+    function A() {
+      var e;
+      (e = f.value) == null || e.blur();
+    }
+    return g({
+      focus: q,
+      blur: A
+    }), (e, l) => e.mode === "read" ? (h(), V("span", K, T(x.value), 1)) : (h(), I(a(G), M({
+      key: 1,
+      "allow-clear": "",
+      ref_key: "selectRef",
+      ref: f
+    }, O.value, {
+      mode: e.multiple ? "multiple" : void 0,
+      value: a(c),
+      "onUpdate:value": a(_),
+      options: u.value,
+      loading: n.value
+    }), R({ _: 2 }, [
+      U(e.$slots, (o, r) => ({
+        name: r,
+        fn: y((i) => [
+          z(e.$slots, r, N($(i || {})))
+        ])
+      })),
+      n.value ? {
+        name: "notFoundContent",
+        fn: y(() => [
+          j(a(H), { size: "small" })
+        ]),
+        key: "0"
+      } : void 0
+    ]), 1040, ["mode", "value", "onUpdate:value", "options", "loading"]));
+  }
+});
+export {
+  ee as default
+};

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

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

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

@@ -0,0 +1,54 @@
+import { ApFieldSwitchProps } from '../interface';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ExtractPropTypes, PropType } from 'vue';
+
+type ApFieldSwitch = {
+    checkedChildren: any;
+    unCheckedChildren: any;
+    default: any;
+};
+declare const _default: __VLS_WithTemplateSlots< DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<ApFieldSwitchProps>, {
+    emptyText: string;
+    checkedValue: boolean;
+    unCheckedValue: boolean;
+    size: string;
+    loading: undefined;
+}>, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    "update:checked": (...args: any[]) => void;
+}, string, PublicProps, Readonly< ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<ApFieldSwitchProps>, {
+    emptyText: string;
+    checkedValue: boolean;
+    unCheckedValue: boolean;
+    size: string;
+    loading: undefined;
+}>>> & {
+    "onUpdate:checked"?: ((...args: any[]) => any) | undefined;
+}, {
+    loading: boolean;
+    size: "default" | "small";
+    checkedValue: string | number | boolean;
+    unCheckedValue: string | number | boolean;
+    emptyText: string;
+}, {}>, Readonly<ApFieldSwitch> & ApFieldSwitch>;
+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;
+    };
+};