@dhtmlx/grid 9.3.3

package/codebase/types/ts-calendar/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./sources/Calendar";
+export * from "./sources/types";

package/codebase/types/ts-calendar/sources/Calendar.d.ts

@@ -0,0 +1,37 @@
+import { IEventSystem } from "../../ts-common/events";
+import { View } from "../../ts-common/view";
+import { CalendarEvents, ICalendar, ICalendarConfig, ViewMode, ICalendarHandlersMap } from "./types";
+export declare class Calendar extends View implements ICalendar {
+    events: IEventSystem<CalendarEvents, ICalendarHandlersMap>;
+    config: ICalendarConfig;
+    private _selected;
+    private _currentDate;
+    private _currentViewMode;
+    private _isSelectedInCurrentRange;
+    private _handlers;
+    private _timepicker;
+    private _time;
+    private _linkedCalendar;
+    constructor(container: HTMLElement | string, config?: ICalendarConfig);
+    setValue(value: Date | Date[] | string | string[]): boolean;
+    getValue<T extends boolean = false>(asDateObject?: T): Date | string;
+    getValue<T extends boolean = true>(asDateObject?: T): Date[] | string[];
+    getCurrentMode(): ViewMode;
+    showDate(date?: Date, mode?: ViewMode): void;
+    destructor(): void;
+    clear(): void;
+    link(targetCalendar: Calendar): void;
+    private _unlink;
+    private _setSelected;
+    private _getSelected;
+    private _draw;
+    private _initHandlers;
+    private _getData;
+    private _drawCalendar;
+    private _drawMonthSelector;
+    private _drawYearSelector;
+    private _drawHeader;
+    private _drawTimepicker;
+    private _selectDate;
+    private _moveBrowseFocus;
+}

package/codebase/types/ts-calendar/sources/helper.d.ts

@@ -0,0 +1 @@
+export declare const linkButtonClasses = ".dhx_button.dhx_button--view_link.dhx_button--icon.dhx_button--size_medium.dhx_button--color_secondary";

package/codebase/types/ts-calendar/sources/types.d.ts

@@ -0,0 +1,64 @@
+export interface ICalendarConfig {
+    value?: Date | Date[] | string | string[];
+    date?: Date | string;
+    css?: string;
+    mark?: (a: Date) => string;
+    disabledDates?: (a: Date) => boolean;
+    weekStart?: "saturday" | "sunday" | "monday";
+    weekNumbers?: boolean;
+    mode?: ViewMode;
+    timePicker?: boolean;
+    dateFormat?: string;
+    timeFormat?: 24 | 12;
+    thisMonthOnly?: boolean;
+    width?: string | number;
+    range?: boolean;
+    $rangeMark?: (a: Date) => string;
+    /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+    block?: (a: Date) => boolean;
+    /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+    view?: ViewMode;
+}
+export interface ICalendar {
+    paint(): void;
+    destructor(): void;
+    clear(): void;
+    showDate(date?: Date, mode?: ViewMode): void;
+    setValue(value: Date | Date[] | string | string[]): boolean;
+    getValue(asDatObj?: boolean): Date | Date[] | string | string[];
+    getCurrentMode(): ViewMode;
+    link(calendar: ICalendar): void;
+}
+export type ViewMode = "calendar" | "year" | "month" | "timepicker";
+export interface ICalendarDay {
+    css: string;
+    date: Date;
+    day: number;
+}
+export interface ICalendarWeek {
+    weekNumber: number;
+    days: ICalendarDay[];
+    disabledWeekNumber?: boolean;
+}
+export declare enum CalendarEvents {
+    change = "change",
+    beforeChange = "beforechange",
+    modeChange = "modeChange",
+    monthSelected = "monthSelected",
+    yearSelected = "yearSelected",
+    cancelClick = "cancelClick",
+    dateMouseOver = "dateMouseOver",
+    /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+    dateHover = "dateHover"
+}
+export interface ICalendarHandlersMap {
+    [key: string]: (...args: any[]) => any;
+    [CalendarEvents.change]: (date: Date, oldDate: Date, byClick: boolean, mode?: "clear") => void;
+    [CalendarEvents.beforeChange]: (date: Date, oldDate: Date, byClick: boolean) => boolean | void;
+    [CalendarEvents.dateMouseOver]: (date: Date, e: MouseEvent) => void;
+    [CalendarEvents.modeChange]: (mode: string) => void;
+    [CalendarEvents.monthSelected]: (month: number) => void;
+    [CalendarEvents.yearSelected]: (year: number) => void;
+    [CalendarEvents.cancelClick]: () => void;
+    [CalendarEvents.dateHover]: (date: Date, e: MouseEvent) => any;
+}

package/codebase/types/ts-combobox/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./sources/Combobox";
+export * from "./sources/ProCombobox";
+export * from "./sources/types";

package/codebase/types/ts-combobox/sources/Combobox.d.ts

@@ -0,0 +1,53 @@
+import { VNode } from "../../ts-common/dom";
+import { IEventSystem } from "../../ts-common/events";
+import { View } from "../../ts-common/view";
+import { DataCollection, DataEvents, IDataEventsHandlersMap, IDataItem } from "../../ts-data";
+import { Layout } from "../../ts-layout";
+import { List } from "../../ts-list";
+import { Popup } from "../../ts-popup";
+import { Id, IHandlers } from "../../ts-common/types";
+import { ComboboxEvents, ICombobox, IComboboxConfig, IComboboxEventHandlersMap, State } from "./types";
+export declare const $template: VNode;
+export declare class Combobox extends View implements ICombobox {
+    data: DataCollection;
+    config: IComboboxConfig;
+    events: IEventSystem<DataEvents | ComboboxEvents, IComboboxEventHandlersMap | IDataEventsHandlersMap>;
+    list: List;
+    popup: Popup;
+    protected _helper: Popup;
+    private _keyListener;
+    protected _layout: Layout;
+    private _isPopupConfiqureted;
+    private _state;
+    protected _handlers: IHandlers;
+    constructor(element: HTMLElement | string, config: IComboboxConfig);
+    focus(): void | boolean;
+    blur(): void | boolean;
+    enable(): void;
+    disable(): void;
+    isDisabled(): boolean;
+    clear(): void | boolean;
+    getValue<T extends boolean = false>(asArray?: T): T extends true ? Id[] : Id;
+    setValue(ids: Id[] | Id, silent?: boolean): void | boolean;
+    addOption<T extends IDataItem>(value: T | string, join?: boolean): void;
+    destructor(): void;
+    /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+    setState(state: State): void;
+    private _setValue;
+    protected _createLayout(): void;
+    private _initHandlers;
+    private _initEvents;
+    private _showOptions;
+    private _configurePopup;
+    private _hideOptions;
+    private _filter;
+    private _findBest;
+    private _exsistId;
+    private _draw;
+    private _drawSelectedItems;
+    private _drawImageOrIcon;
+    private _getItemText;
+    private _updateSelectedItem;
+    private _changePopupPosition;
+    private _updatePopup;
+}

package/codebase/types/ts-combobox/sources/ProCombobox.d.ts

@@ -0,0 +1,6 @@
+import { Combobox } from "./Combobox";
+import { IComboboxConfig } from "./types";
+export declare class ProCombobox extends Combobox {
+    constructor(element: HTMLElement | string, config: IComboboxConfig);
+    protected _createLayout(): void;
+}

package/codebase/types/ts-combobox/sources/helper.d.ts

@@ -0,0 +1,4 @@
+export declare function selectAllView(): any;
+export declare function unselectAllView(): any;
+export declare function emptyListView(value?: string): any;
+export declare function emptyListHeight(value: string, width: number): number;

package/codebase/types/ts-combobox/sources/keyListener.d.ts

@@ -0,0 +1,14 @@
+export declare class KeyListener {
+    private _isActive;
+    private _sequence;
+    private _currentAction;
+    private _clearTimeout;
+    private _handler;
+    constructor();
+    startNewListen(action: (seq: string) => any): void;
+    endListen(): void;
+    reset(): void;
+    destructor(): void;
+    private _change;
+    private _addClearTimeout;
+}

package/codebase/types/ts-combobox/sources/locales/en.d.ts

@@ -0,0 +1,8 @@
+declare const _default: {
+    notFound: string;
+    selectAll: string;
+    unselectAll: string;
+    selectedItems: string;
+    createItem: string;
+};
+export default _default;

package/codebase/types/ts-combobox/sources/types.d.ts

@@ -0,0 +1,95 @@
+import { Id } from "../../ts-common/types";
+import { DataCollection, IDataItem } from "../../ts-data";
+export type ILabelPosition = "left" | "top";
+export interface IComboboxConfig {
+    data?: DataCollection<any> | any[];
+    disabled?: boolean;
+    readOnly?: boolean;
+    template?: (item: any) => string;
+    filter?: (item: any, input: string) => boolean;
+    multiselection?: boolean;
+    label?: string;
+    labelPosition?: ILabelPosition;
+    labelWidth?: string | number;
+    placeholder?: string;
+    selectAllButton?: boolean;
+    itemsCount?: boolean | ((count: number) => string);
+    itemHeight?: number | string;
+    virtual?: boolean;
+    listHeight?: number | string;
+    required?: boolean;
+    helpMessage?: string;
+    hiddenLabel?: boolean;
+    css?: string;
+    value?: Id | Id[];
+    newOptions?: boolean;
+    htmlEnable?: boolean;
+    eventHandlers?: {
+        [eventName: string]: {
+            [className: string]: (event: Event, id: Id) => void | boolean;
+        };
+    };
+    /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+    cellHeight?: number;
+    /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+    help?: string;
+    /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+    showItemsCount?: boolean | ((count: number) => string);
+    /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+    labelInline?: boolean;
+    /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+    readonly?: boolean;
+}
+export declare enum ComboboxEvents {
+    beforeChange = "beforeChange",
+    change = "change",
+    focus = "focus",
+    blur = "blur",
+    keydown = "keydown",
+    input = "input",
+    beforeOpen = "beforeOpen",
+    afterOpen = "afterOpen",
+    beforeClose = "beforeClose",
+    afterClose = "afterClose",
+    /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+    open = "open",
+    /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+    close = "close"
+}
+export interface IComboboxEventHandlersMap {
+    [key: string]: (...args: any[]) => any;
+    [ComboboxEvents.beforeChange]: (ids: Id | Id[]) => boolean | void;
+    [ComboboxEvents.change]: (ids: Id | Id[]) => void;
+    [ComboboxEvents.focus]: () => void;
+    [ComboboxEvents.blur]: () => void;
+    [ComboboxEvents.keydown]: (event: KeyboardEvent, id: Id | undefined) => void;
+    [ComboboxEvents.input]: (value: string) => void;
+    [ComboboxEvents.beforeOpen]: () => boolean | void;
+    [ComboboxEvents.afterOpen]: () => void;
+    [ComboboxEvents.beforeClose]: () => boolean | void;
+    [ComboboxEvents.afterClose]: () => void;
+    [ComboboxEvents.open]: () => void;
+    [ComboboxEvents.close]: () => void;
+}
+export interface ICombobox {
+    disable(): void;
+    enable(): void;
+    isDisabled(): boolean;
+    destructor(): void;
+    paint(): void;
+    clear(): void;
+    focus(): void;
+    blur(): void;
+    getValue(asArray?: boolean): Id[] | Id;
+    setValue(ids: Id[] | Id): void;
+    addOption<T extends IDataItem>(value: T | string, join?: boolean): void;
+    /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+    setState(state: State): void;
+}
+export declare enum ComboState {
+    default = 0,
+    error = 1,
+    success = 2
+}
+/** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+export type State = "success" | "error" | "default";

package/codebase/types/ts-common/CssManager.d.ts

@@ -0,0 +1,26 @@
+interface ICssList {
+    [key: string]: string;
+}
+interface ICssManager {
+    update(): void;
+    remove(className: string): void;
+    add(cssList: ICssList, customId?: string, silent?: boolean): string;
+    get(className: string): ICssList;
+    destructor(): void;
+}
+export declare class CssManager implements ICssManager {
+    private _classes;
+    private _styleCont;
+    constructor();
+    update(): void;
+    remove(className: string): void;
+    add(cssList: ICssList, customId?: string, silent?: boolean): string;
+    get(className: string): ICssList;
+    destructor(): void;
+    private _findSameClassId;
+    private _addNewClass;
+    private _toCssString;
+    private _generateCss;
+}
+export declare const cssManager: CssManager;
+export {};

package/codebase/types/ts-common/FocusManager.d.ts

@@ -0,0 +1,15 @@
+export interface IFocusManager {
+    getFocusId(): string;
+    setFocusId(id: string): void;
+}
+declare class FocusManager implements IFocusManager {
+    private _activeWidgetId;
+    private _initHandler;
+    private _removeFocusClass;
+    private _addFocusClass;
+    constructor();
+    getFocusId(): string;
+    setFocusId(id: string): void;
+}
+export declare const focusManager: FocusManager;
+export {};

package/codebase/types/ts-common/KeyManager.d.ts

@@ -0,0 +1,19 @@
+import { anyFunction } from "./types";
+export interface IKeyManager {
+    destructor(): void;
+    addHotKey(key: string, handler: any): void;
+    removeHotKey(key?: string, context?: any): void;
+    exist(key: string): boolean;
+    getKeyStorageLength(): number;
+}
+export declare class KeyManager implements IKeyManager {
+    private _keysStorage;
+    private _beforeCall;
+    private _initHandler;
+    constructor(beforeCall?: (e: Event, focus: any) => boolean);
+    destructor(): void;
+    addHotKey(key: string, handler: any): void;
+    removeHotKey(key?: string, handler?: anyFunction): void;
+    exist(key: string): boolean;
+    getKeyStorageLength(): number;
+}

package/codebase/types/ts-common/ScrollView.d.ts

@@ -0,0 +1,40 @@
+import { anyFunction } from "./types";
+interface IScrollViewConfig {
+    enable: boolean;
+    autoHide: boolean;
+    timeout: number;
+    scrollHandler: anyFunction;
+}
+export declare const scrollViewConfig: IScrollViewConfig;
+export interface IScrollView {
+    config: IScrollViewConfig;
+    enable(): void;
+    disable(): void;
+    render(nods?: any[]): any;
+    update(): void;
+}
+export declare class ScrollView implements IScrollView {
+    config: IScrollViewConfig;
+    private _getRootView;
+    private _scrollYTop;
+    private _scrollXLeft;
+    private _runnerYTop;
+    private _runnerXLeft;
+    private _runnerHeight;
+    private _runnerWidth;
+    private _visibleYArea;
+    private _visibleXArea;
+    private _scrollWidth;
+    private _scrollHeight;
+    private _wheelName;
+    private _handlers;
+    private _autoHideFunc;
+    private _uid;
+    constructor(getRootView: any, config?: {});
+    enable(): void;
+    disable(): void;
+    render(element: any, uid?: string): any;
+    update(): void;
+    private _getRefs;
+}
+export {};

package/codebase/types/ts-common/core.d.ts

@@ -0,0 +1,40 @@
+type fn<T extends any[], K> = (...args: T) => K;
+type anyFunction = fn<any[], any>;
+export declare function uid(): string;
+export declare function extendComponent(target: any, source: any): any;
+export declare function extend(target: any, source: any, deep?: boolean): any;
+interface IOBj {
+    [key: string]: any;
+}
+export declare function copy(source: IOBj, withoutInner?: boolean): IOBj;
+export declare function naturalSort(arr: any): any[];
+export declare function findIndex<T = any>(arr: T[], predicate: (obj: T) => boolean): number;
+export declare function isExistValue(target: number | string, value: number | string): boolean;
+export declare function singleOuterClick(fn: (e: MouseEvent) => boolean): void;
+export declare function detectWidgetClick(widgetId: string, cb: (inner: boolean) => void): () => void;
+export declare function unwrapBox<T>(box: T | T[]): T;
+export declare function wrapBox<T>(unboxed: T | T[]): T[];
+export declare function isDefined<T>(some: T): boolean;
+export declare function isId<T>(some: T): boolean;
+export declare function range(from: number, to: number): number[];
+export declare function isNumeric(val: any): boolean;
+export declare function downloadFile(data: Blob | string, filename: string, mimeType?: string): void;
+export declare function debounce(func: anyFunction, wait: number, immediate?: boolean): (...args: any[]) => void;
+export declare function compare(obj1: any, obj2: any): boolean;
+export declare const isType: (value: any) => string;
+export declare const isEmptyObj: (obj: any) => boolean;
+export declare const getMaxArrayNumber: (array: number[]) => number;
+export declare const getMinArrayNumber: (array: number[]) => number;
+export interface IContainerConfig {
+    lineHeight?: number;
+    font?: string;
+}
+export declare const getStringWidth: (value: string, config?: IContainerConfig) => number;
+export declare const rgbToHex: (color: string) => string;
+export declare function getCloneObject(obj: any): any;
+export declare function getTextLines({ ctx, text, maxWidth }: {
+    ctx: any;
+    text: any;
+    maxWidth: any;
+}): string[];
+export {};

package/codebase/types/ts-common/date.d.ts

@@ -0,0 +1,34 @@
+export declare const locale: {
+    monthsShort: string[];
+    months: string[];
+    daysShort: string[];
+    days: string[];
+    cancel: string;
+};
+export declare function getFormattedDate(format: string, date: Date): string;
+export declare function getExcelDate(date: Date): number;
+export declare function stringToDate(str: string, format: string, validate?: boolean): any;
+export declare class DateHelper {
+    static nullTimestampDate: Date;
+    static copy(d: Date): Date;
+    static fromYear(year: number): Date;
+    static fromYearAndMonth(year: number, month: number): Date;
+    static weekStart(d: Date, firstWeekday: -1 | 0 | 1): Date;
+    static monthStart(d: Date): Date;
+    static yearStart(d: Date): Date;
+    static dayStart(d: Date): Date;
+    static addDay(d: Date, count?: number): Date;
+    static addMonth(d: Date, count?: number): Date;
+    static addYear(d: Date, count?: number): Date;
+    static withHoursAndMinutes(d: Date, hours: number, minutes: number, dateFormat: boolean): Date;
+    static setMonth(d: Date, month: number): void;
+    static setYear(d: Date, year: number): void;
+    static mergeHoursAndMinutes(source: Date, target: Date): Date;
+    static isWeekEnd(d: Date): boolean;
+    static getTwelweYears(d: Date): number[];
+    static getDayOrdinal(d: Date): number;
+    static getWeekNumber(d: Date): number;
+    static isSameDay(d1: Date, d2: Date): boolean;
+    static toDateObject(date: Date | string, dateFormat: string): Date;
+}
+export declare function stripTime(d: Date, full?: boolean): Date;

package/codebase/types/ts-common/dom.d.ts

@@ -0,0 +1,24 @@
+import { TTheme } from "./types";
+export declare const el: any;
+export declare const sv: any;
+export declare const view: any;
+export declare const create: any;
+export declare const inject: any;
+export declare const KEYED_LIST: any;
+export declare function disableHelp(): void;
+export type VNode = any;
+export interface IDomView {
+    redraw(): any;
+    mount(el: HTMLElement): any;
+}
+export interface IDomRender {
+    render(view: IDomView, data: any): VNode;
+}
+export interface IViewHash {
+    [name: string]: IDomRender;
+}
+export declare function resizer(handler: any): any;
+export declare function resizeHandler(container: any, handler: any): any;
+export declare function awaitRedraw(): Promise<void>;
+export declare function setTheme(theme: TTheme, container: string | HTMLElement): void;
+export declare function getViewHeight(view: VNode, width: number): number;

package/codebase/types/ts-common/events.d.ts

@@ -0,0 +1,35 @@
+export type Callback = (...args: any[]) => any;
+export interface IEventSystem<E, T extends IEventHandlersMap = IEventHandlersMap> {
+    context: any;
+    events: IEvents;
+    on<K extends keyof T>(name: K, callback: T[K], context?: any): any;
+    detach(name: E, context?: any): any;
+    clear(): void;
+    fire<K extends keyof T>(name: K, args?: ArgumentTypes<T[K]>): boolean;
+}
+interface IEvent {
+    callback: Callback;
+    context: any;
+}
+interface IEvents {
+    [key: string]: IEvent[];
+}
+interface IEventHandlersMap {
+    [key: string]: Callback;
+}
+type ArgumentTypes<F extends (...args: any[]) => any> = F extends (...args: infer A) => any ? A : never;
+export declare class EventSystem<E extends string, T extends IEventHandlersMap = IEventHandlersMap> implements IEventSystem<E, T> {
+    events: IEvents;
+    context: any;
+    constructor(context?: any);
+    on<K extends keyof T>(name: K, callback: T[K], context?: any): void;
+    detach(name: E, context?: any): void;
+    fire<K extends keyof T>(name: K, args: ArgumentTypes<T[K]>): boolean;
+    clear(): void;
+}
+export declare function EventsMixin(obj: any): void;
+export interface IEventFacade {
+    attachEvent: any;
+    callEvent: any;
+}
+export {};

package/codebase/types/ts-common/html.d.ts

@@ -0,0 +1,74 @@
+import { anyFunction } from "./types";
+export declare function toNode(node: string | HTMLElement): HTMLElement;
+type eventPrepare = (ev: Event) => any;
+interface IHandlerHash {
+    [name: string]: (...args: any[]) => boolean | void;
+}
+export declare function eventHandler(prepare: eventPrepare, hash: IHandlerHash, afterCall?: anyFunction): (ev: Event) => boolean;
+export declare function locateNode(target: Event | Element, attr?: string, dir?: string): Element;
+export declare function locate(target: Event | Element, attr?: string): string;
+export declare function locateNodeByClassName(target: Event | Element, className?: string): Element;
+export declare function getBox(elem: any): {
+    top: any;
+    left: any;
+    right: number;
+    bottom: number;
+    width: number;
+    height: number;
+};
+export declare function getScrollbarWidth(): number;
+export declare function getScrollbarHeight(): number;
+export interface IFitTarget {
+    top: number;
+    left: number;
+    width: number;
+    height: number;
+}
+export interface IFitPosition {
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+}
+export interface IFitPositionConfig {
+    mode?: Position;
+    auto?: boolean;
+    centering?: boolean;
+    width: number;
+    height: number;
+}
+export type IAlign = "left" | "center" | "right";
+export type Position = "left" | "right" | "bottom" | "top";
+export type FlexDirection = "start" | "center" | "end" | "between" | "around" | "evenly";
+export declare function isIE(): boolean;
+export declare function isSafari(): any;
+export declare function isFirefox(): any;
+export declare function getRealPosition(node: HTMLElement): IFitPosition;
+export declare function calculatePosition(pos: IFitPosition, config: IFitPositionConfig): {
+    left: string;
+    top: string;
+    minWidth: string;
+    position: string;
+};
+export declare function fitPosition(node: HTMLElement, config: IFitPositionConfig): {
+    left: string;
+    top: string;
+    minWidth: string;
+    position: string;
+};
+export declare function getPageCss(): string;
+export declare function getLabelStyle(config: any): false | {
+    style: {
+        width: any;
+        "max-width": string;
+    };
+    label: any;
+};
+export declare function getPageInlineCss(): string;
+export declare function getPageLinksCss(exportStyles?: string[]): string;
+export declare function getElementFromPoint(e: MouseEvent | TouchEvent): Element | null;
+export declare function getNodeOffset(node1: HTMLElement, node2: HTMLElement): {
+    left: number;
+    top: number;
+};
+export {};

package/codebase/types/ts-common/input.d.ts

@@ -0,0 +1,24 @@
+export interface INumberMask {
+    prefix?: string;
+    suffix?: string;
+    groupSeparator?: string;
+    decSeparator?: string;
+    allowNegative?: boolean;
+    maxIntLength?: number;
+    maxDecLength?: number;
+    minDecLength?: number;
+}
+export interface INumberMaskConfig extends INumberMask {
+    onlyView?: boolean;
+    lastCall?: boolean;
+}
+export declare function numberMask(value: string | number, options: INumberMaskConfig, input?: HTMLInputElement): string | number;
+export declare function removeNumberMask(value: string, options: INumberMaskConfig): string;
+export interface IPatternMask {
+    pattern: ((value: string | number) => string) | string;
+    charFormat?: {
+        [char: string]: RegExp;
+    };
+}
+export declare function patternMask(value: string | number, options: IPatternMask | string, input?: HTMLInputElement): string;
+export declare function removePatternMask(value: string, options: IPatternMask | string): string;

package/codebase/types/ts-common/keycodes.d.ts

@@ -0,0 +1,9 @@
+export declare const KEY_CODES: {
+    BACKSPACE: number;
+    ENTER: number;
+    ESC: number;
+    DOWN_ARROW: number;
+    UP_ARROW: number;
+    LEFT_ARROW: number;
+    RIGHT_ARROW: number;
+};

package/codebase/types/ts-common/locale.d.ts

@@ -0,0 +1 @@
+export declare function setLocale(component: string, value: any): void;