@dxtmisha/constructor 0.30.1 → 0.39.5

package/dist/constructors/Mask/basicTypes.d.ts

@@ -0,0 +1,52 @@
+import { ConstrBind, GeoDate } from '@dxtmisha/functional';
+import { FieldPatternItemOrFunction, FieldValidationItem } from '../../types/fieldTypes';
+import { MaskPropsBasic } from './props';
+export type MaskTypeItem = GeoDate | 'text' | 'number' | 'number-format' | 'currency';
+export type MaskElementInput = HTMLInputElement | undefined;
+export type MaskMatchItem = RegExp | string;
+export type MaskFractionItem = string | boolean | number;
+export type MaskSpecialItem = {
+    defaultValue?: string;
+    rubber?: boolean;
+    transitionChar?: string | string[];
+    minLength?: number;
+    maxLength?: number;
+    match?: MaskMatchItem;
+    pattern?: FieldPatternItemOrFunction;
+    view?: string;
+};
+export type MaskSpecialInfo = {
+    index: number;
+    key: number;
+    char: string;
+};
+export type MaskSpecialList = Record<string, MaskSpecialItem>;
+export type MaskSpecialProp = string | string[] | MaskSpecialList;
+export type MaskViewItem = {
+    className: string;
+    value: string;
+};
+export type MaskViewList = MaskViewItem[];
+export type MaskList = string | string[];
+export type MaskEventData = FieldValidationItem;
+export type MaskEventSelection = {
+    target: HTMLInputElement;
+    start: number;
+    end: number;
+    length: number;
+};
+export type MaskComponentInclude = {
+    mask?: object;
+};
+export type MaskPropsInclude<Mask extends MaskPropsBasic = MaskPropsBasic> = {
+    name?: string;
+    mask?: string | ConstrBind<Mask>;
+    maskVisible?: boolean;
+    maskNone?: boolean;
+    currency?: string;
+    currencyHide?: boolean;
+    fraction?: MaskFractionItem;
+    maskAttrs?: ConstrBind<Mask>;
+};
+export declare const MASK_CHAR_DELETE = "~";
+export declare const MASK_VIEW_DEFAULT = "_";

package/dist/constructors/Mask/index.d.ts

@@ -0,0 +1,5 @@
+export * from './Mask';
+export * from './MaskDesign';
+export * from './props';
+export * from './types';
+export * from './basicTypes';

package/dist/constructors/Mask/props.d.ts

@@ -0,0 +1,46 @@
+import { FieldPatternItemOrFunction } from '../../types/fieldTypes';
+import { MaskFractionItem, MaskList, MaskMatchItem, MaskSpecialProp, MaskTypeItem } from './basicTypes';
+export type MaskPropsToken = {
+    visible?: boolean;
+    visiblePartly?: boolean;
+    align?: 'center' | 'left' | 'right';
+    dir?: 'ltr' | 'rtl';
+};
+export type MaskPropsBasic = {
+    name?: string;
+    value?: string | number;
+    valueDefault?: string | number;
+    currency?: string;
+    currencyHide?: boolean;
+    fullOnly?: boolean;
+    mask?: MaskList;
+    special?: MaskSpecialProp;
+    match?: MaskMatchItem;
+    groupSave?: boolean;
+    pattern?: FieldPatternItemOrFunction;
+    check?: FieldPatternItemOrFunction;
+    fraction?: MaskFractionItem;
+    type?: MaskTypeItem;
+    view?: string;
+    inputAttrs?: Partial<HTMLInputElement>;
+    language?: string;
+};
+/**
+ * Type describing incoming properties.
+ *
+ * Тип, описывающий входящие свойства.
+ */
+export type MaskProps = MaskPropsBasic & MaskPropsToken;
+/**
+ * Default value for property.
+ *
+ * Значение по умолчанию для свойства.
+ */
+export declare const defaultsMask: {
+    visible: boolean;
+    special: string;
+    match: RegExp;
+    type: string;
+    groupSave: boolean;
+    view: string;
+};

package/dist/constructors/Mask/types.d.ts

@@ -0,0 +1,62 @@
+import { ComputedRef } from 'vue';
+import { ConstrClass } from '@dxtmisha/functional';
+import { FieldValidationItem } from '../../types/fieldTypes';
+/**
+ * Interface for describing which components need to be connected for work.
+ *
+ * Интерфейс для описания, какие компоненты надо подключить для работы.
+ */
+export type MaskComponents = {};
+/**
+ * Type describing available events.
+ *
+ * Тип, описывающий доступные события.
+ */
+export type MaskEmits = {
+    focus: [event: FocusEvent];
+    blur: [event: FocusEvent];
+    keydown: [event: KeyboardEvent];
+    keyup: [event: KeyboardEvent];
+    beforeinput: [event: InputEvent];
+    input: [
+        event: InputEvent,
+        value: FieldValidationItem
+    ];
+    inputLite: [value: FieldValidationItem];
+    change: [
+        event: InputEvent,
+        value: FieldValidationItem
+    ];
+    changeLite: [value: FieldValidationItem];
+    paste: [event: ClipboardEvent];
+    reset: [event: Event];
+};
+/**
+ * Type describing available properties.
+ *
+ * Тип, описывающий доступные свойства.
+ */
+export interface MaskExpose {
+    valueBasic: ComputedRef<string>;
+    value: ComputedRef<string>;
+    setValue(value: string): boolean;
+    clear(): boolean;
+}
+/**
+ * Type describing available slots.
+ *
+ * Тип, описывающий доступные слоты.
+ */
+export interface MaskSlots {
+}
+/**
+ * Type describing subclasses.
+ *
+ * Тип, описывающий подклассы.
+ */
+export type MaskClasses = {
+    main: ConstrClass;
+    input: string;
+    character: string;
+    characterItem: string;
+};

package/dist/constructors/Menu/Menu.d.ts

@@ -0,0 +1,87 @@
+import { Ref, ToRefs, ComputedRef } from 'vue';
+import { ConstrEmit, DesignComp, ListDataRef } from '@dxtmisha/functional';
+import { EventClickInclude } from '../../classes/EventClickInclude';
+import { BarsInclude } from '../Bars';
+import { WindowInclude } from '../Window';
+import { MenuRequest } from './MenuRequest';
+import { MenuSearch } from './MenuSearch';
+import { MenuWindow } from './MenuWindow';
+import { MenuValue } from './MenuValue';
+import { MenuGo } from './MenuGo';
+import { MenuComponents, MenuEmits, MenuSlots } from './types';
+import { MenuProps } from './props';
+import { MenuControlBasic } from './basicTypes';
+import { ListPropsBasic } from '../List';
+import { EventClickValue } from '../../types/eventClickTypes';
+/**
+ * Menu
+ */
+export declare class Menu {
+    protected readonly props: MenuProps;
+    protected readonly refs: ToRefs<MenuProps>;
+    protected readonly element: Ref<HTMLElement | undefined>;
+    protected readonly classDesign: string;
+    protected readonly className: string;
+    protected readonly components?: DesignComp<MenuComponents, MenuProps> | undefined;
+    protected readonly slots?: MenuSlots | undefined;
+    protected readonly emits?: ConstrEmit<MenuEmits> | undefined;
+    /** Request handler for list data/ Обработчик запросов данных списка */
+    readonly request: MenuRequest;
+    /** Search helper for menu filtering/ Вспомогательный класс поиска для фильтрации меню */
+    readonly search: MenuSearch;
+    /** Value manager for selected handling/ Менеджер выбранного значения */
+    readonly value: MenuValue;
+    /** Data manager for list selection and mapping/ Менеджер данных списка для выбора и сопоставления */
+    readonly data: ListDataRef;
+    readonly go: MenuGo;
+    /** Include for working with the Bars component/ Подключение для работы с компонентом Bars */
+    readonly bars: BarsInclude;
+    /** Include for working with the Window component/ Подключение для работы с компонентом Window */
+    readonly window: WindowInclude;
+    /** Window manager for Menu/ Класс управления окном Menu */
+    readonly menuWindow: MenuWindow;
+    /** Click event helper to unify click emissions/ Вспомогательный класс кликов для унифицированной отправки событий */
+    readonly event: EventClickInclude;
+    /** Data for binding to controls/ Данные для привязки к контролам */
+    readonly slotData: MenuControlBasic;
+    /**
+     * Constructor
+     * @param props input data/ входные данные
+     * @param refs input data in the form of reactive elements/ входные данные в виде реактивных элементов
+     * @param element input element/ элемент ввода
+     * @param classDesign design name/ название дизайна
+     * @param className class name/ название класса
+     * @param components object for working with components/ объект для работы с компонентами
+     * @param slots object for working with slots/ объект для работы со слотами
+     * @param emits the function is called when an event is triggered/ функция вызывается, когда срабатывает событие
+     */
+    constructor(props: MenuProps, refs: ToRefs<MenuProps>, element: Ref<HTMLElement | undefined>, classDesign: string, className: string, components?: DesignComp<MenuComponents, MenuProps> | undefined, slots?: MenuSlots | undefined, emits?: ConstrEmit<MenuEmits> | undefined);
+    /**
+     * Getting data for binding to the List component.
+     *
+     * Получение данных для привязки к компоненту List.
+     */
+    readonly binds: ComputedRef<ListPropsBasic>;
+    /**
+     * Getting data for binding to controls.
+     *
+     * Получение данных для привязки к контролам.
+     * @returns data for binding to controls/ данные для привязки к контролам
+     */
+    getControlBinds(): MenuControlBasic;
+    /**
+     * Click handler.
+     *
+     * Обработчик клика.
+     * @param event event object/ объект события
+     * @param options data object/ объект с данными
+     */
+    readonly onClick: (event: MouseEvent, options?: EventClickValue) => void;
+    /**
+     * Click on the slot handler.
+     *
+     * Обработчик клика по слоту.
+     * @param event event object/ объект события
+     */
+    readonly onClickSlot: (event: Event) => void;
+}

package/dist/constructors/Menu/MenuDesign.d.ts

@@ -0,0 +1,79 @@
+import { VNode } from 'vue';
+import { ConstrOptions, ConstrStyles, DesignConstructorAbstract } from '@dxtmisha/functional';
+import { Menu } from './Menu';
+import { WindowControlItem } from '../Window';
+import { MenuControlItem } from './basicTypes';
+import { MenuPropsBasic } from './props';
+import { MenuClasses, MenuComponents, MenuEmits, MenuExpose, MenuSlots } from './types';
+/**
+ * MenuDesign
+ */
+export declare class MenuDesign<COMP extends MenuComponents, EXPOSE extends MenuExpose, CLASSES extends MenuClasses, P extends MenuPropsBasic> extends DesignConstructorAbstract<HTMLDivElement, COMP, MenuEmits, EXPOSE, MenuSlots, CLASSES, P> {
+    protected readonly item: Menu;
+    /**
+     * Constructor
+     * @param name class name/ название класса
+     * @param props properties/ свойства
+     * @param options list of additional parameters/ список дополнительных параметров
+     */
+    constructor(name: string, props: Readonly<P>, options?: ConstrOptions<COMP, MenuEmits, P>);
+    /**
+     * Initialization of all the necessary properties for work
+     *
+     * Инициализация всех необходимых свойств для работы.
+     */
+    protected initExpose(): EXPOSE;
+    /**
+     * Improvement of the obtained list of classes.
+     *
+     * Доработка полученного списка классов.
+     */
+    protected initClasses(): Partial<CLASSES>;
+    /**
+     * Refinement of the received list of styles.
+     *
+     * Доработка полученного списка стилей.
+     */
+    protected initStyles(): ConstrStyles;
+    /**
+     * A method for rendering.
+     *
+     * Метод для рендеринга.
+     */
+    protected initRender(): VNode[];
+    /**
+     * Generates data for control.
+     *
+     * Генерирует данные для контроля.
+     * @param props data for the transferable property/ данные для передаваемого свойства
+     */
+    readonly renderControl: (props: WindowControlItem) => VNode | undefined;
+    /**
+     * Render title element.
+     *
+     * Рендер элемента заголовка.
+     * @param props data for the transferable property/ данные для передаваемого свойства
+     */
+    readonly renderTitle: (props: WindowControlItem) => VNode[];
+    /**
+     * Render list element.
+     *
+     * Рендер элемента списка.
+     * @param props data for the transferable property/ данные для передаваемого свойства
+     */
+    readonly renderList: (props: WindowControlItem) => VNode | undefined;
+    /**
+     * Render footer element.
+     *
+     * Рендер элемента футера.
+     * @param props data for the transferable property/ данные для передаваемого свойства
+     */
+    readonly renderFooter: (props: WindowControlItem) => VNode | undefined;
+    /**
+     * Generates data for control.
+     *
+     * Генерирует данные для контроля.
+     * @param props data for the transferable property/ данные для передаваемого свойства
+     */
+    protected getBinds(props: WindowControlItem): MenuControlItem;
+}

package/dist/constructors/Menu/MenuGo.d.ts

@@ -0,0 +1,49 @@
+import { ListDataRef, NumberOrStringOrBoolean } from '@dxtmisha/functional';
+import { MenuValue } from './MenuValue';
+import { MenuProps } from './props';
+/**
+ * Navigation manager for Menu component
+ *
+ * Менеджер навигации для компонента Menu
+ */
+export declare class MenuGo {
+    protected readonly props: MenuProps;
+    protected readonly value: MenuValue;
+    protected readonly data: ListDataRef;
+    /**
+     * Constructor
+     * @param props input data/ входные данные
+     * @param value value manager/ менеджер значений
+     * @param data data manager for list/ менеджер данных списка
+     */
+    constructor(props: MenuProps, value: MenuValue, data: ListDataRef);
+    /**
+     * Navigates to the previous item in the menu
+     *
+     * Переходит к предыдущему элементу меню
+     * @returns value of the previous item or undefined/ значение предыдущего элемента или undefined
+     */
+    readonly previous: () => NumberOrStringOrBoolean | undefined;
+    /**
+     * Navigates to the next item in the menu
+     *
+     * Переходит к следующему элементу меню
+     * @returns value of the next item or undefined/ значение следующего элемента или undefined
+     */
+    readonly next: () => NumberOrStringOrBoolean | undefined;
+    /**
+     * Returns the step value for navigation
+     *
+     * Возвращает значение шага для навигации
+     * @returns step value/ значение шага
+     */
+    protected getStep(): number;
+    /**
+     * Navigates through the menu items by the specified direction
+     *
+     * Перемещается по элементам меню в указанном направлении
+     * @param directions direction multiplier (-1 for previous, 1 for next)/ множитель направления (-1 для предыдущего, 1 для следующего)
+     * @returns value of the selected item or undefined/ значение выбранного элемента или undefined
+     */
+    protected go(directions: number): NumberOrStringOrBoolean | undefined;
+}

package/dist/constructors/Menu/MenuInclude.d.ts

@@ -0,0 +1,56 @@
+import { VNode, Ref, ComputedRef } from 'vue';
+import { ConstrBind, DesignComponents, RefOrNormal } from '@dxtmisha/functional';
+import { MenuComponentInclude, MenuExposeInclude, MenuPropsInclude } from './basicTypes';
+import { MenuExpose, MenuSlots } from './types';
+import { MenuProps } from './props';
+/**
+ * MenuInclude class provides functionality for conditionally rendering menu components
+ * within other components. It manages the logic for determining when to display menu
+ * and configures the appropriate properties.
+ *
+ * Класс MenuInclude предоставляет функциональность для условного рендеринга компонентов
+ * меню внутри других компонентов. Он управляет логикой определения необходимости
+ * отображения меню и настраивает соответствующие свойства.
+ */
+export declare class MenuInclude<Props extends MenuPropsInclude = MenuPropsInclude, PropsExtra extends ConstrBind<MenuProps> = ConstrBind<MenuProps>> {
+    protected readonly props: Readonly<Props>;
+    protected readonly className: string;
+    protected readonly components?: DesignComponents<MenuComponentInclude, Props> | undefined;
+    protected readonly extra?: RefOrNormal<PropsExtra> | undefined;
+    protected readonly index?: string | undefined;
+    /** Reference to menu element/ Ссылка на элемент меню */
+    protected readonly element: Ref<ConstrBind<MenuExpose> | undefined, ConstrBind<MenuExpose> | undefined>;
+    /**
+     * Constructor
+     * @param props input parameter/ входной параметр
+     * @param className class name/ название класса
+     * @param components object for working with components/ объект для работы с компонентами
+     * @param extra additional parameter or property name/ дополнительный параметр или имя свойства
+     * @param index index identifier/ идентификатор индекса
+     */
+    constructor(props: Readonly<Props>, className: string, components?: DesignComponents<MenuComponentInclude, Props> | undefined, extra?: RefOrNormal<PropsExtra> | undefined, index?: string | undefined);
+    /**
+     * Checks whether menu should be displayed/
+     * Проверяет, нужно ли отображать меню
+     */
+    readonly is: ComputedRef<boolean>;
+    /** Computed bindings for the menu/ Вычисляемые привязки для меню */
+    readonly binds: ComputedRef<PropsExtra>;
+    /** Menu expose functionality/ Функциональность экспорта меню */
+    readonly expose: MenuExposeInclude;
+    /**
+     * Get the menu element
+     *
+     * Получить элемент меню
+     */
+    getElement(): ConstrBind<MenuExpose> | undefined;
+    /**
+     * Render the Menu component
+     *
+     * Рендер компонента меню
+     * @param slotsChildren menu slots/ слоты меню
+     * @param attrs additional attributes/ дополнительные атрибуты
+     * @returns VNode array/ массив VNode
+     */
+    readonly render: (slotsChildren?: MenuSlots, attrs?: Record<string, any>) => VNode[];
+}

package/dist/constructors/Menu/MenuRequest.d.ts

@@ -0,0 +1,55 @@
+import { ListRecord, ListList, ListDataBasic } from '@dxtmisha/functional';
+import { MenuProps } from './props';
+import { Ref, ComputedRef } from 'vue';
+import { ListItemPropsBasic } from '../ListItem';
+/**
+ * Class for working with list data requests.
+ *
+ * Класс для работы с запросами данных списка.
+ */
+export declare class MenuRequest {
+    protected readonly props: MenuProps;
+    readonly progress: Ref<boolean, boolean>;
+    protected readonly buffer: Ref<ListRecord | undefined, ListRecord | undefined>;
+    /**
+     * Constructor
+     * @param props input data/ входные данные
+     */
+    constructor(props: MenuProps);
+    /**
+     * Returns current list data.
+     *
+     * Возвращает текущие данные списка.
+     */
+    readonly item: ComputedRef<Record<string, any> | ListList<ListDataBasic> | ListList<ListItemPropsBasic>>;
+    /**
+     * Checks whether a request is needed.
+     *
+     * Проверяет, нужно ли делать запрос.
+     */
+    is(): boolean;
+    /**
+     * Prepares data.
+     *
+     * Подготавливает данные.
+     */
+    preparation(): Promise<boolean>;
+    /**
+     * Updates data.
+     *
+     * Обновляет данные.
+     */
+    update(): Promise<void>;
+    /**
+     * Returns data from AJAX or request function.
+     *
+     * Возвращает данные из AJAX или функции запроса.
+     */
+    protected getAjax(): Promise<ListRecord | undefined>;
+    /**
+     * Executes a request to retrieve data.
+     *
+     * Выполняет запрос для получения данных.
+     */
+    protected read(callback: (data: ListRecord | undefined) => void): Promise<void>;
+}

package/dist/constructors/Menu/MenuSearch.d.ts

@@ -0,0 +1,38 @@
+import { MenuProps } from './props';
+import { Ref, ComputedRef } from 'vue';
+/**
+ * Class for working with search.
+ *
+ * Класс для работы с поиском.
+ */
+export declare class MenuSearch {
+    protected readonly props: MenuProps;
+    readonly item: Ref<string | undefined, string | undefined>;
+    /**
+     * Constructor
+     * @param props input data/ входные данные
+     */
+    constructor(props: MenuProps);
+    /** Returns the search string/ Возвращает строку поиска */
+    readonly value: ComputedRef<string | undefined>;
+    /**
+     * Sets the search string.
+     *
+     * Устанавливает строку поиска.
+     * @param value new value/ новое значение
+     */
+    set(value?: string): void;
+    /**
+     * Resets the search string.
+     *
+     * Сбрасывает строку поиска.
+     */
+    reset(): this;
+    /**
+     * Returns a processed value.
+     *
+     * Возвращает обработанное значение.
+     * @param value source value/ исходное значение
+     */
+    protected getValue(value?: string): string | undefined;
+}

package/dist/constructors/Menu/MenuValue.d.ts

@@ -0,0 +1,36 @@
+import { ToRefs, Ref, ComputedRef } from 'vue';
+import { ConstrEmit, ListSelectedList } from '@dxtmisha/functional';
+import { MenuEmits } from './types';
+import { MenuProps } from './props';
+/**
+ * Value manager for Menu
+ *
+ * Менеджер значения для Menu
+ */
+export declare class MenuValue {
+    protected readonly props: MenuProps;
+    protected readonly refs: ToRefs<MenuProps>;
+    protected readonly emits?: ConstrEmit<MenuEmits> | undefined;
+    readonly value: Ref<ListSelectedList | undefined, ListSelectedList | undefined>;
+    /**
+     * Constructor
+     * @param props input data/ входные данные
+     * @param refs input data in the form of reactive elements/ входные данные в виде реактивных элементов
+     * @param emits the function is called when an event is triggered/ функция вызывается, когда срабатывает событие
+     */
+    constructor(props: MenuProps, refs: ToRefs<MenuProps>, emits?: ConstrEmit<MenuEmits> | undefined);
+    /**
+     * Computed selected value
+     *
+     * Вычисляемое выбранное значение
+     */
+    readonly selected: ComputedRef<ListSelectedList | undefined>;
+    /**
+     * Sets a new selected value if it has changed and returns the instance for chaining.
+     *
+     * Устанавливает новое выбранное значение, если оно изменилось, и возвращает экземпляр для чейнинга.
+     * @param value selected list value/ выбранное значение списка
+     * @param isEmit whether to emit the update event/ нужно ли вызвать событие обновления
+     */
+    setValue(value: ListSelectedList, isEmit?: boolean): this;
+}

package/dist/constructors/Menu/MenuWindow.d.ts

@@ -0,0 +1,52 @@
+import { MenuRequest } from './MenuRequest';
+import { WindowProps } from '../Window';
+import { MenuProps } from './props';
+import { Ref } from 'vue';
+/**
+ * Window manager for Menu component
+ *
+ * Класс управления окном для компонента Menu
+ */
+export declare class MenuWindow {
+    protected readonly props: MenuProps;
+    protected readonly request: MenuRequest;
+    readonly lite: Ref<boolean | undefined, boolean | undefined>;
+    readonly control: Ref<boolean | undefined, boolean | undefined>;
+    /**
+     * Constructor
+     * @param props input data/ входные данные
+     * @param request menu request handler/ обработчик запросов меню
+     */
+    constructor(props: MenuProps, request: MenuRequest);
+    /**
+     * Returns extra methods for window management
+     *
+     * Возвращает дополнительные методы для управления окном
+     * @returns object with window management methods/ объект с методами управления окном
+     */
+    getExtra(): WindowProps;
+    /**
+     * Preparing data before opening the menu
+     *
+     * Подготовка данных перед открытием меню
+     * @returns Promise that resolves to true when preparation is complete/
+     * Promise, который разрешается в true после завершения подготовки
+     */
+    protected readonly preparation: () => Promise<void>;
+    /**
+     * Actions performed after opening the window
+     *
+     * Действия, выполняемые после открытия окна
+     * @returns Promise that resolves to true when opening actions are complete/
+     * Promise, который разрешается в true после завершения действий открытия
+     */
+    protected readonly opening: () => Promise<boolean>;
+    /**
+     * Actions performed when closing the window
+     *
+     * Действия, выполняемые при закрытии окна
+     * @returns Promise that resolves to true when closing actions are complete/
+     * Promise, который разрешается в true после завершения действий закрытия
+     */
+    protected readonly closing: () => Promise<boolean>;
+}

package/dist/constructors/Menu/basicTypes.d.ts

@@ -0,0 +1,39 @@
+import { ComputedRef, Ref } from 'vue';
+import { ConstrBind, NumberOrStringOrBoolean } from '@dxtmisha/functional';
+import { WindowControlItem } from '../Window';
+import { ListExpose } from '../List';
+import { MenuExpose } from './types';
+import { MenuPropsBasic } from './props';
+export type MenuControlBasic = ListExpose & {
+    loading: Ref<boolean>;
+    previous(): NumberOrStringOrBoolean | undefined;
+    next(): NumberOrStringOrBoolean | undefined;
+};
+export type MenuControlItem = MenuControlBasic & WindowControlItem;
+export type MenuComponentInclude = {
+    menu?: object;
+};
+/** Type for menu expose functionality/ Тип для функциональности экспорта меню */
+export interface MenuExposeInclude {
+    open: ComputedRef<boolean>;
+    setOpen(open: boolean): Promise<void>;
+    toOpen: MenuExpose['toOpen'];
+    toClose: MenuExpose['toClose'];
+    toggle(): Promise<void>;
+    menuElement: Ref<ConstrBind<MenuExpose> | undefined>;
+}
+export type MenuSlotInclude = {
+    /** Title slot for window title/ Слот заголовка для заголовка окна */
+    title?(props: MenuControlItem): any;
+    /** Footer slot for window bottom/ Слот подвала для низа окна */
+    footer?(props: MenuControlItem): any;
+    /** Context slot for top area / Слот контекстной области сверху */
+    contextTop?(props: MenuControlItem): any;
+    /** Context slot for bottom area / Слот контекстной области снизу */
+    contextBottom?(props: MenuControlItem): any;
+};
+/** Interface for menu include props/ Интерфейс для свойств включения меню */
+export type MenuPropsInclude<Menu extends MenuPropsBasic = MenuPropsBasic> = {
+    disabled?: boolean;
+    menuAttrs?: ConstrBind<Menu>;
+};