@maple-design/ui-vue 1.1.0 → 1.1.1

package/types-generated/date-range/presentation/RangeContent.vue.d.ts

@@ -1,6 +1,7 @@
 import { type PropType } from 'vue';
 import CalendarContent from '../../date/presentation/CalendarContent.vue';
 import type { DisabledTime } from '../../date/time-constraints';
+import { dateText as t } from '../../locale/date-text';
 import { formatElevation } from '../../utils/components';
 type CalendarSummary = Pick<InstanceType<typeof CalendarContent>, 'showDateSummary'>;
 declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
@@ -97,11 +98,11 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     }>;
     pickerBindingProps: import("vue").ComputedRef<import("../../date/wheel-options").DateWheelOptions>;
     dateColumnLabels: import("vue").ComputedRef<any[]>;
-    dateColumns: import("vue").ComputedRef<import("../../picker").PickerColumnOption[][]>;
+    dateColumns: import("vue").ComputedRef<import("../..").PickerColumnOption[][]>;
     datePickerValue: import("vue").ComputedRef<string[]>;
     timeColumnLabels: import("vue").ComputedRef<any[]>;
     customTimeFields: import("vue").ComputedRef<boolean>;
-    timeColumns: import("vue").ComputedRef<import("../../picker").PickerColumnOption[][]>;
+    timeColumns: import("vue").ComputedRef<import("../..").PickerColumnOption[][]>;
     timePickerValue: import("vue").ComputedRef<string[]>;
     quickTimeOptions: import("vue").ComputedRef<{
         text: string;
@@ -207,7 +208,1118 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     datePickerProps: import("../calendar-options").DateRangeCalendarOptions;
     endpointEditor: boolean;
 }, {}, {
-    MpPicker: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    MpPicker: {
+        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+            safeArea: BooleanConstructor;
+            open: {
+                type: BooleanConstructor;
+                default: undefined;
+            };
+            defaultOpen: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            overlayClosable: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            escToClose: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            popupContainer: {
+                type: PropType<import("../..").PopupContainer>;
+                default: undefined;
+                validator: ((value: unknown) => boolean) | undefined;
+            };
+            modelValue: {
+                type: PropType<(string | number)[]>;
+                default: undefined;
+            };
+            defaultValue: {
+                type: PropType<(string | number)[]>;
+                default: () => never[];
+            };
+            columns: {
+                type: PropType<import("../..").PickerColumnOption[] | import("../..").PickerColumnOption[][]>;
+                default: () => never[];
+            };
+            title: StringConstructor;
+            fieldNames: {
+                type: PropType<import("../../utils/options").FieldNames>;
+                default: undefined;
+            };
+            toolbar: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            disabled: BooleanConstructor;
+            selectedValues: {
+                type: PropType<(string | number)[]>;
+                default: () => never[];
+            };
+            cascade: BooleanConstructor;
+            optionHeight: {
+                type: (NumberConstructor | StringConstructor)[];
+                default: number;
+            };
+            optionCount: {
+                type: (NumberConstructor | StringConstructor)[];
+                default: number;
+            };
+            columnsCount: (NumberConstructor | StringConstructor)[];
+            confirmButtonText: StringConstructor;
+            cancelButtonText: StringConstructor;
+            confirmButtonTextColor: StringConstructor;
+            cancelButtonTextColor: StringConstructor;
+            dynamic: BooleanConstructor;
+        }>> & Readonly<{
+            onCancel?: ((values: (string | number)[], indexes: number[], options: import("../..").PickerColumnOption[]) => any) | undefined;
+            onChange?: ((values: (string | number)[], indexes: number[], options: import("../..").PickerColumnOption[]) => any) | undefined;
+            onClose?: (() => any) | undefined;
+            onOpen?: (() => any) | undefined;
+            onOpened?: (() => any) | undefined;
+            onClosed?: (() => any) | undefined;
+            "onClick-overlay"?: ((event: MouseEvent) => any) | undefined;
+            "onKey-escape"?: ((event: KeyboardEvent) => any) | undefined;
+            "onUpdate:open"?: ((open: boolean) => any) | undefined;
+            onConfirm?: ((values: (string | number)[], indexes: number[], options: import("../..").PickerColumnOption[]) => any) | undefined;
+            "onUpdate:modelValue"?: ((value: (string | number)[]) => any) | undefined;
+        }>, {
+            describeError: (value: unknown) => string | undefined;
+            mergedError: import("vue").ComputedRef<boolean>;
+            mergedOpen: import("vue").ComputedRef<boolean>;
+            controlId: string;
+            handleColumnKeydown: (event: KeyboardEvent, column: import("../../picker/Picker.vue").ScrollColumn) => void;
+            optionHeight: import("vue").ComputedRef<number>;
+            optionCount: import("vue").ComputedRef<number>;
+            scrollColumns: import("vue").Ref<{
+                id: number;
+                touching: boolean;
+                index: number;
+                prevY: number;
+                momentumPrevY: number;
+                momentumTime: number;
+                translate: number;
+                duration: number;
+                scrolling: boolean;
+                column: {
+                    [x: string]: any;
+                    [x: number]: any;
+                    [x: symbol]: any;
+                    text?: string | number | undefined;
+                    value?: string | number | undefined;
+                    disabled?: boolean | undefined;
+                    children?: any[] | undefined;
+                    className?: string | undefined;
+                    textClassName?: string | undefined;
+                }[];
+                scrollEl: HTMLElement | null;
+            }[], import("../../picker/Picker.vue").ScrollColumn[] | {
+                id: number;
+                touching: boolean;
+                index: number;
+                prevY: number;
+                momentumPrevY: number;
+                momentumTime: number;
+                translate: number;
+                duration: number;
+                scrolling: boolean;
+                column: {
+                    [x: string]: any;
+                    [x: number]: any;
+                    [x: symbol]: any;
+                    text?: string | number | undefined;
+                    value?: string | number | undefined;
+                    disabled?: boolean | undefined;
+                    children?: any[] | undefined;
+                    className?: string | undefined;
+                    textClassName?: string | undefined;
+                }[];
+                scrollEl: HTMLElement | null;
+            }[]>;
+            columnHeight: import("vue").ComputedRef<number>;
+            center: import("vue").ComputedRef<number>;
+            confirmButtonDisabled: import("vue").ComputedRef<boolean>;
+            Transition: import("vue").FunctionalComponent<import("vue").TransitionProps, {}, any, {}>;
+            toRaw: typeof import("vue").toRaw;
+            pt: ((id: string) => string | undefined) | null;
+            t: typeof import("../../locale/temporal-text").temporalText;
+            n: (suffix?: string | undefined) => string;
+            classes: (...names: (import("../../utils/components").NamespaceClass | [unknown, import("../../utils/components").NamespaceClass, import("../../utils/components").NamespaceClass?])[]) => import("../../utils/components").NamespaceClass[];
+            isOptionSelected: (option: import("../..").PickerColumnOption) => boolean;
+            isOptionDisabled: (option?: import("../..").PickerColumnOption | undefined) => boolean;
+            setScrollEl: (el: Element | import("vue").ComponentPublicInstance | null, scrollColumn: import("../../picker/Picker.vue").ScrollColumn) => void;
+            getOptionKey: (key: "value" | "text" | "children") => string;
+            getValue: (option: import("../..").PickerColumnOption) => string | number;
+            handlePopupUpdateShow: (value: boolean) => void;
+            handlePopupOverlayClick: (event: MouseEvent) => void;
+            handlePopupKeyEscape: (event: KeyboardEvent) => void;
+            handleTouchstart: (event: TouchEvent, scrollColumn: import("../../picker/Picker.vue").ScrollColumn) => void;
+            handleTouchmove: (event: TouchEvent, scrollColumn: import("../../picker/Picker.vue").ScrollColumn) => void;
+            handleTouchend: (scrollColumn: import("../../picker/Picker.vue").ScrollColumn) => void;
+            handleTransitionend: (scrollColumn: import("../../picker/Picker.vue").ScrollColumn, event?: TransitionEvent | undefined) => void;
+            confirm: () => void;
+            cancel: () => void;
+            handleClick: (scrollColumn: import("../../picker/Picker.vue").ScrollColumn, index: number) => void;
+        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            confirm: (values: (string | number)[], indexes: number[], options: import("../..").PickerColumnOption[]) => true;
+            cancel: (values: (string | number)[], indexes: number[], options: import("../..").PickerColumnOption[]) => true;
+            change: (values: (string | number)[], indexes: number[], options: import("../..").PickerColumnOption[]) => true;
+            'update:open': (open: boolean) => true;
+            'update:modelValue': (value: (string | number)[]) => true;
+            open: () => true;
+            opened: () => true;
+            close: () => true;
+            closed: () => true;
+            'click-overlay': (event: MouseEvent) => true;
+            'key-escape': (event: KeyboardEvent) => true;
+        }, import("vue").PublicProps, {
+            optionHeight: string | number;
+            optionCount: string | number;
+            modelValue: (string | number)[];
+            defaultValue: (string | number)[];
+            disabled: boolean;
+            open: boolean;
+            defaultOpen: boolean;
+            overlayClosable: boolean;
+            escToClose: boolean;
+            popupContainer: import("../..").PopupContainer;
+            safeArea: boolean;
+            toolbar: boolean;
+            fieldNames: import("../../utils/options").FieldNames;
+            columns: import("../..").PickerColumnOption[] | import("../..").PickerColumnOption[][];
+            selectedValues: (string | number)[];
+            cascade: boolean;
+            dynamic: boolean;
+        }, true, {}, import("vue").SlotsType<import("../..").PickerSlots>, {
+            MIconCheck: {
+                new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<{
+                    size?: string | number | undefined;
+                    color?: string | undefined;
+                    rotate?: number | undefined;
+                    spin?: boolean | undefined;
+                    title?: string | undefined;
+                    strokeWidth?: number | undefined;
+                    strokeLinecap?: "round" | "butt" | "square" | undefined;
+                    strokeLinejoin?: "inherit" | "round" | "bevel" | "miter" | undefined;
+                }> & Readonly<{
+                    onClick?: ((event: MouseEvent) => any) | undefined;
+                }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                    click: (event: MouseEvent) => any;
+                }, import("vue").PublicProps, {
+                    strokeWidth: number;
+                    strokeLinecap: "round" | "butt" | "square";
+                    strokeLinejoin: "inherit" | "round" | "bevel" | "miter";
+                }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+                    P: {};
+                    B: {};
+                    D: {};
+                    C: {};
+                    M: {};
+                    Defaults: {};
+                }, Readonly<{
+                    size?: string | number | undefined;
+                    color?: string | undefined;
+                    rotate?: number | undefined;
+                    spin?: boolean | undefined;
+                    title?: string | undefined;
+                    strokeWidth?: number | undefined;
+                    strokeLinecap?: "round" | "butt" | "square" | undefined;
+                    strokeLinejoin?: "inherit" | "round" | "bevel" | "miter" | undefined;
+                }> & Readonly<{
+                    onClick?: ((event: MouseEvent) => any) | undefined;
+                }>, {}, {}, {}, {}, {
+                    strokeWidth: number;
+                    strokeLinecap: "round" | "butt" | "square";
+                    strokeLinejoin: "inherit" | "round" | "bevel" | "miter";
+                }>;
+                __isFragment?: undefined;
+                __isTeleport?: undefined;
+                __isSuspense?: undefined;
+            } & import("vue").ComponentOptionsBase<Readonly<{
+                size?: string | number | undefined;
+                color?: string | undefined;
+                rotate?: number | undefined;
+                spin?: boolean | undefined;
+                title?: string | undefined;
+                strokeWidth?: number | undefined;
+                strokeLinecap?: "round" | "butt" | "square" | undefined;
+                strokeLinejoin?: "inherit" | "round" | "bevel" | "miter" | undefined;
+            }> & Readonly<{
+                onClick?: ((event: MouseEvent) => any) | undefined;
+            }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                click: (event: MouseEvent) => any;
+            }, string, {
+                strokeWidth: number;
+                strokeLinecap: "round" | "butt" | "square";
+                strokeLinejoin: "inherit" | "round" | "bevel" | "miter";
+            }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+                install(app: import("vue").App<any>): void;
+            };
+            MpButton: {
+                new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+                    status: {
+                        type: PropType<"success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger">;
+                        validator: (v: "success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger") => boolean;
+                    };
+                    variant: {
+                        type: PropType<"default" | "text" | "tonal" | "outline">;
+                        validator: (v: "default" | "text" | "tonal" | "outline") => boolean;
+                    };
+                    size: {
+                        type: PropType<"xs" | "sm" | "md" | "lg" | "xl">;
+                        validator: (v: "xs" | "sm" | "md" | "lg" | "xl") => boolean;
+                    };
+                    htmlType: {
+                        type: PropType<"button" | "reset" | "submit">;
+                        default: string;
+                        validator: (v: "button" | "reset" | "submit") => boolean;
+                    };
+                    component: {
+                        type: PropType<"a" | "button">;
+                        default: string;
+                        validator: (v: "a" | "button") => boolean;
+                    };
+                    round: BooleanConstructor;
+                    block: BooleanConstructor;
+                    loading: BooleanConstructor;
+                    loadingType: {
+                        type: PropType<import("../..").LoadingType>;
+                        default: string;
+                    };
+                    loadingMode: {
+                        type: PropType<"fill" | "default" | "line">;
+                        default: string;
+                        validator: (v: "fill" | "default" | "line") => boolean;
+                    };
+                    loadingSize: PropType<import("../..").LoadingSize>;
+                    loadingColor: {
+                        type: StringConstructor;
+                        default: string;
+                    };
+                    disabled: {
+                        type: BooleanConstructor;
+                        default: undefined;
+                    };
+                    ripple: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    focusable: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    autofocus: BooleanConstructor;
+                    textColor: StringConstructor;
+                    color: StringConstructor;
+                    elevation: {
+                        type: PropType<number | boolean>;
+                        default: boolean;
+                    };
+                    stacked: {
+                        type: BooleanConstructor;
+                        default: undefined;
+                    };
+                }>> & Readonly<{
+                    onClick?: ((event: MouseEvent) => any) | undefined;
+                }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                    click: (event: MouseEvent) => any;
+                }, import("vue").PublicProps, {
+                    elevation: number | boolean;
+                    disabled: boolean;
+                    loading: boolean;
+                    component: "a" | "button";
+                    ripple: boolean;
+                    loadingMode: "fill" | "default" | "line";
+                    autofocus: boolean;
+                    stacked: boolean;
+                    htmlType: "button" | "reset" | "submit";
+                    round: boolean;
+                    block: boolean;
+                    loadingType: import("../..").LoadingType;
+                    loadingColor: string;
+                    focusable: boolean;
+                }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+                    P: {};
+                    B: {};
+                    D: {};
+                    C: {};
+                    M: {};
+                    Defaults: {};
+                }, Readonly<import("vue").ExtractPropTypes<{
+                    status: {
+                        type: PropType<"success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger">;
+                        validator: (v: "success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger") => boolean;
+                    };
+                    variant: {
+                        type: PropType<"default" | "text" | "tonal" | "outline">;
+                        validator: (v: "default" | "text" | "tonal" | "outline") => boolean;
+                    };
+                    size: {
+                        type: PropType<"xs" | "sm" | "md" | "lg" | "xl">;
+                        validator: (v: "xs" | "sm" | "md" | "lg" | "xl") => boolean;
+                    };
+                    htmlType: {
+                        type: PropType<"button" | "reset" | "submit">;
+                        default: string;
+                        validator: (v: "button" | "reset" | "submit") => boolean;
+                    };
+                    component: {
+                        type: PropType<"a" | "button">;
+                        default: string;
+                        validator: (v: "a" | "button") => boolean;
+                    };
+                    round: BooleanConstructor;
+                    block: BooleanConstructor;
+                    loading: BooleanConstructor;
+                    loadingType: {
+                        type: PropType<import("../..").LoadingType>;
+                        default: string;
+                    };
+                    loadingMode: {
+                        type: PropType<"fill" | "default" | "line">;
+                        default: string;
+                        validator: (v: "fill" | "default" | "line") => boolean;
+                    };
+                    loadingSize: PropType<import("../..").LoadingSize>;
+                    loadingColor: {
+                        type: StringConstructor;
+                        default: string;
+                    };
+                    disabled: {
+                        type: BooleanConstructor;
+                        default: undefined;
+                    };
+                    ripple: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    focusable: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    autofocus: BooleanConstructor;
+                    textColor: StringConstructor;
+                    color: StringConstructor;
+                    elevation: {
+                        type: PropType<number | boolean>;
+                        default: boolean;
+                    };
+                    stacked: {
+                        type: BooleanConstructor;
+                        default: undefined;
+                    };
+                }>> & Readonly<{
+                    onClick?: ((event: MouseEvent) => any) | undefined;
+                }>, {}, {}, {}, {}, {
+                    elevation: number | boolean;
+                    disabled: boolean;
+                    loading: boolean;
+                    component: "a" | "button";
+                    ripple: boolean;
+                    loadingMode: "fill" | "default" | "line";
+                    autofocus: boolean;
+                    stacked: boolean;
+                    htmlType: "button" | "reset" | "submit";
+                    round: boolean;
+                    block: boolean;
+                    loadingType: import("../..").LoadingType;
+                    loadingColor: string;
+                    focusable: boolean;
+                }>;
+                __isFragment?: undefined;
+                __isTeleport?: undefined;
+                __isSuspense?: undefined;
+            } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+                status: {
+                    type: PropType<"success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger">;
+                    validator: (v: "success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger") => boolean;
+                };
+                variant: {
+                    type: PropType<"default" | "text" | "tonal" | "outline">;
+                    validator: (v: "default" | "text" | "tonal" | "outline") => boolean;
+                };
+                size: {
+                    type: PropType<"xs" | "sm" | "md" | "lg" | "xl">;
+                    validator: (v: "xs" | "sm" | "md" | "lg" | "xl") => boolean;
+                };
+                htmlType: {
+                    type: PropType<"button" | "reset" | "submit">;
+                    default: string;
+                    validator: (v: "button" | "reset" | "submit") => boolean;
+                };
+                component: {
+                    type: PropType<"a" | "button">;
+                    default: string;
+                    validator: (v: "a" | "button") => boolean;
+                };
+                round: BooleanConstructor;
+                block: BooleanConstructor;
+                loading: BooleanConstructor;
+                loadingType: {
+                    type: PropType<import("../..").LoadingType>;
+                    default: string;
+                };
+                loadingMode: {
+                    type: PropType<"fill" | "default" | "line">;
+                    default: string;
+                    validator: (v: "fill" | "default" | "line") => boolean;
+                };
+                loadingSize: PropType<import("../..").LoadingSize>;
+                loadingColor: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: undefined;
+                };
+                ripple: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                focusable: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                autofocus: BooleanConstructor;
+                textColor: StringConstructor;
+                color: StringConstructor;
+                elevation: {
+                    type: PropType<number | boolean>;
+                    default: boolean;
+                };
+                stacked: {
+                    type: BooleanConstructor;
+                    default: undefined;
+                };
+            }>> & Readonly<{
+                onClick?: ((event: MouseEvent) => any) | undefined;
+            }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                click: (event: MouseEvent) => any;
+            }, string, {
+                elevation: number | boolean;
+                disabled: boolean;
+                loading: boolean;
+                component: "a" | "button";
+                ripple: boolean;
+                loadingMode: "fill" | "default" | "line";
+                autofocus: boolean;
+                stacked: boolean;
+                htmlType: "button" | "reset" | "submit";
+                round: boolean;
+                block: boolean;
+                loadingType: import("../..").LoadingType;
+                loadingColor: string;
+                focusable: boolean;
+            }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+                $slots: {
+                    icon?: ((props: {}) => any) | undefined;
+                } & {
+                    default?: ((props: {}) => any) | undefined;
+                };
+            }) & {
+                setPropsDefaults: (defaults: Record<string, any>) => void;
+            };
+            MpIcon: {
+                new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+                    name: StringConstructor;
+                    size: (NumberConstructor | StringConstructor)[];
+                    color: StringConstructor;
+                    rotate: NumberConstructor;
+                    spin: BooleanConstructor;
+                    transition: {
+                        type: (NumberConstructor | StringConstructor)[];
+                        default: number;
+                    };
+                    animationClass: StringConstructor;
+                }>> & Readonly<{
+                    onClick?: ((event: MouseEvent) => any) | undefined;
+                }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                    click: (event: MouseEvent) => any;
+                }, import("vue").PublicProps, {
+                    transition: string | number;
+                    spin: boolean;
+                }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+                    P: {};
+                    B: {};
+                    D: {};
+                    C: {};
+                    M: {};
+                    Defaults: {};
+                }, Readonly<import("vue").ExtractPropTypes<{
+                    name: StringConstructor;
+                    size: (NumberConstructor | StringConstructor)[];
+                    color: StringConstructor;
+                    rotate: NumberConstructor;
+                    spin: BooleanConstructor;
+                    transition: {
+                        type: (NumberConstructor | StringConstructor)[];
+                        default: number;
+                    };
+                    animationClass: StringConstructor;
+                }>> & Readonly<{
+                    onClick?: ((event: MouseEvent) => any) | undefined;
+                }>, {}, {}, {}, {}, {
+                    transition: string | number;
+                    spin: boolean;
+                }>;
+                __isFragment?: undefined;
+                __isTeleport?: undefined;
+                __isSuspense?: undefined;
+            } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+                name: StringConstructor;
+                size: (NumberConstructor | StringConstructor)[];
+                color: StringConstructor;
+                rotate: NumberConstructor;
+                spin: BooleanConstructor;
+                transition: {
+                    type: (NumberConstructor | StringConstructor)[];
+                    default: number;
+                };
+                animationClass: StringConstructor;
+            }>> & Readonly<{
+                onClick?: ((event: MouseEvent) => any) | undefined;
+            }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                click: (event: MouseEvent) => any;
+            }, string, {
+                transition: string | number;
+                spin: boolean;
+            }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+                $slots: {
+                    default?: ((props: {}) => any) | undefined;
+                };
+            });
+            MpPopup: {
+                new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+                    loading: BooleanConstructor;
+                    dir: {
+                        type: PropType<import("@maple-design/use-vue").ReadingDirection>;
+                    };
+                    beforeClose: PropType<import("../..").PopupBeforeClose>;
+                    open: {
+                        type: BooleanConstructor;
+                        default: undefined;
+                    };
+                    defaultOpen: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    placement: {
+                        type: PropType<import("../..").PopupPlacement>;
+                        default: string;
+                    };
+                    swipeToClose: BooleanConstructor;
+                    swipeThreshold: {
+                        type: NumberConstructor;
+                        default: number;
+                    };
+                    transition: StringConstructor;
+                    overlayAnimationName: {
+                        type: StringConstructor;
+                        default: undefined;
+                    };
+                    overlay: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    overlayClass: StringConstructor;
+                    overlayStyle: ObjectConstructor;
+                    lockScroll: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    overlayClosable: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    escToClose: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    unstyled: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    zIndex: NumberConstructor;
+                    safeAreaInsetBottom: BooleanConstructor;
+                    safeAreaInsetTop: BooleanConstructor;
+                    safeAreaInsetRight: BooleanConstructor;
+                    safeAreaInsetLeft: BooleanConstructor;
+                    unmountOnClose: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    closeOnRouteChange: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    popupContainer: {
+                        type: PropType<import("../..").PopupContainer>;
+                        default: undefined;
+                        validator: ((value: unknown) => boolean) | undefined;
+                    };
+                }>> & Readonly<{
+                    onClose?: (() => any) | undefined;
+                    onOpen?: (() => any) | undefined;
+                    onOpened?: (() => any) | undefined;
+                    onClosed?: (() => any) | undefined;
+                    "onClick-overlay"?: ((value: MouseEvent) => any) | undefined;
+                    "onKey-escape"?: ((value: KeyboardEvent) => any) | undefined;
+                    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+                    "onSwipe-close"?: ((value: PointerEvent) => any) | undefined;
+                    "onClose-error"?: ((error: unknown, reason: import("../..").PopupCloseReason) => any) | undefined;
+                }>, {
+                    close: (event?: Event | undefined) => Promise<boolean>;
+                    requestClose: (reason?: import("../..").PopupCloseReason, event?: Event | undefined) => Promise<boolean>;
+                    pending: import("vue").ComputedRef<boolean>;
+                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                    "update:open": (value: boolean) => void;
+                    close: () => void;
+                    open: () => void;
+                    opened: () => void;
+                    closed: () => void;
+                    "swipe-close": (value: PointerEvent) => void;
+                    "close-error": (error: unknown, reason: import("../..").PopupCloseReason) => void;
+                    "click-overlay": (value: MouseEvent) => void;
+                    "key-escape": (value: KeyboardEvent) => void;
+                }, import("vue").PublicProps, {
+                    loading: boolean;
+                    open: boolean;
+                    overlay: boolean;
+                    defaultOpen: boolean;
+                    placement: import("../..").PopupPlacement;
+                    swipeToClose: boolean;
+                    swipeThreshold: number;
+                    overlayAnimationName: string;
+                    lockScroll: boolean;
+                    overlayClosable: boolean;
+                    escToClose: boolean;
+                    unstyled: boolean;
+                    safeAreaInsetBottom: boolean;
+                    safeAreaInsetTop: boolean;
+                    safeAreaInsetRight: boolean;
+                    safeAreaInsetLeft: boolean;
+                    unmountOnClose: boolean;
+                    closeOnRouteChange: boolean;
+                    popupContainer: import("../..").PopupContainer;
+                }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+                    P: {};
+                    B: {};
+                    D: {};
+                    C: {};
+                    M: {};
+                    Defaults: {};
+                }, Readonly<import("vue").ExtractPropTypes<{
+                    loading: BooleanConstructor;
+                    dir: {
+                        type: PropType<import("@maple-design/use-vue").ReadingDirection>;
+                    };
+                    beforeClose: PropType<import("../..").PopupBeforeClose>;
+                    open: {
+                        type: BooleanConstructor;
+                        default: undefined;
+                    };
+                    defaultOpen: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    placement: {
+                        type: PropType<import("../..").PopupPlacement>;
+                        default: string;
+                    };
+                    swipeToClose: BooleanConstructor;
+                    swipeThreshold: {
+                        type: NumberConstructor;
+                        default: number;
+                    };
+                    transition: StringConstructor;
+                    overlayAnimationName: {
+                        type: StringConstructor;
+                        default: undefined;
+                    };
+                    overlay: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    overlayClass: StringConstructor;
+                    overlayStyle: ObjectConstructor;
+                    lockScroll: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    overlayClosable: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    escToClose: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    unstyled: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    zIndex: NumberConstructor;
+                    safeAreaInsetBottom: BooleanConstructor;
+                    safeAreaInsetTop: BooleanConstructor;
+                    safeAreaInsetRight: BooleanConstructor;
+                    safeAreaInsetLeft: BooleanConstructor;
+                    unmountOnClose: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    closeOnRouteChange: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    popupContainer: {
+                        type: PropType<import("../..").PopupContainer>;
+                        default: undefined;
+                        validator: ((value: unknown) => boolean) | undefined;
+                    };
+                }>> & Readonly<{
+                    onClose?: (() => any) | undefined;
+                    onOpen?: (() => any) | undefined;
+                    onOpened?: (() => any) | undefined;
+                    onClosed?: (() => any) | undefined;
+                    "onClick-overlay"?: ((value: MouseEvent) => any) | undefined;
+                    "onKey-escape"?: ((value: KeyboardEvent) => any) | undefined;
+                    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+                    "onSwipe-close"?: ((value: PointerEvent) => any) | undefined;
+                    "onClose-error"?: ((error: unknown, reason: import("../..").PopupCloseReason) => any) | undefined;
+                }>, {
+                    close: (event?: Event | undefined) => Promise<boolean>;
+                    requestClose: (reason?: import("../..").PopupCloseReason, event?: Event | undefined) => Promise<boolean>;
+                    pending: import("vue").ComputedRef<boolean>;
+                }, {}, {}, {}, {
+                    loading: boolean;
+                    open: boolean;
+                    overlay: boolean;
+                    defaultOpen: boolean;
+                    placement: import("../..").PopupPlacement;
+                    swipeToClose: boolean;
+                    swipeThreshold: number;
+                    overlayAnimationName: string;
+                    lockScroll: boolean;
+                    overlayClosable: boolean;
+                    escToClose: boolean;
+                    unstyled: boolean;
+                    safeAreaInsetBottom: boolean;
+                    safeAreaInsetTop: boolean;
+                    safeAreaInsetRight: boolean;
+                    safeAreaInsetLeft: boolean;
+                    unmountOnClose: boolean;
+                    closeOnRouteChange: boolean;
+                    popupContainer: import("../..").PopupContainer;
+                }>;
+                __isFragment?: undefined;
+                __isTeleport?: undefined;
+                __isSuspense?: undefined;
+            } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+                loading: BooleanConstructor;
+                dir: {
+                    type: PropType<import("@maple-design/use-vue").ReadingDirection>;
+                };
+                beforeClose: PropType<import("../..").PopupBeforeClose>;
+                open: {
+                    type: BooleanConstructor;
+                    default: undefined;
+                };
+                defaultOpen: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                placement: {
+                    type: PropType<import("../..").PopupPlacement>;
+                    default: string;
+                };
+                swipeToClose: BooleanConstructor;
+                swipeThreshold: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+                transition: StringConstructor;
+                overlayAnimationName: {
+                    type: StringConstructor;
+                    default: undefined;
+                };
+                overlay: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                overlayClass: StringConstructor;
+                overlayStyle: ObjectConstructor;
+                lockScroll: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                overlayClosable: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                escToClose: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                unstyled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                zIndex: NumberConstructor;
+                safeAreaInsetBottom: BooleanConstructor;
+                safeAreaInsetTop: BooleanConstructor;
+                safeAreaInsetRight: BooleanConstructor;
+                safeAreaInsetLeft: BooleanConstructor;
+                unmountOnClose: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                closeOnRouteChange: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                popupContainer: {
+                    type: PropType<import("../..").PopupContainer>;
+                    default: undefined;
+                    validator: ((value: unknown) => boolean) | undefined;
+                };
+            }>> & Readonly<{
+                onClose?: (() => any) | undefined;
+                onOpen?: (() => any) | undefined;
+                onOpened?: (() => any) | undefined;
+                onClosed?: (() => any) | undefined;
+                "onClick-overlay"?: ((value: MouseEvent) => any) | undefined;
+                "onKey-escape"?: ((value: KeyboardEvent) => any) | undefined;
+                "onUpdate:open"?: ((value: boolean) => any) | undefined;
+                "onSwipe-close"?: ((value: PointerEvent) => any) | undefined;
+                "onClose-error"?: ((error: unknown, reason: import("../..").PopupCloseReason) => any) | undefined;
+            }>, {
+                close: (event?: Event | undefined) => Promise<boolean>;
+                requestClose: (reason?: import("../..").PopupCloseReason, event?: Event | undefined) => Promise<boolean>;
+                pending: import("vue").ComputedRef<boolean>;
+            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                "update:open": (value: boolean) => void;
+                close: () => void;
+                open: () => void;
+                opened: () => void;
+                closed: () => void;
+                "swipe-close": (value: PointerEvent) => void;
+                "close-error": (error: unknown, reason: import("../..").PopupCloseReason) => void;
+                "click-overlay": (value: MouseEvent) => void;
+                "key-escape": (value: KeyboardEvent) => void;
+            }, string, {
+                loading: boolean;
+                open: boolean;
+                overlay: boolean;
+                defaultOpen: boolean;
+                placement: import("../..").PopupPlacement;
+                swipeToClose: boolean;
+                swipeThreshold: number;
+                overlayAnimationName: string;
+                lockScroll: boolean;
+                overlayClosable: boolean;
+                escToClose: boolean;
+                unstyled: boolean;
+                safeAreaInsetBottom: boolean;
+                safeAreaInsetTop: boolean;
+                safeAreaInsetRight: boolean;
+                safeAreaInsetLeft: boolean;
+                unmountOnClose: boolean;
+                closeOnRouteChange: boolean;
+                popupContainer: import("../..").PopupContainer;
+            }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+                $slots: {
+                    default?: ((props: {
+                        close: (reason?: import("../..").PopupCloseReason, event?: Event | undefined) => Promise<boolean>;
+                        pending: boolean;
+                    }) => any) | undefined;
+                };
+            });
+        } & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import("vue").ExtractPropTypes<{
+            safeArea: BooleanConstructor;
+            open: {
+                type: BooleanConstructor;
+                default: undefined;
+            };
+            defaultOpen: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            overlayClosable: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            escToClose: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            popupContainer: {
+                type: PropType<import("../..").PopupContainer>;
+                default: undefined;
+                validator: ((value: unknown) => boolean) | undefined;
+            };
+            modelValue: {
+                type: PropType<(string | number)[]>;
+                default: undefined;
+            };
+            defaultValue: {
+                type: PropType<(string | number)[]>;
+                default: () => never[];
+            };
+            columns: {
+                type: PropType<import("../..").PickerColumnOption[] | import("../..").PickerColumnOption[][]>;
+                default: () => never[];
+            };
+            title: StringConstructor;
+            fieldNames: {
+                type: PropType<import("../../utils/options").FieldNames>;
+                default: undefined;
+            };
+            toolbar: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            disabled: BooleanConstructor;
+            selectedValues: {
+                type: PropType<(string | number)[]>;
+                default: () => never[];
+            };
+            cascade: BooleanConstructor;
+            optionHeight: {
+                type: (NumberConstructor | StringConstructor)[];
+                default: number;
+            };
+            optionCount: {
+                type: (NumberConstructor | StringConstructor)[];
+                default: number;
+            };
+            columnsCount: (NumberConstructor | StringConstructor)[];
+            confirmButtonText: StringConstructor;
+            cancelButtonText: StringConstructor;
+            confirmButtonTextColor: StringConstructor;
+            cancelButtonTextColor: StringConstructor;
+            dynamic: BooleanConstructor;
+        }>> & Readonly<{
+            onCancel?: ((values: (string | number)[], indexes: number[], options: import("../..").PickerColumnOption[]) => any) | undefined;
+            onChange?: ((values: (string | number)[], indexes: number[], options: import("../..").PickerColumnOption[]) => any) | undefined;
+            onClose?: (() => any) | undefined;
+            onOpen?: (() => any) | undefined;
+            onOpened?: (() => any) | undefined;
+            onClosed?: (() => any) | undefined;
+            "onClick-overlay"?: ((event: MouseEvent) => any) | undefined;
+            "onKey-escape"?: ((event: KeyboardEvent) => any) | undefined;
+            "onUpdate:open"?: ((open: boolean) => any) | undefined;
+            onConfirm?: ((values: (string | number)[], indexes: number[], options: import("../..").PickerColumnOption[]) => any) | undefined;
+            "onUpdate:modelValue"?: ((value: (string | number)[]) => any) | undefined;
+        }>, {
+            describeError: (value: unknown) => string | undefined;
+            mergedError: import("vue").ComputedRef<boolean>;
+            mergedOpen: import("vue").ComputedRef<boolean>;
+            controlId: string;
+            handleColumnKeydown: (event: KeyboardEvent, column: import("../../picker/Picker.vue").ScrollColumn) => void;
+            optionHeight: import("vue").ComputedRef<number>;
+            optionCount: import("vue").ComputedRef<number>;
+            scrollColumns: import("vue").Ref<{
+                id: number;
+                touching: boolean;
+                index: number;
+                prevY: number;
+                momentumPrevY: number;
+                momentumTime: number;
+                translate: number;
+                duration: number;
+                scrolling: boolean;
+                column: {
+                    [x: string]: any;
+                    [x: number]: any;
+                    [x: symbol]: any;
+                    text?: string | number | undefined;
+                    value?: string | number | undefined;
+                    disabled?: boolean | undefined;
+                    children?: any[] | undefined;
+                    className?: string | undefined;
+                    textClassName?: string | undefined;
+                }[];
+                scrollEl: HTMLElement | null;
+            }[], import("../../picker/Picker.vue").ScrollColumn[] | {
+                id: number;
+                touching: boolean;
+                index: number;
+                prevY: number;
+                momentumPrevY: number;
+                momentumTime: number;
+                translate: number;
+                duration: number;
+                scrolling: boolean;
+                column: {
+                    [x: string]: any;
+                    [x: number]: any;
+                    [x: symbol]: any;
+                    text?: string | number | undefined;
+                    value?: string | number | undefined;
+                    disabled?: boolean | undefined;
+                    children?: any[] | undefined;
+                    className?: string | undefined;
+                    textClassName?: string | undefined;
+                }[];
+                scrollEl: HTMLElement | null;
+            }[]>;
+            columnHeight: import("vue").ComputedRef<number>;
+            center: import("vue").ComputedRef<number>;
+            confirmButtonDisabled: import("vue").ComputedRef<boolean>;
+            Transition: import("vue").FunctionalComponent<import("vue").TransitionProps, {}, any, {}>;
+            toRaw: typeof import("vue").toRaw;
+            pt: ((id: string) => string | undefined) | null;
+            t: typeof import("../../locale/temporal-text").temporalText;
+            n: (suffix?: string | undefined) => string;
+            classes: (...names: (import("../../utils/components").NamespaceClass | [unknown, import("../../utils/components").NamespaceClass, import("../../utils/components").NamespaceClass?])[]) => import("../../utils/components").NamespaceClass[];
+            isOptionSelected: (option: import("../..").PickerColumnOption) => boolean;
+            isOptionDisabled: (option?: import("../..").PickerColumnOption | undefined) => boolean;
+            setScrollEl: (el: Element | import("vue").ComponentPublicInstance | null, scrollColumn: import("../../picker/Picker.vue").ScrollColumn) => void;
+            getOptionKey: (key: "value" | "text" | "children") => string;
+            getValue: (option: import("../..").PickerColumnOption) => string | number;
+            handlePopupUpdateShow: (value: boolean) => void;
+            handlePopupOverlayClick: (event: MouseEvent) => void;
+            handlePopupKeyEscape: (event: KeyboardEvent) => void;
+            handleTouchstart: (event: TouchEvent, scrollColumn: import("../../picker/Picker.vue").ScrollColumn) => void;
+            handleTouchmove: (event: TouchEvent, scrollColumn: import("../../picker/Picker.vue").ScrollColumn) => void;
+            handleTouchend: (scrollColumn: import("../../picker/Picker.vue").ScrollColumn) => void;
+            handleTransitionend: (scrollColumn: import("../../picker/Picker.vue").ScrollColumn, event?: TransitionEvent | undefined) => void;
+            confirm: () => void;
+            cancel: () => void;
+            handleClick: (scrollColumn: import("../../picker/Picker.vue").ScrollColumn, index: number) => void;
+        }, {}, {}, {}, {
+            optionHeight: string | number;
+            optionCount: string | number;
+            modelValue: (string | number)[];
+            defaultValue: (string | number)[];
+            disabled: boolean;
+            open: boolean;
+            defaultOpen: boolean;
+            overlayClosable: boolean;
+            escToClose: boolean;
+            popupContainer: import("../..").PopupContainer;
+            safeArea: boolean;
+            toolbar: boolean;
+            fieldNames: import("../../utils/options").FieldNames;
+            columns: import("../..").PickerColumnOption[] | import("../..").PickerColumnOption[][];
+            selectedValues: (string | number)[];
+            cascade: boolean;
+            dynamic: boolean;
+        }>;
+        __isFragment?: undefined;
+        __isTeleport?: undefined;
+        __isSuspense?: undefined;
+    } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
         safeArea: BooleanConstructor;
         open: {
             type: BooleanConstructor;
@@ -239,7 +1351,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
             default: () => never[];
         };
         columns: {
-            type: PropType<import("../../picker").PickerColumnOption[] | import("../../picker").PickerColumnOption[][]>;
+            type: PropType<import("../..").PickerColumnOption[] | import("../..").PickerColumnOption[][]>;
             default: () => never[];
         };
         title: StringConstructor;
@@ -271,6 +1383,18 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         confirmButtonTextColor: StringConstructor;
         cancelButtonTextColor: StringConstructor;
         dynamic: BooleanConstructor;
+    }>> & Readonly<{
+        onCancel?: ((values: (string | number)[], indexes: number[], options: import("../..").PickerColumnOption[]) => any) | undefined;
+        onChange?: ((values: (string | number)[], indexes: number[], options: import("../..").PickerColumnOption[]) => any) | undefined;
+        onClose?: (() => any) | undefined;
+        onOpen?: (() => any) | undefined;
+        onOpened?: (() => any) | undefined;
+        onClosed?: (() => any) | undefined;
+        "onClick-overlay"?: ((event: MouseEvent) => any) | undefined;
+        "onKey-escape"?: ((event: KeyboardEvent) => any) | undefined;
+        "onUpdate:open"?: ((open: boolean) => any) | undefined;
+        onConfirm?: ((values: (string | number)[], indexes: number[], options: import("../..").PickerColumnOption[]) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: (string | number)[]) => any) | undefined;
     }>, {
         describeError: (value: unknown) => string | undefined;
         mergedError: import("vue").ComputedRef<boolean>;
@@ -330,113 +1454,37 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         Transition: import("vue").FunctionalComponent<import("vue").TransitionProps, {}, any, {}>;
         toRaw: typeof import("vue").toRaw;
         pt: ((id: string) => string | undefined) | null;
-        t: (id: string) => any;
+        t: typeof import("../../locale/temporal-text").temporalText;
         n: (suffix?: string | undefined) => string;
         classes: (...names: (import("../../utils/components").NamespaceClass | [unknown, import("../../utils/components").NamespaceClass, import("../../utils/components").NamespaceClass?])[]) => import("../../utils/components").NamespaceClass[];
-        isOptionSelected: (option: import("../../picker").PickerColumnOption) => boolean;
-        isOptionDisabled: (option?: import("../../picker").PickerColumnOption | undefined) => boolean;
+        isOptionSelected: (option: import("../..").PickerColumnOption) => boolean;
+        isOptionDisabled: (option?: import("../..").PickerColumnOption | undefined) => boolean;
         setScrollEl: (el: Element | import("vue").ComponentPublicInstance | null, scrollColumn: import("../../picker/Picker.vue").ScrollColumn) => void;
         getOptionKey: (key: "value" | "text" | "children") => string;
-        getValue: (option: import("../../picker").PickerColumnOption) => string | number;
+        getValue: (option: import("../..").PickerColumnOption) => string | number;
         handlePopupUpdateShow: (value: boolean) => void;
         handlePopupOverlayClick: (event: MouseEvent) => void;
         handlePopupKeyEscape: (event: KeyboardEvent) => void;
         handleTouchstart: (event: TouchEvent, scrollColumn: import("../../picker/Picker.vue").ScrollColumn) => void;
-        handleTouchmove: (event: TouchEvent, scrollColumn: import("../../picker/Picker.vue").ScrollColumn) => void;
-        handleTouchend: (scrollColumn: import("../../picker/Picker.vue").ScrollColumn) => void;
-        handleTransitionend: (scrollColumn: import("../../picker/Picker.vue").ScrollColumn, event?: TransitionEvent | undefined) => void;
-        confirm: () => void;
-        cancel: () => void;
-        handleClick: (scrollColumn: import("../../picker/Picker.vue").ScrollColumn, index: number) => void;
-    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-        confirm: (values: (string | number)[], indexes: number[], options: import("../../picker").PickerColumnOption[]) => true;
-        cancel: (values: (string | number)[], indexes: number[], options: import("../../picker").PickerColumnOption[]) => true;
-        change: (values: (string | number)[], indexes: number[], options: import("../../picker").PickerColumnOption[]) => true;
-        'update:open': (open: boolean) => true;
-        'update:modelValue': (value: (string | number)[]) => true;
-        open: () => true;
-        opened: () => true;
-        close: () => true;
-        closed: () => true;
-        'click-overlay': (event: MouseEvent) => true;
-        'key-escape': (event: KeyboardEvent) => true;
-    }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
-        safeArea: BooleanConstructor;
-        open: {
-            type: BooleanConstructor;
-            default: undefined;
-        };
-        defaultOpen: {
-            type: BooleanConstructor;
-            default: boolean;
-        };
-        overlayClosable: {
-            type: BooleanConstructor;
-            default: boolean;
-        };
-        escToClose: {
-            type: BooleanConstructor;
-            default: boolean;
-        };
-        popupContainer: {
-            type: PropType<import("../..").PopupContainer>;
-            default: undefined;
-            validator: ((value: unknown) => boolean) | undefined;
-        };
-        modelValue: {
-            type: PropType<(string | number)[]>;
-            default: undefined;
-        };
-        defaultValue: {
-            type: PropType<(string | number)[]>;
-            default: () => never[];
-        };
-        columns: {
-            type: PropType<import("../../picker").PickerColumnOption[] | import("../../picker").PickerColumnOption[][]>;
-            default: () => never[];
-        };
-        title: StringConstructor;
-        fieldNames: {
-            type: PropType<import("../../utils/options").FieldNames>;
-            default: undefined;
-        };
-        toolbar: {
-            type: BooleanConstructor;
-            default: boolean;
-        };
-        disabled: BooleanConstructor;
-        selectedValues: {
-            type: PropType<(string | number)[]>;
-            default: () => never[];
-        };
-        cascade: BooleanConstructor;
-        optionHeight: {
-            type: (NumberConstructor | StringConstructor)[];
-            default: number;
-        };
-        optionCount: {
-            type: (NumberConstructor | StringConstructor)[];
-            default: number;
-        };
-        columnsCount: (NumberConstructor | StringConstructor)[];
-        confirmButtonText: StringConstructor;
-        cancelButtonText: StringConstructor;
-        confirmButtonTextColor: StringConstructor;
-        cancelButtonTextColor: StringConstructor;
-        dynamic: BooleanConstructor;
-    }>> & Readonly<{
-        onCancel?: ((values: (string | number)[], indexes: number[], options: import("../../picker").PickerColumnOption[]) => any) | undefined;
-        onChange?: ((values: (string | number)[], indexes: number[], options: import("../../picker").PickerColumnOption[]) => any) | undefined;
-        onClose?: (() => any) | undefined;
-        onOpen?: (() => any) | undefined;
-        onOpened?: (() => any) | undefined;
-        onClosed?: (() => any) | undefined;
-        "onClick-overlay"?: ((event: MouseEvent) => any) | undefined;
-        "onKey-escape"?: ((event: KeyboardEvent) => any) | undefined;
-        "onUpdate:open"?: ((open: boolean) => any) | undefined;
-        onConfirm?: ((values: (string | number)[], indexes: number[], options: import("../../picker").PickerColumnOption[]) => any) | undefined;
-        "onUpdate:modelValue"?: ((value: (string | number)[]) => any) | undefined;
-    }>, {
+        handleTouchmove: (event: TouchEvent, scrollColumn: import("../../picker/Picker.vue").ScrollColumn) => void;
+        handleTouchend: (scrollColumn: import("../../picker/Picker.vue").ScrollColumn) => void;
+        handleTransitionend: (scrollColumn: import("../../picker/Picker.vue").ScrollColumn, event?: TransitionEvent | undefined) => void;
+        confirm: () => void;
+        cancel: () => void;
+        handleClick: (scrollColumn: import("../../picker/Picker.vue").ScrollColumn, index: number) => void;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        confirm: (values: (string | number)[], indexes: number[], options: import("../..").PickerColumnOption[]) => true;
+        cancel: (values: (string | number)[], indexes: number[], options: import("../..").PickerColumnOption[]) => true;
+        change: (values: (string | number)[], indexes: number[], options: import("../..").PickerColumnOption[]) => true;
+        'update:open': (open: boolean) => true;
+        'update:modelValue': (value: (string | number)[]) => true;
+        open: () => true;
+        opened: () => true;
+        close: () => true;
+        closed: () => true;
+        'click-overlay': (event: MouseEvent) => true;
+        'key-escape': (event: KeyboardEvent) => true;
+    }, string, {
         optionHeight: string | number;
         optionCount: string | number;
         modelValue: (string | number)[];
@@ -450,11 +1498,11 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         safeArea: boolean;
         toolbar: boolean;
         fieldNames: import("../../utils/options").FieldNames;
-        columns: import("../../picker").PickerColumnOption[] | import("../../picker").PickerColumnOption[][];
+        columns: import("../..").PickerColumnOption[] | import("../..").PickerColumnOption[][];
         selectedValues: (string | number)[];
         cascade: boolean;
         dynamic: boolean;
-    }, import("vue").SlotsType<import("../../picker").PickerSlots>, {
+    }, {}, string, import("vue").SlotsType<import("../..").PickerSlots>, {
         MIconCheck: {
             new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<{
                 size?: string | number | undefined;
@@ -519,7 +1567,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
             install(app: import("vue").App<any>): void;
         };
-        MpButton: import("../../utils/components").ComponentWithInstall<{
+        MpButton: {
             new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
                 status: {
                     type: PropType<"success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger">;
@@ -782,129 +1830,8 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
                 default?: ((props: {}) => any) | undefined;
             };
         }) & {
-            Group: {
-                new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
-                    status: {
-                        type: PropType<"success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger">;
-                        default: string;
-                        validator: (value: "success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger") => boolean;
-                    };
-                    size: {
-                        type: PropType<"xs" | "sm" | "md" | "lg" | "xl">;
-                        default: undefined;
-                        validator: (value: "xs" | "sm" | "md" | "lg" | "xl") => boolean;
-                    };
-                    variant: {
-                        type: PropType<"default" | "text" | "tonal" | "outline">;
-                        default: string;
-                        validator: (value: "default" | "text" | "tonal" | "outline") => boolean;
-                    };
-                    color: StringConstructor;
-                    textColor: StringConstructor;
-                    disabled: BooleanConstructor;
-                    stacked: BooleanConstructor;
-                    vertical: BooleanConstructor;
-                    elevation: {
-                        type: (BooleanConstructor | NumberConstructor)[];
-                        default: boolean;
-                    };
-                }>> & Readonly<{}>, {
-                    buttonGroupProvider: import("../../button/group-provide").ButtonGroupProvider;
-                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
-                    size: "xs" | "sm" | "md" | "lg" | "xl";
-                    status: "success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger";
-                    elevation: number | boolean;
-                    disabled: boolean;
-                    vertical: boolean;
-                    variant: "default" | "text" | "tonal" | "outline";
-                    stacked: boolean;
-                }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
-                    P: {};
-                    B: {};
-                    D: {};
-                    C: {};
-                    M: {};
-                    Defaults: {};
-                }, Readonly<import("vue").ExtractPropTypes<{
-                    status: {
-                        type: PropType<"success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger">;
-                        default: string;
-                        validator: (value: "success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger") => boolean;
-                    };
-                    size: {
-                        type: PropType<"xs" | "sm" | "md" | "lg" | "xl">;
-                        default: undefined;
-                        validator: (value: "xs" | "sm" | "md" | "lg" | "xl") => boolean;
-                    };
-                    variant: {
-                        type: PropType<"default" | "text" | "tonal" | "outline">;
-                        default: string;
-                        validator: (value: "default" | "text" | "tonal" | "outline") => boolean;
-                    };
-                    color: StringConstructor;
-                    textColor: StringConstructor;
-                    disabled: BooleanConstructor;
-                    stacked: BooleanConstructor;
-                    vertical: BooleanConstructor;
-                    elevation: {
-                        type: (BooleanConstructor | NumberConstructor)[];
-                        default: boolean;
-                    };
-                }>> & Readonly<{}>, {
-                    buttonGroupProvider: import("../../button/group-provide").ButtonGroupProvider;
-                }, {}, {}, {}, {
-                    size: "xs" | "sm" | "md" | "lg" | "xl";
-                    status: "success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger";
-                    elevation: number | boolean;
-                    disabled: boolean;
-                    vertical: boolean;
-                    variant: "default" | "text" | "tonal" | "outline";
-                    stacked: boolean;
-                }>;
-                __isFragment?: undefined;
-                __isTeleport?: undefined;
-                __isSuspense?: undefined;
-            } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
-                status: {
-                    type: PropType<"success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger">;
-                    default: string;
-                    validator: (value: "success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger") => boolean;
-                };
-                size: {
-                    type: PropType<"xs" | "sm" | "md" | "lg" | "xl">;
-                    default: undefined;
-                    validator: (value: "xs" | "sm" | "md" | "lg" | "xl") => boolean;
-                };
-                variant: {
-                    type: PropType<"default" | "text" | "tonal" | "outline">;
-                    default: string;
-                    validator: (value: "default" | "text" | "tonal" | "outline") => boolean;
-                };
-                color: StringConstructor;
-                textColor: StringConstructor;
-                disabled: BooleanConstructor;
-                stacked: BooleanConstructor;
-                vertical: BooleanConstructor;
-                elevation: {
-                    type: (BooleanConstructor | NumberConstructor)[];
-                    default: boolean;
-                };
-            }>> & Readonly<{}>, {
-                buttonGroupProvider: import("../../button/group-provide").ButtonGroupProvider;
-            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
-                size: "xs" | "sm" | "md" | "lg" | "xl";
-                status: "success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger";
-                elevation: number | boolean;
-                disabled: boolean;
-                vertical: boolean;
-                variant: "default" | "text" | "tonal" | "outline";
-                stacked: boolean;
-            }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
-                $slots: {
-                    default?: ((props: {}) => any) | undefined;
-                };
-            });
-        }>;
+            setPropsDefaults: (defaults: Record<string, any>) => void;
+        };
         MpIcon: {
             new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
                 name: StringConstructor;
@@ -1320,7 +2247,9 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
                 }) => any) | undefined;
             };
         });
-    }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    } & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+        setPropsDefaults: (defaults: Record<string, any>) => void;
+    };
     CalendarContent: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
         calendarLocale: StringConstructor;
         rangeEndpoint: PropType<0 | 1>;
@@ -1444,15 +2373,15 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         timeOnlyColumnLabels: import("vue").ComputedRef<any[]>;
         timeFieldIndexes: import("vue").ComputedRef<number[]>;
         customTimeFields: import("vue").ComputedRef<boolean>;
-        dateTimeColumns: import("vue").ComputedRef<import("../../picker").PickerColumnOption[][]>;
-        timeOnlyColumns: import("vue").ComputedRef<import("../../picker").PickerColumnOption[][]>;
+        dateTimeColumns: import("vue").ComputedRef<import("../..").PickerColumnOption[][]>;
+        timeOnlyColumns: import("vue").ComputedRef<import("../..").PickerColumnOption[][]>;
         dateTimePickerValue: import("vue").ComputedRef<string[]>;
         timeOnlyPickerValue: import("vue").ComputedRef<string[]>;
         pickerBindingProps: import("vue").ComputedRef<import("../../date/wheel-options").DateWheelOptions>;
         handleDateTimePickerChange: (values: (string | number)[]) => void;
         handleTimeOnlyPickerChange: (values: (string | number)[]) => void;
         pt: ((id: string) => string | undefined) | null;
-        t: (id: string) => any;
+        t: typeof t;
         n: (suffix?: string | undefined) => string;
         classes: (...names: (import("../../utils/components").NamespaceClass | [unknown, import("../../utils/components").NamespaceClass, import("../../utils/components").NamespaceClass?])[]) => import("../../utils/components").NamespaceClass[];
         clickEl: (type: string) => void;
@@ -1589,7 +2518,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
             onGridKeydown: (event: KeyboardEvent) => void;
             n: (suffix?: string | undefined) => string;
             nDate: (suffix?: string | undefined) => string;
-            t: (id: string) => any;
+            t: typeof t;
             MONTH_LIST: import("../../date/presentation-props").Month[];
             headerEl: import("vue").Ref<import("vue").RendererNode | null, import("vue").RendererNode | null>;
             reverse: import("vue").Ref<boolean, boolean>;
@@ -1644,7 +2573,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
             readonly: boolean;
             rangePending: boolean;
         }, {}, {
-            MpButton: import("../../utils/components").ComponentWithInstall<{
+            MpButton: {
                 new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
                     status: {
                         type: PropType<"success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger">;
@@ -1837,199 +2766,78 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
                     validator: (v: "button" | "reset" | "submit") => boolean;
                 };
                 component: {
-                    type: PropType<"a" | "button">;
-                    default: string;
-                    validator: (v: "a" | "button") => boolean;
-                };
-                round: BooleanConstructor;
-                block: BooleanConstructor;
-                loading: BooleanConstructor;
-                loadingType: {
-                    type: PropType<import("../..").LoadingType>;
-                    default: string;
-                };
-                loadingMode: {
-                    type: PropType<"fill" | "default" | "line">;
-                    default: string;
-                    validator: (v: "fill" | "default" | "line") => boolean;
-                };
-                loadingSize: PropType<import("../..").LoadingSize>;
-                loadingColor: {
-                    type: StringConstructor;
-                    default: string;
-                };
-                disabled: {
-                    type: BooleanConstructor;
-                    default: undefined;
-                };
-                ripple: {
-                    type: BooleanConstructor;
-                    default: boolean;
-                };
-                focusable: {
-                    type: BooleanConstructor;
-                    default: boolean;
-                };
-                autofocus: BooleanConstructor;
-                textColor: StringConstructor;
-                color: StringConstructor;
-                elevation: {
-                    type: PropType<number | boolean>;
-                    default: boolean;
-                };
-                stacked: {
-                    type: BooleanConstructor;
-                    default: undefined;
-                };
-            }>> & Readonly<{
-                onClick?: ((event: MouseEvent) => any) | undefined;
-            }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-                click: (event: MouseEvent) => any;
-            }, string, {
-                elevation: number | boolean;
-                disabled: boolean;
-                loading: boolean;
-                component: "a" | "button";
-                ripple: boolean;
-                loadingMode: "fill" | "default" | "line";
-                autofocus: boolean;
-                stacked: boolean;
-                htmlType: "button" | "reset" | "submit";
-                round: boolean;
-                block: boolean;
-                loadingType: import("../..").LoadingType;
-                loadingColor: string;
-                focusable: boolean;
-            }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
-                $slots: {
-                    icon?: ((props: {}) => any) | undefined;
-                } & {
-                    default?: ((props: {}) => any) | undefined;
-                };
-            }) & {
-                Group: {
-                    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
-                        status: {
-                            type: PropType<"success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger">;
-                            default: string;
-                            validator: (value: "success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger") => boolean;
-                        };
-                        size: {
-                            type: PropType<"xs" | "sm" | "md" | "lg" | "xl">;
-                            default: undefined;
-                            validator: (value: "xs" | "sm" | "md" | "lg" | "xl") => boolean;
-                        };
-                        variant: {
-                            type: PropType<"default" | "text" | "tonal" | "outline">;
-                            default: string;
-                            validator: (value: "default" | "text" | "tonal" | "outline") => boolean;
-                        };
-                        color: StringConstructor;
-                        textColor: StringConstructor;
-                        disabled: BooleanConstructor;
-                        stacked: BooleanConstructor;
-                        vertical: BooleanConstructor;
-                        elevation: {
-                            type: (BooleanConstructor | NumberConstructor)[];
-                            default: boolean;
-                        };
-                    }>> & Readonly<{}>, {
-                        buttonGroupProvider: import("../../button/group-provide").ButtonGroupProvider;
-                    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
-                        size: "xs" | "sm" | "md" | "lg" | "xl";
-                        status: "success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger";
-                        elevation: number | boolean;
-                        disabled: boolean;
-                        vertical: boolean;
-                        variant: "default" | "text" | "tonal" | "outline";
-                        stacked: boolean;
-                    }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
-                        P: {};
-                        B: {};
-                        D: {};
-                        C: {};
-                        M: {};
-                        Defaults: {};
-                    }, Readonly<import("vue").ExtractPropTypes<{
-                        status: {
-                            type: PropType<"success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger">;
-                            default: string;
-                            validator: (value: "success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger") => boolean;
-                        };
-                        size: {
-                            type: PropType<"xs" | "sm" | "md" | "lg" | "xl">;
-                            default: undefined;
-                            validator: (value: "xs" | "sm" | "md" | "lg" | "xl") => boolean;
-                        };
-                        variant: {
-                            type: PropType<"default" | "text" | "tonal" | "outline">;
-                            default: string;
-                            validator: (value: "default" | "text" | "tonal" | "outline") => boolean;
-                        };
-                        color: StringConstructor;
-                        textColor: StringConstructor;
-                        disabled: BooleanConstructor;
-                        stacked: BooleanConstructor;
-                        vertical: BooleanConstructor;
-                        elevation: {
-                            type: (BooleanConstructor | NumberConstructor)[];
-                            default: boolean;
-                        };
-                    }>> & Readonly<{}>, {
-                        buttonGroupProvider: import("../../button/group-provide").ButtonGroupProvider;
-                    }, {}, {}, {}, {
-                        size: "xs" | "sm" | "md" | "lg" | "xl";
-                        status: "success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger";
-                        elevation: number | boolean;
-                        disabled: boolean;
-                        vertical: boolean;
-                        variant: "default" | "text" | "tonal" | "outline";
-                        stacked: boolean;
-                    }>;
-                    __isFragment?: undefined;
-                    __isTeleport?: undefined;
-                    __isSuspense?: undefined;
-                } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
-                    status: {
-                        type: PropType<"success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger">;
-                        default: string;
-                        validator: (value: "success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger") => boolean;
-                    };
-                    size: {
-                        type: PropType<"xs" | "sm" | "md" | "lg" | "xl">;
-                        default: undefined;
-                        validator: (value: "xs" | "sm" | "md" | "lg" | "xl") => boolean;
-                    };
-                    variant: {
-                        type: PropType<"default" | "text" | "tonal" | "outline">;
-                        default: string;
-                        validator: (value: "default" | "text" | "tonal" | "outline") => boolean;
-                    };
-                    color: StringConstructor;
-                    textColor: StringConstructor;
-                    disabled: BooleanConstructor;
-                    stacked: BooleanConstructor;
-                    vertical: BooleanConstructor;
-                    elevation: {
-                        type: (BooleanConstructor | NumberConstructor)[];
-                        default: boolean;
-                    };
-                }>> & Readonly<{}>, {
-                    buttonGroupProvider: import("../../button/group-provide").ButtonGroupProvider;
-                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
-                    size: "xs" | "sm" | "md" | "lg" | "xl";
-                    status: "success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger";
-                    elevation: number | boolean;
-                    disabled: boolean;
-                    vertical: boolean;
-                    variant: "default" | "text" | "tonal" | "outline";
-                    stacked: boolean;
-                }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
-                    $slots: {
-                        default?: ((props: {}) => any) | undefined;
-                    };
-                });
-            }>;
+                    type: PropType<"a" | "button">;
+                    default: string;
+                    validator: (v: "a" | "button") => boolean;
+                };
+                round: BooleanConstructor;
+                block: BooleanConstructor;
+                loading: BooleanConstructor;
+                loadingType: {
+                    type: PropType<import("../..").LoadingType>;
+                    default: string;
+                };
+                loadingMode: {
+                    type: PropType<"fill" | "default" | "line">;
+                    default: string;
+                    validator: (v: "fill" | "default" | "line") => boolean;
+                };
+                loadingSize: PropType<import("../..").LoadingSize>;
+                loadingColor: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: undefined;
+                };
+                ripple: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                focusable: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                autofocus: BooleanConstructor;
+                textColor: StringConstructor;
+                color: StringConstructor;
+                elevation: {
+                    type: PropType<number | boolean>;
+                    default: boolean;
+                };
+                stacked: {
+                    type: BooleanConstructor;
+                    default: undefined;
+                };
+            }>> & Readonly<{
+                onClick?: ((event: MouseEvent) => any) | undefined;
+            }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                click: (event: MouseEvent) => any;
+            }, string, {
+                elevation: number | boolean;
+                disabled: boolean;
+                loading: boolean;
+                component: "a" | "button";
+                ripple: boolean;
+                loadingMode: "fill" | "default" | "line";
+                autofocus: boolean;
+                stacked: boolean;
+                htmlType: "button" | "reset" | "submit";
+                round: boolean;
+                block: boolean;
+                loadingType: import("../..").LoadingType;
+                loadingColor: string;
+                focusable: boolean;
+            }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+                $slots: {
+                    icon?: ((props: {}) => any) | undefined;
+                } & {
+                    default?: ((props: {}) => any) | undefined;
+                };
+            }) & {
+                setPropsDefaults: (defaults: Record<string, any>) => void;
+            };
             PanelHeader: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
                 date: {
                     type: PropType<import("../../date/presentation-props").Preview>;
@@ -2261,7 +3069,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
                 }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
                     install(app: import("vue").App<any>): void;
                 };
-                MpButton: import("../../utils/components").ComponentWithInstall<{
+                MpButton: {
                     new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
                         status: {
                             type: PropType<"success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger">;
@@ -2524,129 +3332,8 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
                         default?: ((props: {}) => any) | undefined;
                     };
                 }) & {
-                    Group: {
-                        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
-                            status: {
-                                type: PropType<"success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger">;
-                                default: string;
-                                validator: (value: "success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger") => boolean;
-                            };
-                            size: {
-                                type: PropType<"xs" | "sm" | "md" | "lg" | "xl">;
-                                default: undefined;
-                                validator: (value: "xs" | "sm" | "md" | "lg" | "xl") => boolean;
-                            };
-                            variant: {
-                                type: PropType<"default" | "text" | "tonal" | "outline">;
-                                default: string;
-                                validator: (value: "default" | "text" | "tonal" | "outline") => boolean;
-                            };
-                            color: StringConstructor;
-                            textColor: StringConstructor;
-                            disabled: BooleanConstructor;
-                            stacked: BooleanConstructor;
-                            vertical: BooleanConstructor;
-                            elevation: {
-                                type: (BooleanConstructor | NumberConstructor)[];
-                                default: boolean;
-                            };
-                        }>> & Readonly<{}>, {
-                            buttonGroupProvider: import("../../button/group-provide").ButtonGroupProvider;
-                        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
-                            size: "xs" | "sm" | "md" | "lg" | "xl";
-                            status: "success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger";
-                            elevation: number | boolean;
-                            disabled: boolean;
-                            vertical: boolean;
-                            variant: "default" | "text" | "tonal" | "outline";
-                            stacked: boolean;
-                        }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
-                            P: {};
-                            B: {};
-                            D: {};
-                            C: {};
-                            M: {};
-                            Defaults: {};
-                        }, Readonly<import("vue").ExtractPropTypes<{
-                            status: {
-                                type: PropType<"success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger">;
-                                default: string;
-                                validator: (value: "success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger") => boolean;
-                            };
-                            size: {
-                                type: PropType<"xs" | "sm" | "md" | "lg" | "xl">;
-                                default: undefined;
-                                validator: (value: "xs" | "sm" | "md" | "lg" | "xl") => boolean;
-                            };
-                            variant: {
-                                type: PropType<"default" | "text" | "tonal" | "outline">;
-                                default: string;
-                                validator: (value: "default" | "text" | "tonal" | "outline") => boolean;
-                            };
-                            color: StringConstructor;
-                            textColor: StringConstructor;
-                            disabled: BooleanConstructor;
-                            stacked: BooleanConstructor;
-                            vertical: BooleanConstructor;
-                            elevation: {
-                                type: (BooleanConstructor | NumberConstructor)[];
-                                default: boolean;
-                            };
-                        }>> & Readonly<{}>, {
-                            buttonGroupProvider: import("../../button/group-provide").ButtonGroupProvider;
-                        }, {}, {}, {}, {
-                            size: "xs" | "sm" | "md" | "lg" | "xl";
-                            status: "success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger";
-                            elevation: number | boolean;
-                            disabled: boolean;
-                            vertical: boolean;
-                            variant: "default" | "text" | "tonal" | "outline";
-                            stacked: boolean;
-                        }>;
-                        __isFragment?: undefined;
-                        __isTeleport?: undefined;
-                        __isSuspense?: undefined;
-                    } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
-                        status: {
-                            type: PropType<"success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger">;
-                            default: string;
-                            validator: (value: "success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger") => boolean;
-                        };
-                        size: {
-                            type: PropType<"xs" | "sm" | "md" | "lg" | "xl">;
-                            default: undefined;
-                            validator: (value: "xs" | "sm" | "md" | "lg" | "xl") => boolean;
-                        };
-                        variant: {
-                            type: PropType<"default" | "text" | "tonal" | "outline">;
-                            default: string;
-                            validator: (value: "default" | "text" | "tonal" | "outline") => boolean;
-                        };
-                        color: StringConstructor;
-                        textColor: StringConstructor;
-                        disabled: BooleanConstructor;
-                        stacked: BooleanConstructor;
-                        vertical: BooleanConstructor;
-                        elevation: {
-                            type: (BooleanConstructor | NumberConstructor)[];
-                            default: boolean;
-                        };
-                    }>> & Readonly<{}>, {
-                        buttonGroupProvider: import("../../button/group-provide").ButtonGroupProvider;
-                    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
-                        size: "xs" | "sm" | "md" | "lg" | "xl";
-                        status: "success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger";
-                        elevation: number | boolean;
-                        disabled: boolean;
-                        vertical: boolean;
-                        variant: "default" | "text" | "tonal" | "outline";
-                        stacked: boolean;
-                    }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
-                        $slots: {
-                            default?: ((props: {}) => any) | undefined;
-                        };
-                    });
-                }>;
+                    setPropsDefaults: (defaults: Record<string, any>) => void;
+                };
                 MpIcon: {
                     new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
                         name: StringConstructor;
@@ -2791,7 +3478,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
             readonly: boolean;
             rangePending: boolean;
         }, {}, {
-            MpButton: import("../../utils/components").ComponentWithInstall<{
+            MpButton: {
                 new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
                     status: {
                         type: PropType<"success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger">;
@@ -2974,209 +3661,88 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
                     type: PropType<"default" | "text" | "tonal" | "outline">;
                     validator: (v: "default" | "text" | "tonal" | "outline") => boolean;
                 };
-                size: {
-                    type: PropType<"xs" | "sm" | "md" | "lg" | "xl">;
-                    validator: (v: "xs" | "sm" | "md" | "lg" | "xl") => boolean;
-                };
-                htmlType: {
-                    type: PropType<"button" | "reset" | "submit">;
-                    default: string;
-                    validator: (v: "button" | "reset" | "submit") => boolean;
-                };
-                component: {
-                    type: PropType<"a" | "button">;
-                    default: string;
-                    validator: (v: "a" | "button") => boolean;
-                };
-                round: BooleanConstructor;
-                block: BooleanConstructor;
-                loading: BooleanConstructor;
-                loadingType: {
-                    type: PropType<import("../..").LoadingType>;
-                    default: string;
-                };
-                loadingMode: {
-                    type: PropType<"fill" | "default" | "line">;
-                    default: string;
-                    validator: (v: "fill" | "default" | "line") => boolean;
-                };
-                loadingSize: PropType<import("../..").LoadingSize>;
-                loadingColor: {
-                    type: StringConstructor;
-                    default: string;
-                };
-                disabled: {
-                    type: BooleanConstructor;
-                    default: undefined;
-                };
-                ripple: {
-                    type: BooleanConstructor;
-                    default: boolean;
-                };
-                focusable: {
-                    type: BooleanConstructor;
-                    default: boolean;
-                };
-                autofocus: BooleanConstructor;
-                textColor: StringConstructor;
-                color: StringConstructor;
-                elevation: {
-                    type: PropType<number | boolean>;
-                    default: boolean;
-                };
-                stacked: {
-                    type: BooleanConstructor;
-                    default: undefined;
-                };
-            }>> & Readonly<{
-                onClick?: ((event: MouseEvent) => any) | undefined;
-            }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-                click: (event: MouseEvent) => any;
-            }, string, {
-                elevation: number | boolean;
-                disabled: boolean;
-                loading: boolean;
-                component: "a" | "button";
-                ripple: boolean;
-                loadingMode: "fill" | "default" | "line";
-                autofocus: boolean;
-                stacked: boolean;
-                htmlType: "button" | "reset" | "submit";
-                round: boolean;
-                block: boolean;
-                loadingType: import("../..").LoadingType;
-                loadingColor: string;
-                focusable: boolean;
-            }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
-                $slots: {
-                    icon?: ((props: {}) => any) | undefined;
-                } & {
-                    default?: ((props: {}) => any) | undefined;
-                };
-            }) & {
-                Group: {
-                    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
-                        status: {
-                            type: PropType<"success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger">;
-                            default: string;
-                            validator: (value: "success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger") => boolean;
-                        };
-                        size: {
-                            type: PropType<"xs" | "sm" | "md" | "lg" | "xl">;
-                            default: undefined;
-                            validator: (value: "xs" | "sm" | "md" | "lg" | "xl") => boolean;
-                        };
-                        variant: {
-                            type: PropType<"default" | "text" | "tonal" | "outline">;
-                            default: string;
-                            validator: (value: "default" | "text" | "tonal" | "outline") => boolean;
-                        };
-                        color: StringConstructor;
-                        textColor: StringConstructor;
-                        disabled: BooleanConstructor;
-                        stacked: BooleanConstructor;
-                        vertical: BooleanConstructor;
-                        elevation: {
-                            type: (BooleanConstructor | NumberConstructor)[];
-                            default: boolean;
-                        };
-                    }>> & Readonly<{}>, {
-                        buttonGroupProvider: import("../../button/group-provide").ButtonGroupProvider;
-                    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
-                        size: "xs" | "sm" | "md" | "lg" | "xl";
-                        status: "success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger";
-                        elevation: number | boolean;
-                        disabled: boolean;
-                        vertical: boolean;
-                        variant: "default" | "text" | "tonal" | "outline";
-                        stacked: boolean;
-                    }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
-                        P: {};
-                        B: {};
-                        D: {};
-                        C: {};
-                        M: {};
-                        Defaults: {};
-                    }, Readonly<import("vue").ExtractPropTypes<{
-                        status: {
-                            type: PropType<"success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger">;
-                            default: string;
-                            validator: (value: "success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger") => boolean;
-                        };
-                        size: {
-                            type: PropType<"xs" | "sm" | "md" | "lg" | "xl">;
-                            default: undefined;
-                            validator: (value: "xs" | "sm" | "md" | "lg" | "xl") => boolean;
-                        };
-                        variant: {
-                            type: PropType<"default" | "text" | "tonal" | "outline">;
-                            default: string;
-                            validator: (value: "default" | "text" | "tonal" | "outline") => boolean;
-                        };
-                        color: StringConstructor;
-                        textColor: StringConstructor;
-                        disabled: BooleanConstructor;
-                        stacked: BooleanConstructor;
-                        vertical: BooleanConstructor;
-                        elevation: {
-                            type: (BooleanConstructor | NumberConstructor)[];
-                            default: boolean;
-                        };
-                    }>> & Readonly<{}>, {
-                        buttonGroupProvider: import("../../button/group-provide").ButtonGroupProvider;
-                    }, {}, {}, {}, {
-                        size: "xs" | "sm" | "md" | "lg" | "xl";
-                        status: "success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger";
-                        elevation: number | boolean;
-                        disabled: boolean;
-                        vertical: boolean;
-                        variant: "default" | "text" | "tonal" | "outline";
-                        stacked: boolean;
-                    }>;
-                    __isFragment?: undefined;
-                    __isTeleport?: undefined;
-                    __isSuspense?: undefined;
-                } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
-                    status: {
-                        type: PropType<"success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger">;
-                        default: string;
-                        validator: (value: "success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger") => boolean;
-                    };
-                    size: {
-                        type: PropType<"xs" | "sm" | "md" | "lg" | "xl">;
-                        default: undefined;
-                        validator: (value: "xs" | "sm" | "md" | "lg" | "xl") => boolean;
-                    };
-                    variant: {
-                        type: PropType<"default" | "text" | "tonal" | "outline">;
-                        default: string;
-                        validator: (value: "default" | "text" | "tonal" | "outline") => boolean;
-                    };
-                    color: StringConstructor;
-                    textColor: StringConstructor;
-                    disabled: BooleanConstructor;
-                    stacked: BooleanConstructor;
-                    vertical: BooleanConstructor;
-                    elevation: {
-                        type: (BooleanConstructor | NumberConstructor)[];
-                        default: boolean;
-                    };
-                }>> & Readonly<{}>, {
-                    buttonGroupProvider: import("../../button/group-provide").ButtonGroupProvider;
-                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
-                    size: "xs" | "sm" | "md" | "lg" | "xl";
-                    status: "success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger";
-                    elevation: number | boolean;
-                    disabled: boolean;
-                    vertical: boolean;
-                    variant: "default" | "text" | "tonal" | "outline";
-                    stacked: boolean;
-                }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
-                    $slots: {
-                        default?: ((props: {}) => any) | undefined;
-                    };
-                });
-            }>;
+                size: {
+                    type: PropType<"xs" | "sm" | "md" | "lg" | "xl">;
+                    validator: (v: "xs" | "sm" | "md" | "lg" | "xl") => boolean;
+                };
+                htmlType: {
+                    type: PropType<"button" | "reset" | "submit">;
+                    default: string;
+                    validator: (v: "button" | "reset" | "submit") => boolean;
+                };
+                component: {
+                    type: PropType<"a" | "button">;
+                    default: string;
+                    validator: (v: "a" | "button") => boolean;
+                };
+                round: BooleanConstructor;
+                block: BooleanConstructor;
+                loading: BooleanConstructor;
+                loadingType: {
+                    type: PropType<import("../..").LoadingType>;
+                    default: string;
+                };
+                loadingMode: {
+                    type: PropType<"fill" | "default" | "line">;
+                    default: string;
+                    validator: (v: "fill" | "default" | "line") => boolean;
+                };
+                loadingSize: PropType<import("../..").LoadingSize>;
+                loadingColor: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: undefined;
+                };
+                ripple: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                focusable: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                autofocus: BooleanConstructor;
+                textColor: StringConstructor;
+                color: StringConstructor;
+                elevation: {
+                    type: PropType<number | boolean>;
+                    default: boolean;
+                };
+                stacked: {
+                    type: BooleanConstructor;
+                    default: undefined;
+                };
+            }>> & Readonly<{
+                onClick?: ((event: MouseEvent) => any) | undefined;
+            }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                click: (event: MouseEvent) => any;
+            }, string, {
+                elevation: number | boolean;
+                disabled: boolean;
+                loading: boolean;
+                component: "a" | "button";
+                ripple: boolean;
+                loadingMode: "fill" | "default" | "line";
+                autofocus: boolean;
+                stacked: boolean;
+                htmlType: "button" | "reset" | "submit";
+                round: boolean;
+                block: boolean;
+                loadingType: import("../..").LoadingType;
+                loadingColor: string;
+                focusable: boolean;
+            }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+                $slots: {
+                    icon?: ((props: {}) => any) | undefined;
+                } & {
+                    default?: ((props: {}) => any) | undefined;
+                };
+            }) & {
+                setPropsDefaults: (defaults: Record<string, any>) => void;
+            };
             MpAffix: {
                 new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
                     offsetTop: {
@@ -3510,7 +4076,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
                 }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
                     install(app: import("vue").App<any>): void;
                 };
-                MpButton: import("../../utils/components").ComponentWithInstall<{
+                MpButton: {
                     new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
                         status: {
                             type: PropType<"success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger">;
@@ -3773,129 +4339,8 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
                         default?: ((props: {}) => any) | undefined;
                     };
                 }) & {
-                    Group: {
-                        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
-                            status: {
-                                type: PropType<"success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger">;
-                                default: string;
-                                validator: (value: "success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger") => boolean;
-                            };
-                            size: {
-                                type: PropType<"xs" | "sm" | "md" | "lg" | "xl">;
-                                default: undefined;
-                                validator: (value: "xs" | "sm" | "md" | "lg" | "xl") => boolean;
-                            };
-                            variant: {
-                                type: PropType<"default" | "text" | "tonal" | "outline">;
-                                default: string;
-                                validator: (value: "default" | "text" | "tonal" | "outline") => boolean;
-                            };
-                            color: StringConstructor;
-                            textColor: StringConstructor;
-                            disabled: BooleanConstructor;
-                            stacked: BooleanConstructor;
-                            vertical: BooleanConstructor;
-                            elevation: {
-                                type: (BooleanConstructor | NumberConstructor)[];
-                                default: boolean;
-                            };
-                        }>> & Readonly<{}>, {
-                            buttonGroupProvider: import("../../button/group-provide").ButtonGroupProvider;
-                        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
-                            size: "xs" | "sm" | "md" | "lg" | "xl";
-                            status: "success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger";
-                            elevation: number | boolean;
-                            disabled: boolean;
-                            vertical: boolean;
-                            variant: "default" | "text" | "tonal" | "outline";
-                            stacked: boolean;
-                        }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
-                            P: {};
-                            B: {};
-                            D: {};
-                            C: {};
-                            M: {};
-                            Defaults: {};
-                        }, Readonly<import("vue").ExtractPropTypes<{
-                            status: {
-                                type: PropType<"success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger">;
-                                default: string;
-                                validator: (value: "success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger") => boolean;
-                            };
-                            size: {
-                                type: PropType<"xs" | "sm" | "md" | "lg" | "xl">;
-                                default: undefined;
-                                validator: (value: "xs" | "sm" | "md" | "lg" | "xl") => boolean;
-                            };
-                            variant: {
-                                type: PropType<"default" | "text" | "tonal" | "outline">;
-                                default: string;
-                                validator: (value: "default" | "text" | "tonal" | "outline") => boolean;
-                            };
-                            color: StringConstructor;
-                            textColor: StringConstructor;
-                            disabled: BooleanConstructor;
-                            stacked: BooleanConstructor;
-                            vertical: BooleanConstructor;
-                            elevation: {
-                                type: (BooleanConstructor | NumberConstructor)[];
-                                default: boolean;
-                            };
-                        }>> & Readonly<{}>, {
-                            buttonGroupProvider: import("../../button/group-provide").ButtonGroupProvider;
-                        }, {}, {}, {}, {
-                            size: "xs" | "sm" | "md" | "lg" | "xl";
-                            status: "success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger";
-                            elevation: number | boolean;
-                            disabled: boolean;
-                            vertical: boolean;
-                            variant: "default" | "text" | "tonal" | "outline";
-                            stacked: boolean;
-                        }>;
-                        __isFragment?: undefined;
-                        __isTeleport?: undefined;
-                        __isSuspense?: undefined;
-                    } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
-                        status: {
-                            type: PropType<"success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger">;
-                            default: string;
-                            validator: (value: "success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger") => boolean;
-                        };
-                        size: {
-                            type: PropType<"xs" | "sm" | "md" | "lg" | "xl">;
-                            default: undefined;
-                            validator: (value: "xs" | "sm" | "md" | "lg" | "xl") => boolean;
-                        };
-                        variant: {
-                            type: PropType<"default" | "text" | "tonal" | "outline">;
-                            default: string;
-                            validator: (value: "default" | "text" | "tonal" | "outline") => boolean;
-                        };
-                        color: StringConstructor;
-                        textColor: StringConstructor;
-                        disabled: BooleanConstructor;
-                        stacked: BooleanConstructor;
-                        vertical: BooleanConstructor;
-                        elevation: {
-                            type: (BooleanConstructor | NumberConstructor)[];
-                            default: boolean;
-                        };
-                    }>> & Readonly<{}>, {
-                        buttonGroupProvider: import("../../button/group-provide").ButtonGroupProvider;
-                    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
-                        size: "xs" | "sm" | "md" | "lg" | "xl";
-                        status: "success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger";
-                        elevation: number | boolean;
-                        disabled: boolean;
-                        vertical: boolean;
-                        variant: "default" | "text" | "tonal" | "outline";
-                        stacked: boolean;
-                    }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
-                        $slots: {
-                            default?: ((props: {}) => any) | undefined;
-                        };
-                    });
-                }>;
+                    setPropsDefaults: (defaults: Record<string, any>) => void;
+                };
                 MpIcon: {
                     new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
                         name: StringConstructor;
@@ -4060,7 +4505,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
             readonly: boolean;
             rangePending: boolean;
         }, {}, {
-            MpButton: import("../../utils/components").ComponentWithInstall<{
+            MpButton: {
                 new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
                     status: {
                         type: PropType<"success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger">;
@@ -4322,43 +4767,323 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
                 } & {
                     default?: ((props: {}) => any) | undefined;
                 };
-            }) & {
-                Group: {
+            }) & {
+                setPropsDefaults: (defaults: Record<string, any>) => void;
+            };
+            PanelHeader: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                date: {
+                    type: PropType<import("../../date/presentation-props").Preview>;
+                    required: true;
+                };
+                type: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                disabled: {
+                    type: PropType<import("../../date/presentation-props").PanelBtnDisabled>;
+                    required: true;
+                };
+            }>, {
+                n: (suffix?: string | undefined) => string;
+                previousLabel: import("vue").ComputedRef<any>;
+                nextLabel: import("vue").ComputedRef<any>;
+                reverse: import("vue").Ref<boolean, boolean>;
+                showDate: import("vue").ComputedRef<string | number>;
+                checkDate: (checkType: string) => void;
+            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("check-panel" | "check-date")[], "check-panel" | "check-date", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                date: {
+                    type: PropType<import("../../date/presentation-props").Preview>;
+                    required: true;
+                };
+                type: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                disabled: {
+                    type: PropType<import("../../date/presentation-props").PanelBtnDisabled>;
+                    required: true;
+                };
+            }>> & Readonly<{
+                "onCheck-panel"?: ((...args: any[]) => any) | undefined;
+                "onCheck-date"?: ((...args: any[]) => any) | undefined;
+            }>, {
+                type: string;
+            }, {}, {
+                MIconChevronLeft: {
+                    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<{
+                        size?: string | number | undefined;
+                        color?: string | undefined;
+                        rotate?: number | undefined;
+                        spin?: boolean | undefined;
+                        title?: string | undefined;
+                        strokeWidth?: number | undefined;
+                        strokeLinecap?: "round" | "butt" | "square" | undefined;
+                        strokeLinejoin?: "inherit" | "round" | "bevel" | "miter" | undefined;
+                    }> & Readonly<{
+                        onClick?: ((event: MouseEvent) => any) | undefined;
+                    }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                        click: (event: MouseEvent) => any;
+                    }, import("vue").PublicProps, {
+                        strokeWidth: number;
+                        strokeLinecap: "round" | "butt" | "square";
+                        strokeLinejoin: "inherit" | "round" | "bevel" | "miter";
+                    }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+                        P: {};
+                        B: {};
+                        D: {};
+                        C: {};
+                        M: {};
+                        Defaults: {};
+                    }, Readonly<{
+                        size?: string | number | undefined;
+                        color?: string | undefined;
+                        rotate?: number | undefined;
+                        spin?: boolean | undefined;
+                        title?: string | undefined;
+                        strokeWidth?: number | undefined;
+                        strokeLinecap?: "round" | "butt" | "square" | undefined;
+                        strokeLinejoin?: "inherit" | "round" | "bevel" | "miter" | undefined;
+                    }> & Readonly<{
+                        onClick?: ((event: MouseEvent) => any) | undefined;
+                    }>, {}, {}, {}, {}, {
+                        strokeWidth: number;
+                        strokeLinecap: "round" | "butt" | "square";
+                        strokeLinejoin: "inherit" | "round" | "bevel" | "miter";
+                    }>;
+                    __isFragment?: undefined;
+                    __isTeleport?: undefined;
+                    __isSuspense?: undefined;
+                } & import("vue").ComponentOptionsBase<Readonly<{
+                    size?: string | number | undefined;
+                    color?: string | undefined;
+                    rotate?: number | undefined;
+                    spin?: boolean | undefined;
+                    title?: string | undefined;
+                    strokeWidth?: number | undefined;
+                    strokeLinecap?: "round" | "butt" | "square" | undefined;
+                    strokeLinejoin?: "inherit" | "round" | "bevel" | "miter" | undefined;
+                }> & Readonly<{
+                    onClick?: ((event: MouseEvent) => any) | undefined;
+                }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                    click: (event: MouseEvent) => any;
+                }, string, {
+                    strokeWidth: number;
+                    strokeLinecap: "round" | "butt" | "square";
+                    strokeLinejoin: "inherit" | "round" | "bevel" | "miter";
+                }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+                    install(app: import("vue").App<any>): void;
+                };
+                MIconChevronRight: {
+                    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<{
+                        size?: string | number | undefined;
+                        color?: string | undefined;
+                        rotate?: number | undefined;
+                        spin?: boolean | undefined;
+                        title?: string | undefined;
+                        strokeWidth?: number | undefined;
+                        strokeLinecap?: "round" | "butt" | "square" | undefined;
+                        strokeLinejoin?: "inherit" | "round" | "bevel" | "miter" | undefined;
+                    }> & Readonly<{
+                        onClick?: ((event: MouseEvent) => any) | undefined;
+                    }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                        click: (event: MouseEvent) => any;
+                    }, import("vue").PublicProps, {
+                        strokeWidth: number;
+                        strokeLinecap: "round" | "butt" | "square";
+                        strokeLinejoin: "inherit" | "round" | "bevel" | "miter";
+                    }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+                        P: {};
+                        B: {};
+                        D: {};
+                        C: {};
+                        M: {};
+                        Defaults: {};
+                    }, Readonly<{
+                        size?: string | number | undefined;
+                        color?: string | undefined;
+                        rotate?: number | undefined;
+                        spin?: boolean | undefined;
+                        title?: string | undefined;
+                        strokeWidth?: number | undefined;
+                        strokeLinecap?: "round" | "butt" | "square" | undefined;
+                        strokeLinejoin?: "inherit" | "round" | "bevel" | "miter" | undefined;
+                    }> & Readonly<{
+                        onClick?: ((event: MouseEvent) => any) | undefined;
+                    }>, {}, {}, {}, {}, {
+                        strokeWidth: number;
+                        strokeLinecap: "round" | "butt" | "square";
+                        strokeLinejoin: "inherit" | "round" | "bevel" | "miter";
+                    }>;
+                    __isFragment?: undefined;
+                    __isTeleport?: undefined;
+                    __isSuspense?: undefined;
+                } & import("vue").ComponentOptionsBase<Readonly<{
+                    size?: string | number | undefined;
+                    color?: string | undefined;
+                    rotate?: number | undefined;
+                    spin?: boolean | undefined;
+                    title?: string | undefined;
+                    strokeWidth?: number | undefined;
+                    strokeLinecap?: "round" | "butt" | "square" | undefined;
+                    strokeLinejoin?: "inherit" | "round" | "bevel" | "miter" | undefined;
+                }> & Readonly<{
+                    onClick?: ((event: MouseEvent) => any) | undefined;
+                }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                    click: (event: MouseEvent) => any;
+                }, string, {
+                    strokeWidth: number;
+                    strokeLinecap: "round" | "butt" | "square";
+                    strokeLinejoin: "inherit" | "round" | "bevel" | "miter";
+                }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+                    install(app: import("vue").App<any>): void;
+                };
+                MIconChevronDown: {
+                    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<{
+                        size?: string | number | undefined;
+                        color?: string | undefined;
+                        rotate?: number | undefined;
+                        spin?: boolean | undefined;
+                        title?: string | undefined;
+                        strokeWidth?: number | undefined;
+                        strokeLinecap?: "round" | "butt" | "square" | undefined;
+                        strokeLinejoin?: "inherit" | "round" | "bevel" | "miter" | undefined;
+                    }> & Readonly<{
+                        onClick?: ((event: MouseEvent) => any) | undefined;
+                    }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                        click: (event: MouseEvent) => any;
+                    }, import("vue").PublicProps, {
+                        strokeWidth: number;
+                        strokeLinecap: "round" | "butt" | "square";
+                        strokeLinejoin: "inherit" | "round" | "bevel" | "miter";
+                    }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+                        P: {};
+                        B: {};
+                        D: {};
+                        C: {};
+                        M: {};
+                        Defaults: {};
+                    }, Readonly<{
+                        size?: string | number | undefined;
+                        color?: string | undefined;
+                        rotate?: number | undefined;
+                        spin?: boolean | undefined;
+                        title?: string | undefined;
+                        strokeWidth?: number | undefined;
+                        strokeLinecap?: "round" | "butt" | "square" | undefined;
+                        strokeLinejoin?: "inherit" | "round" | "bevel" | "miter" | undefined;
+                    }> & Readonly<{
+                        onClick?: ((event: MouseEvent) => any) | undefined;
+                    }>, {}, {}, {}, {}, {
+                        strokeWidth: number;
+                        strokeLinecap: "round" | "butt" | "square";
+                        strokeLinejoin: "inherit" | "round" | "bevel" | "miter";
+                    }>;
+                    __isFragment?: undefined;
+                    __isTeleport?: undefined;
+                    __isSuspense?: undefined;
+                } & import("vue").ComponentOptionsBase<Readonly<{
+                    size?: string | number | undefined;
+                    color?: string | undefined;
+                    rotate?: number | undefined;
+                    spin?: boolean | undefined;
+                    title?: string | undefined;
+                    strokeWidth?: number | undefined;
+                    strokeLinecap?: "round" | "butt" | "square" | undefined;
+                    strokeLinejoin?: "inherit" | "round" | "bevel" | "miter" | undefined;
+                }> & Readonly<{
+                    onClick?: ((event: MouseEvent) => any) | undefined;
+                }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                    click: (event: MouseEvent) => any;
+                }, string, {
+                    strokeWidth: number;
+                    strokeLinecap: "round" | "butt" | "square";
+                    strokeLinejoin: "inherit" | "round" | "bevel" | "miter";
+                }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+                    install(app: import("vue").App<any>): void;
+                };
+                MpButton: {
                     new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
                         status: {
                             type: PropType<"success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger">;
-                            default: string;
-                            validator: (value: "success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger") => boolean;
+                            validator: (v: "success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger") => boolean;
+                        };
+                        variant: {
+                            type: PropType<"default" | "text" | "tonal" | "outline">;
+                            validator: (v: "default" | "text" | "tonal" | "outline") => boolean;
                         };
                         size: {
                             type: PropType<"xs" | "sm" | "md" | "lg" | "xl">;
-                            default: undefined;
-                            validator: (value: "xs" | "sm" | "md" | "lg" | "xl") => boolean;
+                            validator: (v: "xs" | "sm" | "md" | "lg" | "xl") => boolean;
                         };
-                        variant: {
-                            type: PropType<"default" | "text" | "tonal" | "outline">;
+                        htmlType: {
+                            type: PropType<"button" | "reset" | "submit">;
                             default: string;
-                            validator: (value: "default" | "text" | "tonal" | "outline") => boolean;
+                            validator: (v: "button" | "reset" | "submit") => boolean;
                         };
-                        color: StringConstructor;
+                        component: {
+                            type: PropType<"a" | "button">;
+                            default: string;
+                            validator: (v: "a" | "button") => boolean;
+                        };
+                        round: BooleanConstructor;
+                        block: BooleanConstructor;
+                        loading: BooleanConstructor;
+                        loadingType: {
+                            type: PropType<import("../..").LoadingType>;
+                            default: string;
+                        };
+                        loadingMode: {
+                            type: PropType<"fill" | "default" | "line">;
+                            default: string;
+                            validator: (v: "fill" | "default" | "line") => boolean;
+                        };
+                        loadingSize: PropType<import("../..").LoadingSize>;
+                        loadingColor: {
+                            type: StringConstructor;
+                            default: string;
+                        };
+                        disabled: {
+                            type: BooleanConstructor;
+                            default: undefined;
+                        };
+                        ripple: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        focusable: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        autofocus: BooleanConstructor;
                         textColor: StringConstructor;
-                        disabled: BooleanConstructor;
-                        stacked: BooleanConstructor;
-                        vertical: BooleanConstructor;
+                        color: StringConstructor;
                         elevation: {
-                            type: (BooleanConstructor | NumberConstructor)[];
+                            type: PropType<number | boolean>;
                             default: boolean;
                         };
-                    }>> & Readonly<{}>, {
-                        buttonGroupProvider: import("../../button/group-provide").ButtonGroupProvider;
-                    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
-                        size: "xs" | "sm" | "md" | "lg" | "xl";
-                        status: "success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger";
+                        stacked: {
+                            type: BooleanConstructor;
+                            default: undefined;
+                        };
+                    }>> & Readonly<{
+                        onClick?: ((event: MouseEvent) => any) | undefined;
+                    }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                        click: (event: MouseEvent) => any;
+                    }, import("vue").PublicProps, {
                         elevation: number | boolean;
                         disabled: boolean;
-                        vertical: boolean;
-                        variant: "default" | "text" | "tonal" | "outline";
+                        loading: boolean;
+                        component: "a" | "button";
+                        ripple: boolean;
+                        loadingMode: "fill" | "default" | "line";
+                        autofocus: boolean;
                         stacked: boolean;
+                        htmlType: "button" | "reset" | "submit";
+                        round: boolean;
+                        block: boolean;
+                        loadingType: import("../..").LoadingType;
+                        loadingColor: string;
+                        focusable: boolean;
                     }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
                         P: {};
                         B: {};
@@ -4369,38 +5094,83 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
                     }, Readonly<import("vue").ExtractPropTypes<{
                         status: {
                             type: PropType<"success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger">;
-                            default: string;
-                            validator: (value: "success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger") => boolean;
+                            validator: (v: "success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger") => boolean;
+                        };
+                        variant: {
+                            type: PropType<"default" | "text" | "tonal" | "outline">;
+                            validator: (v: "default" | "text" | "tonal" | "outline") => boolean;
                         };
                         size: {
                             type: PropType<"xs" | "sm" | "md" | "lg" | "xl">;
-                            default: undefined;
-                            validator: (value: "xs" | "sm" | "md" | "lg" | "xl") => boolean;
+                            validator: (v: "xs" | "sm" | "md" | "lg" | "xl") => boolean;
                         };
-                        variant: {
-                            type: PropType<"default" | "text" | "tonal" | "outline">;
+                        htmlType: {
+                            type: PropType<"button" | "reset" | "submit">;
                             default: string;
-                            validator: (value: "default" | "text" | "tonal" | "outline") => boolean;
+                            validator: (v: "button" | "reset" | "submit") => boolean;
                         };
-                        color: StringConstructor;
+                        component: {
+                            type: PropType<"a" | "button">;
+                            default: string;
+                            validator: (v: "a" | "button") => boolean;
+                        };
+                        round: BooleanConstructor;
+                        block: BooleanConstructor;
+                        loading: BooleanConstructor;
+                        loadingType: {
+                            type: PropType<import("../..").LoadingType>;
+                            default: string;
+                        };
+                        loadingMode: {
+                            type: PropType<"fill" | "default" | "line">;
+                            default: string;
+                            validator: (v: "fill" | "default" | "line") => boolean;
+                        };
+                        loadingSize: PropType<import("../..").LoadingSize>;
+                        loadingColor: {
+                            type: StringConstructor;
+                            default: string;
+                        };
+                        disabled: {
+                            type: BooleanConstructor;
+                            default: undefined;
+                        };
+                        ripple: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        focusable: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        autofocus: BooleanConstructor;
                         textColor: StringConstructor;
-                        disabled: BooleanConstructor;
-                        stacked: BooleanConstructor;
-                        vertical: BooleanConstructor;
+                        color: StringConstructor;
                         elevation: {
-                            type: (BooleanConstructor | NumberConstructor)[];
+                            type: PropType<number | boolean>;
                             default: boolean;
                         };
-                    }>> & Readonly<{}>, {
-                        buttonGroupProvider: import("../../button/group-provide").ButtonGroupProvider;
-                    }, {}, {}, {}, {
-                        size: "xs" | "sm" | "md" | "lg" | "xl";
-                        status: "success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger";
+                        stacked: {
+                            type: BooleanConstructor;
+                            default: undefined;
+                        };
+                    }>> & Readonly<{
+                        onClick?: ((event: MouseEvent) => any) | undefined;
+                    }>, {}, {}, {}, {}, {
                         elevation: number | boolean;
                         disabled: boolean;
-                        vertical: boolean;
-                        variant: "default" | "text" | "tonal" | "outline";
+                        loading: boolean;
+                        component: "a" | "button";
+                        ripple: boolean;
+                        loadingMode: "fill" | "default" | "line";
+                        autofocus: boolean;
                         stacked: boolean;
+                        htmlType: "button" | "reset" | "submit";
+                        round: boolean;
+                        block: boolean;
+                        loadingType: import("../..").LoadingType;
+                        loadingColor: string;
+                        focusable: boolean;
                     }>;
                     __isFragment?: undefined;
                     __isTeleport?: undefined;
@@ -4408,212 +5178,351 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
                 } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
                     status: {
                         type: PropType<"success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger">;
+                        validator: (v: "success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger") => boolean;
+                    };
+                    variant: {
+                        type: PropType<"default" | "text" | "tonal" | "outline">;
+                        validator: (v: "default" | "text" | "tonal" | "outline") => boolean;
+                    };
+                    size: {
+                        type: PropType<"xs" | "sm" | "md" | "lg" | "xl">;
+                        validator: (v: "xs" | "sm" | "md" | "lg" | "xl") => boolean;
+                    };
+                    htmlType: {
+                        type: PropType<"button" | "reset" | "submit">;
+                        default: string;
+                        validator: (v: "button" | "reset" | "submit") => boolean;
+                    };
+                    component: {
+                        type: PropType<"a" | "button">;
+                        default: string;
+                        validator: (v: "a" | "button") => boolean;
+                    };
+                    round: BooleanConstructor;
+                    block: BooleanConstructor;
+                    loading: BooleanConstructor;
+                    loadingType: {
+                        type: PropType<import("../..").LoadingType>;
+                        default: string;
+                    };
+                    loadingMode: {
+                        type: PropType<"fill" | "default" | "line">;
+                        default: string;
+                        validator: (v: "fill" | "default" | "line") => boolean;
+                    };
+                    loadingSize: PropType<import("../..").LoadingSize>;
+                    loadingColor: {
+                        type: StringConstructor;
                         default: string;
-                        validator: (value: "success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger") => boolean;
                     };
-                    size: {
-                        type: PropType<"xs" | "sm" | "md" | "lg" | "xl">;
+                    disabled: {
+                        type: BooleanConstructor;
                         default: undefined;
-                        validator: (value: "xs" | "sm" | "md" | "lg" | "xl") => boolean;
                     };
-                    variant: {
-                        type: PropType<"default" | "text" | "tonal" | "outline">;
-                        default: string;
-                        validator: (value: "default" | "text" | "tonal" | "outline") => boolean;
+                    ripple: {
+                        type: BooleanConstructor;
+                        default: boolean;
                     };
-                    color: StringConstructor;
+                    focusable: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    autofocus: BooleanConstructor;
                     textColor: StringConstructor;
-                    disabled: BooleanConstructor;
-                    stacked: BooleanConstructor;
-                    vertical: BooleanConstructor;
+                    color: StringConstructor;
                     elevation: {
-                        type: (BooleanConstructor | NumberConstructor)[];
+                        type: PropType<number | boolean>;
                         default: boolean;
                     };
-                }>> & Readonly<{}>, {
-                    buttonGroupProvider: import("../../button/group-provide").ButtonGroupProvider;
-                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
-                    size: "xs" | "sm" | "md" | "lg" | "xl";
-                    status: "success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger";
+                    stacked: {
+                        type: BooleanConstructor;
+                        default: undefined;
+                    };
+                }>> & Readonly<{
+                    onClick?: ((event: MouseEvent) => any) | undefined;
+                }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                    click: (event: MouseEvent) => any;
+                }, string, {
                     elevation: number | boolean;
                     disabled: boolean;
-                    vertical: boolean;
-                    variant: "default" | "text" | "tonal" | "outline";
+                    loading: boolean;
+                    component: "a" | "button";
+                    ripple: boolean;
+                    loadingMode: "fill" | "default" | "line";
+                    autofocus: boolean;
                     stacked: boolean;
+                    htmlType: "button" | "reset" | "submit";
+                    round: boolean;
+                    block: boolean;
+                    loadingType: import("../..").LoadingType;
+                    loadingColor: string;
+                    focusable: boolean;
                 }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
                     $slots: {
+                        icon?: ((props: {}) => any) | undefined;
+                    } & {
                         default?: ((props: {}) => any) | undefined;
                     };
-                });
-            }>;
-            PanelHeader: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
-                date: {
-                    type: PropType<import("../../date/presentation-props").Preview>;
-                    required: true;
-                };
-                type: {
-                    type: StringConstructor;
-                    default: string;
-                };
-                disabled: {
-                    type: PropType<import("../../date/presentation-props").PanelBtnDisabled>;
-                    required: true;
-                };
-            }>, {
-                n: (suffix?: string | undefined) => string;
-                previousLabel: import("vue").ComputedRef<any>;
-                nextLabel: import("vue").ComputedRef<any>;
-                reverse: import("vue").Ref<boolean, boolean>;
-                showDate: import("vue").ComputedRef<string | number>;
-                checkDate: (checkType: string) => void;
-            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("check-panel" | "check-date")[], "check-panel" | "check-date", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
-                date: {
-                    type: PropType<import("../../date/presentation-props").Preview>;
-                    required: true;
-                };
-                type: {
-                    type: StringConstructor;
-                    default: string;
-                };
-                disabled: {
-                    type: PropType<import("../../date/presentation-props").PanelBtnDisabled>;
-                    required: true;
+                }) & {
+                    setPropsDefaults: (defaults: Record<string, any>) => void;
                 };
-            }>> & Readonly<{
-                "onCheck-panel"?: ((...args: any[]) => any) | undefined;
-                "onCheck-date"?: ((...args: any[]) => any) | undefined;
-            }>, {
-                type: string;
-            }, {}, {
-                MIconChevronLeft: {
-                    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<{
-                        size?: string | number | undefined;
-                        color?: string | undefined;
-                        rotate?: number | undefined;
-                        spin?: boolean | undefined;
-                        title?: string | undefined;
-                        strokeWidth?: number | undefined;
-                        strokeLinecap?: "round" | "butt" | "square" | undefined;
-                        strokeLinejoin?: "inherit" | "round" | "bevel" | "miter" | undefined;
-                    }> & Readonly<{
+                MpIcon: {
+                    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+                        name: StringConstructor;
+                        size: (NumberConstructor | StringConstructor)[];
+                        color: StringConstructor;
+                        rotate: NumberConstructor;
+                        spin: BooleanConstructor;
+                        transition: {
+                            type: (NumberConstructor | StringConstructor)[];
+                            default: number;
+                        };
+                        animationClass: StringConstructor;
+                    }>> & Readonly<{
                         onClick?: ((event: MouseEvent) => any) | undefined;
                     }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
                         click: (event: MouseEvent) => any;
                     }, import("vue").PublicProps, {
-                        strokeWidth: number;
-                        strokeLinecap: "round" | "butt" | "square";
-                        strokeLinejoin: "inherit" | "round" | "bevel" | "miter";
-                    }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+                        transition: string | number;
+                        spin: boolean;
+                    }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
                         P: {};
                         B: {};
                         D: {};
                         C: {};
                         M: {};
                         Defaults: {};
-                    }, Readonly<{
-                        size?: string | number | undefined;
-                        color?: string | undefined;
-                        rotate?: number | undefined;
-                        spin?: boolean | undefined;
-                        title?: string | undefined;
-                        strokeWidth?: number | undefined;
-                        strokeLinecap?: "round" | "butt" | "square" | undefined;
-                        strokeLinejoin?: "inherit" | "round" | "bevel" | "miter" | undefined;
-                    }> & Readonly<{
+                    }, Readonly<import("vue").ExtractPropTypes<{
+                        name: StringConstructor;
+                        size: (NumberConstructor | StringConstructor)[];
+                        color: StringConstructor;
+                        rotate: NumberConstructor;
+                        spin: BooleanConstructor;
+                        transition: {
+                            type: (NumberConstructor | StringConstructor)[];
+                            default: number;
+                        };
+                        animationClass: StringConstructor;
+                    }>> & Readonly<{
                         onClick?: ((event: MouseEvent) => any) | undefined;
                     }>, {}, {}, {}, {}, {
-                        strokeWidth: number;
-                        strokeLinecap: "round" | "butt" | "square";
-                        strokeLinejoin: "inherit" | "round" | "bevel" | "miter";
+                        transition: string | number;
+                        spin: boolean;
                     }>;
                     __isFragment?: undefined;
                     __isTeleport?: undefined;
                     __isSuspense?: undefined;
-                } & import("vue").ComponentOptionsBase<Readonly<{
-                    size?: string | number | undefined;
-                    color?: string | undefined;
-                    rotate?: number | undefined;
-                    spin?: boolean | undefined;
-                    title?: string | undefined;
-                    strokeWidth?: number | undefined;
-                    strokeLinecap?: "round" | "butt" | "square" | undefined;
-                    strokeLinejoin?: "inherit" | "round" | "bevel" | "miter" | undefined;
-                }> & Readonly<{
+                } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+                    name: StringConstructor;
+                    size: (NumberConstructor | StringConstructor)[];
+                    color: StringConstructor;
+                    rotate: NumberConstructor;
+                    spin: BooleanConstructor;
+                    transition: {
+                        type: (NumberConstructor | StringConstructor)[];
+                        default: number;
+                    };
+                    animationClass: StringConstructor;
+                }>> & Readonly<{
                     onClick?: ((event: MouseEvent) => any) | undefined;
                 }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
                     click: (event: MouseEvent) => any;
                 }, string, {
-                    strokeWidth: number;
-                    strokeLinecap: "round" | "butt" | "square";
-                    strokeLinejoin: "inherit" | "round" | "bevel" | "miter";
-                }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
-                    install(app: import("vue").App<any>): void;
+                    transition: string | number;
+                    spin: boolean;
+                }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+                    $slots: {
+                        default?: ((props: {}) => any) | undefined;
+                    };
+                });
+            }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        MpPicker: {
+            new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+                safeArea: BooleanConstructor;
+                open: {
+                    type: BooleanConstructor;
+                    default: undefined;
                 };
-                MIconChevronRight: {
-                    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<{
-                        size?: string | number | undefined;
-                        color?: string | undefined;
-                        rotate?: number | undefined;
-                        spin?: boolean | undefined;
-                        title?: string | undefined;
-                        strokeWidth?: number | undefined;
-                        strokeLinecap?: "round" | "butt" | "square" | undefined;
-                        strokeLinejoin?: "inherit" | "round" | "bevel" | "miter" | undefined;
-                    }> & Readonly<{
-                        onClick?: ((event: MouseEvent) => any) | undefined;
-                    }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-                        click: (event: MouseEvent) => any;
-                    }, import("vue").PublicProps, {
-                        strokeWidth: number;
-                        strokeLinecap: "round" | "butt" | "square";
-                        strokeLinejoin: "inherit" | "round" | "bevel" | "miter";
-                    }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
-                        P: {};
-                        B: {};
-                        D: {};
-                        C: {};
-                        M: {};
-                        Defaults: {};
-                    }, Readonly<{
-                        size?: string | number | undefined;
-                        color?: string | undefined;
-                        rotate?: number | undefined;
-                        spin?: boolean | undefined;
-                        title?: string | undefined;
-                        strokeWidth?: number | undefined;
-                        strokeLinecap?: "round" | "butt" | "square" | undefined;
-                        strokeLinejoin?: "inherit" | "round" | "bevel" | "miter" | undefined;
-                    }> & Readonly<{
-                        onClick?: ((event: MouseEvent) => any) | undefined;
-                    }>, {}, {}, {}, {}, {
-                        strokeWidth: number;
-                        strokeLinecap: "round" | "butt" | "square";
-                        strokeLinejoin: "inherit" | "round" | "bevel" | "miter";
-                    }>;
-                    __isFragment?: undefined;
-                    __isTeleport?: undefined;
-                    __isSuspense?: undefined;
-                } & import("vue").ComponentOptionsBase<Readonly<{
-                    size?: string | number | undefined;
-                    color?: string | undefined;
-                    rotate?: number | undefined;
-                    spin?: boolean | undefined;
-                    title?: string | undefined;
-                    strokeWidth?: number | undefined;
-                    strokeLinecap?: "round" | "butt" | "square" | undefined;
-                    strokeLinejoin?: "inherit" | "round" | "bevel" | "miter" | undefined;
-                }> & Readonly<{
-                    onClick?: ((event: MouseEvent) => any) | undefined;
-                }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-                    click: (event: MouseEvent) => any;
-                }, string, {
-                    strokeWidth: number;
-                    strokeLinecap: "round" | "butt" | "square";
-                    strokeLinejoin: "inherit" | "round" | "bevel" | "miter";
-                }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
-                    install(app: import("vue").App<any>): void;
+                defaultOpen: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                overlayClosable: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                escToClose: {
+                    type: BooleanConstructor;
+                    default: boolean;
                 };
-                MIconChevronDown: {
+                popupContainer: {
+                    type: PropType<import("../..").PopupContainer>;
+                    default: undefined;
+                    validator: ((value: unknown) => boolean) | undefined;
+                };
+                modelValue: {
+                    type: PropType<(string | number)[]>;
+                    default: undefined;
+                };
+                defaultValue: {
+                    type: PropType<(string | number)[]>;
+                    default: () => never[];
+                };
+                columns: {
+                    type: PropType<import("../..").PickerColumnOption[] | import("../..").PickerColumnOption[][]>;
+                    default: () => never[];
+                };
+                title: StringConstructor;
+                fieldNames: {
+                    type: PropType<import("../../utils/options").FieldNames>;
+                    default: undefined;
+                };
+                toolbar: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                disabled: BooleanConstructor;
+                selectedValues: {
+                    type: PropType<(string | number)[]>;
+                    default: () => never[];
+                };
+                cascade: BooleanConstructor;
+                optionHeight: {
+                    type: (NumberConstructor | StringConstructor)[];
+                    default: number;
+                };
+                optionCount: {
+                    type: (NumberConstructor | StringConstructor)[];
+                    default: number;
+                };
+                columnsCount: (NumberConstructor | StringConstructor)[];
+                confirmButtonText: StringConstructor;
+                cancelButtonText: StringConstructor;
+                confirmButtonTextColor: StringConstructor;
+                cancelButtonTextColor: StringConstructor;
+                dynamic: BooleanConstructor;
+            }>> & Readonly<{
+                onCancel?: ((values: (string | number)[], indexes: number[], options: import("../..").PickerColumnOption[]) => any) | undefined;
+                onChange?: ((values: (string | number)[], indexes: number[], options: import("../..").PickerColumnOption[]) => any) | undefined;
+                onClose?: (() => any) | undefined;
+                onOpen?: (() => any) | undefined;
+                onOpened?: (() => any) | undefined;
+                onClosed?: (() => any) | undefined;
+                "onClick-overlay"?: ((event: MouseEvent) => any) | undefined;
+                "onKey-escape"?: ((event: KeyboardEvent) => any) | undefined;
+                "onUpdate:open"?: ((open: boolean) => any) | undefined;
+                onConfirm?: ((values: (string | number)[], indexes: number[], options: import("../..").PickerColumnOption[]) => any) | undefined;
+                "onUpdate:modelValue"?: ((value: (string | number)[]) => any) | undefined;
+            }>, {
+                describeError: (value: unknown) => string | undefined;
+                mergedError: import("vue").ComputedRef<boolean>;
+                mergedOpen: import("vue").ComputedRef<boolean>;
+                controlId: string;
+                handleColumnKeydown: (event: KeyboardEvent, column: import("../../picker/Picker.vue").ScrollColumn) => void;
+                optionHeight: import("vue").ComputedRef<number>;
+                optionCount: import("vue").ComputedRef<number>;
+                scrollColumns: import("vue").Ref<{
+                    id: number;
+                    touching: boolean;
+                    index: number;
+                    prevY: number;
+                    momentumPrevY: number;
+                    momentumTime: number;
+                    translate: number;
+                    duration: number;
+                    scrolling: boolean;
+                    column: {
+                        [x: string]: any;
+                        [x: number]: any;
+                        [x: symbol]: any;
+                        text?: string | number | undefined;
+                        value?: string | number | undefined;
+                        disabled?: boolean | undefined;
+                        children?: any[] | undefined;
+                        className?: string | undefined;
+                        textClassName?: string | undefined;
+                    }[];
+                    scrollEl: HTMLElement | null;
+                }[], import("../../picker/Picker.vue").ScrollColumn[] | {
+                    id: number;
+                    touching: boolean;
+                    index: number;
+                    prevY: number;
+                    momentumPrevY: number;
+                    momentumTime: number;
+                    translate: number;
+                    duration: number;
+                    scrolling: boolean;
+                    column: {
+                        [x: string]: any;
+                        [x: number]: any;
+                        [x: symbol]: any;
+                        text?: string | number | undefined;
+                        value?: string | number | undefined;
+                        disabled?: boolean | undefined;
+                        children?: any[] | undefined;
+                        className?: string | undefined;
+                        textClassName?: string | undefined;
+                    }[];
+                    scrollEl: HTMLElement | null;
+                }[]>;
+                columnHeight: import("vue").ComputedRef<number>;
+                center: import("vue").ComputedRef<number>;
+                confirmButtonDisabled: import("vue").ComputedRef<boolean>;
+                Transition: import("vue").FunctionalComponent<import("vue").TransitionProps, {}, any, {}>;
+                toRaw: typeof import("vue").toRaw;
+                pt: ((id: string) => string | undefined) | null;
+                t: typeof import("../../locale/temporal-text").temporalText;
+                n: (suffix?: string | undefined) => string;
+                classes: (...names: (import("../../utils/components").NamespaceClass | [unknown, import("../../utils/components").NamespaceClass, import("../../utils/components").NamespaceClass?])[]) => import("../../utils/components").NamespaceClass[];
+                isOptionSelected: (option: import("../..").PickerColumnOption) => boolean;
+                isOptionDisabled: (option?: import("../..").PickerColumnOption | undefined) => boolean;
+                setScrollEl: (el: Element | import("vue").ComponentPublicInstance | null, scrollColumn: import("../../picker/Picker.vue").ScrollColumn) => void;
+                getOptionKey: (key: "value" | "text" | "children") => string;
+                getValue: (option: import("../..").PickerColumnOption) => string | number;
+                handlePopupUpdateShow: (value: boolean) => void;
+                handlePopupOverlayClick: (event: MouseEvent) => void;
+                handlePopupKeyEscape: (event: KeyboardEvent) => void;
+                handleTouchstart: (event: TouchEvent, scrollColumn: import("../../picker/Picker.vue").ScrollColumn) => void;
+                handleTouchmove: (event: TouchEvent, scrollColumn: import("../../picker/Picker.vue").ScrollColumn) => void;
+                handleTouchend: (scrollColumn: import("../../picker/Picker.vue").ScrollColumn) => void;
+                handleTransitionend: (scrollColumn: import("../../picker/Picker.vue").ScrollColumn, event?: TransitionEvent | undefined) => void;
+                confirm: () => void;
+                cancel: () => void;
+                handleClick: (scrollColumn: import("../../picker/Picker.vue").ScrollColumn, index: number) => void;
+            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                confirm: (values: (string | number)[], indexes: number[], options: import("../..").PickerColumnOption[]) => true;
+                cancel: (values: (string | number)[], indexes: number[], options: import("../..").PickerColumnOption[]) => true;
+                change: (values: (string | number)[], indexes: number[], options: import("../..").PickerColumnOption[]) => true;
+                'update:open': (open: boolean) => true;
+                'update:modelValue': (value: (string | number)[]) => true;
+                open: () => true;
+                opened: () => true;
+                close: () => true;
+                closed: () => true;
+                'click-overlay': (event: MouseEvent) => true;
+                'key-escape': (event: KeyboardEvent) => true;
+            }, import("vue").PublicProps, {
+                optionHeight: string | number;
+                optionCount: string | number;
+                modelValue: (string | number)[];
+                defaultValue: (string | number)[];
+                disabled: boolean;
+                open: boolean;
+                defaultOpen: boolean;
+                overlayClosable: boolean;
+                escToClose: boolean;
+                popupContainer: import("../..").PopupContainer;
+                safeArea: boolean;
+                toolbar: boolean;
+                fieldNames: import("../../utils/options").FieldNames;
+                columns: import("../..").PickerColumnOption[] | import("../..").PickerColumnOption[][];
+                selectedValues: (string | number)[];
+                cascade: boolean;
+                dynamic: boolean;
+            }, true, {}, import("vue").SlotsType<import("../..").PickerSlots>, {
+                MIconCheck: {
                     new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<{
                         size?: string | number | undefined;
                         color?: string | undefined;
@@ -4677,7 +5586,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
                 }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
                     install(app: import("vue").App<any>): void;
                 };
-                MpButton: import("../../utils/components").ComponentWithInstall<{
+                MpButton: {
                     new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
                         status: {
                             type: PropType<"success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger">;
@@ -4940,129 +5849,8 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
                         default?: ((props: {}) => any) | undefined;
                     };
                 }) & {
-                    Group: {
-                        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
-                            status: {
-                                type: PropType<"success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger">;
-                                default: string;
-                                validator: (value: "success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger") => boolean;
-                            };
-                            size: {
-                                type: PropType<"xs" | "sm" | "md" | "lg" | "xl">;
-                                default: undefined;
-                                validator: (value: "xs" | "sm" | "md" | "lg" | "xl") => boolean;
-                            };
-                            variant: {
-                                type: PropType<"default" | "text" | "tonal" | "outline">;
-                                default: string;
-                                validator: (value: "default" | "text" | "tonal" | "outline") => boolean;
-                            };
-                            color: StringConstructor;
-                            textColor: StringConstructor;
-                            disabled: BooleanConstructor;
-                            stacked: BooleanConstructor;
-                            vertical: BooleanConstructor;
-                            elevation: {
-                                type: (BooleanConstructor | NumberConstructor)[];
-                                default: boolean;
-                            };
-                        }>> & Readonly<{}>, {
-                            buttonGroupProvider: import("../../button/group-provide").ButtonGroupProvider;
-                        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
-                            size: "xs" | "sm" | "md" | "lg" | "xl";
-                            status: "success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger";
-                            elevation: number | boolean;
-                            disabled: boolean;
-                            vertical: boolean;
-                            variant: "default" | "text" | "tonal" | "outline";
-                            stacked: boolean;
-                        }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
-                            P: {};
-                            B: {};
-                            D: {};
-                            C: {};
-                            M: {};
-                            Defaults: {};
-                        }, Readonly<import("vue").ExtractPropTypes<{
-                            status: {
-                                type: PropType<"success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger">;
-                                default: string;
-                                validator: (value: "success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger") => boolean;
-                            };
-                            size: {
-                                type: PropType<"xs" | "sm" | "md" | "lg" | "xl">;
-                                default: undefined;
-                                validator: (value: "xs" | "sm" | "md" | "lg" | "xl") => boolean;
-                            };
-                            variant: {
-                                type: PropType<"default" | "text" | "tonal" | "outline">;
-                                default: string;
-                                validator: (value: "default" | "text" | "tonal" | "outline") => boolean;
-                            };
-                            color: StringConstructor;
-                            textColor: StringConstructor;
-                            disabled: BooleanConstructor;
-                            stacked: BooleanConstructor;
-                            vertical: BooleanConstructor;
-                            elevation: {
-                                type: (BooleanConstructor | NumberConstructor)[];
-                                default: boolean;
-                            };
-                        }>> & Readonly<{}>, {
-                            buttonGroupProvider: import("../../button/group-provide").ButtonGroupProvider;
-                        }, {}, {}, {}, {
-                            size: "xs" | "sm" | "md" | "lg" | "xl";
-                            status: "success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger";
-                            elevation: number | boolean;
-                            disabled: boolean;
-                            vertical: boolean;
-                            variant: "default" | "text" | "tonal" | "outline";
-                            stacked: boolean;
-                        }>;
-                        __isFragment?: undefined;
-                        __isTeleport?: undefined;
-                        __isSuspense?: undefined;
-                    } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
-                        status: {
-                            type: PropType<"success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger">;
-                            default: string;
-                            validator: (value: "success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger") => boolean;
-                        };
-                        size: {
-                            type: PropType<"xs" | "sm" | "md" | "lg" | "xl">;
-                            default: undefined;
-                            validator: (value: "xs" | "sm" | "md" | "lg" | "xl") => boolean;
-                        };
-                        variant: {
-                            type: PropType<"default" | "text" | "tonal" | "outline">;
-                            default: string;
-                            validator: (value: "default" | "text" | "tonal" | "outline") => boolean;
-                        };
-                        color: StringConstructor;
-                        textColor: StringConstructor;
-                        disabled: BooleanConstructor;
-                        stacked: BooleanConstructor;
-                        vertical: BooleanConstructor;
-                        elevation: {
-                            type: (BooleanConstructor | NumberConstructor)[];
-                            default: boolean;
-                        };
-                    }>> & Readonly<{}>, {
-                        buttonGroupProvider: import("../../button/group-provide").ButtonGroupProvider;
-                    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
-                        size: "xs" | "sm" | "md" | "lg" | "xl";
-                        status: "success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger";
-                        elevation: number | boolean;
-                        disabled: boolean;
-                        vertical: boolean;
-                        variant: "default" | "text" | "tonal" | "outline";
-                        stacked: boolean;
-                    }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
-                        $slots: {
-                            default?: ((props: {}) => any) | undefined;
-                        };
-                    });
-                }>;
+                    setPropsDefaults: (defaults: Record<string, any>) => void;
+                };
                 MpIcon: {
                     new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
                         name: StringConstructor;
@@ -5125,16 +5913,542 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
                 }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
                     click: (event: MouseEvent) => any;
                 }, string, {
-                    transition: string | number;
-                    spin: boolean;
+                    transition: string | number;
+                    spin: boolean;
+                }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+                    $slots: {
+                        default?: ((props: {}) => any) | undefined;
+                    };
+                });
+                MpPopup: {
+                    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+                        loading: BooleanConstructor;
+                        dir: {
+                            type: PropType<import("@maple-design/use-vue").ReadingDirection>;
+                        };
+                        beforeClose: PropType<import("../..").PopupBeforeClose>;
+                        open: {
+                            type: BooleanConstructor;
+                            default: undefined;
+                        };
+                        defaultOpen: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        placement: {
+                            type: PropType<import("../..").PopupPlacement>;
+                            default: string;
+                        };
+                        swipeToClose: BooleanConstructor;
+                        swipeThreshold: {
+                            type: NumberConstructor;
+                            default: number;
+                        };
+                        transition: StringConstructor;
+                        overlayAnimationName: {
+                            type: StringConstructor;
+                            default: undefined;
+                        };
+                        overlay: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        overlayClass: StringConstructor;
+                        overlayStyle: ObjectConstructor;
+                        lockScroll: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        overlayClosable: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        escToClose: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        unstyled: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        zIndex: NumberConstructor;
+                        safeAreaInsetBottom: BooleanConstructor;
+                        safeAreaInsetTop: BooleanConstructor;
+                        safeAreaInsetRight: BooleanConstructor;
+                        safeAreaInsetLeft: BooleanConstructor;
+                        unmountOnClose: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        closeOnRouteChange: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        popupContainer: {
+                            type: PropType<import("../..").PopupContainer>;
+                            default: undefined;
+                            validator: ((value: unknown) => boolean) | undefined;
+                        };
+                    }>> & Readonly<{
+                        onClose?: (() => any) | undefined;
+                        onOpen?: (() => any) | undefined;
+                        onOpened?: (() => any) | undefined;
+                        onClosed?: (() => any) | undefined;
+                        "onClick-overlay"?: ((value: MouseEvent) => any) | undefined;
+                        "onKey-escape"?: ((value: KeyboardEvent) => any) | undefined;
+                        "onUpdate:open"?: ((value: boolean) => any) | undefined;
+                        "onSwipe-close"?: ((value: PointerEvent) => any) | undefined;
+                        "onClose-error"?: ((error: unknown, reason: import("../..").PopupCloseReason) => any) | undefined;
+                    }>, {
+                        close: (event?: Event | undefined) => Promise<boolean>;
+                        requestClose: (reason?: import("../..").PopupCloseReason, event?: Event | undefined) => Promise<boolean>;
+                        pending: import("vue").ComputedRef<boolean>;
+                    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                        "update:open": (value: boolean) => void;
+                        close: () => void;
+                        open: () => void;
+                        opened: () => void;
+                        closed: () => void;
+                        "swipe-close": (value: PointerEvent) => void;
+                        "close-error": (error: unknown, reason: import("../..").PopupCloseReason) => void;
+                        "click-overlay": (value: MouseEvent) => void;
+                        "key-escape": (value: KeyboardEvent) => void;
+                    }, import("vue").PublicProps, {
+                        loading: boolean;
+                        open: boolean;
+                        overlay: boolean;
+                        defaultOpen: boolean;
+                        placement: import("../..").PopupPlacement;
+                        swipeToClose: boolean;
+                        swipeThreshold: number;
+                        overlayAnimationName: string;
+                        lockScroll: boolean;
+                        overlayClosable: boolean;
+                        escToClose: boolean;
+                        unstyled: boolean;
+                        safeAreaInsetBottom: boolean;
+                        safeAreaInsetTop: boolean;
+                        safeAreaInsetRight: boolean;
+                        safeAreaInsetLeft: boolean;
+                        unmountOnClose: boolean;
+                        closeOnRouteChange: boolean;
+                        popupContainer: import("../..").PopupContainer;
+                    }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+                        P: {};
+                        B: {};
+                        D: {};
+                        C: {};
+                        M: {};
+                        Defaults: {};
+                    }, Readonly<import("vue").ExtractPropTypes<{
+                        loading: BooleanConstructor;
+                        dir: {
+                            type: PropType<import("@maple-design/use-vue").ReadingDirection>;
+                        };
+                        beforeClose: PropType<import("../..").PopupBeforeClose>;
+                        open: {
+                            type: BooleanConstructor;
+                            default: undefined;
+                        };
+                        defaultOpen: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        placement: {
+                            type: PropType<import("../..").PopupPlacement>;
+                            default: string;
+                        };
+                        swipeToClose: BooleanConstructor;
+                        swipeThreshold: {
+                            type: NumberConstructor;
+                            default: number;
+                        };
+                        transition: StringConstructor;
+                        overlayAnimationName: {
+                            type: StringConstructor;
+                            default: undefined;
+                        };
+                        overlay: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        overlayClass: StringConstructor;
+                        overlayStyle: ObjectConstructor;
+                        lockScroll: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        overlayClosable: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        escToClose: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        unstyled: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        zIndex: NumberConstructor;
+                        safeAreaInsetBottom: BooleanConstructor;
+                        safeAreaInsetTop: BooleanConstructor;
+                        safeAreaInsetRight: BooleanConstructor;
+                        safeAreaInsetLeft: BooleanConstructor;
+                        unmountOnClose: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        closeOnRouteChange: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        popupContainer: {
+                            type: PropType<import("../..").PopupContainer>;
+                            default: undefined;
+                            validator: ((value: unknown) => boolean) | undefined;
+                        };
+                    }>> & Readonly<{
+                        onClose?: (() => any) | undefined;
+                        onOpen?: (() => any) | undefined;
+                        onOpened?: (() => any) | undefined;
+                        onClosed?: (() => any) | undefined;
+                        "onClick-overlay"?: ((value: MouseEvent) => any) | undefined;
+                        "onKey-escape"?: ((value: KeyboardEvent) => any) | undefined;
+                        "onUpdate:open"?: ((value: boolean) => any) | undefined;
+                        "onSwipe-close"?: ((value: PointerEvent) => any) | undefined;
+                        "onClose-error"?: ((error: unknown, reason: import("../..").PopupCloseReason) => any) | undefined;
+                    }>, {
+                        close: (event?: Event | undefined) => Promise<boolean>;
+                        requestClose: (reason?: import("../..").PopupCloseReason, event?: Event | undefined) => Promise<boolean>;
+                        pending: import("vue").ComputedRef<boolean>;
+                    }, {}, {}, {}, {
+                        loading: boolean;
+                        open: boolean;
+                        overlay: boolean;
+                        defaultOpen: boolean;
+                        placement: import("../..").PopupPlacement;
+                        swipeToClose: boolean;
+                        swipeThreshold: number;
+                        overlayAnimationName: string;
+                        lockScroll: boolean;
+                        overlayClosable: boolean;
+                        escToClose: boolean;
+                        unstyled: boolean;
+                        safeAreaInsetBottom: boolean;
+                        safeAreaInsetTop: boolean;
+                        safeAreaInsetRight: boolean;
+                        safeAreaInsetLeft: boolean;
+                        unmountOnClose: boolean;
+                        closeOnRouteChange: boolean;
+                        popupContainer: import("../..").PopupContainer;
+                    }>;
+                    __isFragment?: undefined;
+                    __isTeleport?: undefined;
+                    __isSuspense?: undefined;
+                } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+                    loading: BooleanConstructor;
+                    dir: {
+                        type: PropType<import("@maple-design/use-vue").ReadingDirection>;
+                    };
+                    beforeClose: PropType<import("../..").PopupBeforeClose>;
+                    open: {
+                        type: BooleanConstructor;
+                        default: undefined;
+                    };
+                    defaultOpen: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    placement: {
+                        type: PropType<import("../..").PopupPlacement>;
+                        default: string;
+                    };
+                    swipeToClose: BooleanConstructor;
+                    swipeThreshold: {
+                        type: NumberConstructor;
+                        default: number;
+                    };
+                    transition: StringConstructor;
+                    overlayAnimationName: {
+                        type: StringConstructor;
+                        default: undefined;
+                    };
+                    overlay: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    overlayClass: StringConstructor;
+                    overlayStyle: ObjectConstructor;
+                    lockScroll: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    overlayClosable: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    escToClose: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    unstyled: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    zIndex: NumberConstructor;
+                    safeAreaInsetBottom: BooleanConstructor;
+                    safeAreaInsetTop: BooleanConstructor;
+                    safeAreaInsetRight: BooleanConstructor;
+                    safeAreaInsetLeft: BooleanConstructor;
+                    unmountOnClose: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    closeOnRouteChange: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    popupContainer: {
+                        type: PropType<import("../..").PopupContainer>;
+                        default: undefined;
+                        validator: ((value: unknown) => boolean) | undefined;
+                    };
+                }>> & Readonly<{
+                    onClose?: (() => any) | undefined;
+                    onOpen?: (() => any) | undefined;
+                    onOpened?: (() => any) | undefined;
+                    onClosed?: (() => any) | undefined;
+                    "onClick-overlay"?: ((value: MouseEvent) => any) | undefined;
+                    "onKey-escape"?: ((value: KeyboardEvent) => any) | undefined;
+                    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+                    "onSwipe-close"?: ((value: PointerEvent) => any) | undefined;
+                    "onClose-error"?: ((error: unknown, reason: import("../..").PopupCloseReason) => any) | undefined;
+                }>, {
+                    close: (event?: Event | undefined) => Promise<boolean>;
+                    requestClose: (reason?: import("../..").PopupCloseReason, event?: Event | undefined) => Promise<boolean>;
+                    pending: import("vue").ComputedRef<boolean>;
+                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                    "update:open": (value: boolean) => void;
+                    close: () => void;
+                    open: () => void;
+                    opened: () => void;
+                    closed: () => void;
+                    "swipe-close": (value: PointerEvent) => void;
+                    "close-error": (error: unknown, reason: import("../..").PopupCloseReason) => void;
+                    "click-overlay": (value: MouseEvent) => void;
+                    "key-escape": (value: KeyboardEvent) => void;
+                }, string, {
+                    loading: boolean;
+                    open: boolean;
+                    overlay: boolean;
+                    defaultOpen: boolean;
+                    placement: import("../..").PopupPlacement;
+                    swipeToClose: boolean;
+                    swipeThreshold: number;
+                    overlayAnimationName: string;
+                    lockScroll: boolean;
+                    overlayClosable: boolean;
+                    escToClose: boolean;
+                    unstyled: boolean;
+                    safeAreaInsetBottom: boolean;
+                    safeAreaInsetTop: boolean;
+                    safeAreaInsetRight: boolean;
+                    safeAreaInsetLeft: boolean;
+                    unmountOnClose: boolean;
+                    closeOnRouteChange: boolean;
+                    popupContainer: import("../..").PopupContainer;
                 }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
                     $slots: {
-                        default?: ((props: {}) => any) | undefined;
+                        default?: ((props: {
+                            close: (reason?: import("../..").PopupCloseReason, event?: Event | undefined) => Promise<boolean>;
+                            pending: boolean;
+                        }) => any) | undefined;
                     };
                 });
-            }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
-        }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
-        MpPicker: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+            } & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+                P: {};
+                B: {};
+                D: {};
+                C: {};
+                M: {};
+                Defaults: {};
+            }, Readonly<import("vue").ExtractPropTypes<{
+                safeArea: BooleanConstructor;
+                open: {
+                    type: BooleanConstructor;
+                    default: undefined;
+                };
+                defaultOpen: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                overlayClosable: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                escToClose: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                popupContainer: {
+                    type: PropType<import("../..").PopupContainer>;
+                    default: undefined;
+                    validator: ((value: unknown) => boolean) | undefined;
+                };
+                modelValue: {
+                    type: PropType<(string | number)[]>;
+                    default: undefined;
+                };
+                defaultValue: {
+                    type: PropType<(string | number)[]>;
+                    default: () => never[];
+                };
+                columns: {
+                    type: PropType<import("../..").PickerColumnOption[] | import("../..").PickerColumnOption[][]>;
+                    default: () => never[];
+                };
+                title: StringConstructor;
+                fieldNames: {
+                    type: PropType<import("../../utils/options").FieldNames>;
+                    default: undefined;
+                };
+                toolbar: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                disabled: BooleanConstructor;
+                selectedValues: {
+                    type: PropType<(string | number)[]>;
+                    default: () => never[];
+                };
+                cascade: BooleanConstructor;
+                optionHeight: {
+                    type: (NumberConstructor | StringConstructor)[];
+                    default: number;
+                };
+                optionCount: {
+                    type: (NumberConstructor | StringConstructor)[];
+                    default: number;
+                };
+                columnsCount: (NumberConstructor | StringConstructor)[];
+                confirmButtonText: StringConstructor;
+                cancelButtonText: StringConstructor;
+                confirmButtonTextColor: StringConstructor;
+                cancelButtonTextColor: StringConstructor;
+                dynamic: BooleanConstructor;
+            }>> & Readonly<{
+                onCancel?: ((values: (string | number)[], indexes: number[], options: import("../..").PickerColumnOption[]) => any) | undefined;
+                onChange?: ((values: (string | number)[], indexes: number[], options: import("../..").PickerColumnOption[]) => any) | undefined;
+                onClose?: (() => any) | undefined;
+                onOpen?: (() => any) | undefined;
+                onOpened?: (() => any) | undefined;
+                onClosed?: (() => any) | undefined;
+                "onClick-overlay"?: ((event: MouseEvent) => any) | undefined;
+                "onKey-escape"?: ((event: KeyboardEvent) => any) | undefined;
+                "onUpdate:open"?: ((open: boolean) => any) | undefined;
+                onConfirm?: ((values: (string | number)[], indexes: number[], options: import("../..").PickerColumnOption[]) => any) | undefined;
+                "onUpdate:modelValue"?: ((value: (string | number)[]) => any) | undefined;
+            }>, {
+                describeError: (value: unknown) => string | undefined;
+                mergedError: import("vue").ComputedRef<boolean>;
+                mergedOpen: import("vue").ComputedRef<boolean>;
+                controlId: string;
+                handleColumnKeydown: (event: KeyboardEvent, column: import("../../picker/Picker.vue").ScrollColumn) => void;
+                optionHeight: import("vue").ComputedRef<number>;
+                optionCount: import("vue").ComputedRef<number>;
+                scrollColumns: import("vue").Ref<{
+                    id: number;
+                    touching: boolean;
+                    index: number;
+                    prevY: number;
+                    momentumPrevY: number;
+                    momentumTime: number;
+                    translate: number;
+                    duration: number;
+                    scrolling: boolean;
+                    column: {
+                        [x: string]: any;
+                        [x: number]: any;
+                        [x: symbol]: any;
+                        text?: string | number | undefined;
+                        value?: string | number | undefined;
+                        disabled?: boolean | undefined;
+                        children?: any[] | undefined;
+                        className?: string | undefined;
+                        textClassName?: string | undefined;
+                    }[];
+                    scrollEl: HTMLElement | null;
+                }[], import("../../picker/Picker.vue").ScrollColumn[] | {
+                    id: number;
+                    touching: boolean;
+                    index: number;
+                    prevY: number;
+                    momentumPrevY: number;
+                    momentumTime: number;
+                    translate: number;
+                    duration: number;
+                    scrolling: boolean;
+                    column: {
+                        [x: string]: any;
+                        [x: number]: any;
+                        [x: symbol]: any;
+                        text?: string | number | undefined;
+                        value?: string | number | undefined;
+                        disabled?: boolean | undefined;
+                        children?: any[] | undefined;
+                        className?: string | undefined;
+                        textClassName?: string | undefined;
+                    }[];
+                    scrollEl: HTMLElement | null;
+                }[]>;
+                columnHeight: import("vue").ComputedRef<number>;
+                center: import("vue").ComputedRef<number>;
+                confirmButtonDisabled: import("vue").ComputedRef<boolean>;
+                Transition: import("vue").FunctionalComponent<import("vue").TransitionProps, {}, any, {}>;
+                toRaw: typeof import("vue").toRaw;
+                pt: ((id: string) => string | undefined) | null;
+                t: typeof import("../../locale/temporal-text").temporalText;
+                n: (suffix?: string | undefined) => string;
+                classes: (...names: (import("../../utils/components").NamespaceClass | [unknown, import("../../utils/components").NamespaceClass, import("../../utils/components").NamespaceClass?])[]) => import("../../utils/components").NamespaceClass[];
+                isOptionSelected: (option: import("../..").PickerColumnOption) => boolean;
+                isOptionDisabled: (option?: import("../..").PickerColumnOption | undefined) => boolean;
+                setScrollEl: (el: Element | import("vue").ComponentPublicInstance | null, scrollColumn: import("../../picker/Picker.vue").ScrollColumn) => void;
+                getOptionKey: (key: "value" | "text" | "children") => string;
+                getValue: (option: import("../..").PickerColumnOption) => string | number;
+                handlePopupUpdateShow: (value: boolean) => void;
+                handlePopupOverlayClick: (event: MouseEvent) => void;
+                handlePopupKeyEscape: (event: KeyboardEvent) => void;
+                handleTouchstart: (event: TouchEvent, scrollColumn: import("../../picker/Picker.vue").ScrollColumn) => void;
+                handleTouchmove: (event: TouchEvent, scrollColumn: import("../../picker/Picker.vue").ScrollColumn) => void;
+                handleTouchend: (scrollColumn: import("../../picker/Picker.vue").ScrollColumn) => void;
+                handleTransitionend: (scrollColumn: import("../../picker/Picker.vue").ScrollColumn, event?: TransitionEvent | undefined) => void;
+                confirm: () => void;
+                cancel: () => void;
+                handleClick: (scrollColumn: import("../../picker/Picker.vue").ScrollColumn, index: number) => void;
+            }, {}, {}, {}, {
+                optionHeight: string | number;
+                optionCount: string | number;
+                modelValue: (string | number)[];
+                defaultValue: (string | number)[];
+                disabled: boolean;
+                open: boolean;
+                defaultOpen: boolean;
+                overlayClosable: boolean;
+                escToClose: boolean;
+                popupContainer: import("../..").PopupContainer;
+                safeArea: boolean;
+                toolbar: boolean;
+                fieldNames: import("../../utils/options").FieldNames;
+                columns: import("../..").PickerColumnOption[] | import("../..").PickerColumnOption[][];
+                selectedValues: (string | number)[];
+                cascade: boolean;
+                dynamic: boolean;
+            }>;
+            __isFragment?: undefined;
+            __isTeleport?: undefined;
+            __isSuspense?: undefined;
+        } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
             safeArea: BooleanConstructor;
             open: {
                 type: BooleanConstructor;
@@ -5166,7 +6480,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
                 default: () => never[];
             };
             columns: {
-                type: PropType<import("../../picker").PickerColumnOption[] | import("../../picker").PickerColumnOption[][]>;
+                type: PropType<import("../..").PickerColumnOption[] | import("../..").PickerColumnOption[][]>;
                 default: () => never[];
             };
             title: StringConstructor;
@@ -5198,6 +6512,18 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
             confirmButtonTextColor: StringConstructor;
             cancelButtonTextColor: StringConstructor;
             dynamic: BooleanConstructor;
+        }>> & Readonly<{
+            onCancel?: ((values: (string | number)[], indexes: number[], options: import("../..").PickerColumnOption[]) => any) | undefined;
+            onChange?: ((values: (string | number)[], indexes: number[], options: import("../..").PickerColumnOption[]) => any) | undefined;
+            onClose?: (() => any) | undefined;
+            onOpen?: (() => any) | undefined;
+            onOpened?: (() => any) | undefined;
+            onClosed?: (() => any) | undefined;
+            "onClick-overlay"?: ((event: MouseEvent) => any) | undefined;
+            "onKey-escape"?: ((event: KeyboardEvent) => any) | undefined;
+            "onUpdate:open"?: ((open: boolean) => any) | undefined;
+            onConfirm?: ((values: (string | number)[], indexes: number[], options: import("../..").PickerColumnOption[]) => any) | undefined;
+            "onUpdate:modelValue"?: ((value: (string | number)[]) => any) | undefined;
         }>, {
             describeError: (value: unknown) => string | undefined;
             mergedError: import("vue").ComputedRef<boolean>;
@@ -5257,14 +6583,14 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
             Transition: import("vue").FunctionalComponent<import("vue").TransitionProps, {}, any, {}>;
             toRaw: typeof import("vue").toRaw;
             pt: ((id: string) => string | undefined) | null;
-            t: (id: string) => any;
+            t: typeof import("../../locale/temporal-text").temporalText;
             n: (suffix?: string | undefined) => string;
             classes: (...names: (import("../../utils/components").NamespaceClass | [unknown, import("../../utils/components").NamespaceClass, import("../../utils/components").NamespaceClass?])[]) => import("../../utils/components").NamespaceClass[];
-            isOptionSelected: (option: import("../../picker").PickerColumnOption) => boolean;
-            isOptionDisabled: (option?: import("../../picker").PickerColumnOption | undefined) => boolean;
+            isOptionSelected: (option: import("../..").PickerColumnOption) => boolean;
+            isOptionDisabled: (option?: import("../..").PickerColumnOption | undefined) => boolean;
             setScrollEl: (el: Element | import("vue").ComponentPublicInstance | null, scrollColumn: import("../../picker/Picker.vue").ScrollColumn) => void;
             getOptionKey: (key: "value" | "text" | "children") => string;
-            getValue: (option: import("../../picker").PickerColumnOption) => string | number;
+            getValue: (option: import("../..").PickerColumnOption) => string | number;
             handlePopupUpdateShow: (value: boolean) => void;
             handlePopupOverlayClick: (event: MouseEvent) => void;
             handlePopupKeyEscape: (event: KeyboardEvent) => void;
@@ -5276,9 +6602,9 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
             cancel: () => void;
             handleClick: (scrollColumn: import("../../picker/Picker.vue").ScrollColumn, index: number) => void;
         }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-            confirm: (values: (string | number)[], indexes: number[], options: import("../../picker").PickerColumnOption[]) => true;
-            cancel: (values: (string | number)[], indexes: number[], options: import("../../picker").PickerColumnOption[]) => true;
-            change: (values: (string | number)[], indexes: number[], options: import("../../picker").PickerColumnOption[]) => true;
+            confirm: (values: (string | number)[], indexes: number[], options: import("../..").PickerColumnOption[]) => true;
+            cancel: (values: (string | number)[], indexes: number[], options: import("../..").PickerColumnOption[]) => true;
+            change: (values: (string | number)[], indexes: number[], options: import("../..").PickerColumnOption[]) => true;
             'update:open': (open: boolean) => true;
             'update:modelValue': (value: (string | number)[]) => true;
             open: () => true;
@@ -5287,83 +6613,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
             closed: () => true;
             'click-overlay': (event: MouseEvent) => true;
             'key-escape': (event: KeyboardEvent) => true;
-        }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
-            safeArea: BooleanConstructor;
-            open: {
-                type: BooleanConstructor;
-                default: undefined;
-            };
-            defaultOpen: {
-                type: BooleanConstructor;
-                default: boolean;
-            };
-            overlayClosable: {
-                type: BooleanConstructor;
-                default: boolean;
-            };
-            escToClose: {
-                type: BooleanConstructor;
-                default: boolean;
-            };
-            popupContainer: {
-                type: PropType<import("../..").PopupContainer>;
-                default: undefined;
-                validator: ((value: unknown) => boolean) | undefined;
-            };
-            modelValue: {
-                type: PropType<(string | number)[]>;
-                default: undefined;
-            };
-            defaultValue: {
-                type: PropType<(string | number)[]>;
-                default: () => never[];
-            };
-            columns: {
-                type: PropType<import("../../picker").PickerColumnOption[] | import("../../picker").PickerColumnOption[][]>;
-                default: () => never[];
-            };
-            title: StringConstructor;
-            fieldNames: {
-                type: PropType<import("../../utils/options").FieldNames>;
-                default: undefined;
-            };
-            toolbar: {
-                type: BooleanConstructor;
-                default: boolean;
-            };
-            disabled: BooleanConstructor;
-            selectedValues: {
-                type: PropType<(string | number)[]>;
-                default: () => never[];
-            };
-            cascade: BooleanConstructor;
-            optionHeight: {
-                type: (NumberConstructor | StringConstructor)[];
-                default: number;
-            };
-            optionCount: {
-                type: (NumberConstructor | StringConstructor)[];
-                default: number;
-            };
-            columnsCount: (NumberConstructor | StringConstructor)[];
-            confirmButtonText: StringConstructor;
-            cancelButtonText: StringConstructor;
-            confirmButtonTextColor: StringConstructor;
-            cancelButtonTextColor: StringConstructor;
-            dynamic: BooleanConstructor;
-        }>> & Readonly<{
-            onCancel?: ((values: (string | number)[], indexes: number[], options: import("../../picker").PickerColumnOption[]) => any) | undefined;
-            onChange?: ((values: (string | number)[], indexes: number[], options: import("../../picker").PickerColumnOption[]) => any) | undefined;
-            onClose?: (() => any) | undefined;
-            onOpen?: (() => any) | undefined;
-            onOpened?: (() => any) | undefined;
-            onClosed?: (() => any) | undefined;
-            "onClick-overlay"?: ((event: MouseEvent) => any) | undefined;
-            "onKey-escape"?: ((event: KeyboardEvent) => any) | undefined;
-            "onUpdate:open"?: ((open: boolean) => any) | undefined;
-            onConfirm?: ((values: (string | number)[], indexes: number[], options: import("../../picker").PickerColumnOption[]) => any) | undefined;
-            "onUpdate:modelValue"?: ((value: (string | number)[]) => any) | undefined;
-        }>, {
+        }, string, {
             optionHeight: string | number;
             optionCount: string | number;
             modelValue: (string | number)[];
@@ -5377,11 +6627,11 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
             safeArea: boolean;
             toolbar: boolean;
             fieldNames: import("../../utils/options").FieldNames;
-            columns: import("../../picker").PickerColumnOption[] | import("../../picker").PickerColumnOption[][];
+            columns: import("../..").PickerColumnOption[] | import("../..").PickerColumnOption[][];
             selectedValues: (string | number)[];
             cascade: boolean;
             dynamic: boolean;
-        }, import("vue").SlotsType<import("../../picker").PickerSlots>, {
+        }, {}, string, import("vue").SlotsType<import("../..").PickerSlots>, {
             MIconCheck: {
                 new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<{
                     size?: string | number | undefined;
@@ -5446,7 +6696,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
             }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
                 install(app: import("vue").App<any>): void;
             };
-            MpButton: import("../../utils/components").ComponentWithInstall<{
+            MpButton: {
                 new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
                     status: {
                         type: PropType<"success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger">;
@@ -5709,129 +6959,8 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
                     default?: ((props: {}) => any) | undefined;
                 };
             }) & {
-                Group: {
-                    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
-                        status: {
-                            type: PropType<"success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger">;
-                            default: string;
-                            validator: (value: "success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger") => boolean;
-                        };
-                        size: {
-                            type: PropType<"xs" | "sm" | "md" | "lg" | "xl">;
-                            default: undefined;
-                            validator: (value: "xs" | "sm" | "md" | "lg" | "xl") => boolean;
-                        };
-                        variant: {
-                            type: PropType<"default" | "text" | "tonal" | "outline">;
-                            default: string;
-                            validator: (value: "default" | "text" | "tonal" | "outline") => boolean;
-                        };
-                        color: StringConstructor;
-                        textColor: StringConstructor;
-                        disabled: BooleanConstructor;
-                        stacked: BooleanConstructor;
-                        vertical: BooleanConstructor;
-                        elevation: {
-                            type: (BooleanConstructor | NumberConstructor)[];
-                            default: boolean;
-                        };
-                    }>> & Readonly<{}>, {
-                        buttonGroupProvider: import("../../button/group-provide").ButtonGroupProvider;
-                    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
-                        size: "xs" | "sm" | "md" | "lg" | "xl";
-                        status: "success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger";
-                        elevation: number | boolean;
-                        disabled: boolean;
-                        vertical: boolean;
-                        variant: "default" | "text" | "tonal" | "outline";
-                        stacked: boolean;
-                    }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
-                        P: {};
-                        B: {};
-                        D: {};
-                        C: {};
-                        M: {};
-                        Defaults: {};
-                    }, Readonly<import("vue").ExtractPropTypes<{
-                        status: {
-                            type: PropType<"success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger">;
-                            default: string;
-                            validator: (value: "success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger") => boolean;
-                        };
-                        size: {
-                            type: PropType<"xs" | "sm" | "md" | "lg" | "xl">;
-                            default: undefined;
-                            validator: (value: "xs" | "sm" | "md" | "lg" | "xl") => boolean;
-                        };
-                        variant: {
-                            type: PropType<"default" | "text" | "tonal" | "outline">;
-                            default: string;
-                            validator: (value: "default" | "text" | "tonal" | "outline") => boolean;
-                        };
-                        color: StringConstructor;
-                        textColor: StringConstructor;
-                        disabled: BooleanConstructor;
-                        stacked: BooleanConstructor;
-                        vertical: BooleanConstructor;
-                        elevation: {
-                            type: (BooleanConstructor | NumberConstructor)[];
-                            default: boolean;
-                        };
-                    }>> & Readonly<{}>, {
-                        buttonGroupProvider: import("../../button/group-provide").ButtonGroupProvider;
-                    }, {}, {}, {}, {
-                        size: "xs" | "sm" | "md" | "lg" | "xl";
-                        status: "success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger";
-                        elevation: number | boolean;
-                        disabled: boolean;
-                        vertical: boolean;
-                        variant: "default" | "text" | "tonal" | "outline";
-                        stacked: boolean;
-                    }>;
-                    __isFragment?: undefined;
-                    __isTeleport?: undefined;
-                    __isSuspense?: undefined;
-                } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
-                    status: {
-                        type: PropType<"success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger">;
-                        default: string;
-                        validator: (value: "success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger") => boolean;
-                    };
-                    size: {
-                        type: PropType<"xs" | "sm" | "md" | "lg" | "xl">;
-                        default: undefined;
-                        validator: (value: "xs" | "sm" | "md" | "lg" | "xl") => boolean;
-                    };
-                    variant: {
-                        type: PropType<"default" | "text" | "tonal" | "outline">;
-                        default: string;
-                        validator: (value: "default" | "text" | "tonal" | "outline") => boolean;
-                    };
-                    color: StringConstructor;
-                    textColor: StringConstructor;
-                    disabled: BooleanConstructor;
-                    stacked: BooleanConstructor;
-                    vertical: BooleanConstructor;
-                    elevation: {
-                        type: (BooleanConstructor | NumberConstructor)[];
-                        default: boolean;
-                    };
-                }>> & Readonly<{}>, {
-                    buttonGroupProvider: import("../../button/group-provide").ButtonGroupProvider;
-                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
-                    size: "xs" | "sm" | "md" | "lg" | "xl";
-                    status: "success" | "default" | "primary" | "secondary" | "tertiary" | "info" | "warning" | "danger";
-                    elevation: number | boolean;
-                    disabled: boolean;
-                    vertical: boolean;
-                    variant: "default" | "text" | "tonal" | "outline";
-                    stacked: boolean;
-                }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
-                    $slots: {
-                        default?: ((props: {}) => any) | undefined;
-                    };
-                });
-            }>;
+                setPropsDefaults: (defaults: Record<string, any>) => void;
+            };
             MpIcon: {
                 new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
                     name: StringConstructor;
@@ -6247,7 +7376,9 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
                     }) => any) | undefined;
                 };
             });
-        }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        } & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+            setPropsDefaults: (defaults: Record<string, any>) => void;
+        };
         CalendarViewport: import("vue").DefineComponent<{
             locale?: string | undefined;
             mode: import("../..").CalendarInteractiveMode;