@dhtmlx/vault 5.0.6

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-navbar/index.d.ts

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

package/codebase/types/ts-navbar/sources/Navbar.d.ts

@@ -0,0 +1,61 @@
+import { Id, IHandlers } from "../../ts-common/types";
+import { VNode } from "../../ts-common/dom";
+import { IEventSystem } from "../../ts-common/events";
+import { View } from "../../ts-common/view";
+import { TreeCollection, IDataEventsHandlersMap } from "../../ts-data";
+import { DataEvents, IItem, IGroups, NavigationBarEvents, INavbarEventHandlersMap, INavbarConfig } from "./types";
+export declare abstract class Navbar<T extends IItem = IItem> extends View {
+    data: TreeCollection<T>;
+    events: IEventSystem<DataEvents | NavigationBarEvents, IDataEventsHandlersMap & INavbarEventHandlersMap>;
+    config: INavbarConfig;
+    protected _vpopups: VNode;
+    protected _activeMenu: Id;
+    protected _activePosition: {
+        left: number;
+        right: number;
+        top: number;
+        bottom: number;
+        zIndex?: number;
+    };
+    protected _handlers: IHandlers;
+    protected _currentRoot: Id;
+    protected _factory: (item: T, asMenuItem?: boolean) => any;
+    protected _groups: IGroups;
+    private _isActive;
+    private _popupActive;
+    private _currentTimeout;
+    private _documentClick;
+    private _documentHaveListener;
+    private _rootItem;
+    private _activeParents;
+    private _keyManager;
+    constructor(element?: string | HTMLElement, config?: any);
+    paint(): void;
+    disable(ids: Id | Id[]): void;
+    enable(ids: Id | Id[]): void;
+    isDisabled(id: Id): boolean;
+    show(ids: Id | Id[]): void;
+    hide(ids: Id | Id[]): void;
+    destructor(): void;
+    select(id: Id, unselect?: boolean): void;
+    unselect(id?: Id): void;
+    isSelected(id: Id): boolean;
+    getSelected(): Id[];
+    protected abstract _getFactory(): (item: T, asMenuItem?: boolean) => any;
+    protected _customHandlers(): {};
+    protected _close(e: MouseEvent | TouchEvent): void;
+    protected _init(): void;
+    protected _initHandlers(): void;
+    protected _initEvents(): void;
+    protected _getMode(item: T, root: Id, _active?: boolean): "bottom" | "right";
+    protected _drawMenuItems(id: Id, asMenuItem?: boolean): any[];
+    protected _setRoot(_id: Id): void;
+    protected _getParents(id: any, root: any): Id[];
+    protected _listenOuterClick(): void;
+    protected _customInitEvents(): void;
+    private _drawPopups;
+    private _onMenuItemClick;
+    private _activeItemChange;
+    private _resetHotkeys;
+    private _setProp;
+}

package/codebase/types/ts-navbar/sources/elements/button.d.ts

@@ -0,0 +1 @@
+export declare function button(item: any, widgetName: string): any;

package/codebase/types/ts-navbar/sources/elements/customHTMLButton.d.ts

@@ -0,0 +1 @@
+export declare function customHTMLButton(item: any, widgetName?: string, asMenuItem?: boolean): any;

package/codebase/types/ts-navbar/sources/elements/datePicker.d.ts

@@ -0,0 +1 @@
+export declare function datePicker(item: any, events: any, widgetName: string): any;

package/codebase/types/ts-navbar/sources/elements/helpers.d.ts

@@ -0,0 +1,17 @@
+import { VNode } from "../../../ts-common/dom";
+import { IItem } from "../types";
+export declare function getCount(item: any, widgetClass: any, isLimited: any): any;
+export declare function getIcon(iconName: string, type: any): any;
+export declare function navbarComponentMixin(widgetName: string, item: IItem, asMenuItem: boolean, body: VNode): VNode;
+export declare function getNavbarButtonCSS({ color, size, view, full, icon, circle, loading, value, active, count }: {
+    color: any;
+    size: any;
+    view: any;
+    full: any;
+    icon: any;
+    circle: any;
+    loading: any;
+    value: any;
+    active: any;
+    count: any;
+}, widgetName: any): string;

package/codebase/types/ts-navbar/sources/elements/imageButton.d.ts

@@ -0,0 +1 @@
+export declare function imageButton(item: any, widgetName: string): any;

package/codebase/types/ts-navbar/sources/elements/input.d.ts

@@ -0,0 +1 @@
+export declare function input(item: any, events: any, widgetName: string): any;

package/codebase/types/ts-navbar/sources/elements/menuItem.d.ts

@@ -0,0 +1 @@
+export declare function menuItem(item: any, widgetName: string, asMenuItem: boolean): any;

package/codebase/types/ts-navbar/sources/elements/navItem.d.ts

@@ -0,0 +1 @@
+export declare function navItem(item: any, widgetName: string, collapsed?: boolean): any;

package/codebase/types/ts-navbar/sources/elements/separator.d.ts

@@ -0,0 +1 @@
+export declare function separator(item: any, widgetName: string): any;

package/codebase/types/ts-navbar/sources/elements/spacer.d.ts

@@ -0,0 +1 @@
+export declare function spacer(item: any, widgetName: string): any;

package/codebase/types/ts-navbar/sources/elements/title.d.ts

@@ -0,0 +1 @@
+export declare function title(item: any, widgetName: string): any;

package/codebase/types/ts-navbar/sources/itemfactory.d.ts

@@ -0,0 +1,10 @@
+import { Navbar } from "./Navbar";
+import { IItem, ItemType } from "./types";
+interface IFactoryConfig<T extends Navbar> {
+    defaultType: ItemType;
+    allowedTypes: ItemType[];
+    widgetName: string;
+    widget: T;
+}
+export declare function createFactory<T extends Navbar>({ defaultType, allowedTypes, widgetName, widget, }: IFactoryConfig<T>): (item: IItem, asMenuItem?: boolean) => any;
+export {};