@dhtmlx/chart 9.3.3

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

@@ -0,0 +1,129 @@
+import { IView, IViewLike } from "../../ts-common/view";
+import { VNode } from "../../ts-common/dom";
+import { IEventSystem } from "../../ts-common/events";
+import { FlexDirection } from "../../ts-common/html";
+import { ScrollView } from "../../ts-common/ScrollView";
+import { TLabelAlignment } from "../../ts-common/types";
+export interface ICellConfig {
+    id?: string;
+    html?: string;
+    hidden?: boolean;
+    header?: string;
+    headerIcon?: string;
+    headerImage?: string;
+    headerHeight?: number;
+    on?: {
+        [key: string]: any;
+    };
+    width?: number | string;
+    height?: number | string;
+    minWidth?: number | string;
+    maxWidth?: number | string;
+    minHeight?: number | string;
+    maxHeight?: number | string;
+    css?: string;
+    padding?: number | string;
+    align?: FlexDirection;
+    type?: "line" | "wide" | "space" | string;
+    gravity?: number | boolean;
+    collapsable?: boolean;
+    resizable?: boolean;
+    collapsed?: boolean;
+    tab?: string;
+    tabCss?: string;
+    full?: boolean;
+    progressDefault?: boolean;
+    init?: (c: ICell, cfg: ICellConfig | IView) => void;
+    $fixed?: boolean;
+    $autoWidth?: boolean;
+    $autoHeight?: boolean;
+    $fieldset?: boolean;
+    $disabled?: boolean;
+    label?: string;
+    labelAlignment?: TLabelAlignment;
+}
+export interface ILayoutConfig extends ICellConfig {
+    rows?: ICellConfig[] | ILayoutConfig[];
+    cols?: ICellConfig[] | ILayoutConfig[];
+    views?: ICellConfig[] | ILayoutConfig[];
+    activeView?: string;
+    activeTab?: string;
+    parent?: ILayout;
+}
+export type IViewFn = (cfg: any) => VNode;
+export interface IViewConstructor {
+    new: (container: HTMLElement | string | null, config: any) => IView;
+}
+export interface ICell extends IView {
+    id: string;
+    config: ICellConfig;
+    events: IEventSystem<LayoutEvents, ILayoutEventHandlersMap>;
+    attach(component: string | IViewFn | IView | IViewConstructor, config?: any): IViewLike;
+    attachHTML(html: string): void;
+    isVisible(): boolean;
+    toVDOM(nodes?: any[]): any;
+    getParent(): ILayout;
+    show(): void;
+    hide(): void;
+    paint(): void;
+    destructor(): void;
+    getWidget(): any;
+    collapse(): void;
+    expand(): void;
+    toggle(): void;
+    detach(): void;
+    progressShow(): void;
+    progressHide(): void;
+    isVisibleProgress(): boolean;
+}
+export interface IProCell extends ICell {
+    scrollView: ScrollView;
+}
+export interface ILayout extends ICell {
+    config: ILayoutConfig;
+    removeCell(id: string): void;
+    getRefs(str: any): any;
+    getCell(id: string): ICell;
+    getId(index: number): string;
+    forEach(callback: LayoutCallback): void;
+    destructor(): void;
+    /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+    cell(id: string): ICell;
+}
+export declare enum LayoutEvents {
+    beforeShow = "beforeShow",
+    afterShow = "afterShow",
+    beforeHide = "beforeHide",
+    afterHide = "afterHide",
+    beforeResizeStart = "beforeResizeStart",
+    resize = "resize",
+    afterResizeEnd = "afterResizeEnd",
+    beforeAdd = "beforeAdd",
+    afterAdd = "afterAdd",
+    beforeRemove = "beforeRemove",
+    afterRemove = "afterRemove",
+    beforeCollapse = "beforeCollapse",
+    afterCollapse = "afterCollapse",
+    beforeExpand = "beforeExpand",
+    afterExpand = "afterExpand"
+}
+export interface ILayoutEventHandlersMap {
+    [key: string]: (...args: any[]) => any;
+    [LayoutEvents.beforeShow]: (id: string) => boolean | void;
+    [LayoutEvents.afterShow]: (id: string) => void;
+    [LayoutEvents.beforeHide]: (id: string) => boolean | void;
+    [LayoutEvents.afterHide]: (id: string) => any;
+    [LayoutEvents.beforeResizeStart]: (id: string) => boolean | void;
+    [LayoutEvents.resize]: (id: string) => void;
+    [LayoutEvents.afterResizeEnd]: (id: string) => void;
+    [LayoutEvents.beforeAdd]: (id: string) => boolean | void;
+    [LayoutEvents.afterAdd]: (id: string) => void;
+    [LayoutEvents.beforeRemove]: (id: string) => boolean | void;
+    [LayoutEvents.afterRemove]: (id: string) => void;
+    [LayoutEvents.beforeCollapse]: (id: string) => boolean | void;
+    [LayoutEvents.afterCollapse]: (id: string) => void;
+    [LayoutEvents.beforeExpand]: (id: string) => boolean | void;
+    [LayoutEvents.afterExpand]: (id: string) => void;
+}
+export type LayoutCallback = (cell: ICell, index: number, array: any) => any;
+export type IFillSpace = boolean | "x" | "y";

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

@@ -0,0 +1,4 @@
+export * from "./sources/List";
+export * from "./sources/ProList";
+export * from "./sources/Selection";
+export * from "./sources/types";

package/codebase/types/ts-list/sources/List.d.ts

@@ -0,0 +1,56 @@
+import { DataCollection, DataEvents, DragEvents, IDataEventsHandlersMap, IDragEventsHandlersMap } from "../../ts-data";
+import { VNode } from "../../ts-common/dom";
+import { IEventSystem } from "../../ts-common/events";
+import { IKeyManager } from "../../ts-common/KeyManager";
+import { IHandlers, Id } from "../../ts-common/types";
+import { View } from "../../ts-common/view";
+import { IList, IListConfig, IListEventHandlersMap, IListItem, ISelection, ListEvents } from "./types";
+export declare const MOVE_UP = 1;
+export declare const MOVE_DOWN = 2;
+export declare class List extends View implements IList {
+    config: IListConfig;
+    data: DataCollection;
+    events: IEventSystem<DataEvents | ListEvents | DragEvents, IListEventHandlersMap & IDataEventsHandlersMap & IDragEventsHandlersMap>;
+    selection: ISelection;
+    keyManager: IKeyManager;
+    protected _handlers: IHandlers;
+    protected _focus: Id | undefined;
+    protected _edited: Id;
+    protected _events: IHandlers;
+    private _topOffset;
+    private _visibleHeight;
+    private _touch;
+    protected _changed: boolean;
+    protected _destructed: boolean;
+    constructor(node: HTMLElement | string, config?: IListConfig);
+    protected _didRedraw(vm: any): void;
+    private _dblClick;
+    private _clearTouchTimer;
+    private _dragStart;
+    /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+    disableSelection(): void;
+    /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+    enableSelection(): void;
+    editItem(id: Id): void;
+    editEnd(value: any, id?: Id): void;
+    getFocusItem(): any;
+    setFocus(id: Id): void;
+    resetFocus(): void;
+    getFocus(): Id;
+    destructor(): void;
+    scrollTo(id: Id): void;
+    protected _scrollTo(id: Id, el: HTMLElement): void;
+    protected _renderItem(item: IListItem, index: number): VNode;
+    protected _renderList(): VNode;
+    moveFocus(mode: number, step?: number): void;
+    protected _getRange(): [number, number, number, number];
+    protected _getHotkeys(): IHandlers;
+    private _initHotKey;
+    private getItemAriaAttrs;
+    protected _getListAriaAttrs(config: any, dataLength: any): {
+        role: string;
+        "aria-label": string;
+        "aria-multiselectable": string;
+        "aria-readonly": string;
+    };
+}

package/codebase/types/ts-list/sources/ProList.d.ts

@@ -0,0 +1,11 @@
+import { VNode } from "../../ts-common/dom";
+import { ScrollView } from "../../ts-common/ScrollView";
+import { List } from "./List";
+import { IListConfig, IProList } from "./types";
+export declare class ProList extends List implements IProList {
+    scrollView: ScrollView;
+    constructor(container: HTMLElement | string, config?: IListConfig);
+    destructor(): void;
+    scrollTo(id: string): void;
+    protected _renderList(): VNode;
+}

package/codebase/types/ts-list/sources/Selection.d.ts

@@ -0,0 +1,24 @@
+import { IEventSystem } from "../../ts-common/events";
+import { SelectionEvents, ISelectionEventsHandlersMap, Id } from "../../ts-common/types";
+import { DataCollection, DataEvents, IDataEventsHandlersMap, IDataItem } from "../../ts-data";
+import { ISelectionConfig, ISelection } from "./types";
+export declare class Selection implements ISelection {
+    config: ISelectionConfig;
+    events: IEventSystem<SelectionEvents | DataEvents, ISelectionEventsHandlersMap & IDataEventsHandlersMap>;
+    private _selected;
+    private _data;
+    private _nextSelection;
+    constructor(config: ISelectionConfig, data: DataCollection, events: IEventSystem<any>);
+    enable(): void;
+    disable(): void;
+    getId(): Id | Id[] | undefined;
+    getItem(): IDataItem | IDataItem[];
+    contains(id?: Id): boolean;
+    remove(id?: Id, silent?: boolean): void;
+    add(id?: Id, isCtrl?: boolean, isShift?: boolean, silent?: boolean): void;
+    destructor(): void;
+    private _addMulti;
+    private _addSingle;
+    private _selectItem;
+    private _unselectItem;
+}

package/codebase/types/ts-list/sources/editors/InputEditor.d.ts

@@ -0,0 +1,16 @@
+import { IListConfig, IListItem } from "../types";
+import { List } from "../List";
+export declare class InputEditor {
+    protected _handlers: {
+        [key: string]: (...args: any[]) => void;
+    };
+    protected _mode: boolean;
+    protected _config: IListConfig;
+    protected _list: List;
+    protected _item: IListItem;
+    protected _input: HTMLInputElement;
+    constructor(item: any, list: List);
+    endEdit(): void;
+    toHTML(): any;
+    protected _initHandlers(): void;
+}

package/codebase/types/ts-list/sources/editors/editors.d.ts

@@ -0,0 +1,4 @@
+import { InputEditor } from "./InputEditor";
+import { List } from "../List";
+import { IListItem } from "../types";
+export declare function getEditor(item: IListItem, list: List): InputEditor;

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

@@ -0,0 +1,98 @@
+import { IDataItem, DataCollection, DataEvents, DragEvents, IDataEventsHandlersMap, IDragEventsHandlersMap, IDragConfig } from "../../ts-data";
+import { IEventSystem } from "../../ts-common/events";
+import { IHandlers, SelectionEvents, ISelectionEventsHandlersMap, Id } from "../../ts-common/types";
+import { IKeyManager } from "../../ts-common/KeyManager";
+import { ScrollView } from "../../ts-common/ScrollView";
+import { VNode } from "../../ts-common/dom";
+export type MultiselectionMode = "click" | "ctrlClick";
+export interface IListConfig extends IDragConfig {
+    template?: (obj: IDataItem) => string;
+    data?: DataCollection<any> | any[];
+    virtual?: boolean;
+    itemHeight?: number | string;
+    css?: string;
+    height?: number | string;
+    selection?: boolean;
+    multiselection?: boolean | MultiselectionMode;
+    keyNavigation?: boolean | (() => boolean);
+    editable?: boolean;
+    hotkeys?: IHandlers;
+    eventHandlers?: {
+        [eventName: string]: {
+            [className: string]: (event: Event, id: Id) => void | boolean;
+        };
+    };
+    htmlEnable?: boolean;
+    $template?: (obj: IDataItem) => VNode;
+    /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+    editing?: boolean;
+    /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+    multiselectionMode?: MultiselectionMode;
+}
+export declare enum ListEvents {
+    click = "click",
+    doubleClick = "doubleclick",
+    focusChange = "focuschange",
+    beforeEditStart = "beforeEditStart",
+    afterEditStart = "afterEditStart",
+    beforeEditEnd = "beforeEditEnd",
+    afterEditEnd = "afterEditEnd",
+    itemRightClick = "itemRightClick",
+    itemMouseOver = "itemMouseOver",
+    /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+    contextmenu = "contextmenu"
+}
+export interface IListEventHandlersMap {
+    [key: string]: (...args: any[]) => any;
+    [ListEvents.click]: (id: Id, e: Event) => void;
+    [ListEvents.itemMouseOver]: (id: Id, e: Event) => void;
+    [ListEvents.doubleClick]: (id: Id, e: Event) => void;
+    [ListEvents.itemRightClick]: (id: Id, e: MouseEvent) => void;
+    [ListEvents.focusChange]: (focusIndex?: number, id?: Id) => void;
+    [ListEvents.beforeEditStart]: (id: Id) => void | boolean;
+    [ListEvents.afterEditStart]: (id: Id) => void;
+    [ListEvents.beforeEditEnd]: (value: string, id: Id) => void | boolean;
+    [ListEvents.afterEditEnd]: (value: string, id: Id) => void;
+    [ListEvents.contextmenu]: (id: Id, e: MouseEvent) => any;
+}
+export interface ISelectionConfig {
+    multiselection?: boolean | MultiselectionMode;
+    disabled?: boolean;
+}
+export interface IList<T extends IDataItem = any> {
+    config: IListConfig;
+    data: DataCollection<T>;
+    events: IEventSystem<DataEvents | ListEvents | DragEvents, IListEventHandlersMap & IDataEventsHandlersMap & IDragEventsHandlersMap>;
+    selection: ISelection;
+    keyManager: IKeyManager;
+    paint(): void;
+    destructor(): void;
+    editItem(id: Id): void;
+    getFocusItem(): T;
+    setFocus(id: Id): void;
+    resetFocus(): void;
+    getFocus(): Id;
+    scrollTo(id: Id): void;
+    /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+    disableSelection(): void;
+    /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+    enableSelection(): void;
+}
+export interface IProList extends IList {
+    scrollView: ScrollView;
+}
+export interface ISelection<T = any> {
+    config: ISelectionConfig;
+    events: IEventSystem<SelectionEvents | DataEvents, ISelectionEventsHandlersMap & IDataEventsHandlersMap>;
+    getId(): Id | Id[] | undefined;
+    getItem(): T;
+    contains(id?: Id): boolean;
+    remove(id?: Id, silent?: boolean): void;
+    add(id?: Id, isShift?: boolean, isCtrl?: boolean, silent?: boolean): void;
+    enable(): void;
+    disable(): void;
+    destructor(): void;
+}
+export interface IListItem {
+    [key: string]: any;
+}

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

@@ -0,0 +1,5 @@
+export * from "./sources/message";
+export * from "./sources/alert";
+export * from "./sources/confirm";
+export * from "./sources/tooltip";
+export * from "./sources/types";

package/codebase/types/ts-message/sources/alert.d.ts

@@ -0,0 +1,2 @@
+import { IAlertProps } from "./types";
+export declare function alert(props: IAlertProps): Promise<unknown>;

package/codebase/types/ts-message/sources/common.d.ts

@@ -0,0 +1 @@
+export declare function blockScreen(css?: string): () => void;

package/codebase/types/ts-message/sources/confirm.d.ts

@@ -0,0 +1,2 @@
+import { IConfirmProps } from "./types";
+export declare function confirm(props: IConfirmProps): Promise<unknown>;

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

@@ -0,0 +1,5 @@
+declare const locale: {
+    apply: string;
+    reject: string;
+};
+export default locale;

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

@@ -0,0 +1,4 @@
+import { IMessageProps } from "./types";
+export declare function message(props: string | IMessageProps): {
+    close: () => void;
+};

package/codebase/types/ts-message/sources/tooltip.d.ts

@@ -0,0 +1,6 @@
+import { IPosition, ITooltipConfig, Position } from "./types";
+export declare function findPosition(targetRect: ClientRect, position: Position, width: number, height: number, margin?: number, recursion?: number): IPosition;
+export declare function getZIndex(node: Element | HTMLElement): 10000000 | 9999999;
+export declare function tooltip(text: string, config: ITooltipConfig): void;
+export declare function enableTooltip(): void;
+export declare function disableTooltip(): void;

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

@@ -0,0 +1,79 @@
+import { IAlign } from "../../ts-common/html";
+export interface IBaseProps {
+    text: string;
+    header?: string;
+    css?: string;
+    buttonsAlignment?: IAlign;
+    blockerCss?: string;
+    htmlEnable?: boolean;
+}
+export interface IAlertProps extends IBaseProps {
+    buttons?: [string];
+}
+export interface IConfirmProps extends IBaseProps {
+    buttons?: [string, string?];
+}
+export declare enum RealPosition {
+    left = "left",
+    right = "right",
+    top = "top",
+    bottom = "bottom",
+    center = "center"
+}
+export interface ITooltipConfig extends IScreenPosition {
+    force?: boolean;
+    showDelay?: number;
+    hideDelay?: number;
+    htmlEnable?: boolean;
+    margin?: number;
+}
+export interface IPosition {
+    left: number;
+    top: number;
+    pos: RealPosition;
+}
+export interface IScreenPosition {
+    node: HTMLElement | string;
+    position?: Position;
+    css?: string;
+}
+export declare enum Position {
+    right = "right",
+    bottom = "bottom",
+    center = "center",
+    left = "left",
+    top = "top"
+}
+export declare enum MessageContainerPosition {
+    topLeft = "top-left",
+    topRight = "top-right",
+    bottomLeft = "bottom-left",
+    bottomRight = "bottom-right"
+}
+export interface IMessageProps {
+    text?: string;
+    html?: string;
+    css?: string;
+    expire?: number;
+    node?: HTMLElement;
+    icon?: string;
+    position?: MessageContainerPosition;
+}
+export interface IMessageContainerInfo {
+    [MessageContainerPosition.bottomLeft]?: {
+        stack: HTMLElement[];
+        container: HTMLElement;
+    };
+    [MessageContainerPosition.bottomRight]?: {
+        stack: HTMLElement[];
+        container: HTMLElement;
+    };
+    [MessageContainerPosition.topLeft]?: {
+        stack: HTMLElement[];
+        container: HTMLElement;
+    };
+    [MessageContainerPosition.topRight]?: {
+        stack: HTMLElement[];
+        container: HTMLElement;
+    };
+}

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

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

package/codebase/types/ts-popup/sources/Popup.d.ts

@@ -0,0 +1,29 @@
+import { VNode } from "../../ts-common/dom";
+import { IEventSystem } from "../../ts-common/events";
+import { View } from "../../ts-common/view";
+import { IPopup, IPopupConfig, IPopupEventHandlersMap, IShowConfig, PopupEvents } from "./types";
+export declare class Popup extends View implements IPopup {
+    config: IPopupConfig;
+    events: IEventSystem<PopupEvents, IPopupEventHandlersMap>;
+    private _html;
+    private _ui;
+    private _popup;
+    private _clickEvent;
+    private _isActive;
+    private _outerClickDestructor;
+    private _timeout;
+    constructor(config?: IPopupConfig);
+    show(node: HTMLElement, config?: IShowConfig, attached?: any): void;
+    hide(): void;
+    isVisible(): boolean;
+    attach(name: any, config?: any): VNode;
+    attachHTML(html: string): void;
+    getWidget(): any;
+    getContainer(): HTMLElement;
+    toVDOM(): any;
+    destructor(): void;
+    private _setTheme;
+    private _setPopupSize;
+    private _detectOuterClick;
+    private _hide;
+}

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

@@ -0,0 +1,42 @@
+import { VNode } from "../../ts-common/dom";
+import { IEventSystem } from "../../ts-common/events";
+import { Position } from "../../ts-common/html";
+export interface IPopup {
+    show(node: HTMLElement, config?: IShowConfig, attach?: any): void;
+    hide(): void;
+    toVDOM(): void;
+    attachHTML(html: string): void;
+    attach(node: HTMLElement, config?: IShowConfig, attached?: any): VNode;
+    isVisible(): boolean;
+    paint(): void;
+    destructor(): void;
+    getWidget(): any;
+    getContainer(): HTMLElement;
+}
+export interface IPopupConfig {
+    css?: string;
+    events?: IEventSystem<any>;
+    theme?: HTMLElement | string;
+}
+export declare enum PopupEvents {
+    beforeHide = "beforeHide",
+    beforeShow = "beforeShow",
+    afterHide = "afterHide",
+    afterShow = "afterShow",
+    click = "click"
+}
+export interface IShowConfig {
+    centering?: boolean;
+    auto?: boolean;
+    mode?: Position;
+    indent?: number | string;
+    theme?: string | HTMLElement;
+}
+export interface IPopupEventHandlersMap {
+    [key: string]: (...args: any[]) => any;
+    [PopupEvents.click]: (e: Event) => any;
+    [PopupEvents.afterHide]: (e: Event) => void;
+    [PopupEvents.afterShow]: (node: HTMLElement) => void;
+    [PopupEvents.beforeHide]: (fromOuterClick: boolean, e: Event) => void | boolean;
+    [PopupEvents.beforeShow]: (node: HTMLElement) => void | boolean;
+}

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

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

package/codebase/types/ts-slider/sources/Slider.d.ts

@@ -0,0 +1,55 @@
+import { IEventSystem } from "../../ts-common/events";
+import { View } from "../../ts-common/view";
+import { Popup } from "../../ts-popup";
+import { ISlider, SliderEvents, ISliderConfig, ISliderEventHandlersMap } from "./types";
+export declare class Slider extends View implements ISlider {
+    config: ISliderConfig;
+    events: IEventSystem<SliderEvents, ISliderEventHandlersMap>;
+    protected _helper: Popup;
+    private _offsets;
+    private _currentPosition;
+    private _extraCurrentPosition;
+    private _length;
+    private _axis;
+    private _isExtraActive;
+    private _disabled;
+    private _isMouseMoving;
+    private _keyManager;
+    private _handlers;
+    private _possibleRange;
+    private _findNewDirection;
+    private _mouseIn;
+    private _focusIn;
+    private _tooltip;
+    private _activeTooltip;
+    constructor(container: HTMLElement | string, config: ISliderConfig);
+    disable(): void;
+    enable(): void;
+    isDisabled(): boolean;
+    focus(extra?: boolean): void;
+    blur(): void;
+    getValue(): number[];
+    setValue(value: string | number | number[]): void;
+    destructor(): void;
+    private _calcSliderPosition;
+    private _initHotkeys;
+    private _move;
+    private _initStartPosition;
+    private _getValue;
+    private _setValue;
+    private _initHandlers;
+    private _getBegining;
+    private _inSide;
+    private _updatePosition;
+    private _getRunnerStyle;
+    private _isInverse;
+    private _getRunnerCss;
+    private _draw;
+    private _drawSlider;
+    private _getDetector;
+    private _drawTooltip;
+    private _getTicks;
+    private _drawTicks;
+    private _isNullable;
+    private _setTooltip;
+}

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

@@ -0,0 +1,60 @@
+export type Direction = "vertical" | "horizontal";
+export type ActiveSlider = "tooltip" | "extraTooltip" | "none";
+export interface ISlider {
+    config: ISliderConfig;
+    paint(): void;
+    destructor(): void;
+    getValue(): number[];
+    setValue(value: string | number | number[]): void;
+    disable(): void;
+    enable(): void;
+    isDisabled(): boolean;
+    focus(extra?: boolean): void;
+    blur(): void;
+}
+export declare enum SliderEvents {
+    beforeChange = "beforeChange",
+    change = "change",
+    focus = "focus",
+    blur = "blur",
+    keydown = "keydown",
+    mousedown = "mousedown",
+    mouseup = "mouseup"
+}
+export interface ISliderEventHandlersMap {
+    [key: string]: (...args: any[]) => any;
+    [SliderEvents.beforeChange]: (value: number, oldValue: number, isRange: boolean) => void;
+    [SliderEvents.change]: (value: number, oldValue: number, isRange: boolean) => void;
+    [SliderEvents.focus]: () => void;
+    [SliderEvents.blur]: () => void;
+    [SliderEvents.keydown]: (event: KeyboardEvent) => void;
+    [SliderEvents.mousedown]: (event: Event) => void;
+    [SliderEvents.mouseup]: (event: Event) => void;
+}
+export type ILabelPosition = "left" | "top";
+export interface ISliderConfig {
+    min?: number;
+    max?: number;
+    step?: number;
+    mode?: Direction;
+    range?: boolean;
+    value?: number[] | number | string;
+    inverse?: boolean;
+    tooltip?: boolean;
+    css?: string;
+    tick?: number;
+    tickTemplate?: (position: number) => string;
+    majorTick?: number;
+    label?: string;
+    required?: boolean;
+    helpMessage?: string;
+    labelPosition?: ILabelPosition;
+    labelWidth?: string | number;
+    hiddenLabel?: boolean;
+    /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+    help?: string;
+    /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+    thumbLabel?: boolean;
+    /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
+    labelInline?: boolean;
+}

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

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