@mekari/pixel3-date-picker 0.0.1-dev.0

package/dist/composables/useCalendarRange.d.ts

@@ -0,0 +1,277 @@
+import * as vue from 'vue';
+import { CalendarPanelRangeProps } from '../modules/date-picker.props.js';
+import '../components/parts/date.js';
+import 'vue/jsx-runtime';
+import '@mekari/pixel3-styled-system/types';
+import '@mekari/pixel3-styled-system/css';
+import '@mekari/pixel3-styled-system/recipes';
+import '../components/parts/month.js';
+import '../components/parts/year.js';
+
+declare function useCalendarRange(props: CalendarPanelRangeProps): {
+    startDate: vue.Ref<{
+        toString: () => string;
+        toDateString: () => string;
+        toTimeString: () => string;
+        toLocaleString: {
+            (): string;
+            (locales?: string | string[] | undefined, options?: Intl.DateTimeFormatOptions | undefined): string;
+            (locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions | undefined): string;
+        };
+        toLocaleDateString: {
+            (): string;
+            (locales?: string | string[] | undefined, options?: Intl.DateTimeFormatOptions | undefined): string;
+            (locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions | undefined): string;
+        };
+        toLocaleTimeString: {
+            (): string;
+            (locales?: string | string[] | undefined, options?: Intl.DateTimeFormatOptions | undefined): string;
+            (locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions | undefined): string;
+        };
+        valueOf: () => number;
+        getTime: () => number;
+        getFullYear: () => number;
+        getUTCFullYear: () => number;
+        getMonth: () => number;
+        getUTCMonth: () => number;
+        getDate: () => number;
+        getUTCDate: () => number;
+        getDay: () => number;
+        getUTCDay: () => number;
+        getHours: () => number;
+        getUTCHours: () => number;
+        getMinutes: () => number;
+        getUTCMinutes: () => number;
+        getSeconds: () => number;
+        getUTCSeconds: () => number;
+        getMilliseconds: () => number;
+        getUTCMilliseconds: () => number;
+        getTimezoneOffset: () => number;
+        setTime: (time: number) => number;
+        setMilliseconds: (ms: number) => number;
+        setUTCMilliseconds: (ms: number) => number;
+        setSeconds: (sec: number, ms?: number | undefined) => number;
+        setUTCSeconds: (sec: number, ms?: number | undefined) => number;
+        setMinutes: (min: number, sec?: number | undefined, ms?: number | undefined) => number;
+        setUTCMinutes: (min: number, sec?: number | undefined, ms?: number | undefined) => number;
+        setHours: (hours: number, min?: number | undefined, sec?: number | undefined, ms?: number | undefined) => number;
+        setUTCHours: (hours: number, min?: number | undefined, sec?: number | undefined, ms?: number | undefined) => number;
+        setDate: (date: number) => number;
+        setUTCDate: (date: number) => number;
+        setMonth: (month: number, date?: number | undefined) => number;
+        setUTCMonth: (month: number, date?: number | undefined) => number;
+        setFullYear: (year: number, month?: number | undefined, date?: number | undefined) => number;
+        setUTCFullYear: (year: number, month?: number | undefined, date?: number | undefined) => number;
+        toUTCString: () => string;
+        toISOString: () => string;
+        toJSON: (key?: any) => string;
+        [Symbol.toPrimitive]: {
+            (hint: "default"): string;
+            (hint: "string"): string;
+            (hint: "number"): number;
+            (hint: string): string | number;
+        };
+    }>;
+    endDate: vue.Ref<{
+        toString: () => string;
+        toDateString: () => string;
+        toTimeString: () => string;
+        toLocaleString: {
+            (): string;
+            (locales?: string | string[] | undefined, options?: Intl.DateTimeFormatOptions | undefined): string;
+            (locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions | undefined): string;
+        };
+        toLocaleDateString: {
+            (): string;
+            (locales?: string | string[] | undefined, options?: Intl.DateTimeFormatOptions | undefined): string;
+            (locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions | undefined): string;
+        };
+        toLocaleTimeString: {
+            (): string;
+            (locales?: string | string[] | undefined, options?: Intl.DateTimeFormatOptions | undefined): string;
+            (locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions | undefined): string;
+        };
+        valueOf: () => number;
+        getTime: () => number;
+        getFullYear: () => number;
+        getUTCFullYear: () => number;
+        getMonth: () => number;
+        getUTCMonth: () => number;
+        getDate: () => number;
+        getUTCDate: () => number;
+        getDay: () => number;
+        getUTCDay: () => number;
+        getHours: () => number;
+        getUTCHours: () => number;
+        getMinutes: () => number;
+        getUTCMinutes: () => number;
+        getSeconds: () => number;
+        getUTCSeconds: () => number;
+        getMilliseconds: () => number;
+        getUTCMilliseconds: () => number;
+        getTimezoneOffset: () => number;
+        setTime: (time: number) => number;
+        setMilliseconds: (ms: number) => number;
+        setUTCMilliseconds: (ms: number) => number;
+        setSeconds: (sec: number, ms?: number | undefined) => number;
+        setUTCSeconds: (sec: number, ms?: number | undefined) => number;
+        setMinutes: (min: number, sec?: number | undefined, ms?: number | undefined) => number;
+        setUTCMinutes: (min: number, sec?: number | undefined, ms?: number | undefined) => number;
+        setHours: (hours: number, min?: number | undefined, sec?: number | undefined, ms?: number | undefined) => number;
+        setUTCHours: (hours: number, min?: number | undefined, sec?: number | undefined, ms?: number | undefined) => number;
+        setDate: (date: number) => number;
+        setUTCDate: (date: number) => number;
+        setMonth: (month: number, date?: number | undefined) => number;
+        setUTCMonth: (month: number, date?: number | undefined) => number;
+        setFullYear: (year: number, month?: number | undefined, date?: number | undefined) => number;
+        setUTCFullYear: (year: number, month?: number | undefined, date?: number | undefined) => number;
+        toUTCString: () => string;
+        toISOString: () => string;
+        toJSON: (key?: any) => string;
+        [Symbol.toPrimitive]: {
+            (hint: "default"): string;
+            (hint: "string"): string;
+            (hint: "number"): number;
+            (hint: string): string | number;
+        };
+    }>;
+    hoveredDate: vue.Ref<any>;
+    calendars: vue.Ref<{
+        toString: () => string;
+        toDateString: () => string;
+        toTimeString: () => string;
+        toLocaleString: {
+            (): string;
+            (locales?: string | string[] | undefined, options?: Intl.DateTimeFormatOptions | undefined): string;
+            (locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions | undefined): string;
+        };
+        toLocaleDateString: {
+            (): string;
+            (locales?: string | string[] | undefined, options?: Intl.DateTimeFormatOptions | undefined): string;
+            (locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions | undefined): string;
+        };
+        toLocaleTimeString: {
+            (): string;
+            (locales?: string | string[] | undefined, options?: Intl.DateTimeFormatOptions | undefined): string;
+            (locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions | undefined): string;
+        };
+        valueOf: () => number;
+        getTime: () => number;
+        getFullYear: () => number;
+        getUTCFullYear: () => number;
+        getMonth: () => number;
+        getUTCMonth: () => number;
+        getDate: () => number;
+        getUTCDate: () => number;
+        getDay: () => number;
+        getUTCDay: () => number;
+        getHours: () => number;
+        getUTCHours: () => number;
+        getMinutes: () => number;
+        getUTCMinutes: () => number;
+        getSeconds: () => number;
+        getUTCSeconds: () => number;
+        getMilliseconds: () => number;
+        getUTCMilliseconds: () => number;
+        getTimezoneOffset: () => number;
+        setTime: (time: number) => number;
+        setMilliseconds: (ms: number) => number;
+        setUTCMilliseconds: (ms: number) => number;
+        setSeconds: (sec: number, ms?: number | undefined) => number;
+        setUTCSeconds: (sec: number, ms?: number | undefined) => number;
+        setMinutes: (min: number, sec?: number | undefined, ms?: number | undefined) => number;
+        setUTCMinutes: (min: number, sec?: number | undefined, ms?: number | undefined) => number;
+        setHours: (hours: number, min?: number | undefined, sec?: number | undefined, ms?: number | undefined) => number;
+        setUTCHours: (hours: number, min?: number | undefined, sec?: number | undefined, ms?: number | undefined) => number;
+        setDate: (date: number) => number;
+        setUTCDate: (date: number) => number;
+        setMonth: (month: number, date?: number | undefined) => number;
+        setUTCMonth: (month: number, date?: number | undefined) => number;
+        setFullYear: (year: number, month?: number | undefined, date?: number | undefined) => number;
+        setUTCFullYear: (year: number, month?: number | undefined, date?: number | undefined) => number;
+        toUTCString: () => string;
+        toISOString: () => string;
+        toJSON: (key?: any) => string;
+        [Symbol.toPrimitive]: {
+            (hint: "default"): string;
+            (hint: "string"): string;
+            (hint: "number"): number;
+            (hint: string): string | number;
+        };
+    }[]>;
+    getCurrentDates: vue.ComputedRef<{
+        toString: () => string;
+        toDateString: () => string;
+        toTimeString: () => string;
+        toLocaleString: {
+            (): string;
+            (locales?: string | string[] | undefined, options?: Intl.DateTimeFormatOptions | undefined): string;
+            (locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions | undefined): string;
+        };
+        toLocaleDateString: {
+            (): string;
+            (locales?: string | string[] | undefined, options?: Intl.DateTimeFormatOptions | undefined): string;
+            (locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions | undefined): string;
+        };
+        toLocaleTimeString: {
+            (): string;
+            (locales?: string | string[] | undefined, options?: Intl.DateTimeFormatOptions | undefined): string;
+            (locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions | undefined): string;
+        };
+        valueOf: () => number;
+        getTime: () => number;
+        getFullYear: () => number;
+        getUTCFullYear: () => number;
+        getMonth: () => number;
+        getUTCMonth: () => number;
+        getDate: () => number;
+        getUTCDate: () => number;
+        getDay: () => number;
+        getUTCDay: () => number;
+        getHours: () => number;
+        getUTCHours: () => number;
+        getMinutes: () => number;
+        getUTCMinutes: () => number;
+        getSeconds: () => number;
+        getUTCSeconds: () => number;
+        getMilliseconds: () => number;
+        getUTCMilliseconds: () => number;
+        getTimezoneOffset: () => number;
+        setTime: (time: number) => number;
+        setMilliseconds: (ms: number) => number;
+        setUTCMilliseconds: (ms: number) => number;
+        setSeconds: (sec: number, ms?: number | undefined) => number;
+        setUTCSeconds: (sec: number, ms?: number | undefined) => number;
+        setMinutes: (min: number, sec?: number | undefined, ms?: number | undefined) => number;
+        setUTCMinutes: (min: number, sec?: number | undefined, ms?: number | undefined) => number;
+        setHours: (hours: number, min?: number | undefined, sec?: number | undefined, ms?: number | undefined) => number;
+        setUTCHours: (hours: number, min?: number | undefined, sec?: number | undefined, ms?: number | undefined) => number;
+        setDate: (date: number) => number;
+        setUTCDate: (date: number) => number;
+        setMonth: (month: number, date?: number | undefined) => number;
+        setUTCMonth: (month: number, date?: number | undefined) => number;
+        setFullYear: (year: number, month?: number | undefined, date?: number | undefined) => number;
+        setUTCFullYear: (year: number, month?: number | undefined, date?: number | undefined) => number;
+        toUTCString: () => string;
+        toISOString: () => string;
+        toJSON: (key?: any) => string;
+        [Symbol.toPrimitive]: {
+            (hint: "default"): string;
+            (hint: "string"): string;
+            (hint: "number"): number;
+            (hint: string): string | number;
+        };
+    }[]>;
+    setStartDate: (date: Date | undefined) => void;
+    setEndDate: (date: Date | undefined) => void;
+    setHoveredDate: (date: Date | undefined) => void;
+    getDateRangeStatus: (cellDate: any) => {
+        inRange: boolean;
+        hoverInRange: boolean;
+        activeDragRange: boolean;
+    };
+    updateStartCalendar: (value: Date) => void;
+    updateEndCalendar: (value: Date) => void;
+};
+
+export { useCalendarRange };

package/dist/composables/useCalendarRange.js

@@ -0,0 +1,160 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/composables/useCalendarRange.ts
+var useCalendarRange_exports = {};
+__export(useCalendarRange_exports, {
+  useCalendarRange: () => useCalendarRange
+});
+module.exports = __toCommonJS(useCalendarRange_exports);
+var import_vue = require("vue");
+
+// src/utils/date.ts
+var import_date_fns = require("date-fns");
+function startOfMonth(value) {
+  const date = new Date(value);
+  date.setDate(1);
+  date.setHours(0, 0, 0, 0);
+  return date;
+}
+__name(startOfMonth, "startOfMonth");
+function getNextMonth(date) {
+  return (0, import_date_fns.addMonths)(date, 1);
+}
+__name(getNextMonth, "getNextMonth");
+
+// src/composables/useCalendarRange.ts
+function useCalendarRange(props) {
+  const leftCalendar = startOfMonth(/* @__PURE__ */ new Date());
+  const rightCalendar = startOfMonth(getNextMonth(/* @__PURE__ */ new Date()));
+  const startDate = (0, import_vue.ref)(props.modelValue[0]);
+  const endDate = (0, import_vue.ref)(props.modelValue[1]);
+  const hoveredDate = (0, import_vue.ref)();
+  const calendars = (0, import_vue.ref)([leftCalendar, rightCalendar]);
+  const getCurrentDates = (0, import_vue.computed)(() => {
+    if (startDate.value && !endDate.value)
+      return [startDate.value];
+    if (startDate.value && endDate.value)
+      return [startDate.value, endDate.value];
+    return [];
+  });
+  const calendarMinDiff = (0, import_vue.computed)(() => {
+    const map = {
+      date: 1,
+      // type:date  min 1 month
+      month: 1 * 12,
+      // type:month min 1 year
+      year: 10 * 12
+      // type:year  min 10 year
+    };
+    return map[props.type] || map.date;
+  });
+  const calendarMaxDiff = (0, import_vue.computed)(() => Infinity);
+  function setStartDate(date) {
+    startDate.value = date;
+  }
+  __name(setStartDate, "setStartDate");
+  function setEndDate(date) {
+    endDate.value = date;
+  }
+  __name(setEndDate, "setEndDate");
+  function setHoveredDate(date) {
+    hoveredDate.value = date;
+  }
+  __name(setHoveredDate, "setHoveredDate");
+  function getDateRangeStatus(cellDate) {
+    const status = {
+      inRange: false,
+      hoverInRange: false,
+      activeDragRange: false
+    };
+    const isInRange = /* @__PURE__ */ __name((data, range, fn = (v) => v.getTime()) => {
+      const value = fn(data);
+      let [min, max] = range.map(fn);
+      if (min > max) {
+        [min, max] = [max, min];
+      }
+      return value > min && value < max;
+    }, "isInRange");
+    if (getCurrentDates.value.length === 2 && isInRange(cellDate, getCurrentDates.value)) {
+      status.inRange = true;
+    }
+    if (getCurrentDates.value.length === 1 && hoveredDate.value && isInRange(cellDate, [getCurrentDates.value[0], hoveredDate.value])) {
+      status.hoverInRange = true;
+    }
+    if (getCurrentDates.value[0]) {
+      status.activeDragRange = true;
+    }
+    return status;
+  }
+  __name(getDateRangeStatus, "getDateRangeStatus");
+  function updateStartCalendar(value) {
+    updateCalendars([value, calendars.value[1]], 1);
+  }
+  __name(updateStartCalendar, "updateStartCalendar");
+  function updateEndCalendar(value) {
+    updateCalendars([calendars.value[0], value], 0);
+  }
+  __name(updateEndCalendar, "updateEndCalendar");
+  function updateCalendars(value, adjustIndex = 1) {
+    const gap = getCalendarGap(value);
+    if (gap) {
+      const calendar = new Date(value[adjustIndex]);
+      calendar.setMonth(calendar.getMonth() + (adjustIndex === 0 ? -gap : gap));
+      value[adjustIndex] = calendar;
+    }
+    calendars.value = value;
+  }
+  __name(updateCalendars, "updateCalendars");
+  function getCalendarGap(calendars2) {
+    const [calendarLeft, calendarRight] = calendars2;
+    const yearDiff = calendarRight.getFullYear() - calendarLeft.getFullYear();
+    const monthDiff = calendarRight.getMonth() - calendarLeft.getMonth();
+    const diff = yearDiff * 12 + monthDiff;
+    const min = calendarMinDiff.value;
+    const max = calendarMaxDiff.value;
+    if (diff < min) {
+      return min - diff;
+    }
+    if (diff > max) {
+      return max - diff;
+    }
+    return 0;
+  }
+  __name(getCalendarGap, "getCalendarGap");
+  return {
+    startDate,
+    endDate,
+    hoveredDate,
+    calendars,
+    getCurrentDates,
+    setStartDate,
+    setEndDate,
+    setHoveredDate,
+    getDateRangeStatus,
+    updateStartCalendar,
+    updateEndCalendar
+  };
+}
+__name(useCalendarRange, "useCalendarRange");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useCalendarRange
+});

package/dist/composables/useCalendarRange.mjs

@@ -0,0 +1,8 @@
+import {
+  useCalendarRange
+} from "../chunk-JZ2KFYWF.mjs";
+import "../chunk-26Y3AVJW.mjs";
+import "../chunk-QZ7VFGWC.mjs";
+export {
+  useCalendarRange
+};

package/dist/date-picker.d.mts

@@ -0,0 +1,237 @@
+import * as vue_jsx_runtime from 'vue/jsx-runtime';
+import * as vue from 'vue';
+
+declare const MpDatePicker: vue.DefineComponent<{
+    id: {
+        type: vue.PropType<string>;
+    };
+    modelValue: {
+        type: vue.PropType<string | number | Date | Date[] | string[] | number[]>;
+    };
+    type: {
+        type: vue.PropType<"date" | "month" | "year" | "week" | "biweek">;
+        default: string;
+    };
+    valueType: {
+        type: vue.PropType<"string" | "date" | "timestamp">;
+        default: string;
+    };
+    format: {
+        type: vue.PropType<string>;
+    };
+    rangeSeparator: {
+        type: vue.PropType<string>;
+        default: string;
+    };
+    placeholder: {
+        type: vue.PropType<string>;
+        default: string;
+    };
+    errorMessage: {
+        type: vue.PropType<string>;
+        default: string;
+    };
+    disabledMessage: {
+        type: vue.PropType<string>;
+        default: string;
+    };
+    lang: {
+        type: ObjectConstructor;
+        default: () => void;
+    };
+    inputAttr: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+    contentAttr: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+    isRange: {
+        type: vue.PropType<boolean>;
+        default: boolean;
+    };
+    isReadOnly: {
+        type: vue.PropType<boolean>;
+        default: boolean;
+    };
+    isDisabled: {
+        type: vue.PropType<boolean>;
+        default: boolean;
+    };
+    isClearable: {
+        type: vue.PropType<boolean>;
+        default: boolean;
+    };
+    isInvalid: {
+        type: vue.PropType<boolean>;
+        default: boolean;
+    };
+    usePortal: {
+        type: vue.PropType<boolean>;
+        default: boolean;
+    };
+    isKeepAlive: {
+        type: vue.PropType<boolean>;
+        default: boolean;
+    };
+    isInline: {
+        type: vue.PropType<boolean>;
+        default: boolean;
+    };
+    isNotClickable: {
+        type: vue.PropType<boolean>;
+        default: boolean;
+    };
+    isDisableHeader: {
+        type: vue.PropType<boolean>;
+        default: boolean;
+    };
+    isShowShortcut: {
+        type: vue.PropType<boolean>;
+        default: boolean;
+    };
+    disabledDate: {
+        type: vue.PropType<(date: Date) => boolean>;
+        default: () => void;
+    };
+    disabledMonth: {
+        type: vue.PropType<(month: number, year: number) => boolean>;
+        default: () => void;
+    };
+    disabledYear: {
+        type: vue.PropType<(year: number) => boolean>;
+        default: () => void;
+    };
+}, () => vue_jsx_runtime.JSX.Element, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, ("update:modelValue" | "error")[], "update:modelValue" | "error", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    id: {
+        type: vue.PropType<string>;
+    };
+    modelValue: {
+        type: vue.PropType<string | number | Date | Date[] | string[] | number[]>;
+    };
+    type: {
+        type: vue.PropType<"date" | "month" | "year" | "week" | "biweek">;
+        default: string;
+    };
+    valueType: {
+        type: vue.PropType<"string" | "date" | "timestamp">;
+        default: string;
+    };
+    format: {
+        type: vue.PropType<string>;
+    };
+    rangeSeparator: {
+        type: vue.PropType<string>;
+        default: string;
+    };
+    placeholder: {
+        type: vue.PropType<string>;
+        default: string;
+    };
+    errorMessage: {
+        type: vue.PropType<string>;
+        default: string;
+    };
+    disabledMessage: {
+        type: vue.PropType<string>;
+        default: string;
+    };
+    lang: {
+        type: ObjectConstructor;
+        default: () => void;
+    };
+    inputAttr: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+    contentAttr: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+    isRange: {
+        type: vue.PropType<boolean>;
+        default: boolean;
+    };
+    isReadOnly: {
+        type: vue.PropType<boolean>;
+        default: boolean;
+    };
+    isDisabled: {
+        type: vue.PropType<boolean>;
+        default: boolean;
+    };
+    isClearable: {
+        type: vue.PropType<boolean>;
+        default: boolean;
+    };
+    isInvalid: {
+        type: vue.PropType<boolean>;
+        default: boolean;
+    };
+    usePortal: {
+        type: vue.PropType<boolean>;
+        default: boolean;
+    };
+    isKeepAlive: {
+        type: vue.PropType<boolean>;
+        default: boolean;
+    };
+    isInline: {
+        type: vue.PropType<boolean>;
+        default: boolean;
+    };
+    isNotClickable: {
+        type: vue.PropType<boolean>;
+        default: boolean;
+    };
+    isDisableHeader: {
+        type: vue.PropType<boolean>;
+        default: boolean;
+    };
+    isShowShortcut: {
+        type: vue.PropType<boolean>;
+        default: boolean;
+    };
+    disabledDate: {
+        type: vue.PropType<(date: Date) => boolean>;
+        default: () => void;
+    };
+    disabledMonth: {
+        type: vue.PropType<(month: number, year: number) => boolean>;
+        default: () => void;
+    };
+    disabledYear: {
+        type: vue.PropType<(year: number) => boolean>;
+        default: () => void;
+    };
+}>> & {
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+    onError?: ((...args: any[]) => any) | undefined;
+}, {
+    type: "date" | "month" | "year" | "week" | "biweek";
+    valueType: "string" | "date" | "timestamp";
+    rangeSeparator: string;
+    placeholder: string;
+    errorMessage: string;
+    disabledMessage: string;
+    lang: Record<string, any>;
+    inputAttr: Record<string, any>;
+    contentAttr: Record<string, any>;
+    isRange: boolean;
+    isReadOnly: boolean;
+    isDisabled: boolean;
+    isClearable: boolean;
+    isInvalid: boolean;
+    usePortal: boolean;
+    isKeepAlive: boolean;
+    isInline: boolean;
+    isNotClickable: boolean;
+    isDisableHeader: boolean;
+    isShowShortcut: boolean;
+    disabledDate: (date: Date) => boolean;
+    disabledMonth: (month: number, year: number) => boolean;
+    disabledYear: (year: number) => boolean;
+}, {}>;
+
+export { MpDatePicker };