@wavemaker-ai/react-runtime 1.0.0-rc.309

package/components/input/epoch/datetime/props.d.ts

@@ -0,0 +1,212 @@
+import { BaseProps, Prettify } from "@wavemaker-ai/react-runtime/higherOrder/props";
+import { ValidatorConfig } from "@wavemaker-ai/react-runtime/components/data/form/form-controller/props";
+/**
+ * Props specific to the WmDateTime component.
+ */
+export interface DateTimeProps {
+    /**
+     * Placeholder text shown when no datetime is selected.
+     */
+    placeholder?: string;
+    /**
+     * Whether to show AM/PM toggle buttons.
+     */
+    showampmbuttons?: boolean;
+    /**
+     * Keyboard shortcut key to focus the datetime picker.
+     */
+    shortcutkey?: string;
+    /**
+     * The bound data value of the datetime input.
+     */
+    datavalue?: string | Date | null;
+    /**
+     * Date pattern for display formatting.
+     * @example "yyyy-MM-dd HH:mm:ss"
+     */
+    datepattern?: string;
+    /**
+     * Step increment for hours.
+     * @default 1
+     */
+    hourstep?: number;
+    /**
+     * Step increment for minutes.
+     * @default 1
+     */
+    minutestep?: number;
+    /**
+     * Output format for the datetime value.
+     */
+    outputformat?: string;
+    /**
+     * Full default display pattern when `datepattern` is unset (standalone / overrides split defaults).
+     */
+    defaultDateTimeFormat?: string;
+    /**
+     * Default date segment for display when `datepattern` is unset and `defaultDateTimeFormat` is not set.
+     * Falls back to `listener.localeFormats.date`, then `"MMM d, y"`.
+     */
+    defaultDateFormat?: string;
+    /**
+     * Default time segment for display when `datepattern` is unset and `defaultDateTimeFormat` is not set.
+     * Falls back to `listener.localeFormats.time`, then `"h:mm:ss a"`.
+     */
+    defaultTimeFormat?: string;
+    /**
+     * Whether a datetime selection is required.
+     */
+    required?: boolean;
+    /**
+     * The earliest selectable date.
+     */
+    mindate?: string | Date;
+    /**
+     * The latest selectable date.
+     */
+    maxdate?: string | Date;
+    /**
+     * Comma-separated day indices to exclude (0=Sunday).
+     */
+    excludedays?: string;
+    /**
+     * Dates to exclude from selection.
+     */
+    excludedates?: string | string[] | Date[];
+    /**
+     * Whether to show week numbers.
+     */
+    showweeks?: boolean;
+    /**
+     * Whether to show the button bar (today/clear buttons).
+     */
+    showbuttonbar?: boolean;
+    /**
+     * Whether the input should be focused on mount.
+     */
+    autofocus?: boolean;
+    /**
+     * Whether the datetime picker is read-only.
+     */
+    readonly?: boolean;
+    /**
+     * Whether the datetime picker is disabled.
+     */
+    disabled?: boolean;
+    /**
+     * Whether dates from other months can be selected.
+     */
+    selectfromothermonth?: boolean;
+    /**
+     * Whether to show a "Today" button.
+     */
+    todaybutton?: boolean;
+    /**
+     * Whether to show a "Clear" button.
+     */
+    clearbutton?: boolean;
+    /**
+     * Label for the "Today" button.
+     */
+    todaybuttonlabel?: string;
+    /**
+     * Label for the "Clear" button.
+     */
+    clearbuttonlabel?: string;
+    /**
+     * Whether to show a custom picker UI.
+     */
+    showcustompicker?: boolean;
+    /**
+     * Whether to adaptively position the popover.
+     */
+    adaptiveposition?: boolean;
+    /**
+     * When to show the dropdown picker.
+     */
+    showdropdownon?: string;
+    /**
+     * Data entry mode for the datetime input.
+     */
+    dataentrymode?: string;
+    /**
+     * Callback invoked when the date changes.
+     */
+    onDateChange?: (date: Date | null) => void;
+    /**
+     * Checks whether a given value is a valid date.
+     */
+    isValidDate?: (date: Date) => boolean;
+    /**
+     * Converts a value to a Date object.
+     */
+    getDateObj?: (value: string | Date | null) => Date;
+    /**
+     * Validates a date against min/max constraints.
+     */
+    minDateMaxDateValidationOnInput?: (date: Date) => boolean;
+    /**
+     * Validates the format of the input value.
+     */
+    formatValidation?: (date: Date, dateString: string) => boolean;
+    /**
+     * Updates the previously bound data value.
+     */
+    updatePrevDatavalue?: (date: Date | null) => void;
+    /**
+     * Updates the bound variable with a new value.
+     */
+    updateBoundVariable?: (date: Date | null) => void;
+    /**
+     * Handles key down events on the datetime input.
+     */
+    handleKeyDown?: (event: React.KeyboardEvent) => void;
+    /**
+     * Callback invoked when the datetime value changes.
+     */
+    onChange?: (event: React.SyntheticEvent, widget: Record<string, unknown>, newValue: Date | string | null, oldValue: Date | string | null) => void;
+    /**
+     * Callback invoked when the datetime picker is clicked.
+     */
+    onClick?: (event: React.MouseEvent, widget: Record<string, unknown>) => void;
+    /**
+     * Callback invoked when the datetime picker receives focus.
+     */
+    onFocus?: (event: React.FocusEvent, widget: Record<string, unknown>) => void;
+    /**
+     * Callback invoked when the datetime picker loses focus.
+     */
+    onBlur?: (event: React.FocusEvent, widget: Record<string, unknown>) => void;
+    /**
+     * Callback invoked when the mouse enters the datetime picker.
+     */
+    onMouseEnter?: (event: React.MouseEvent, widget: Record<string, unknown>) => void;
+    /**
+     * Callback invoked when the mouse leaves the datetime picker.
+     */
+    onMouseLeave?: (event: React.MouseEvent, widget: Record<string, unknown>) => void;
+    /**
+     * Callback invoked before the datetime widget loads.
+     */
+    onBeforeload?: (event: React.SyntheticEvent, widget: Record<string, unknown>) => void;
+    /**
+     * Whether to show a floating label.
+     */
+    floatinglabel?: string;
+    /**
+     * Array of validator functions or configurations.
+     */
+    validators?: ValidatorConfig[];
+    /**
+     * Custom validation error message.
+     */
+    validationmessage?: string;
+    /**
+     * Field name used by the form controller.
+     */
+    fieldName?: string;
+}
+/**
+ * Combined props for the WmDateTime component, including base WaveMaker props.
+ */
+export type WmDateTimeProps = Prettify<DateTimeProps & BaseProps>;

package/components/input/epoch/datetime/props.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/components/input/epoch/datetime/utils.d.ts

@@ -0,0 +1,20 @@
+import moment from "moment-timezone";
+import { TimeView } from "@mui/x-date-pickers";
+import { ValidatorConfig } from "@/components/data/form/form-controller/props";
+export declare function ensureTime(date: Date | null): Date | null;
+export declare function mapToMomentPattern(pattern: string): string;
+export declare function getTimezone(): string;
+export declare function getWidthStyle(width?: string | number): string;
+export declare function parseDateWithCurrent(dateValue: string | Date | null | undefined, mode: "min" | "max"): Date | null;
+export declare function parseExcludedDays(excludedays: string | null | undefined): number[];
+export declare function parseExcludedDates(excludedates: string | string[] | Date[] | null | undefined): Date[];
+export declare function formatDate(date: Date | null, pattern: string, timezone?: string): string;
+export declare function parseDateValue(datavalue: any, datepattern: string): Date | null;
+export declare function validateDate(date: Date | null, minDateObj: Date | null, maxDateObj: Date | null, excludedDaysArray: number[], excludedDatesArray: Date[], validators?: ValidatorConfig[], validationmessage?: string): {
+    isValid: boolean;
+    isOutOfRange: boolean;
+    validationMessage?: string;
+};
+export declare function shouldDisableDate(date: moment.Moment | null, excludedDaysArray: number[], excludedDatesArray: Date[]): boolean;
+export declare function getTimeViews(datepattern: string): TimeView[];
+export declare function updateListener(name: string | undefined, listener: any, dateString: string, outputValue: string, props: any, onChange?: (event: React.SyntheticEvent, widget: any, newValue: any, oldValue: any) => void, oldValue?: string, timestampValue?: string): void;

package/components/input/epoch/datetime/utils.js

@@ -0,0 +1,283 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ensureTime = ensureTime;
+exports.formatDate = formatDate;
+exports.getTimeViews = getTimeViews;
+exports.getTimezone = getTimezone;
+exports.getWidthStyle = getWidthStyle;
+exports.mapToMomentPattern = mapToMomentPattern;
+exports.parseDateValue = parseDateValue;
+exports.parseDateWithCurrent = parseDateWithCurrent;
+exports.parseExcludedDates = parseExcludedDates;
+exports.parseExcludedDays = parseExcludedDays;
+exports.shouldDisableDate = shouldDisableDate;
+exports.updateListener = updateListener;
+exports.validateDate = validateDate;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _momentTimezone = _interopRequireDefault(require("moment-timezone"));
+var _util = require("../../../../core/util");
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2["default"])(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+// Utility to ensure a date has a time component (otherwise use current time)
+function ensureTime(date) {
+  if (!date) return null;
+  var hasTime = date.getHours() !== 0 || date.getMinutes() !== 0 || date.getSeconds() !== 0;
+  if (hasTime) return date;
+  var now = new Date();
+  var withTime = new Date(date);
+  withTime.setHours(now.getHours(), now.getMinutes(), now.getSeconds(), now.getMilliseconds());
+  return withTime;
+}
+
+// Utility to map custom date patterns to moment.js patterns
+function mapToMomentPattern(pattern) {
+  return pattern
+  // Convert lowercase 'y' sequences (1-4 characters) to uppercase 'Y'
+  // This handles cases like "yyyy" or "yy" even when followed by word characters (e.g., "yyyyT")
+  .replace(/y{1,4}/g, function (match) {
+    return match.toUpperCase();
+  })
+  // Convert lowercase 'd' sequences (1-2 characters) to uppercase 'D'
+  // This handles cases like "dd" even when followed by word characters (e.g., "ddT")
+  .replace(/d{1,2}/g, function (match) {
+    return match.toUpperCase();
+  }).replace(/\bEEEE\b/g, "dddd").replace(/\bEEE\b/g, "ddd").replace(/\bMMMM\b/g, "MMMM").replace(/\bMMM\b/g, "MMM").replace(/\byyyy\b/g, "YYYY").replace(/\byy\b/g, "YY").replace(/\bdd\b/g, "DD").replace(/\bd\b/g, "D").replace(/\bMM\b/g, "MM").replace(/\bM\b/g, "M").replace(/\bHH\b/g, "HH").replace(/\bH\b/g, "H").replace(/\bhh\b/g, "hh").replace(/\bh\b/g, "h").replace(/\bmm\b/g, "mm").replace(/\bm\b/g, "m").replace(/\bss\b/g, "ss").replace(/\ba\b/g, "A").replace(/\bZ\b/g, "ZZ");
+}
+
+// Get timezone utility
+function getTimezone() {
+  return (0, _util.getTimezone)();
+}
+
+// Width style helper
+function getWidthStyle(width) {
+  if (!width) return "";
+  if (typeof width === "number") return "".concat(width, "px");
+  // Check if string contains only numeric characters
+  if (typeof width === "string" && /^\d+$/.test(width)) {
+    return "".concat(width, "px");
+  }
+  return width;
+}
+
+// Parse min/max dates with CURRENT_DATE support
+function parseDateWithCurrent(dateValue, mode) {
+  if (!dateValue) return null;
+  if (dateValue === "CURRENT_DATE") {
+    return mode === "min" ? (0, _momentTimezone["default"])().startOf("day").toDate() : (0, _momentTimezone["default"])().endOf("day").toDate();
+  }
+  try {
+    return typeof dateValue === "string" ? (0, _momentTimezone["default"])(dateValue).toDate() : dateValue;
+  } catch (error) {
+    console.warn("Error parsing ".concat(mode, "date:"), error);
+    return null;
+  }
+}
+
+// Parse excluded days array
+function parseExcludedDays(excludedays) {
+  if (!excludedays) return [];
+  return excludedays.split(",").map(function (day) {
+    return parseInt(day.trim(), 10);
+  });
+}
+
+// Parse excluded dates array
+function parseExcludedDates(excludedates) {
+  if (!excludedates) return [];
+  if (typeof excludedates === "string") {
+    return excludedates.split(",").map(function (date) {
+      return (0, _momentTimezone["default"])(date.trim()).toDate();
+    });
+  }
+  if (Array.isArray(excludedates)) {
+    return excludedates.map(function (date) {
+      if (typeof date === "string") {
+        return (0, _momentTimezone["default"])(date).toDate();
+      }
+      return (0, _momentTimezone["default"])(date).toDate();
+    });
+  }
+  return [];
+}
+
+// Format date utility
+function formatDate(date, pattern, timezone) {
+  if (!date) return "";
+  if (pattern === "timestamp") {
+    return date.getTime().toString();
+  }
+  if (pattern === "UTC") {
+    return date.toISOString();
+  }
+  try {
+    var momentPattern = mapToMomentPattern(pattern).replaceAll("y", "Y").replaceAll("d", "D").replaceAll("a", "A");
+    var tz = timezone || getTimezone();
+    return (0, _momentTimezone["default"])(date).tz(tz).format(momentPattern);
+  } catch (error) {
+    console.warn("Date formatting error:", error);
+    var _tz = timezone || getTimezone();
+    return (0, _momentTimezone["default"])(date).tz(_tz).format(mapToMomentPattern(pattern));
+  }
+}
+
+// Parse date value utility
+function parseDateValue(datavalue, datepattern) {
+  if (!datavalue) return null;
+  if (datavalue instanceof Date) {
+    return datavalue;
+  } else if (typeof datavalue === "string" || typeof datavalue === "number") {
+    // Convert to string for consistent processing
+    var valueStr = String(datavalue);
+    if (/^\d+$/.test(valueStr)) {
+      // Timestamp - handle both seconds and milliseconds
+      var numValue = Number(valueStr);
+      var m;
+
+      // If timestamp is in seconds (less than 13 digits), convert to milliseconds
+      if (valueStr.length <= 10) {
+        m = (0, _momentTimezone["default"])(numValue * 1000);
+      } else {
+        m = (0, _momentTimezone["default"])(numValue);
+      }
+      return m.isValid() ? m.toDate() : null;
+    } else if (datepattern === "UTC") {
+      // UTC ISO string
+      var _m = _momentTimezone["default"].utc(valueStr);
+      return _m.isValid() ? _m.toDate() : null;
+    } else if (datepattern && datepattern !== "timestamp") {
+      // Custom pattern - use the specific pattern for parsing
+      var momentPattern = mapToMomentPattern(datepattern);
+      var _m2 = (0, _momentTimezone["default"])(valueStr, momentPattern, true); // strict parsing
+      if (!_m2.isValid()) {
+        // Try lenient parsing as fallback
+        _m2 = (0, _momentTimezone["default"])(valueStr);
+      }
+      return _m2 && _m2.isValid() ? _m2.toDate() : null;
+    } else {
+      // Fallback
+      var _m3 = (0, _momentTimezone["default"])(valueStr);
+      return _m3.isValid() ? _m3.toDate() : null;
+    }
+  }
+  return null;
+}
+function getValidatorErrorMessage(validators, validatorType) {
+  if (!validators || validators.length === 0) return undefined;
+  var validator = validators.find(function (v) {
+    return (0, _typeof2["default"])(v) === "object" && v !== null && "type" in v && v.type === validatorType;
+  });
+  if (validator && (0, _typeof2["default"])(validator) === "object" && "errorMessage" in validator) {
+    var errorMessage = validator.errorMessage;
+    if (typeof errorMessage === "string") {
+      return errorMessage;
+    }
+  }
+  return undefined;
+}
+
+// Validate date utility
+function validateDate(date, minDateObj, maxDateObj, excludedDaysArray, excludedDatesArray) {
+  var validators = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : [];
+  var validationmessage = arguments.length > 6 ? arguments[6] : undefined;
+  if (!date) return {
+    isValid: true,
+    isOutOfRange: false
+  };
+  // Check min/max date
+  if (minDateObj && (0, _momentTimezone["default"])(date).startOf("day").valueOf() < (0, _momentTimezone["default"])(minDateObj).startOf("day").valueOf()) {
+    var validatorMessage = getValidatorErrorMessage(validators, "mindate");
+    var errorMessage = validatorMessage || validationmessage || "Date is before minimum date";
+    return {
+      isValid: false,
+      isOutOfRange: true,
+      validationMessage: errorMessage
+    };
+  }
+  if (maxDateObj && (0, _momentTimezone["default"])(date).startOf("day").valueOf() > (0, _momentTimezone["default"])(maxDateObj).startOf("day").valueOf()) {
+    var _validatorMessage = getValidatorErrorMessage(validators, "maxdate");
+    var _errorMessage = _validatorMessage || validationmessage || "Date is after maximum date";
+    return {
+      isValid: false,
+      isOutOfRange: true,
+      validationMessage: _errorMessage
+    };
+  }
+
+  // Check excluded days
+  var day = date.getDay();
+  if (excludedDaysArray.includes(day)) {
+    var _validatorMessage2 = getValidatorErrorMessage(validators, "excludedays");
+    var _errorMessage2 = _validatorMessage2 || validationmessage || "Date is excluded";
+    return {
+      isValid: false,
+      isOutOfRange: true,
+      validationMessage: _errorMessage2
+    };
+  }
+
+  // Check excluded dates
+  var formattedDate = (0, _momentTimezone["default"])(date).startOf("day").valueOf();
+  if (excludedDatesArray.some(function (excludedDate) {
+    return (0, _momentTimezone["default"])(excludedDate).startOf("day").valueOf() === formattedDate;
+  })) {
+    var _validatorMessage3 = getValidatorErrorMessage(validators, "excludedates");
+    var _errorMessage3 = _validatorMessage3 || validationmessage || "Date is excluded";
+    return {
+      isValid: false,
+      isOutOfRange: true,
+      validationMessage: _errorMessage3
+    };
+  }
+  return {
+    isValid: true,
+    isOutOfRange: false
+  };
+}
+
+// Should disable date function for DatePicker
+function shouldDisableDate(date, excludedDaysArray, excludedDatesArray) {
+  if (!date) return false;
+
+  // Check excluded days
+  var day = date.day();
+  if (excludedDaysArray.includes(day)) return true;
+
+  // Check excluded dates
+  var dateTime = date.valueOf();
+  return excludedDatesArray.some(function (excludedDate) {
+    return (0, _momentTimezone["default"])(excludedDate).startOf("day").valueOf() === (0, _momentTimezone["default"])(dateTime).startOf("day").valueOf();
+  });
+}
+
+// Get time views based on date pattern
+function getTimeViews(datepattern) {
+  var timeViews = ["hours", "minutes"];
+  if (datepattern.includes("s")) {
+    timeViews.push("seconds");
+  }
+  return timeViews;
+}
+function updateListener(name, listener, dateString, outputValue, props, onChange, oldValue, timestampValue) {
+  var _listener$Widgets, _listener$Widgets2;
+  // Update listener widget display value
+  if (name && listener !== null && listener !== void 0 && (_listener$Widgets = listener.Widgets) !== null && _listener$Widgets !== void 0 && _listener$Widgets[name] && !props.fieldName) {
+    listener.Widgets[name].displayValue = dateString;
+    listener.Widgets[name].datavalue = outputValue;
+  }
+  if (onChange && name && listener !== null && listener !== void 0 && (_listener$Widgets2 = listener.Widgets) !== null && _listener$Widgets2 !== void 0 && _listener$Widgets2[name]) {
+    onChange({}, listener.Widgets[name], outputValue, listener.Widgets[name].datavalue);
+  }
+  // Update listener onChange
+  if (listener !== null && listener !== void 0 && listener.onChange) {
+    listener.onChange(props.fieldName || name, _objectSpread(_objectSpread({}, props), {}, {
+      datavalue: outputValue,
+      timestamp: timestampValue
+    }));
+  }
+}

package/components/input/epoch/time/index.d.ts

@@ -0,0 +1,86 @@
+import React from "react";
+declare const WmTimeStandalone: React.ComponentType<import("@wavemaker-ai/react-runtime/higherOrder/withBaseWrapper").BaseProps & import("@wavemaker-ai/react-runtime/higherOrder/BaseDateTime").CustomProps & import("@wavemaker-ai/react-runtime/higherOrder/withStandalone").WithStandaloneProps>;
+export { WmTimeStandalone as WmTime };
+/**
+ * The WmTime component provides a time picker input with format and interval support.
+ *
+ * - [Playground](https://react-components.wavemaker.ai/?path=/story/input-time--showcase)
+ *
+ * - [Docs](https://react-components.wavemaker.ai/?path=/story/input-time--docs)
+ *
+ * @param props - {@link WmTimeProps}
+ */
+declare const _default: React.ComponentType<{
+    standalone?: boolean;
+    ref?: React.RefObject<HTMLElement> | React.RefObject<null>;
+    animation?: string;
+    show?: boolean | string;
+    padding?: string;
+    margin?: string;
+    width?: number | string;
+    height?: number | string;
+    className?: string;
+    conditionalstyle?: React.CSSProperties;
+    conditionalclass?: string;
+    showindevice?: ("xs" | "sm" | "md" | "lg" | "all")[];
+    onClick?: (event?: React.MouseEvent<HTMLElement>, widget?: Record<string, any>, newVal?: string | number | null, oldVal?: string | number | null) => void;
+    onDoubleClick?: (event: React.MouseEvent<HTMLElement>, widget?: Record<string, any>, newVal?: string | number | null, oldVal?: string | number | null) => void;
+    onMouseEnter?: (event: React.MouseEvent<HTMLElement>, widget?: Record<string, any>, newVal?: string | number | null, oldVal?: string | number | null) => void;
+    onMouseLeave?: (event: React.MouseEvent<HTMLElement>, widget?: Record<string, any>, newVal?: string | number | null, oldVal?: string | number | null) => void;
+    onMouseOver?: (event: React.MouseEvent<HTMLElement>, widget?: Record<string, any>, newVal?: string | number | null, oldVal?: string | number | null) => void;
+    onMouseOut?: (event: React.MouseEvent<HTMLElement>, widget?: Record<string, any>, newVal?: string | number | null, oldVal?: string | number | null) => void;
+    onFocus?: (event: React.FocusEvent<HTMLElement>, widget?: Record<string, any>, newVal?: string | number | null, oldVal?: string | number | null) => void;
+    onBlur?: (event: React.FocusEvent<HTMLElement>, widget?: Record<string, any>, newVal?: string | number | null, oldVal?: string | number | null) => void;
+    onKeydown?: (event: React.KeyboardEvent<HTMLElement>, widget?: Record<string, any>, newVal?: string | number | null, oldVal?: string | number | null) => void;
+    onKeyup?: (event: React.KeyboardEvent<HTMLElement>, widget?: Record<string, any>, newVal?: string | number | null, oldVal?: string | number | null) => void;
+    onKeypress?: (event: React.KeyboardEvent<HTMLElement>, widget?: Record<string, any>, newVal?: string | number | null, oldVal?: string | number | null) => void;
+    eventCallback?: (eventName: string, data: any) => void;
+    forwardedRef?: React.ForwardedRef<any>;
+    viewParent?: any;
+    destroy?: ((names: string[]) => void) | ((formName?: string) => void);
+    hint?: string;
+    arialabel?: string;
+    tabindex?: number;
+    styles?: React.CSSProperties;
+    children?: React.ReactNode;
+    hidden?: boolean;
+    id?: string;
+    name?: string;
+    listener?: Record<string, any>;
+    "data-widget-id"?: string;
+    iswidget?: boolean | string;
+    deferload?: boolean | string;
+    "item-id"?: string;
+    datavalue?: any;
+    prefab?: boolean;
+    inbound?: Record<string, any>;
+    outbound?: Record<string, any>;
+    key?: string;
+    formfield?: boolean;
+    updateon?: string;
+    dataset?: any;
+    prefabName?: string;
+    formControlName?: string;
+    required?: boolean;
+    outputformat?: string;
+    mindate?: string | Date;
+    maxdate?: string | Date;
+    excludedays?: number[];
+    excludedates?: string[] | Date[];
+    dataentrymode?: "date" | "time" | "datetime";
+    datepattern?: string;
+    timepattern?: string;
+    showweeks?: boolean;
+    selectfromothermonth?: boolean;
+    todaybutton?: boolean;
+    clearbutton?: boolean;
+    todaybuttonlabel?: string;
+    clearbuttonlabel?: string;
+    showcustompicker?: boolean;
+    adaptiveposition?: boolean;
+    widgetSubType?: string;
+    context?: import("@wavemaker-ai/react-runtime/higherOrder/BaseDateTime").DateTimeContext;
+    invokeEventCallback?: (eventName: string, payload: any) => void;
+    formControlRegistry?: import("@wavemaker-ai/react-runtime/higherOrder/BaseDateTime").FormControlRegistry;
+}>;
+export default _default;