mc-plus 1.0.7 → 1.0.9

package/dist/types/components/index.d.ts

@@ -1,3 +1,14 @@
+export * from './mc-alert';
 export * from './mc-button';
-export * from './mc-icon';
 export * from './mc-collapse';
+export * from './mc-icon';
+export * from './mc-input';
+export * from './mc-message';
+export * from './mc-radio';
+export * from './mc-select';
+export * from './mc-switch';
+export * from './mc-table';
+export * from './mc-tag';
+export * from './mc-toast';
+export * from './mc-checkbox';
+export * from './mc-tooltip';

package/dist/types/components/mc-alert/index.d.ts

@@ -0,0 +1,49 @@
+export * from './types';
+export declare const McAlert: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('../../core').AlertProps> & Readonly<{
+        onClose?: ((val: MouseEvent) => any) | undefined;
+    }>, {
+        ref: import('vue').Ref<HTMLDivElement | void>;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+        close: (val: MouseEvent) => any;
+    }, import('vue').PublicProps, {
+        type: import('../../core').AlertType;
+        closable: boolean;
+        showIcon: boolean;
+    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+        _ref: HTMLDivElement;
+    }, any, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('../../core').AlertProps> & Readonly<{
+        onClose?: ((val: MouseEvent) => any) | undefined;
+    }>, {
+        ref: import('vue').Ref<HTMLDivElement | void>;
+    }, {}, {}, {}, {
+        type: import('../../core').AlertType;
+        closable: boolean;
+        showIcon: boolean;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('../../core').AlertProps> & Readonly<{
+    onClose?: ((val: MouseEvent) => any) | undefined;
+}>, {
+    ref: import('vue').Ref<HTMLDivElement | void>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    close: (val: MouseEvent) => any;
+}, string, {
+    type: import('../../core').AlertType;
+    closable: boolean;
+    showIcon: boolean;
+}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+    $slots: {
+        title?(_: {}): any;
+        description?(_: {}): any;
+    };
+}) & import('vue').Plugin;

package/dist/types/components/mc-alert/types.d.ts

@@ -0,0 +1,17 @@
+import { Ref } from 'vue';
+export type AlertType = "success" | "info" | "warning" | "error";
+export interface AlertProps {
+    type?: AlertType;
+    title?: string;
+    description?: string;
+    closable?: boolean;
+    showIcon?: boolean;
+    height?: string;
+    width?: string;
+}
+export interface AlertEmits {
+    (e: "close", val: MouseEvent): void;
+}
+export interface AlertInstance {
+    ref: Ref<HTMLDivElement | void>;
+}

package/dist/types/components/mc-checkbox/index.d.ts

@@ -0,0 +1,29 @@
+export * from './types';
+export declare const McCheckbox: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('../../core').CheckboxProps> & Readonly<{
+        "onUpdate:modelValue"?: ((val: boolean) => any) | undefined;
+        onChange?: ((val: boolean) => any) | undefined;
+    }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+        "update:modelValue": (val: boolean) => any;
+        change: (val: boolean) => any;
+    }, import('vue').PublicProps, {}, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, HTMLDivElement, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('../../core').CheckboxProps> & Readonly<{
+        "onUpdate:modelValue"?: ((val: boolean) => any) | undefined;
+        onChange?: ((val: boolean) => any) | undefined;
+    }>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('../../core').CheckboxProps> & Readonly<{
+    "onUpdate:modelValue"?: ((val: boolean) => any) | undefined;
+    onChange?: ((val: boolean) => any) | undefined;
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    "update:modelValue": (val: boolean) => any;
+    change: (val: boolean) => any;
+}, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & import('vue').Plugin;

package/dist/types/components/mc-checkbox/types.d.ts

@@ -0,0 +1,15 @@
+import { Ref } from 'vue';
+export interface CheckboxProps {
+    modelValue?: boolean;
+    disabled?: boolean;
+    content?: string;
+    remarks?: string;
+    partial?: boolean;
+}
+export interface CheckboxEmits {
+    (e: "change", val: boolean): void;
+    (e: "update:modelValue", val: boolean): void;
+}
+export interface CheckboxInstance {
+    ref: Ref<HTMLButtonElement | void>;
+}

package/dist/types/components/mc-form/constanst.d.ts

@@ -0,0 +1,4 @@
+import { InjectionKey } from 'vue';
+import { FormContext, FormItemContext } from './types';
+export declare const FORM_CTX_KEY: InjectionKey<FormContext>;
+export declare const FORM_ITEM_CTX_KEY: InjectionKey<FormItemContext>;

package/dist/types/components/mc-form/types.d.ts

@@ -0,0 +1,47 @@
+import { RuleItem, ValidateError, ValidateFieldsError } from 'async-validator';
+import { Ref } from 'vue';
+export interface FormItemRule extends RuleItem {
+    trigger?: string | string[];
+}
+export type FormRules = Record<string, FormItemRule[]>;
+export type FormValidateResult = Promise<boolean>;
+export type FormValidateCallback = (isValid: boolean, invalidFields?: ValidateFieldsError) => void;
+export type ValidateStatus = "success" | "error" | "init" | "validating";
+export interface FormValidateFailuer {
+    errors?: ValidateError[];
+    fields: ValidateFieldsError;
+}
+export interface FormProps {
+    model: Record<string, any>;
+    rules?: FormRules;
+}
+export interface FormEmits {
+    (event: "validate", prop: FormItemProps, isValid: boolean, message: string): void;
+}
+export interface FormItemProps {
+    prop?: string;
+    label?: string;
+    disabled?: boolean;
+    required?: boolean;
+    rules?: FormItemRule[];
+}
+export interface FormInstance {
+    validate(callback?: FormValidateCallback): FormValidateResult;
+    validateField(keys?: string[], callback?: FormValidateCallback): FormValidateResult;
+    clearValidate(keys?: string[]): void;
+}
+export interface FormItemInstance {
+    validateStatus: Ref<ValidateStatus>;
+    validateMessage: Ref<string>;
+    validate(trigger: string, callback?: FormValidateCallback): FormValidateResult;
+    clearValidate(): void;
+}
+export interface FormContext extends FormProps {
+    emits: FormEmits;
+    addField(field: FormItemContext): void;
+    removeField(field: FormItemContext): void;
+}
+export interface FormItemContext extends FormItemProps {
+    validate(trigger: string, callback?: FormValidateCallback): FormValidateResult;
+    clearValidate(): void;
+}

package/dist/types/components/mc-input/index.d.ts

@@ -0,0 +1,57 @@
+export * from './types';
+export declare const McInput: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('../../core').InputProps> & Readonly<{
+        onInput?: ((value?: string | undefined) => any) | undefined;
+        "onUpdate:modelValue"?: ((value?: string | undefined) => any) | undefined;
+        onChange?: ((value?: string | undefined) => any) | undefined;
+        onFocus?: ((event: Event) => any) | undefined;
+        onBlur?: ((event: Event) => any) | undefined;
+    }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+        input: (value?: string | undefined) => any;
+        "update:modelValue": (value?: string | undefined) => any;
+        change: (value?: string | undefined) => any;
+        focus: (event: Event) => any;
+        blur: (event: Event) => any;
+    }, import('vue').PublicProps, {
+        placeholder: string;
+    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, HTMLDivElement, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('../../core').InputProps> & Readonly<{
+        onInput?: ((value?: string | undefined) => any) | undefined;
+        "onUpdate:modelValue"?: ((value?: string | undefined) => any) | undefined;
+        onChange?: ((value?: string | undefined) => any) | undefined;
+        onFocus?: ((event: Event) => any) | undefined;
+        onBlur?: ((event: Event) => any) | undefined;
+    }>, {}, {}, {}, {}, {
+        placeholder: string;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('../../core').InputProps> & Readonly<{
+    onInput?: ((value?: string | undefined) => any) | undefined;
+    "onUpdate:modelValue"?: ((value?: string | undefined) => any) | undefined;
+    onChange?: ((value?: string | undefined) => any) | undefined;
+    onFocus?: ((event: Event) => any) | undefined;
+    onBlur?: ((event: Event) => any) | undefined;
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    input: (value?: string | undefined) => any;
+    "update:modelValue": (value?: string | undefined) => any;
+    change: (value?: string | undefined) => any;
+    focus: (event: Event) => any;
+    blur: (event: Event) => any;
+}, string, {
+    placeholder: string;
+}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+    $slots: {
+        pre?(_: {}): any;
+        default?(_: {
+            class: string;
+        }): any;
+    };
+}) & import('vue').Plugin;

package/dist/types/components/mc-input/types.d.ts

@@ -0,0 +1,17 @@
+export interface InputProps {
+    modelValue?: string;
+    search?: boolean;
+    disabled?: boolean;
+    password?: boolean;
+    placeholder?: string;
+}
+export interface InputEmits {
+    (e: "update:modelValue", value?: string): void;
+    (e: "input", value?: string): void;
+    (e: "change", value?: string): void;
+    (e: "focus", event: Event): void;
+    (e: "blur", event: Event): void;
+}
+export interface InputInstance {
+    ref: HTMLInputElement;
+}

package/dist/types/components/mc-message/index.d.ts

@@ -0,0 +1,61 @@
+import { App } from 'vue';
+import { MessageService, MessageType } from './types';
+export * from './types';
+export declare const McMessage: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('../../core').MessageProps> & Readonly<{
+        onClose?: (() => any) | undefined;
+    }>, {
+        ref: import('vue').Ref<HTMLDivElement | undefined>;
+        handleClose: () => void;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+        close: () => any;
+    }, import('vue').PublicProps, {
+        type: MessageType;
+        closable: boolean;
+        showIcon: boolean;
+        message: string;
+        duration: number;
+    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+        _ref: HTMLDivElement;
+    }, any, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('../../core').MessageProps> & Readonly<{
+        onClose?: (() => any) | undefined;
+    }>, {
+        ref: import('vue').Ref<HTMLDivElement | undefined>;
+        handleClose: () => void;
+    }, {}, {}, {}, {
+        type: MessageType;
+        closable: boolean;
+        showIcon: boolean;
+        message: string;
+        duration: number;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('../../core').MessageProps> & Readonly<{
+    onClose?: (() => any) | undefined;
+}>, {
+    ref: import('vue').Ref<HTMLDivElement | undefined>;
+    handleClose: () => void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    close: () => any;
+}, string, {
+    type: MessageType;
+    closable: boolean;
+    showIcon: boolean;
+    message: string;
+    duration: number;
+}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & import('vue').Plugin;
+declare const Message: MessageService;
+export { Message };
+declare const _default: {
+    install: (app: App) => void;
+};
+export default _default;

package/dist/types/components/mc-message/types.d.ts

@@ -0,0 +1,34 @@
+import { Ref } from 'vue';
+export type MessageType = "success" | "info" | "warning" | "error";
+export type MessagePosition = "top" | "bottom";
+export interface MessageProps {
+    type?: MessageType;
+    message?: string;
+    duration?: number;
+    showIcon?: boolean;
+    closable?: boolean;
+    onClose?: () => void;
+}
+export interface MessageEmits {
+    (e: "close"): void;
+}
+export interface MessageComponentExposed {
+    handleClose: () => void;
+}
+export interface MessageInstance {
+    ref: Ref<HTMLDivElement | undefined>;
+}
+export interface MessageOptions extends MessageProps {
+    id?: string;
+}
+export interface MessageMethod {
+    (options: MessageOptions | string): void;
+}
+export interface MessageService {
+    info: MessageMethod;
+    success: MessageMethod;
+    warning: MessageMethod;
+    error: MessageMethod;
+    close: (id: string) => void;
+    closeAll: () => void;
+}

package/dist/types/components/mc-radio/constant.d.ts

@@ -0,0 +1,3 @@
+import { InjectionKey } from 'vue';
+import { RadioGroupContext } from './types';
+export declare const RADIO_INJECTION_KEY: InjectionKey<RadioGroupContext>;

package/dist/types/components/mc-radio/index.d.ts

@@ -0,0 +1,51 @@
+export * from './types';
+export declare const McRadioGroup: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('../../core').RadioGroupProps> & Readonly<{
+        "onUpdate:modelValue"?: ((val?: string | undefined) => any) | undefined;
+        onChange?: ((val?: string | undefined) => any) | undefined;
+    }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+        "update:modelValue": (val?: string | undefined) => any;
+        change: (val?: string | undefined) => any;
+    }, import('vue').PublicProps, {}, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, HTMLDivElement, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('../../core').RadioGroupProps> & Readonly<{
+        "onUpdate:modelValue"?: ((val?: string | undefined) => any) | undefined;
+        onChange?: ((val?: string | undefined) => any) | undefined;
+    }>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('../../core').RadioGroupProps> & Readonly<{
+    "onUpdate:modelValue"?: ((val?: string | undefined) => any) | undefined;
+    onChange?: ((val?: string | undefined) => any) | undefined;
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    "update:modelValue": (val?: string | undefined) => any;
+    change: (val?: string | undefined) => any;
+}, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+    $slots: {
+        default?(_: {}): any;
+    };
+}) & import('vue').Plugin;
+export declare const McRadio: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('../../core').RadioProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {}, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, HTMLDivElement, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('../../core').RadioProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('../../core').RadioProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+    $slots: {
+        default?(_: {}): any;
+        remark?(_: {}): any;
+    };
+}) & import('vue').Plugin;

package/dist/types/components/mc-radio/types.d.ts

@@ -0,0 +1,20 @@
+import { ComputedRef } from 'vue';
+export interface RadioProps {
+    label?: string;
+    value: string;
+    disabled?: boolean;
+    remark?: string;
+}
+export interface RadioGroupProps {
+    modelValue?: string;
+    disabled?: boolean;
+}
+export interface RadioGroupContext {
+    modelValue?: ComputedRef<string | undefined>;
+    disabled?: ComputedRef<boolean | undefined>;
+    handleSelect: (val?: string) => void;
+}
+export interface RadioGroupEmits {
+    (e: "update:modelValue", val?: string): void;
+    (e: "change", val?: string): void;
+}

package/dist/types/components/mc-select/constant.d.ts

@@ -0,0 +1,4 @@
+import { InjectionKey } from 'vue';
+import { SelectContext, SelectGroupContext } from './types';
+export declare const SELECT_INJECTION_KEY: InjectionKey<SelectContext>;
+export declare const SELECT_GROUP_INJECTION_KEY: InjectionKey<SelectGroupContext>;

package/dist/types/components/mc-select/index.d.ts

@@ -0,0 +1,93 @@
+export * from './types';
+export declare const McSelect: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('../../core').SelectProps> & Readonly<{
+        "onUpdate:modelValue"?: ((val: string | string[]) => any) | undefined;
+        onChange?: ((val: string | string[]) => any) | undefined;
+    }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+        "update:modelValue": (val: string | string[]) => any;
+        change: (val: string | string[]) => any;
+    }, import('vue').PublicProps, {
+        type: import('../../core').SelectType;
+        modelValue: string;
+        placeholder: string;
+    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+        _ref: HTMLDivElement;
+    }, any, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('../../core').SelectProps> & Readonly<{
+        "onUpdate:modelValue"?: ((val: string | string[]) => any) | undefined;
+        onChange?: ((val: string | string[]) => any) | undefined;
+    }>, {}, {}, {}, {}, {
+        type: import('../../core').SelectType;
+        modelValue: string;
+        placeholder: string;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('../../core').SelectProps> & Readonly<{
+    "onUpdate:modelValue"?: ((val: string | string[]) => any) | undefined;
+    onChange?: ((val: string | string[]) => any) | undefined;
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    "update:modelValue": (val: string | string[]) => any;
+    change: (val: string | string[]) => any;
+}, string, {
+    type: import('../../core').SelectType;
+    modelValue: string;
+    placeholder: string;
+}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+    $slots: {
+        default?(_: {}): any;
+        empty?(_: {}): any;
+    };
+}) & import('vue').Plugin;
+export declare const McSelectOption: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('../../core').SelectOptionProps> & Readonly<{}>, {
+        isShow: boolean;
+        ref: import('vue').Ref<HTMLLIElement | undefined>;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {}, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+        _ref: HTMLDivElement;
+    }, any, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('../../core').SelectOptionProps> & Readonly<{}>, {
+        isShow: boolean;
+        ref: import('vue').Ref<HTMLLIElement | undefined>;
+    }, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('../../core').SelectOptionProps> & Readonly<{}>, {
+    isShow: boolean;
+    ref: import('vue').Ref<HTMLLIElement | undefined>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+    $slots: {
+        default?(_: {}): any;
+    };
+}) & import('vue').Plugin;
+export declare const McSelectGroup: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('../../core').SelectGroupProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {}, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('../../core').SelectGroupProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('../../core').SelectGroupProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+    $slots: {
+        default?(_: {}): any;
+    };
+}) & import('vue').Plugin;

package/dist/types/components/mc-select/types.d.ts

@@ -0,0 +1,42 @@
+import { ComputedRef, Ref, VNode } from 'vue';
+export type SelectType = "single";
+export interface SelectOptionProps {
+    value: string;
+    label?: string;
+    width?: string;
+    height?: string;
+    _group?: string;
+    _vnode?: VNode;
+}
+export interface SelectOptionInstance {
+    isShow: boolean;
+    ref: Ref<HTMLLIElement | undefined>;
+}
+export interface SelectGroupProps {
+    label: string;
+    width?: string;
+    height?: string;
+}
+export interface SelectProps {
+    modelValue?: string;
+    placeholder?: string;
+    disabled?: boolean;
+    type?: SelectType;
+    width?: string;
+    height?: string;
+    search?: boolean;
+}
+export interface SelectEmits {
+    (e: "update:modelValue", val: string | string[]): void;
+    (e: "change", val: string | string[]): void;
+}
+export interface SelectContext {
+    filterOptions: ComputedRef<SelectOptionProps[]>;
+    selectValues: Ref<string[]>;
+    handleSelect(item: SelectOptionProps): void;
+    removeOption(item: SelectOptionProps): void;
+    addOption(item: SelectOptionProps): void;
+}
+export interface SelectGroupContext {
+    groupName: string;
+}

package/dist/types/components/mc-switch/index.d.ts

@@ -0,0 +1,45 @@
+export * from './types';
+export declare const McSwitch: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('../../core').SwitchProps> & Readonly<{
+        "onUpdate:modelValue"?: ((val: boolean) => any) | undefined;
+    }>, {
+        ref: import('vue').Ref<HTMLLabelElement | void>;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+        "update:modelValue": (val: boolean) => any;
+    }, import('vue').PublicProps, {
+        disabled: boolean;
+        modelValue: boolean;
+    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+        _ref: HTMLLabelElement;
+    }, HTMLDivElement, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('../../core').SwitchProps> & Readonly<{
+        "onUpdate:modelValue"?: ((val: boolean) => any) | undefined;
+    }>, {
+        ref: import('vue').Ref<HTMLLabelElement | void>;
+    }, {}, {}, {}, {
+        disabled: boolean;
+        modelValue: boolean;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('../../core').SwitchProps> & Readonly<{
+    "onUpdate:modelValue"?: ((val: boolean) => any) | undefined;
+}>, {
+    ref: import('vue').Ref<HTMLLabelElement | void>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    "update:modelValue": (val: boolean) => any;
+}, string, {
+    disabled: boolean;
+    modelValue: boolean;
+}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+    $slots: {
+        default?(_: {}): any;
+    };
+}) & import('vue').Plugin;

package/dist/types/components/mc-switch/types.d.ts

@@ -0,0 +1,15 @@
+import { Ref } from 'vue';
+export interface SwitchProps {
+    modelValue?: boolean;
+    width?: string;
+    label?: string;
+    disabled?: boolean;
+    onText?: string;
+    offText?: string;
+}
+export interface SwitchEmits {
+    (e: "update:modelValue", val: boolean): void;
+}
+export interface SwitchInstance {
+    ref: Ref<HTMLLabelElement | void>;
+}

package/dist/types/components/mc-table/composables/usePagination.d.ts

@@ -0,0 +1,11 @@
+import { Ref } from 'vue';
+import { PaginationConfig } from '../types';
+export declare function usePagination(data: Ref<Record<string, unknown>[]>, pagination: Ref<PaginationConfig | undefined>): {
+    currentPage: Ref<number, number>;
+    pageSize: Ref<number, number>;
+    paginatedData: import('vue').ComputedRef<Record<string, unknown>[]>;
+    updatePagination: (payload: {
+        pageSize: number;
+        pageNum: number;
+    }) => void;
+};