@tylertech/forge 2.0.0

package/esm/date-picker/base/base-date-picker.d.ts

@@ -0,0 +1,82 @@
+/**
+ * @license
+ * Copyright 2022 Tyler Technologies, Inc. 
+ * License: Apache-2.0
+ */
+import { DayOfWeek } from '../../calendar/calendar-constants';
+import { BaseComponent, IBaseComponent } from '../../core/base/base-component';
+import { DatePickerFormatCallback, DatePickerParseCallback, DatePickerPrepareMaskCallback, DatePickerValueMode } from './base-date-picker-constants';
+import { BaseDatePickerFoundation } from './base-date-picker-foundation';
+import { IBaseDatePickerAdapter } from './base-date-picker-adapter';
+export interface IBaseDatePickerComponent<TValue> extends IBaseComponent {
+    value: TValue;
+    min: Date | string | null;
+    max: Date | string | null;
+    disabledDates: Date | Date[] | null;
+    open: boolean;
+    parseCallback: DatePickerParseCallback;
+    formatCallback: DatePickerFormatCallback;
+    prepareMaskCallback: DatePickerPrepareMaskCallback;
+    disableDayCallback: (date: Date) => boolean;
+    popupClasses: string | string[];
+    disabled: boolean;
+    masked: boolean;
+    maskFormat: string;
+    showMaskFormat: boolean;
+    valueMode: DatePickerValueMode;
+    notifyInputValueChanges: boolean;
+    allowInvalidDate: boolean;
+    showToday: boolean;
+    showClear: boolean;
+    disabledDaysOfWeek: DayOfWeek[];
+    yearRange: string;
+}
+export declare abstract class BaseDatePickerComponent<TPublicValue, TPrivateValue, TFoundation extends BaseDatePickerFoundation<IBaseDatePickerAdapter, TPublicValue, TPrivateValue>> extends BaseComponent implements IBaseDatePickerComponent<TPublicValue> {
+    protected _foundation: TFoundation;
+    constructor();
+    connectedCallback(): Promise<void>;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string, oldValue: string, newValue: string): void;
+    /** Gets/sets the value of the component. */
+    value: TPublicValue;
+    /** Gets/sets the minimum date the calendar will allow. */
+    min: Date | string | null;
+    /** Gets/sets the maximum date the calendar will allow. */
+    max: Date | string | null;
+    /** Gets/sets the dates that are restricted from being selected. */
+    disabledDates: Date | Date[] | null;
+    /** Gets/sets whether the calendar dropdown is open. */
+    open: boolean;
+    /** Gets/sets the CSS classes that are applied to the popup element. */
+    popupClasses: string | string[];
+    /** Gets/sets whether the date picker is disabled or not. */
+    disabled: boolean;
+    /** Gets/sets whether the input mask is applied or not. */
+    masked: boolean;
+    /** Gets/sets the mask format that displayed in the input. Default is `MM/DD/YYYY` */
+    maskFormat: string;
+    /** Gets/sets whether the mask format is displayed in the input or not. Only applies if `masked` is `true`. */
+    showMaskFormat: boolean;
+    /** Gets/sets the type for the `value` property and `forge-date-picker-change` event. */
+    valueMode: DatePickerValueMode;
+    /** Gets/sets whether the native input will be notified of value changes via the `input` and `change` events. */
+    notifyInputValueChanges: boolean;
+    /** Gets/sets whether to allow an invalid date to be input. When true, the date picker will not clear out the value of the input if the date was invalid (i.e. could not be parsed). */
+    allowInvalidDate: boolean;
+    /** Gets/sets whether the today button is visible in the popup. */
+    showToday: boolean;
+    /** Gets/sets whether the clear button is visible in the popup. */
+    showClear: boolean;
+    /** Sets the callback to use for parsing a date value string to a `Date` object. */
+    parseCallback: DatePickerParseCallback;
+    /** Sets the callback to use for formatting `Date` value to a custom string format. */
+    formatCallback: DatePickerFormatCallback;
+    /** Sets the callback to use when altering default mask entry. */
+    prepareMaskCallback: DatePickerPrepareMaskCallback;
+    /** Sets the days of the week to disable from selection. */
+    disabledDaysOfWeek: DayOfWeek[];
+    /** Sets the callback to use for testing whether a specific date should be disabled or not. */
+    disableDayCallback: (date: Date) => boolean;
+    /** Sets the year range. */
+    yearRange: string;
+}

package/esm/date-picker/base/base-date-picker.js

@@ -0,0 +1,135 @@
+/**
+ * @license
+ * Copyright 2022 Tyler Technologies, Inc. 
+ * License: Apache-2.0
+ */
+import { __decorate } from "tslib";
+import { coerceBoolean, ensureChild, FoundationProperty, coerceNumberArray } from '@tylertech/forge-core';
+import { BaseComponent } from '../../core/base/base-component';
+import { BASE_DATE_PICKER_CONSTANTS } from './base-date-picker-constants';
+export class BaseDatePickerComponent extends BaseComponent {
+    constructor() {
+        super();
+    }
+    async connectedCallback() {
+        if (this.querySelector(BASE_DATE_PICKER_CONSTANTS.selectors.INPUT)) {
+            this._foundation.initialize();
+        }
+        else {
+            await ensureChild(this, BASE_DATE_PICKER_CONSTANTS.selectors.INPUT);
+            this._foundation.initialize();
+        }
+    }
+    disconnectedCallback() {
+        this._foundation.disconnect();
+    }
+    attributeChangedCallback(name, oldValue, newValue) {
+        switch (name) {
+            case BASE_DATE_PICKER_CONSTANTS.observedAttributes.MIN:
+                this.min = newValue;
+                break;
+            case BASE_DATE_PICKER_CONSTANTS.observedAttributes.MAX:
+                this.max = newValue;
+                break;
+            case BASE_DATE_PICKER_CONSTANTS.observedAttributes.OPEN:
+                this.open = coerceBoolean(newValue);
+                break;
+            case BASE_DATE_PICKER_CONSTANTS.observedAttributes.POPUP_CLASSES:
+                this.popupClasses = newValue;
+                break;
+            case BASE_DATE_PICKER_CONSTANTS.observedAttributes.DISABLED:
+                this.disabled = coerceBoolean(newValue);
+                break;
+            case BASE_DATE_PICKER_CONSTANTS.observedAttributes.MASKED:
+                this.masked = coerceBoolean(newValue);
+                break;
+            case BASE_DATE_PICKER_CONSTANTS.observedAttributes.SHOW_MASK_FORMAT:
+                this.showMaskFormat = coerceBoolean(newValue);
+                break;
+            case BASE_DATE_PICKER_CONSTANTS.observedAttributes.MASK_FORMAT:
+                this.maskFormat = newValue;
+                break;
+            case BASE_DATE_PICKER_CONSTANTS.observedAttributes.VALUE_MODE:
+                this.valueMode = newValue;
+                break;
+            case BASE_DATE_PICKER_CONSTANTS.observedAttributes.ALLOW_INVALID_DATE:
+                this.allowInvalidDate = coerceBoolean(newValue);
+                break;
+            case BASE_DATE_PICKER_CONSTANTS.observedAttributes.SHOW_TODAY:
+                this.showToday = coerceBoolean(newValue);
+                break;
+            case BASE_DATE_PICKER_CONSTANTS.observedAttributes.SHOW_CLEAR:
+                this.showClear = coerceBoolean(newValue);
+                break;
+            case BASE_DATE_PICKER_CONSTANTS.observedAttributes.DISABLED_DAYS_OF_WEEK:
+                this.disabledDaysOfWeek = coerceNumberArray(newValue);
+                break;
+            case BASE_DATE_PICKER_CONSTANTS.observedAttributes.YEAR_RANGE:
+                this.yearRange = newValue;
+                break;
+        }
+    }
+}
+__decorate([
+    FoundationProperty()
+], BaseDatePickerComponent.prototype, "value", void 0);
+__decorate([
+    FoundationProperty()
+], BaseDatePickerComponent.prototype, "min", void 0);
+__decorate([
+    FoundationProperty()
+], BaseDatePickerComponent.prototype, "max", void 0);
+__decorate([
+    FoundationProperty()
+], BaseDatePickerComponent.prototype, "disabledDates", void 0);
+__decorate([
+    FoundationProperty()
+], BaseDatePickerComponent.prototype, "open", void 0);
+__decorate([
+    FoundationProperty()
+], BaseDatePickerComponent.prototype, "popupClasses", void 0);
+__decorate([
+    FoundationProperty()
+], BaseDatePickerComponent.prototype, "disabled", void 0);
+__decorate([
+    FoundationProperty()
+], BaseDatePickerComponent.prototype, "masked", void 0);
+__decorate([
+    FoundationProperty()
+], BaseDatePickerComponent.prototype, "maskFormat", void 0);
+__decorate([
+    FoundationProperty()
+], BaseDatePickerComponent.prototype, "showMaskFormat", void 0);
+__decorate([
+    FoundationProperty()
+], BaseDatePickerComponent.prototype, "valueMode", void 0);
+__decorate([
+    FoundationProperty()
+], BaseDatePickerComponent.prototype, "notifyInputValueChanges", void 0);
+__decorate([
+    FoundationProperty()
+], BaseDatePickerComponent.prototype, "allowInvalidDate", void 0);
+__decorate([
+    FoundationProperty()
+], BaseDatePickerComponent.prototype, "showToday", void 0);
+__decorate([
+    FoundationProperty()
+], BaseDatePickerComponent.prototype, "showClear", void 0);
+__decorate([
+    FoundationProperty()
+], BaseDatePickerComponent.prototype, "parseCallback", void 0);
+__decorate([
+    FoundationProperty()
+], BaseDatePickerComponent.prototype, "formatCallback", void 0);
+__decorate([
+    FoundationProperty()
+], BaseDatePickerComponent.prototype, "prepareMaskCallback", void 0);
+__decorate([
+    FoundationProperty()
+], BaseDatePickerComponent.prototype, "disabledDaysOfWeek", void 0);
+__decorate([
+    FoundationProperty()
+], BaseDatePickerComponent.prototype, "disableDayCallback", void 0);
+__decorate([
+    FoundationProperty()
+], BaseDatePickerComponent.prototype, "yearRange", void 0);

package/esm/date-picker/date-picker-adapter.d.ts

@@ -0,0 +1,39 @@
+/**
+ * @license
+ * Copyright 2022 Tyler Technologies, Inc. 
+ * License: Apache-2.0
+ */
+import { ICalendarDropdownPopupConfig } from '../calendar/calendar-dropdown';
+import { IDateInputMaskOptions } from '../core/mask/date-input-mask';
+import { BaseDatePickerAdapter, IBaseDatePickerAdapter } from './base/base-date-picker-adapter';
+import { IDatePickerCalendarDropdownConfig } from './base/base-date-picker-constants';
+import { IDatePickerComponent } from './date-picker';
+export interface IDatePickerAdapter extends IBaseDatePickerAdapter {
+}
+export declare class DatePickerAdapter extends BaseDatePickerAdapter<IDatePickerComponent> implements IDatePickerAdapter {
+    private _inputElement;
+    private _inputMask;
+    private _dropdownIdentifier;
+    constructor(component: IDatePickerComponent);
+    protected _initializeInput(): void;
+    protected _initializeCalendarDropdown(): void;
+    initializeMask(options: IDateInputMaskOptions): void;
+    destroyMask(): void;
+    initializeAccessibility(): void;
+    addInputListener(type: string, listener: (event: Event) => void, capture?: boolean): void;
+    removeInputListener(type: string, listener: (event: Event) => void, capture?: boolean): void;
+    setInputValueChangedListener(context: any, listener: (value: any) => void): void;
+    hasInputElement(): boolean;
+    attachCalendar(calendarConfig: IDatePickerCalendarDropdownConfig<Date | null>, dropdownConfig?: ICalendarDropdownPopupConfig): void;
+    detachCalendar(): void;
+    setActiveDescendant(id: string): void;
+    setInputValue(value: string, emitEvents: boolean): void;
+    isInputDisabled(): boolean;
+    isInputFocused(): boolean;
+    getInputValue(): string;
+    setDisabled(value: boolean): void;
+    tryFocusInput(): void;
+    tryBlurInput(): void;
+    selectInputText(): void;
+    emitInputEvent(type: string, data?: any): void;
+}

package/esm/date-picker/date-picker-adapter.js

@@ -0,0 +1,121 @@
+/**
+ * @license
+ * Copyright 2022 Tyler Technologies, Inc. 
+ * License: Apache-2.0
+ */
+import { emitEvent, listenOwnProperty, getActiveElement } from '@tylertech/forge-core';
+import { CalendarDropdown } from '../calendar/calendar-dropdown/calendar-dropdown';
+import { DateInputMask } from '../core/mask/date-input-mask';
+import { BaseDatePickerAdapter } from './base/base-date-picker-adapter';
+import { DATE_PICKER_CONSTANTS } from './date-picker-constants';
+export class DatePickerAdapter extends BaseDatePickerAdapter {
+    constructor(component) {
+        super(component);
+        this._dropdownIdentifier = `forge-date-picker-${this._identifier}`;
+    }
+    _initializeInput() {
+        this._inputElement = this._component.querySelector(DATE_PICKER_CONSTANTS.selectors.INPUT);
+    }
+    _initializeCalendarDropdown() {
+        const targetElement = this._getDefaultTargetElement();
+        this._calendarDropdown = new CalendarDropdown(targetElement, this._dropdownIdentifier);
+    }
+    initializeMask(options) {
+        if (this._inputMask) {
+            this._inputMask.destroy();
+        }
+        this._inputMask = new DateInputMask(this._inputElement, options);
+    }
+    destroyMask() {
+        if (this._inputMask) {
+            this._inputMask.destroy();
+            this._inputMask = undefined;
+        }
+    }
+    initializeAccessibility() {
+        this._inputElement.setAttribute('autocomplete', 'off');
+        this._inputElement.setAttribute('autocorrect', 'off');
+        this._inputElement.setAttribute('autocapitalize', 'off');
+        this._inputElement.setAttribute('spellcheck', 'false');
+        this._inputElement.setAttribute('role', 'combobox');
+        this._inputElement.setAttribute('aria-live', 'assertive');
+        this._inputElement.setAttribute('aria-atomic', 'true');
+        this._inputElement.setAttribute('aria-haspopup', 'true');
+        this._inputElement.setAttribute('aria-expanded', 'false');
+        this._inputElement.setAttribute('aria-owns', this._dropdownIdentifier);
+    }
+    addInputListener(type, listener, capture) {
+        var _a;
+        (_a = this._inputElement) === null || _a === void 0 ? void 0 : _a.addEventListener(type, listener, { capture });
+    }
+    removeInputListener(type, listener, capture) {
+        var _a;
+        (_a = this._inputElement) === null || _a === void 0 ? void 0 : _a.removeEventListener(type, listener, { capture });
+    }
+    setInputValueChangedListener(context, listener) {
+        this.destroyValueChangeListener();
+        const destroyListenerCb = listenOwnProperty(context, this._inputElement, 'value', listener);
+        this._valueChangeListeners.push(destroyListenerCb);
+    }
+    hasInputElement() {
+        return !!this._inputElement;
+    }
+    attachCalendar(calendarConfig, dropdownConfig) {
+        super.attachCalendar(calendarConfig, dropdownConfig);
+        this._inputElement.setAttribute('aria-expanded', 'true');
+    }
+    detachCalendar() {
+        super.detachCalendar();
+        if (this._inputElement) {
+            this._inputElement.setAttribute('aria-expanded', 'false');
+            this._inputElement.removeAttribute('aria-activedescendant');
+        }
+    }
+    setActiveDescendant(id) {
+        this._inputElement.setAttribute('aria-activedescendant', id);
+    }
+    setInputValue(value, emitEvents) {
+        if (this._inputElement.value === value) {
+            return;
+        }
+        this._inputElement.value = value;
+        if (this._inputMask) {
+            this._inputMask.updateMask();
+        }
+        if (emitEvents) {
+            this._inputElement.dispatchEvent(new Event('change'));
+            this._inputElement.dispatchEvent(new Event('input'));
+        }
+    }
+    isInputDisabled() {
+        return this._inputElement.disabled;
+    }
+    isInputFocused() {
+        return getActiveElement() === this._inputElement;
+    }
+    getInputValue() {
+        return this._inputMask ? this._inputMask.maskedValue : this._inputElement.value;
+    }
+    setDisabled(value) {
+        this._inputElement.disabled = value;
+        this._inputElement.setAttribute('aria-disabled', value.toString());
+        if (this._toggleElement) {
+            this._toggleElement.setAttribute('aria-disabled', value.toString());
+            if (this._toggleElement.hasOwnProperty('disabled')) {
+                this._toggleElement.disabled = value;
+            }
+        }
+    }
+    tryFocusInput() {
+        this._inputElement.focus();
+    }
+    tryBlurInput() {
+        this._inputElement.blur();
+    }
+    selectInputText() {
+        this._inputElement.select();
+    }
+    emitInputEvent(type, data) {
+        emitEvent(this._inputElement, type, data);
+    }
+}

package/esm/date-picker/date-picker-component-delegate.d.ts

@@ -0,0 +1,34 @@
+/**
+ * @license
+ * Copyright 2022 Tyler Technologies, Inc. 
+ * License: Apache-2.0
+ */
+import { IBaseComponentDelegateConfig } from '../core/delegates/base-component-delegate';
+import { FormFieldComponentDelegate, IFormFieldComponentDelegateOptions } from '../core/delegates/form-field-component-delegate';
+import { ITextFieldComponent, ITextFieldComponentDelegateConfig } from '../text-field';
+import { IDatePickerComponent } from './date-picker';
+export declare type DatePickerComponentDelegateProps = Partial<IDatePickerComponent>;
+export interface IDatePickerComponentDelegateOptions extends IFormFieldComponentDelegateOptions {
+    useDropdownIcon?: boolean;
+    textFieldDelegateConfig?: ITextFieldComponentDelegateConfig;
+}
+export interface IDatePickerComponentDelegateConfig extends IBaseComponentDelegateConfig<IDatePickerComponent, IDatePickerComponentDelegateOptions> {
+}
+export declare class DatePickerComponentDelegate extends FormFieldComponentDelegate<IDatePickerComponent, IDatePickerComponentDelegateOptions> {
+    private _textFieldDelegate;
+    constructor(config?: IDatePickerComponentDelegateConfig);
+    protected _build(): IDatePickerComponent;
+    getInputElement(): HTMLInputElement;
+    getTextFieldElement(): ITextFieldComponent;
+    get value(): any;
+    set value(value: any);
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    get invalid(): boolean;
+    set invalid(value: boolean);
+    onChange(listener: (value: string) => void): void;
+    onInput(listener: (value: string) => void): void;
+    onFocus(listener: (evt: FocusEvent) => void): void;
+    onBlur(listener: (evt: FocusEvent) => void): void;
+    private _attachTextField;
+}

package/esm/date-picker/date-picker-component-delegate.js

@@ -0,0 +1,73 @@
+/**
+ * @license
+ * Copyright 2022 Tyler Technologies, Inc. 
+ * License: Apache-2.0
+ */
+import { FormFieldComponentDelegate } from '../core/delegates/form-field-component-delegate';
+import { TextFieldComponentDelegate } from '../text-field';
+import { DATE_PICKER_CONSTANTS } from './date-picker-constants';
+export class DatePickerComponentDelegate extends FormFieldComponentDelegate {
+    constructor(config) {
+        super(config);
+    }
+    _build() {
+        const datePicker = document.createElement(DATE_PICKER_CONSTANTS.elementName);
+        this._attachTextField(datePicker);
+        return datePicker;
+    }
+    getInputElement() {
+        return this._textFieldDelegate.inputElement;
+    }
+    getTextFieldElement() {
+        return this._textFieldDelegate.element;
+    }
+    get value() {
+        return this._element.value;
+    }
+    set value(value) {
+        this._element.value = value;
+    }
+    get disabled() {
+        return this._element.disabled;
+    }
+    set disabled(value) {
+        this._element.disabled = value;
+    }
+    get invalid() {
+        return this._textFieldDelegate.invalid || false;
+    }
+    set invalid(value) {
+        this._textFieldDelegate.invalid = value;
+    }
+    onChange(listener) {
+        if (this._element.masked) {
+            this._element.addEventListener(DATE_PICKER_CONSTANTS.events.INPUT, evt => listener(evt.target.value));
+        }
+        else {
+            this.getInputElement().addEventListener('input', evt => listener(evt.target.value));
+        }
+    }
+    onInput(listener) {
+        if (this._element.masked) {
+            this._element.addEventListener(DATE_PICKER_CONSTANTS.events.INPUT, (evt) => listener(evt.detail));
+        }
+        else {
+            this._textFieldDelegate.inputElement.addEventListener('input', evt => listener(evt.target.value));
+        }
+    }
+    onFocus(listener) {
+        this._textFieldDelegate.inputElement.addEventListener('focus', (evt) => listener(evt));
+    }
+    onBlur(listener) {
+        this._textFieldDelegate.inputElement.addEventListener('blur', (evt) => listener(evt));
+    }
+    _attachTextField(datePicker) {
+        var _a, _b, _c, _d;
+        const textFieldConfig = {
+            props: Object.assign({}, (_b = (_a = this._config.options) === null || _a === void 0 ? void 0 : _a.textFieldDelegateConfig) === null || _b === void 0 ? void 0 : _b.props),
+            options: Object.assign({}, (_d = (_c = this._config.options) === null || _c === void 0 ? void 0 : _c.textFieldDelegateConfig) === null || _d === void 0 ? void 0 : _d.options)
+        };
+        this._textFieldDelegate = new TextFieldComponentDelegate(textFieldConfig);
+        datePicker.appendChild(this._textFieldDelegate.element);
+    }
+}

package/esm/date-picker/date-picker-constants.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @license
+ * Copyright 2022 Tyler Technologies, Inc. 
+ * License: Apache-2.0
+ */
+export declare const DATE_PICKER_CONSTANTS: {
+    elementName: "forge-date-picker";
+    selectors: {
+        INPUT: string;
+    };
+    events: {
+        CHANGE: string;
+        OPEN: string;
+        CLOSE: string;
+        INPUT: string;
+    };
+    observedAttributes: {
+        VALUE: string;
+    };
+};

package/esm/date-picker/date-picker-constants.js

@@ -0,0 +1,25 @@
+/**
+ * @license
+ * Copyright 2022 Tyler Technologies, Inc. 
+ * License: Apache-2.0
+ */
+import { COMPONENT_NAME_PREFIX } from '../constants';
+const elementName = `${COMPONENT_NAME_PREFIX}date-picker`;
+const observedAttributes = {
+    VALUE: 'value'
+};
+const selectors = {
+    INPUT: 'input,input[forge-date-picker-input]'
+};
+const events = {
+    CHANGE: `${elementName}-change`,
+    OPEN: `${elementName}-open`,
+    CLOSE: `${elementName}-close`,
+    INPUT: `${elementName}-input`
+};
+export const DATE_PICKER_CONSTANTS = {
+    elementName,
+    selectors,
+    events,
+    observedAttributes
+};

package/esm/date-picker/date-picker-foundation.d.ts

@@ -0,0 +1,34 @@
+/**
+ * @license
+ * Copyright 2022 Tyler Technologies, Inc. 
+ * License: Apache-2.0
+ */
+import { CalendarMode, ICalendarDateSelectEventData } from '../calendar';
+import { BaseDatePickerFoundation, IBaseDatePickerFoundation } from './base/base-date-picker-foundation';
+import { IDatePickerAdapter } from './date-picker-adapter';
+export interface IDatePickerFoundation extends IBaseDatePickerFoundation<Date | string> {
+}
+export declare class DatePickerFoundation extends BaseDatePickerFoundation<IDatePickerAdapter, Date | string | null, Date> implements IDatePickerFoundation {
+    protected _mode: CalendarMode;
+    constructor(adapter: IDatePickerAdapter);
+    protected _initializeState(): void;
+    protected _emitChangeEvent(value: Date | null, force?: boolean): boolean;
+    protected _emitOpenEvent(): void;
+    protected _emitCloseEvent(): void;
+    protected _onToday(): void;
+    protected _onClear(): void;
+    protected _getCurrentValue(): Date | null;
+    protected _setFormattedInputValue(suppressValueChanges?: boolean): void;
+    protected _setValue(value: Date | null): void;
+    protected _onDateSelected(event: ICalendarDateSelectEventData): void;
+    protected _openCalendar(emitOpenEvent?: boolean): void;
+    protected _applyMin(): void;
+    protected _applyMax(): void;
+    protected _applyDisabledDates(): void;
+    protected _applyDisabledDaysOfWeek(): void;
+    protected _handleInput(value: string): void;
+    protected _onInputValueChanged(value: string): void;
+    private _applyValue;
+    get value(): Date | string | null;
+    set value(value: Date | string | null);
+}