@maxtropy/v-components 0.1.12-beta.5 → 0.1.12-beta.6

package/es/components/checkbox/MxCheckbox.css

@@ -0,0 +1,35 @@
+.mx-checkbox.el-checkbox[data-v-9157b884] {
+  --el-checkbox-text-color: rgba(255, 255, 255, 0.65);
+  --el-checkbox-checked-text-color: var(--el-checkbox-text-color);
+  --el-border-color: rgba(0, 173, 255, 0.5);
+  --el-color-primary: #4a90e2;
+  margin-right: 24px;
+}
+.mx-checkbox.el-checkbox[data-v-9157b884] .el-checkbox__inner {
+  --el-checkbox-bg-color: transparent;
+  --el-checkbox-disabled-input-fill: rgba(255, 255, 255, 0.05);
+  --el-checkbox-disabled-border-color: rgba(255, 255, 255, 0.2);
+  --el-checkbox-disabled-checked-input-fill: var(--el-checkbox-disabled-input-fill);
+  --el-checkbox-disabled-checked-input-border-color: var(--el-checkbox-disabled-border-color);
+  --el-checkbox-disabled-checked-icon-color: var(--el-checkbox-disabled-border-color);
+  --el-checkbox-input-border-color-hover: rgba(0, 173, 255, 0.8);
+  --el-checkbox-input-width: 16px;
+  --el-checkbox-input-height: 16px;
+  --el-border-color: rgba(0, 173, 255, 0.5);
+  --el-checkbox-input-border: 1px solid var(--el-border-color);
+}
+.mx-checkbox.el-checkbox[data-v-9157b884] .is-indeterminate {
+  --el-checkbox-checked-bg-color: transparent;
+  --el-checkbox-checked-input-border-color: rgba(0, 173, 255, 0.5);
+  --el-checkbox-checked-icon-color: var(--el-color-primary);
+}
+.mx-checkbox.el-checkbox[data-v-9157b884] .is-indeterminate .el-checkbox__inner::before {
+  top: 6px;
+}
+.mx-checkbox.el-checkbox[data-v-9157b884] .el-checkbox__inner::after {
+  left: 5px;
+  top: 2px;
+}
+.mx-checkbox.el-checkbox[data-v-9157b884] .el-checkbox__label {
+  --el-disabled-text-color: rgba(255, 255, 255, 0.3);
+}

package/es/components/checkbox/MxCheckbox.vue.d.ts

@@ -0,0 +1,104 @@
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<import("lodash").Omit<{
+    modelValue: {
+        type: (BooleanConstructor | StringConstructor | NumberConstructor)[];
+        default: undefined;
+    };
+    label: {
+        type: (BooleanConstructor | StringConstructor | ObjectConstructor | NumberConstructor)[];
+    };
+    indeterminate: BooleanConstructor;
+    disabled: BooleanConstructor;
+    checked: BooleanConstructor;
+    name: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    trueLabel: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: undefined;
+    };
+    falseLabel: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: undefined;
+    };
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    controls: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    border: BooleanConstructor;
+    size: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils/index.js").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    tabindex: (StringConstructor | NumberConstructor)[];
+    validateEvent: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}, "modelValue">, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<import("lodash").Omit<{
+    modelValue: {
+        type: (BooleanConstructor | StringConstructor | NumberConstructor)[];
+        default: undefined;
+    };
+    label: {
+        type: (BooleanConstructor | StringConstructor | ObjectConstructor | NumberConstructor)[];
+    };
+    indeterminate: BooleanConstructor;
+    disabled: BooleanConstructor;
+    checked: BooleanConstructor;
+    name: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    trueLabel: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: undefined;
+    };
+    falseLabel: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: undefined;
+    };
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    controls: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    border: BooleanConstructor;
+    size: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils/index.js").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    tabindex: (StringConstructor | NumberConstructor)[];
+    validateEvent: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}, "modelValue">>>, {
+    id: string;
+    name: string;
+    disabled: boolean;
+    indeterminate: boolean;
+    checked: boolean;
+    trueLabel: string | number;
+    falseLabel: string | number;
+    controls: string;
+    border: boolean;
+    validateEvent: boolean;
+}, {}>, Partial<Record<NonNullable<string | number>, (_: {}) => any>>>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/es/components/checkbox/MxCheckbox.vue.js

@@ -0,0 +1,35 @@
+import { defineComponent, openBlock, createBlock, unref, mergeProps, createSlots, renderList, withCtx, renderSlot } from "vue";
+import { checkboxProps, ElCheckbox } from "element-plus";
+import "element-plus/es/components/checkbox/style/css";
+import { omit } from "lodash-es";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "MxCheckbox",
+  props: omit(checkboxProps, ["modelValue"]),
+  setup(__props) {
+    const props = __props;
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(ElCheckbox), mergeProps({ class: "mx-checkbox" }, { ...props, ..._ctx.$attrs }), createSlots({ _: 2 }, [
+        renderList(_ctx.$slots, (item, key, index) => {
+          return {
+            name: key,
+            fn: withCtx(() => [
+              renderSlot(_ctx.$slots, key, {}, void 0, true)
+            ])
+          };
+        })
+      ]), 1040);
+    };
+  }
+});
+const MxCheckbox_vue_vue_type_style_index_0_scoped_9157b884_lang = "";
+const _export_sfc = (sfc, props) => {
+  const target = sfc.__vccOpts || sfc;
+  for (const [key, val] of props) {
+    target[key] = val;
+  }
+  return target;
+};
+const MxCheckbox = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-9157b884"]]);
+export {
+  MxCheckbox as default
+};

package/es/components/checkbox/MxCheckboxGroup.vue.d.ts

@@ -0,0 +1,43 @@
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<import("lodash").Omit<{
+    readonly modelValue: import("element-plus/es/utils/index.js").EpPropFinalized<(new (...args: any[]) => import("element-plus").CheckboxGroupValueType) | (() => import("element-plus").CheckboxGroupValueType) | ((new (...args: any[]) => import("element-plus").CheckboxGroupValueType) | (() => import("element-plus").CheckboxGroupValueType))[], unknown, unknown, () => never[], boolean>;
+    readonly disabled: BooleanConstructor;
+    readonly min: NumberConstructor;
+    readonly max: NumberConstructor;
+    readonly size: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils/index.js").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly label: StringConstructor;
+    readonly fill: StringConstructor;
+    readonly textColor: StringConstructor;
+    readonly tag: import("element-plus/es/utils/index.js").EpPropFinalized<StringConstructor, unknown, unknown, "div", boolean>;
+    readonly validateEvent: import("element-plus/es/utils/index.js").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+}, "modelValue">, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<import("lodash").Omit<{
+    readonly modelValue: import("element-plus/es/utils/index.js").EpPropFinalized<(new (...args: any[]) => import("element-plus").CheckboxGroupValueType) | (() => import("element-plus").CheckboxGroupValueType) | ((new (...args: any[]) => import("element-plus").CheckboxGroupValueType) | (() => import("element-plus").CheckboxGroupValueType))[], unknown, unknown, () => never[], boolean>;
+    readonly disabled: BooleanConstructor;
+    readonly min: NumberConstructor;
+    readonly max: NumberConstructor;
+    readonly size: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils/index.js").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly label: StringConstructor;
+    readonly fill: StringConstructor;
+    readonly textColor: StringConstructor;
+    readonly tag: import("element-plus/es/utils/index.js").EpPropFinalized<StringConstructor, unknown, unknown, "div", boolean>;
+    readonly validateEvent: import("element-plus/es/utils/index.js").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+}, "modelValue">>>, {
+    readonly disabled: boolean;
+    readonly tag: string;
+    readonly validateEvent: import("element-plus/es/utils/index.js").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+}, {}>, Partial<Record<NonNullable<string | number>, (_: {}) => any>>>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/es/components/checkbox/MxCheckboxGroup.vue.js

@@ -0,0 +1,26 @@
+import { defineComponent, openBlock, createBlock, unref, mergeProps, createSlots, renderList, withCtx, renderSlot } from "vue";
+import { checkboxGroupProps, ElCheckboxGroup } from "element-plus";
+import "element-plus/es/components/checkbox-group/style/css";
+import { omit } from "lodash-es";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "MxCheckboxGroup",
+  props: omit(checkboxGroupProps, ["modelValue"]),
+  setup(__props) {
+    const props = __props;
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(ElCheckboxGroup), mergeProps({ ...props, ..._ctx.$attrs }, { class: "mx-checkbox-group" }), createSlots({ _: 2 }, [
+        renderList(_ctx.$slots, (item, key, index) => {
+          return {
+            name: key,
+            fn: withCtx(() => [
+              renderSlot(_ctx.$slots, key)
+            ])
+          };
+        })
+      ]), 1040);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/es/components/checkbox/index.d.ts

@@ -0,0 +1,351 @@
+import { ElCheckboxButton } from 'element-plus';
+import MxCheckbox from './MxCheckbox.vue';
+declare module 'vue' {
+    interface GlobalComponents {
+        MxCheckbox: typeof MxCheckbox;
+        MxCheckboxGroup: typeof MxCheckboxGroup;
+        MxCheckboxButton: typeof ElCheckboxButton;
+    }
+}
+export default MxCheckbox;
+export declare const MxCheckboxGroup: {
+    new (...args: any[]): {
+        $: import("vue").ComponentInternalInstance;
+        $data: {};
+        $props: {
+            readonly disabled?: boolean | undefined;
+            readonly tag?: string | undefined;
+            readonly validateEvent?: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown> | undefined;
+            readonly fill?: string | undefined;
+            key?: string | number | symbol | undefined;
+            ref?: import("vue").VNodeRef | undefined;
+            ref_for?: boolean | undefined;
+            ref_key?: string | undefined;
+            onVnodeBeforeMount?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[] | undefined;
+            onVnodeMounted?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[] | undefined;
+            onVnodeBeforeUpdate?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[] | undefined;
+            onVnodeUpdated?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[] | undefined;
+            onVnodeBeforeUnmount?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[] | undefined;
+            onVnodeUnmounted?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[] | undefined;
+            class?: unknown;
+            style?: unknown;
+            readonly label?: string | undefined;
+            readonly max?: number | undefined;
+            readonly min?: number | undefined;
+            readonly size?: import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never> | undefined;
+            readonly textColor?: string | undefined;
+        };
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import("vue").Slot<any> | undefined;
+        }>;
+        $root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null;
+        $parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null;
+        $emit: (event: string, ...args: any[]) => void;
+        $el: any;
+        $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<import("lodash").Omit<{
+            readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("element-plus").CheckboxGroupValueType) | (() => import("element-plus").CheckboxGroupValueType) | ((new (...args: any[]) => import("element-plus").CheckboxGroupValueType) | (() => import("element-plus").CheckboxGroupValueType))[], unknown, unknown, () => never[], boolean>;
+            readonly disabled: BooleanConstructor;
+            readonly min: NumberConstructor;
+            readonly max: NumberConstructor;
+            readonly size: {
+                readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly label: StringConstructor;
+            readonly fill: StringConstructor;
+            readonly textColor: StringConstructor;
+            readonly tag: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "div", boolean>;
+            readonly validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+        }, "modelValue">>>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+            readonly disabled: boolean;
+            readonly tag: string;
+            readonly validateEvent: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        }, {}, string, {}> & {
+            beforeCreate?: ((() => void) | (() => void)[]) | undefined;
+            created?: ((() => void) | (() => void)[]) | undefined;
+            beforeMount?: ((() => void) | (() => void)[]) | undefined;
+            mounted?: ((() => void) | (() => void)[]) | undefined;
+            beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
+            updated?: ((() => void) | (() => void)[]) | undefined;
+            activated?: ((() => void) | (() => void)[]) | undefined;
+            deactivated?: ((() => void) | (() => void)[]) | undefined;
+            beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
+            beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
+            destroyed?: ((() => void) | (() => void)[]) | undefined;
+            unmounted?: ((() => void) | (() => void)[]) | undefined;
+            renderTracked?: (((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[]) | undefined;
+            renderTriggered?: (((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[]) | undefined;
+            errorCaptured?: (((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null, info: string) => boolean | void)[]) | undefined;
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof import("vue").nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: import("vue").WatchOptions<boolean> | undefined): import("vue").WatchStopHandle;
+    } & Readonly<import("vue").ExtractPropTypes<import("lodash").Omit<{
+        readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("element-plus").CheckboxGroupValueType) | (() => import("element-plus").CheckboxGroupValueType) | ((new (...args: any[]) => import("element-plus").CheckboxGroupValueType) | (() => import("element-plus").CheckboxGroupValueType))[], unknown, unknown, () => never[], boolean>;
+        readonly disabled: BooleanConstructor;
+        readonly min: NumberConstructor;
+        readonly max: NumberConstructor;
+        readonly size: {
+            readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly label: StringConstructor;
+        readonly fill: StringConstructor;
+        readonly textColor: StringConstructor;
+        readonly tag: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "div", boolean>;
+        readonly validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    }, "modelValue">>> & import("vue").ShallowUnwrapRef<{}> & {} & import("vue").ComponentCustomProperties & {};
+    __isFragment?: undefined;
+    __isTeleport?: undefined;
+    __isSuspense?: undefined;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<import("lodash").Omit<{
+    readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("element-plus").CheckboxGroupValueType) | (() => import("element-plus").CheckboxGroupValueType) | ((new (...args: any[]) => import("element-plus").CheckboxGroupValueType) | (() => import("element-plus").CheckboxGroupValueType))[], unknown, unknown, () => never[], boolean>;
+    readonly disabled: BooleanConstructor;
+    readonly min: NumberConstructor;
+    readonly max: NumberConstructor;
+    readonly size: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly label: StringConstructor;
+    readonly fill: StringConstructor;
+    readonly textColor: StringConstructor;
+    readonly tag: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "div", boolean>;
+    readonly validateEvent: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+}, "modelValue">>>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+    readonly disabled: boolean;
+    readonly tag: string;
+    readonly validateEvent: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+}, {}, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+    $slots: Partial<Record<NonNullable<string | number>, (_: {}) => any>>;
+});
+export declare const MxCheckboxButton: import("element-plus/es/utils").SFCWithInstall<import("vue").DefineComponent<{
+    modelValue: {
+        type: (BooleanConstructor | StringConstructor | NumberConstructor)[];
+        default: undefined;
+    };
+    label: {
+        type: (BooleanConstructor | StringConstructor | ObjectConstructor | NumberConstructor)[];
+    };
+    indeterminate: BooleanConstructor;
+    disabled: BooleanConstructor;
+    checked: BooleanConstructor;
+    name: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    trueLabel: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: undefined;
+    };
+    falseLabel: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: undefined;
+    };
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    controls: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    border: BooleanConstructor;
+    size: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    tabindex: (StringConstructor | NumberConstructor)[];
+    validateEvent: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}, {
+    props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
+        modelValue: {
+            type: (BooleanConstructor | StringConstructor | NumberConstructor)[];
+            default: undefined;
+        };
+        label: {
+            type: (BooleanConstructor | StringConstructor | ObjectConstructor | NumberConstructor)[];
+        };
+        indeterminate: BooleanConstructor;
+        disabled: BooleanConstructor;
+        checked: BooleanConstructor;
+        name: {
+            type: StringConstructor;
+            default: undefined;
+        };
+        trueLabel: {
+            type: (StringConstructor | NumberConstructor)[];
+            default: undefined;
+        };
+        falseLabel: {
+            type: (StringConstructor | NumberConstructor)[];
+            default: undefined;
+        };
+        id: {
+            type: StringConstructor;
+            default: undefined;
+        };
+        controls: {
+            type: StringConstructor;
+            default: undefined;
+        };
+        border: BooleanConstructor;
+        size: {
+            readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        tabindex: (StringConstructor | NumberConstructor)[];
+        validateEvent: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>> & {
+        onChange?: ((val: import("element-plus").CheckboxValueType) => any) | undefined;
+        "onUpdate:modelValue"?: ((val: import("element-plus").CheckboxValueType) => any) | undefined;
+    }>>;
+    slots: Readonly<{
+        [name: string]: import("vue").Slot<any> | undefined;
+    }>;
+    isFocused: import("vue").Ref<boolean>;
+    isChecked: import("vue").ComputedRef<boolean>;
+    isDisabled: import("vue").ComputedRef<boolean>;
+    checkboxButtonSize: import("vue").ComputedRef<"" | "default" | "small" | "large">;
+    model: import("vue").WritableComputedRef<any>;
+    handleChange: (e: Event) => void;
+    checkboxGroup: ({
+        modelValue?: import("vue").WritableComputedRef<any> | undefined;
+        changeEvent?: ((...args: any) => any) | undefined;
+    } & import("vue").ToRefs<Pick<import("element-plus").CheckboxGroupProps, "fill" | "max" | "min" | "disabled" | "size" | "validateEvent" | "textColor">>) | undefined;
+    ns: {
+        namespace: import("vue").ComputedRef<string>;
+        b: (blockSuffix?: string | undefined) => string;
+        e: (element?: string | undefined) => string;
+        m: (modifier?: string | undefined) => string;
+        be: (blockSuffix?: string | undefined, element?: string | undefined) => string;
+        em: (element?: string | undefined, modifier?: string | undefined) => string;
+        bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;
+        bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;
+        is: {
+            (name: string, state: boolean | undefined): string;
+            (name: string): string;
+        };
+        cssVar: (object: Record<string, string>) => Record<string, string>;
+        cssVarName: (name: string) => string;
+        cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+        cssVarBlockName: (name: string) => string;
+    };
+    activeStyle: import("vue").ComputedRef<import("vue").CSSProperties>;
+    labelKls: import("vue").ComputedRef<string[]>;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (val: import("element-plus").CheckboxValueType) => boolean;
+    change: (val: import("element-plus").CheckboxValueType) => boolean;
+}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    modelValue: {
+        type: (BooleanConstructor | StringConstructor | NumberConstructor)[];
+        default: undefined;
+    };
+    label: {
+        type: (BooleanConstructor | StringConstructor | ObjectConstructor | NumberConstructor)[];
+    };
+    indeterminate: BooleanConstructor;
+    disabled: BooleanConstructor;
+    checked: BooleanConstructor;
+    name: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    trueLabel: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: undefined;
+    };
+    falseLabel: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: undefined;
+    };
+    id: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    controls: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    border: BooleanConstructor;
+    size: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    tabindex: (StringConstructor | NumberConstructor)[];
+    validateEvent: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & {
+    onChange?: ((val: import("element-plus").CheckboxValueType) => any) | undefined;
+    "onUpdate:modelValue"?: ((val: import("element-plus").CheckboxValueType) => any) | undefined;
+}, {
+    modelValue: string | number | boolean;
+    id: string;
+    disabled: boolean;
+    name: string;
+    validateEvent: boolean;
+    border: boolean;
+    indeterminate: boolean;
+    checked: boolean;
+    trueLabel: string | number;
+    falseLabel: string | number;
+    controls: string;
+}, {}>>;

package/es/components/checkbox/index.js

@@ -0,0 +1,17 @@
+import { ElCheckboxButton } from "element-plus";
+import "element-plus/es/components/checkbox-button/style/css";
+import MxCheckbox from "./MxCheckbox.vue";
+import { default as default2 } from "./MxCheckbox.vue";
+import CheckboxGroup from "./MxCheckboxGroup.vue";
+MxCheckbox.install = (app) => {
+  app.component(MxCheckbox.__name, MxCheckbox);
+  app.component(MxCheckboxGroup.__name, MxCheckboxGroup);
+  app.component(MxCheckboxButton.__name, ElCheckboxButton);
+};
+const MxCheckboxGroup = CheckboxGroup;
+const MxCheckboxButton = ElCheckboxButton;
+export {
+  MxCheckboxButton,
+  MxCheckboxGroup,
+  default2 as default
+};