tsgrid-ui 2.7.1 → 2.10.0

package/dist/sidebar.d.ts

@@ -0,0 +1,138 @@
+import { TsBase } from './base.js';
+
+/**
+ * Part of TsUi 2.0 library
+ *  - Dependencies: mQuery, TsUtils, TsBase, TsTooltip, TsMenu
+ *
+ * == TODO ==
+ *  - dbl click should be like it is in grid (with timer not HTML dbl click event)
+ *  - node.style is misleading - should be there to apply color for example
+ *  - node.plus - is not working
+ *
+ * == 2.0 changes
+ *  - remove jQuery dependency
+ *  - deprecarted obj.img, node.img
+ *  - CSP - fixed inline events
+ *  - observeResize for the box
+ *  - search(..., compare) - comparison function
+ *  - editable = true
+ *  - edit(id) - new method
+ *  - onEdit, onRename - new events
+ *  - reorder = true - to allow reorder
+ *  - mouseDown - for reorder
+ *  - onReorder, onDragStart, onDragOver - events
+ *  - this.mutlti - for multi select (ctrl for one at a time and shift for range)
+ *  - onSelect, onUnselect - new events
+ *  - prev(), next(), getChain()
+ */
+
+/** Options accepted by refresh() */
+interface TsSidebarRefreshOptions {
+    recursive?: boolean;
+}
+/** Options accepted by update() — mirrors node property names that can be updated in-place */
+interface TsSidebarUpdateOptions {
+    icon?: string | ((nd: unknown, level: number) => string) | null;
+    class?: string | null;
+    style?: string | null;
+    text?: string | ((nd: unknown, level: number) => string) | null;
+    count?: number | string | null;
+    [key: string]: unknown;
+}
+/** Options accepted by setCount() */
+interface TsSidebarSetCountOptions {
+    className?: string;
+    style?: string;
+    noRepeat?: boolean;
+}
+/** Options for find() */
+interface TsSidebarFindOptions {
+    returnDisabled?: boolean;
+    returnGroups?: boolean;
+    [key: string]: unknown;
+}
+/** Options for sort() */
+interface TsSidebarSortOptions {
+    foldersFirst?: boolean;
+    caseSensitive?: boolean;
+    reverse?: boolean;
+    [key: string]: unknown;
+}
+declare class TsSidebar extends TsBase {
+    box: HTMLElement | null;
+    name: string;
+    nodes: any[];
+    selected: any;
+    img: any;
+    icon: any;
+    style: string;
+    hasFocus: boolean;
+    flat: boolean;
+    flatButton: boolean;
+    keyboard: boolean;
+    editable: boolean;
+    reorder: boolean;
+    tabIndex: number | null;
+    routeData: Record<string, unknown>;
+    multi: boolean;
+    skipRefresh: boolean;
+    last: any;
+    node_template: Record<string, unknown>;
+    [key: string]: any;
+    constructor(options: any);
+    add(parent?: any, nodes?: any): any;
+    insert(parent?: any, before?: any, nodes?: any): any;
+    remove(...args: any[]): number;
+    set(parent?: any, id?: any, node?: any): boolean | null;
+    get(parent?: any, id?: any, returnIndex?: any): any;
+    setCount(id: any, count: any, options?: TsSidebarSetCountOptions): void;
+    find(parent?: any, params?: any, results?: any): any;
+    sort(options: TsSidebarSortOptions | null | undefined, nodes?: any): void;
+    each(fn: any, nodes?: any): void;
+    search(str: any, compare?: any): number;
+    show(...args: any[]): any[];
+    hide(...args: any[]): any[];
+    enable(...args: any[]): any[];
+    disable(...args: any[]): any[];
+    select(id: any): boolean | undefined;
+    unselect(id?: any): boolean | undefined;
+    toggle(id: any): boolean | undefined;
+    collapse(id: any): boolean | undefined;
+    expand(id: any): true | undefined;
+    collapseAll(parent?: any): boolean;
+    expandAll(parent?: any): false | undefined;
+    expandParents(id: any): boolean;
+    click(id: any, event?: any): void;
+    flatMenu(el: any, items: any): void;
+    focus(event?: any): false | undefined;
+    blur(event: any): false | undefined;
+    next(node: any, noSubs?: any): any;
+    prev(node: any): any;
+    getChain(nodes?: any, options?: TsSidebarFindOptions): any[];
+    keydown(event: any): void;
+    inView(id: any): boolean;
+    scrollIntoView(id?: any, instant?: any): Promise<void>;
+    dblClick(id: any, event: any): void;
+    /**
+     * This is needed for not reorder
+     */
+    mouseDown(id: any, event: any): void;
+    edit(id: any): Node | Node[] | null | undefined;
+    contextMenu(id: any, event: any): void;
+    menuClick(itemId: any, detail?: any): void;
+    goFlat(): void;
+    render(box?: any): number | undefined;
+    update(id: any, options?: TsSidebarUpdateOptions): TsSidebarUpdateOptions;
+    refresh(id?: any, options?: TsSidebarRefreshOptions): number | undefined;
+    mouseAction(action: any, anchor: any, nodeId: any, event: any, type: any): void;
+    tooltip(el: any, text: any): void;
+    otherTooltip(el: any, text: any): void;
+    showPlus(el: any, color: any): void;
+    resize(): number | undefined;
+    destroy(): void;
+    unmount(): void;
+    lock(msg?: any, showSpinner?: any): void;
+    unlock(speed: any): void;
+}
+
+export { TsSidebar, type TsSidebarFindOptions, type TsSidebarRefreshOptions, type TsSidebarSetCountOptions, type TsSidebarSortOptions, type TsSidebarUpdateOptions };

package/dist/sidebar.es6.js

@@ -0,0 +1,12 @@
+import {
+  TsSidebar
+} from "./chunks/chunk-DZSFZLV6.js";
+import "./chunks/chunk-FAIRNXQR.js";
+import "./chunks/chunk-EQK6JAHT.js";
+import "./chunks/chunk-3NYH6545.js";
+import "./chunks/chunk-IYF3Q7GX.js";
+import "./chunks/chunk-DXZJHS4M.js";
+export {
+  TsSidebar
+};
+//# sourceMappingURL=sidebar.es6.js.map

package/dist/sidebar.es6.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/tabs.d.ts

@@ -0,0 +1,63 @@
+import { TsBase } from './base.js';
+
+/**
+ * Part of TsUi 2.0 library
+ *  - Dependencies: mQuery, TsUtils, TsBase, TsTooltip
+ *
+ * == 2.0 changes
+ *  - CSP - fixed inline events
+ *  - removed jQuery dependency
+ *  - observeResize for the box
+ *  - refactored w2events
+ *  - scrollIntoView - removed callback
+ *  - scroll, scrollIntoView return promise
+ *  - animateInsert, animateClose - returns a promise
+ *  - add, insert return a promise
+ *  - onMouseEnter, onMouseLeave, onMouseDown, onMouseUp
+ */
+
+declare class TsTabs extends TsBase {
+    box: HTMLElement | null;
+    name: string;
+    active: any;
+    reorder: boolean;
+    flow: string;
+    tooltip: string;
+    tabs: any[];
+    routeData: Record<string, unknown>;
+    last: any;
+    right: string;
+    style: string;
+    tab_template: Record<string, unknown>;
+    [key: string]: any;
+    constructor(options: any);
+    add(tab: any): Promise<any>;
+    insert(id: any, tabs: any): Promise<any>;
+    remove(...ids: any[]): number;
+    select(id: any): boolean;
+    set(id: any, tab: any): boolean;
+    get(id?: any, returnIndex?: boolean): any;
+    show(...ids: any[]): any[];
+    hide(...ids: any[]): any[];
+    enable(...ids: any[]): any[];
+    disable(...ids: any[]): any[];
+    dragMove(event: MouseEvent): void;
+    mouseAction(action: string, id: any, event: MouseEvent): void;
+    tooltipShow(id: any): void;
+    tooltipHide(_id: any): void;
+    getTabHTML(id: any): string | false;
+    refresh(id?: any): number | undefined;
+    render(box?: any): number | false | undefined;
+    initReorder(id: any, event: MouseEvent): void;
+    scroll(direction?: any, instant?: any): Promise<void>;
+    scrollIntoView(id?: any, instant?: any): Promise<void>;
+    resize(): number | undefined;
+    destroy(): void;
+    unmount(): void;
+    click(id: any, event?: MouseEvent): false | void;
+    clickClose(id: any, event?: MouseEvent): false | void;
+    animateClose(id?: any): Promise<void>;
+    animateInsert(id: any, tab: any): Promise<void>;
+}
+
+export { TsTabs };

package/dist/tabs.es6.js

@@ -0,0 +1,12 @@
+import {
+  TsTabs
+} from "./chunks/chunk-GZFWK4LZ.js";
+import "./chunks/chunk-FAIRNXQR.js";
+import "./chunks/chunk-EQK6JAHT.js";
+import "./chunks/chunk-3NYH6545.js";
+import "./chunks/chunk-IYF3Q7GX.js";
+import "./chunks/chunk-DXZJHS4M.js";
+export {
+  TsTabs
+};
+//# sourceMappingURL=tabs.es6.js.map

package/dist/tabs.es6.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/toolbar.d.ts

@@ -0,0 +1,97 @@
+import { TsBase } from './base.js';
+
+/**
+ * Part of TsUi 2.0 library
+ *  - Dependencies: mQuery, TsUtils, TsBase, TsTooltip, TsColor, TsMenu
+ *
+ * == TODO ==
+ *  - tab navigation (index state)
+ *  - vertical toolbar
+ *  - TsMenu on second click of tb button should hide
+ *  - button display groups for each show/hide, possibly add state: { single: t/f, multiple: t/f, type: 'font' }
+ *  - item.count - should just support html, so a custom block can be created, such as a colored line
+ *
+ * == 2.0 changes
+ *  - CSP - fixed inline events
+ *  - removed jQuery dependency
+ *  - item.icon - can be class or <custom-icon-component> or <svg>
+ *  - new w2tooltips and TsMenu
+ *  - scroll returns promise
+ *  - added onMouseEntter, onMouseLeave, onMouseDown, onMouseUp events
+ *  - add(..., skipRefresh), insert(..., skipRefresh)
+ *  - item.items can be a function
+ *  - item.icon_style - style for the icon
+ *  - item.icon - can be a function
+ *  - item.type = 'label', item.type = 'input'
+ *  - item.placeholder
+ *  - item.input: { spinner, style, min, max, step, precision, suffix }
+ *  - item.backColor
+ *  - onLiveUpdate - for colors
+ */
+
+declare class TsToolbar extends TsBase {
+    box: HTMLElement | null;
+    name: string;
+    routeData: Record<string, unknown>;
+    items: any[];
+    right: string | string[];
+    tooltip: string;
+    item_template: Record<string, unknown>;
+    last: any;
+    _refresh: (opts: any) => void;
+    _refreshDebounced: () => void;
+    [key: string]: any;
+    constructor(options: any);
+    add(items: any, skipRefresh?: any): void;
+    insert(id: any, items: any, skipRefresh?: any): void;
+    remove(...args: any[]): number;
+    set(id: any, newOptions: any): boolean;
+    get(id?: any, returnIndex?: boolean, items?: any[]): any;
+    setCount(id: any, count: any, className?: any, style?: any): void;
+    show(...args: any[]): any[];
+    hide(...args: any[]): any[];
+    enable(...args: any[]): any[];
+    disable(...args: any[]): any[];
+    check(...args: any[]): any[];
+    uncheck(...args: any[]): any[];
+    /**
+     * Toggle the `checked` state of one or more items.
+     *
+     * State management only — does NOT fire events (no `onClick`, no `onChange`)
+     * and does NOT open drop / menu / color overlays. For full UI interaction
+     * including opening pickers, call `click(id)` instead.
+     *
+     * Per-item behaviour:
+     *   - button / check / html / spacer / break: flips `it.checked`.
+     *   - drop / menu / menu-radio / menu-check / color / text-color: if currently
+     *     checked, closes the toolbar's `-drop` overlay via `TsTooltip.hide` before
+     *     flipping. Same overlay-close path as `uncheck()`. Never opens overlays.
+     *   - radio: emits `console.warn` and is skipped (would leave the group with
+     *     no checked member). Use `check()` / `uncheck()` for radios.
+     *   - group: recurses into `it.items` and toggles each child individually; the
+     *     group container itself is never in the effected list.
+     *   - sub-id with `:` notation: skipped (same guard as siblings).
+     *   - missing id: silently skipped.
+     *
+     * @param args  ids of items to toggle. Varargs, independent per id.
+     * @returns     array of ids whose checked state actually flipped. Never `undefined`.
+     */
+    toggle(...args: any[]): any[];
+    click(id: any, event?: any): void;
+    scroll(direction?: any, line?: any, instant?: any): Promise<void>;
+    render(box?: any): number | undefined;
+    refresh(id?: any): number | false | undefined;
+    resize(): number | undefined;
+    destroy(): void;
+    unmount(): void;
+    getItemHTML(item: any): string;
+    spinner(id: any, action: any, event?: any): void;
+    change(id?: any, value?: any, dynamic?: any): void;
+    tooltipShow(id: any): void;
+    tooltipHide(_id: any): void;
+    menuClick(event: any): void;
+    colorClick(event: any): void;
+    mouseAction(event: any, target: any, action: any, id: any): void;
+}
+
+export { TsToolbar };

package/dist/toolbar.es6.js

@@ -0,0 +1,12 @@
+import {
+  TsToolbar
+} from "./chunks/chunk-LUSNRF73.js";
+import "./chunks/chunk-FAIRNXQR.js";
+import "./chunks/chunk-EQK6JAHT.js";
+import "./chunks/chunk-3NYH6545.js";
+import "./chunks/chunk-IYF3Q7GX.js";
+import "./chunks/chunk-DXZJHS4M.js";
+export {
+  TsToolbar
+};
+//# sourceMappingURL=toolbar.es6.js.map

package/dist/toolbar.es6.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/tooltip.d.ts

@@ -0,0 +1,330 @@
+import { TsBase } from './base.js';
+
+/**
+ * Part of TsUi 2.0 library
+ * - Dependencies: mQuery, TsUtils, TsBase
+ *
+ * T3.1: Ported to TypeScript with aggressive typing per typing_policy.
+ * No @ts-nocheck. Targeted `any` sites documented with // any: comments.
+ *
+ * TODO:
+ * - need help pages
+ *
+ * 2.0 Changes
+ * - multiple tooltips to the same anchor
+ * - options.contextMenu
+ * - options.prefilter - if true, it will show prefiltered items for TsMenu, otherwise all
+ * - menu.item.help, menu.item.hotkey, menu.item.extra
+ * - options.selected -> for TsMenu
+ * - options.tooltip => {}
+ * - TsMenu event onTooltip
+ * - added onMouseEnter and onMouseLeave for TsMenu
+ */
+
+/** Base options shared by all tooltip variants */
+interface TooltipOptions {
+    name?: string | null;
+    html?: string;
+    style?: string;
+    class?: string;
+    position?: string | string[];
+    draggable?: boolean;
+    align?: string;
+    anchor?: HTMLElement | null;
+    contextMenu?: boolean;
+    anchorClass?: string;
+    anchorStyle?: string;
+    autoShow?: boolean;
+    autoShowOn?: string | null;
+    autoHideOn?: string | null;
+    arrowSize?: number;
+    screenMargin?: number;
+    autoResize?: boolean;
+    margin?: number;
+    offsetX?: number;
+    offsetY?: number;
+    maxWidth?: number | null;
+    maxHeight?: number | null;
+    hideOn?: string | string[] | null;
+    onThen?: ((event: unknown) => void) | null;
+    onShow?: ((event: unknown) => void) | null;
+    onHide?: ((event: unknown) => void) | null;
+    onUpdate?: ((event: unknown) => void) | null;
+    onMove?: ((event: unknown) => void) | null;
+    _keep?: boolean;
+    text?: string;
+    [key: string]: unknown;
+}
+/** A single menu item */
+interface MenuItem {
+    id?: string | number | null;
+    text?: string | null | ((item: MenuItem, options: MenuOptions) => string);
+    style?: string;
+    icon?: string | null;
+    count?: string | number | null;
+    tooltip?: string | {
+        html?: string;
+        [key: string]: unknown;
+    } | null;
+    hint?: string | null;
+    hotkey?: string | null;
+    removable?: boolean | null;
+    remove?: boolean | null;
+    help?: string | null;
+    items?: MenuItem[] | ((item: MenuItem) => MenuItem[]) | null;
+    indent?: number;
+    type?: 'check' | 'radio' | 'break' | null;
+    group?: string | boolean | null;
+    expanded?: boolean;
+    hidden?: boolean;
+    checked?: boolean | null;
+    disabled?: boolean;
+    keepOpen?: boolean | null;
+    extra?: string;
+    _noSearchInside?: boolean;
+    [key: string]: unknown;
+}
+/** Options for TsMenu (MenuTooltip) */
+interface MenuOptions extends TooltipOptions {
+    type?: 'normal' | 'radio' | 'check';
+    items?: MenuItem[];
+    selected?: null | string | number | MenuItem | Array<string | number | MenuItem>;
+    render?: ((item: MenuItem, options: MenuOptions) => string) | null;
+    spinner?: boolean;
+    msgNoItems?: string;
+    msgSearch?: string;
+    topHTML?: string;
+    menuStyle?: string;
+    search?: boolean;
+    filter?: boolean;
+    match?: 'contains' | 'is' | 'begins' | 'begins with' | 'ends' | 'ends with' | 'regexp';
+    markSearch?: boolean;
+    prefilter?: boolean;
+    altRows?: boolean;
+    url?: string;
+    postData?: Record<string, unknown>;
+    method?: string;
+    recId?: string | ((item: Record<string, unknown>) => unknown) | null;
+    recid?: string | null;
+    recText?: string | ((item: Record<string, unknown>) => unknown) | null;
+    cacheMax?: number;
+    minLength?: number;
+    debounce?: number;
+    hideSelected?: boolean;
+    parentOverlay?: TooltipOverlay | null;
+    parents?: number[];
+    onSelect?: ((event: unknown) => void) | null;
+    onSubMenu?: ((event: unknown) => void) | null;
+    onRemove?: ((event: unknown) => void) | null;
+    onTooltip?: ((event: unknown) => void) | null;
+    onMouseEnter?: ((event: unknown) => void) | null;
+    onMouseLeave?: ((event: unknown) => void) | null;
+}
+/** Options for TsColor (ColorTooltip) */
+interface ColorOptions extends TooltipOptions {
+    advanced?: boolean;
+    transparent?: boolean;
+    color?: string;
+    updateInput?: boolean;
+    onSelect?: ((event: unknown) => void) | null;
+    onLiveUpdate?: ((event: unknown) => void) | null;
+}
+/** Options for TsDate (DateTooltip) */
+interface DateOptions extends TooltipOptions {
+    type?: 'date' | 'time' | 'datetime';
+    value?: string;
+    format?: string;
+    start?: string | HTMLElement | null;
+    end?: string | HTMLElement | null;
+    btnNow?: boolean;
+    blockDates?: string[];
+    blockWeekdays?: number[];
+    colored?: Record<string, string>;
+    noMinutes?: boolean;
+    startTime?: string;
+    endTime?: string;
+    onSelect?: ((event: unknown) => void) | null;
+}
+/** The overlay object — a TsBase instance extended at runtime with many dynamic props */
+type TooltipOverlay = // any: dynamic TsBase extension
+InstanceType<typeof TsBase> & {
+    id: string;
+    name: string;
+    options: TooltipOptions & MenuOptions & ColorOptions & DateOptions;
+    anchor: HTMLElement;
+    self: Tooltip;
+    displayed: boolean;
+    box: HTMLElement & {
+        overlay?: TooltipOverlay;
+    } | null;
+    needsUpdate?: boolean;
+    prevOptions?: TooltipOptions;
+    tmp: Record<string, unknown>;
+    selected?: string | number | null;
+    newColor?: string;
+    newValue?: string;
+    newDate?: string;
+    next?: () => void;
+    prev?: () => void;
+    click?: () => void;
+    hide: () => void;
+};
+/** Return value of Tooltip.attach() */
+interface AttachReturn {
+    overlay: TooltipOverlay;
+    then: (callback: (event: unknown) => void) => AttachReturn;
+    show: (callback: (event: unknown) => void) => AttachReturn;
+    hide: (callback: (event: unknown) => void) => AttachReturn;
+    update: (callback: (event: unknown) => void) => AttachReturn;
+    move: (callback: (event: unknown) => void) => AttachReturn;
+    liveUpdate?: (callback: (event: unknown) => void) => AttachReturn;
+    select?: (callback: (event: unknown) => void) => AttachReturn;
+    remove?: (callback: (event: unknown) => void) => AttachReturn;
+    subMenu?: (callback: (event: unknown) => void) => AttachReturn;
+}
+/** Position calculation result */
+interface TooltipPosition {
+    left: number;
+    top: number;
+    arrow: {
+        offset: number;
+        class: string;
+        style: string;
+    };
+    adjust: {
+        left: number;
+        top: number;
+    };
+    width?: number;
+    height?: number;
+    pos: string;
+}
+declare class Tooltip {
+    static active: Record<string, TooltipOverlay>;
+    defaults: TooltipOptions;
+    setColor?: (color: Partial<{
+        h: number;
+        s: number;
+        v: number;
+        a: number;
+    }>, fullUpdate?: boolean, initial?: string) => void;
+    initControls(_overlay: any): void;
+    constructor();
+    static observeRemove: MutationObserver;
+    trigger(event: any, data?: any): {
+        isCancelled?: boolean;
+        finish: () => void;
+        detail?: Record<string, unknown>;
+    };
+    get(name?: string | true): string[] | Record<string, TooltipOverlay> | TooltipOverlay | undefined;
+    attach(anchorArg?: HTMLElement | TooltipOptions | null, textArg?: string | TooltipOptions): AttachReturn | undefined;
+    update(name: string, html: string): void;
+    show(name?: string | HTMLElement | TooltipOptions, extraOptions?: TooltipOptions): AttachReturn | {
+        overlay: TooltipOverlay;
+    } | undefined;
+    hide(name?: string | HTMLElement): void;
+    resize(name?: string): {
+        moved: boolean;
+        resize: boolean;
+    } | {
+        multiple: boolean;
+    } | void;
+    getPosition(name: string): TooltipPosition | undefined;
+    /**
+     * Move overlay node to the end of its parent (typically body) so it stacks above other .tsg-overlay siblings
+     * without relying on z-index. No-op if it is already the last element child.
+     */
+    bringOverlayToFront(overlay: TooltipOverlay): void;
+    startDrag(event: MouseEvent & {
+        target: EventTarget & {
+            _lastBoundingRect?: DOMRect;
+        };
+    }): void;
+}
+declare class ColorTooltip extends Tooltip {
+    static custom_colors: string[];
+    palette: string[][];
+    index: [number, number];
+    constructor();
+    attach(anchor: any, text?: any): AttachReturn | undefined;
+    select(color: any, name: any): void;
+    nextColor(direction: string): string | undefined;
+    tabClick(index: any, name: any): void;
+    getColorHTML(name: any, options: any): string;
+    getCustomColorsHTML(name: string): string;
+    initControls(overlay: TooltipOverlay): void;
+    addCustomColor(color: any, _name: any): any;
+    pickAndSelect(name: string, event: any): Promise<void>;
+    pickAndUse(_name: string): Promise<void>;
+    pickColor(): Promise<string | undefined>;
+}
+declare class MenuTooltip extends Tooltip {
+    constructor();
+    attach(anchor: any, text?: any): AttachReturn | undefined;
+    update(name: any, items: any): void;
+    initControls(overlay: any): void;
+    getCurrent(name: string, id?: any): {
+        last: number;
+        index: any;
+        items: any;
+        item: any;
+        parents: string;
+    };
+    getMenuHTML(options: any): string;
+    openSubMenu(event: any): void;
+    closeSubMenu(event: any): void;
+    refreshIndex(name: string, instant?: boolean): void;
+    showTooltip(name: string, options?: any): void;
+    refreshSearch(name: string): void;
+    /**
+     * Loops through the items and markes item.hidden = true for those that need to be hidden, and item.hidden = false
+     * for those that are visible. Return a promise (since items can be on the server) with the number of visible items.
+     */
+    applyFilter(name: string, items: any, search: any, debounce?: any): Promise<any>;
+    request(overlay: any, search: any, debounce: any): Promise<any>;
+    /**
+     * Builds an array of item ids that sequencial order for navigation with up/down keys. Skips hidden and disabled items
+     * and goes into nested structures. It will remember last active chain in 'overlay.tmp.activeChain'
+     */
+    getActiveChain(name: string, items?: any, parents?: any[], res?: any[], noSave?: boolean): any[];
+    menuDown(overlay: any, event: any, index: any, parents: any): void;
+    menuClick(overlay: any, event: any, index: any, parents: any): void;
+    findChecked(items: any): any[];
+    keyUp(overlay: any, event: any): void;
+}
+declare class DateTooltip extends Tooltip {
+    daysCount: number[];
+    today: string;
+    constructor();
+    attach(anchor: any, text?: any): AttachReturn | undefined;
+    initControls(overlay: any): void;
+    getMonthHTML(options: any, month?: any, year?: any): {
+        html: string;
+        month: any;
+        year: any;
+    };
+    getYearHTML(): string;
+    getHourHTML(options: any): {
+        html: string;
+    };
+    getMinHTML(hour: any, options: any): {
+        html: string;
+    };
+    inRange(str: any, options: any, dateOnly?: boolean): boolean;
+    str2min(str: any): number | null;
+    min2str(time: number, format?: any): string;
+}
+declare const TsTooltip: Tooltip;
+declare const TsMenu: MenuTooltip;
+declare const TsColor: ColorTooltip;
+declare const TsDate: DateTooltip;
+
+declare const __test_internals: {
+    readonly tooltipCtorCount: number;
+    readonly menuCtorCount: number;
+    readonly colorCtorCount: number;
+    readonly dateCtorCount: number;
+    reset(): void;
+};
+
+export { Tooltip, TsColor, TsDate, TsMenu, TsTooltip, __test_internals };