1) All these methods are in the @dxtmisha/constructor library.
2) Everything that is exported can be used.
3) Use what is in this library if it exists; do not use other libraries if there is an analogue here. Do not create new ones if an analogue already exists here.

The following is the content of "exports" from package.json:
{
  ".": {
    "types": "./dist/src/library.d.ts",
    "default": "./dist/library.js"
  },
  "./Accordion": {
    "types": "./dist/src/constructors/Accordion/index.d.ts",
    "default": "./dist/accordion.js"
  },
  "./ActionSheet": {
    "types": "./dist/src/constructors/ActionSheet/index.d.ts",
    "default": "./dist/actionSheet.js"
  },
  "./Actions": {
    "types": "./dist/src/constructors/Actions/index.d.ts",
    "default": "./dist/actions.js"
  },
  "./Anchor": {
    "types": "./dist/src/constructors/Anchor/index.d.ts",
    "default": "./dist/anchor.js"
  },
  "./Area": {
    "types": "./dist/src/constructors/Area/index.d.ts",
    "default": "./dist/area.js"
  },
  "./Arrow": {
    "types": "./dist/src/constructors/Arrow/index.d.ts",
    "default": "./dist/arrow.js"
  },
  "./Badge": {
    "types": "./dist/src/constructors/Badge/index.d.ts",
    "default": "./dist/badge.js"
  },
  "./Bars": {
    "types": "./dist/src/constructors/Bars/index.d.ts",
    "default": "./dist/bars.js"
  },
  "./Block": {
    "types": "./dist/src/constructors/Block/index.d.ts",
    "default": "./dist/block.js"
  },
  "./Button": {
    "types": "./dist/src/constructors/Button/index.d.ts",
    "default": "./dist/button.js"
  },
  "./ButtonGroup": {
    "types": "./dist/src/constructors/ButtonGroup/index.d.ts",
    "default": "./dist/buttonGroup.js"
  },
  "./Cell": {
    "types": "./dist/src/constructors/Cell/index.d.ts",
    "default": "./dist/cell.js"
  },
  "./Checkbox": {
    "types": "./dist/src/constructors/Checkbox/index.d.ts",
    "default": "./dist/checkbox.js"
  },
  "./Chip": {
    "types": "./dist/src/constructors/Chip/index.d.ts",
    "default": "./dist/chip.js"
  },
  "./ChipGroup": {
    "types": "./dist/src/constructors/ChipGroup/index.d.ts",
    "default": "./dist/chipGroup.js"
  },
  "./ClientOnly": {
    "types": "./dist/src/constructors/ClientOnly/index.d.ts",
    "default": "./dist/clientOnly.js"
  },
  "./Container": {
    "types": "./dist/src/constructors/Container/index.d.ts",
    "default": "./dist/container.js"
  },
  "./Dialog": {
    "types": "./dist/src/constructors/Dialog/index.d.ts",
    "default": "./dist/dialog.js"
  },
  "./Dummy": {
    "types": "./dist/src/constructors/Dummy/index.d.ts",
    "default": "./dist/dummy.js"
  },
  "./Field": {
    "types": "./dist/src/constructors/Field/index.d.ts",
    "default": "./dist/field.js"
  },
  "./FieldCounter": {
    "types": "./dist/src/constructors/FieldCounter/index.d.ts",
    "default": "./dist/fieldCounter.js"
  },
  "./FieldLabel": {
    "types": "./dist/src/constructors/FieldLabel/index.d.ts",
    "default": "./dist/fieldLabel.js"
  },
  "./FieldMessage": {
    "types": "./dist/src/constructors/FieldMessage/index.d.ts",
    "default": "./dist/fieldMessage.js"
  },
  "./Grid": {
    "types": "./dist/src/constructors/Grid/index.d.ts",
    "default": "./dist/grid.js"
  },
  "./GridItem": {
    "types": "./dist/src/constructors/GridItem/index.d.ts",
    "default": "./dist/gridItem.js"
  },
  "./Group": {
    "types": "./dist/src/constructors/Group/index.d.ts",
    "default": "./dist/group.js"
  },
  "./Header": {
    "types": "./dist/src/constructors/Header/index.d.ts",
    "default": "./dist/header.js"
  },
  "./HorizontalScroll": {
    "types": "./dist/src/constructors/HorizontalScroll/index.d.ts",
    "default": "./dist/horizontalScroll.js"
  },
  "./Icon": {
    "types": "./dist/src/constructors/Icon/index.d.ts",
    "default": "./dist/icon.js"
  },
  "./Image": {
    "types": "./dist/src/constructors/Image/index.d.ts",
    "default": "./dist/image.js"
  },
  "./Input": {
    "types": "./dist/src/constructors/Input/index.d.ts",
    "default": "./dist/input.js"
  },
  "./List": {
    "types": "./dist/src/constructors/List/index.d.ts",
    "default": "./dist/list.js"
  },
  "./ListGroup": {
    "types": "./dist/src/constructors/ListGroup/index.d.ts",
    "default": "./dist/listGroup.js"
  },
  "./ListItem": {
    "types": "./dist/src/constructors/ListItem/index.d.ts",
    "default": "./dist/listItem.js"
  },
  "./ListMenu": {
    "types": "./dist/src/constructors/ListMenu/index.d.ts",
    "default": "./dist/listMenu.js"
  },
  "./Mask": {
    "types": "./dist/src/constructors/Mask/index.d.ts",
    "default": "./dist/mask.js"
  },
  "./Menu": {
    "types": "./dist/src/constructors/Menu/index.d.ts",
    "default": "./dist/menu.js"
  },
  "./Modal": {
    "types": "./dist/src/constructors/Modal/index.d.ts",
    "default": "./dist/modal.js"
  },
  "./MotionAxis": {
    "types": "./dist/src/constructors/MotionAxis/index.d.ts",
    "default": "./dist/motionAxis.js"
  },
  "./MotionTransform": {
    "types": "./dist/src/constructors/MotionTransform/index.d.ts",
    "default": "./dist/motionTransform.js"
  },
  "./Page": {
    "types": "./dist/src/constructors/Page/index.d.ts",
    "default": "./dist/page.js"
  },
  "./PageArea": {
    "types": "./dist/src/constructors/PageArea/index.d.ts",
    "default": "./dist/pageArea.js"
  },
  "./Progress": {
    "types": "./dist/src/constructors/Progress/index.d.ts",
    "default": "./dist/progress.js"
  },
  "./Radio": {
    "types": "./dist/src/constructors/Radio/index.d.ts",
    "default": "./dist/radio.js"
  },
  "./Ripple": {
    "types": "./dist/src/constructors/Ripple/index.d.ts",
    "default": "./dist/ripple.js"
  },
  "./Scrollbar": {
    "types": "./dist/src/constructors/Scrollbar/index.d.ts",
    "default": "./dist/scrollbar.js"
  },
  "./Section": {
    "types": "./dist/src/constructors/Section/index.d.ts",
    "default": "./dist/section.js"
  },
  "./Select": {
    "types": "./dist/src/constructors/Select/index.d.ts",
    "default": "./dist/select.js"
  },
  "./SelectValue": {
    "types": "./dist/src/constructors/SelectValue/index.d.ts",
    "default": "./dist/selectValue.js"
  },
  "./Skeleton": {
    "types": "./dist/src/constructors/Skeleton/index.d.ts",
    "default": "./dist/skeleton.js"
  },
  "./Snackbar": {
    "types": "./dist/src/constructors/Snackbar/index.d.ts",
    "default": "./dist/snackbar.js"
  },
  "./SnackbarItem": {
    "types": "./dist/src/constructors/SnackbarItem/index.d.ts",
    "default": "./dist/snackbarItem.js"
  },
  "./TabItem": {
    "types": "./dist/src/constructors/TabItem/index.d.ts",
    "default": "./dist/tabItem.js"
  },
  "./Tabs": {
    "types": "./dist/src/constructors/Tabs/index.d.ts",
    "default": "./dist/tabs.js"
  },
  "./TabsNavigation": {
    "types": "./dist/src/constructors/TabsNavigation/index.d.ts",
    "default": "./dist/tabsNavigation.js"
  },
  "./Textarea": {
    "types": "./dist/src/constructors/Textarea/index.d.ts",
    "default": "./dist/textarea.js"
  },
  "./TextareaAutosize": {
    "types": "./dist/src/constructors/TextareaAutosize/index.d.ts",
    "default": "./dist/textareaAutosize.js"
  },
  "./Tooltip": {
    "types": "./dist/src/constructors/Tooltip/index.d.ts",
    "default": "./dist/tooltip.js"
  },
  "./Window": {
    "types": "./dist/src/constructors/Window/index.d.ts",
    "default": "./dist/window.js"
  },
  "./plugin": {
    "types": "./dist/src/library/plugin.d.ts",
    "default": "./dist/plugin.js"
  },
  "./style.scss": "./src/library/style.scss",
  "./Bleed": {
    "types": "./dist/src/constructors/Bleed/index.d.ts",
    "default": "./dist/bleed.js"
  },
  "./Divider": {
    "types": "./dist/src/constructors/Divider/index.d.ts",
    "default": "./dist/divider.js"
  },
  "./Switch": {
    "types": "./dist/src/constructors/Switch/index.d.ts",
    "default": "./dist/switch.js"
  },
  "./TextLabel": {
    "types": "./dist/src/constructors/TextLabel/index.d.ts",
    "default": "./dist/textLabel.js"
  },
  "./TextDescription": {
    "types": "./dist/src/constructors/TextDescription/index.d.ts",
    "default": "./dist/textDescription.js"
  },
  "./MenuCountry": {
    "types": "./dist/src/constructors/MenuCountry/index.d.ts",
    "default": "./dist/menuCountry.js"
  },
  "./MenuButton": {
    "types": "./dist/src/constructors/MenuButton/index.d.ts",
    "default": "./dist/menuButton.js"
  },
  "./MenuChip": {
    "types": "./dist/src/constructors/MenuChip/index.d.ts",
    "default": "./dist/menuChip.js"
  }
}

// File: src/classes/AreaInclude.d.ts
export declare class AreaInclude {
    constructor(props: AreaPropsInclude);
}

// File: src/classes/AriaStaticInclude.d.ts
export declare class AriaStaticInclude {
    static role(role?: RoleType): AriaList;
    static atomic(isAtomic?: boolean): AriaList;
    static checked(isChecked?: boolean): AriaList;
    static controls(controls?: string): AriaList;
    static current(value?: AriaList['aria-current']): AriaList;
    static busy(isBusy?: boolean): AriaList;
    static describedby(id?: string): AriaList;
    static disabled(isDisabled?: boolean): AriaList;
    static expanded(isExpanded?: boolean): AriaList;
    static haspopup(haspopup?: AriaList['aria-haspopup']): AriaList;
    static label(label?: string): AriaList;
    static labelledby(id?: string): AriaList;
    static invalid(isInvalid?: boolean): AriaList;
    static control(id?: string, controls?: string, haspopup?: AriaList['aria-haspopup'], expanded?: boolean): AriaList;
    static hidden(isHidden?: boolean): AriaList;
    static live(live?: AriaList['aria-live']): AriaList;
    static ariaModal(isModal?: boolean): AriaList;
    static modal(isModal?: boolean, ariaLabelledby?: string, ariaDescribedby?: string): AriaList;
    static multiselectable(isMultiselectable?: boolean): AriaList;
    static selected(isSelected?: boolean): AriaList;
    static valueMinMax(value?: string | number, min?: string | number, max?: string | number): AriaList;
    static isTrueOrFalse(value?: boolean): AriaTrueOrFalse | undefined;
}

// File: src/classes/CaptionInclude.d.ts
export declare class CaptionInclude {
    constructor(props: Readonly<CaptionProps>, className: string, slots?: CaptionSlots | undefined, skeleton?: SkeletonInclude | undefined);
    readonly is: ComputedRef<boolean>;
    readonly binds: ComputedRef<{
        'aria-activedescendant'?: string;
        'aria-atomic'?: AriaTrueOrFalse;
        'aria-autocomplete'?: "none" | "inline" | "list" | "both";
        'aria-busy'?: AriaTrueOrFalse;
        'aria-checked'?: AriaTrueOrFalse | "mixed";
        'aria-colcount'?: number;
        'aria-colindex'?: number;
        'aria-colspan'?: number;
        'aria-controls'?: string;
        'aria-current'?: AriaTrueOrFalse | "page" | "step" | "location" | "date" | "time";
        'aria-describedby'?: string;
        'aria-details'?: string;
        'aria-disabled'?: AriaTrueOrFalse;
        'aria-errormessage'?: string;
        'aria-expanded'?: AriaTrueOrFalse;
        'aria-flowto'?: string;
        'aria-grabbed'?: AriaTrueOrFalse;
        'aria-haspopup'?: AriaTrueOrFalse | "dialog" | "menu" | "listbox" | "tree" | "grid";
        'aria-hidden'?: AriaTrueOrFalse;
        'aria-invalid'?: AriaTrueOrFalse | "grammar" | "spelling";
        'aria-keyshortcuts'?: string;
        'aria-label'?: string;
        'aria-labelledby'?: string;
        'aria-level'?: number;
        'aria-live'?: "off" | "polite" | "assertive";
        'aria-modal'?: AriaTrueOrFalse;
        'aria-multiline'?: AriaTrueOrFalse;
        'aria-multiselectable'?: AriaTrueOrFalse;
        'aria-orientation'?: "horizontal" | "vertical" | "undefined";
        'aria-owns'?: string;
        'aria-placeholder'?: string;
        'aria-posinset'?: number;
        'aria-pressed'?: AriaTrueOrFalse | "mixed";
        'aria-readonly'?: AriaTrueOrFalse;
        'aria-relevant'?: "additions" | "removals" | "text" | "all" | string;
        'aria-required'?: AriaTrueOrFalse;
        'aria-roledescription'?: string;
        'aria-rowcount'?: number;
        'aria-rowindex'?: number;
        'aria-rowspan'?: number;
        'aria-selected'?: AriaTrueOrFalse;
        'aria-setsize'?: number;
        'aria-sort'?: "none" | "ascending" | "descending" | "other";
        'aria-valuemax'?: string | number;
        'aria-valuemin'?: string | number;
        'aria-valuenow'?: string | number;
        'aria-valuetext'?: string;
        id?: string;
        role?: RoleType;
        tabindex?: NumberOrString;
        class: {
            [x: string]: boolean | undefined;
        };
        'data-event-type': string;
    }>;
    render(): VNode[];
}

// File: src/classes/ClientOnlyInclude.d.ts
export declare class ClientOnlyInclude {
    isMounted: Ref<boolean, boolean>;
    constructor(props?: ClientOnlyPropsInclude | undefined);
    readonly isRender: ComputedRef<boolean>;
    is(): boolean;
}

// File: src/classes/DescriptionInclude.d.ts
export declare class DescriptionInclude {
    constructor(props: Readonly<DescriptionProps>, className: string, slots?: DescriptionSlots | undefined, skeleton?: SkeletonInclude | undefined, tag?: RefOrNormal<string>);
    readonly is: ComputedRef<boolean>;
    readonly id: ComputedRef<string>;
    render(childrenExtra?: any[], props?: Record<string, any>): VNode[];
}

// File: src/classes/EnabledInclude.d.ts
export declare class EnabledInclude {
    constructor(props: EnabledProps, progress?: ProgressInclude | undefined);
    readonly isEnabled: ComputedRef<boolean>;
    readonly isReadonly: ComputedRef<boolean>;
    readonly isDisabled: ComputedRef<boolean>;
    readonly isDisabledOrUndefined: ComputedRef<boolean | undefined>;
    readonly aria: ComputedRef<AriaList>;
}

// File: src/classes/EventClickInclude.d.ts
export declare class EventClickInclude {
    constructor(props?: EventClickProps | undefined, enabled?: EnabledInclude | undefined, emits?: ConstrEmit<EventClickEmits> | undefined);
    get binds(): {
        onClick: (event: MouseEvent, options?: EventClickValue) => void;
        onKeydown: (event: KeyboardEvent, options?: EventClickValue) => void;
        href?: string;
    };
    get expose(): EventClickExpose;
    getHref(): ConstrHrefProps;
    readonly onClick: (event: MouseEvent, options?: EventClickValue) => void;
    readonly onKeydown: (event: KeyboardEvent, options?: EventClickValue) => void;
}

// File: src/classes/Field/FieldArrowInclude.d.ts
export declare class FieldArrowInclude {
    constructor(props: FieldAllProps, value: FieldValueInclude, type?: FieldTypeInclude | undefined);
    get is(): boolean;
    get disabledPrevious(): boolean;
    get disabledNext(): boolean;
    isCarousel(): boolean;
    isStepper(): boolean;
    isPrevious(value: number): boolean;
    isNext(value: number): boolean;
    get(): FieldArrowProps['arrow'] | undefined;
    align(): string | undefined;
    previous(): this;
    next(): this;
    toMin(): this;
    toMax(): this;
}

// File: src/classes/Field/FieldAttributesInclude.d.ts
export declare class FieldAttributesInclude {
    constructor(props: FieldAllProps, type?: FieldTypeInclude | undefined, pattern?: FieldPatternInclude | undefined, inputMode?: FieldInputModeInclude | undefined, typeDefault?: string);
    readonly list: ComputedRef<Record<string, any>>;
    readonly listForCheck: ComputedRef<Record<string, any>>;
    readonly listForInput: ComputedRef<Record<string, any>>;
    readonly listForCheckbox: ComputedRef<Record<string, any>>;
}

// File: src/classes/Field/FieldChangeInclude.d.ts
export declare class FieldChangeInclude {
    readonly item: Ref<boolean, boolean>;
    constructor(props: FieldAllProps);
    is(): boolean;
    set(change: boolean): void;
    to(): void;
}

// File: src/classes/Field/FieldCodeInclude.d.ts
export declare class FieldCodeInclude {
    constructor(props: FieldAllProps);
    get(state?: ValidityState): string | undefined;
}

// File: src/classes/Field/FieldElementInclude.d.ts
export declare class FieldElementInclude {
    constructor(props: FieldAllProps, element: Ref<FieldElementInput>);
    get(): HTMLInputElement | undefined;
    getElement(): Ref<FieldElementInput>;
    findByName(nameSelectors: string | HTMLInputElement): HTMLInputElement | undefined;
    clear(): this;
}

// File: src/classes/Field/FieldEventInclude.d.ts
export declare class FieldEventInclude {
    constructor(props: FieldAllProps, change: FieldChangeInclude, value: FieldValueInclude, validation?: FieldValidationInclude | undefined, emits?: ConstrEmit<FieldBasicEmits> | undefined);
    isEnabled(): boolean;
    readonly onBlur: () => void;
    readonly onInput: (event: InputEvent, data?: Record<string, any>) => void;
    readonly onChange: (event?: InputEvent | Event) => void;
    readonly onSelect: (event: Event, data?: Record<string, any>) => void;
    readonly onChecked: (event: Event) => void;
    readonly onRadio: (event: Event) => void;
    readonly onClear: (event: MouseEvent) => void;
    readonly onValue: (value: any) => void;
    readonly on: <E>(event?: E, type?: string & keyof FieldBasicEmits) => this;
}

// File: src/classes/Field/FieldInputCheckInclude.d.ts
export declare class FieldInputCheckInclude<Value = any> {
    readonly pattern: FieldPatternItemOrFunction;
    readonly group: string;
    readonly input: HTMLInputElement | undefined;
    constructor(pattern: FieldPatternItemOrFunction, group?: string, code?: FieldCodeInclude | undefined);
    check(value: Value): FieldValidationItem;
    checkByInput(input: FieldElementDom): FieldValidationItem;
    static getGroupDefault(): string;
}
export type FieldInputCheckListInclude = Record<string, FieldInputCheckInclude>;

// File: src/classes/Field/FieldInputModeInclude.d.ts
export declare class FieldInputModeInclude {
    constructor(props: FieldAllProps, type: FieldTypeInclude);
    get item(): string | undefined;
    get autocomplete(): string | undefined;
}

// File: src/classes/Field/FieldMatchInclude.d.ts
export declare class FieldMatchInclude {
    constructor(props: FieldAllProps, element: FieldElementInclude, value: FieldValueInclude, text?: TextInclude | undefined);
    is(): boolean;
    getSelectors(): string | HTMLInputElement | undefined;
    getValidationMessage(): string;
    check(): FieldValidationItem | undefined;
}

// File: src/classes/Field/FieldPatternInclude.d.ts
export declare class FieldPatternInclude {
    constructor(props: FieldAllProps, type?: FieldTypeInclude | undefined);
    get item(): string | undefined;
}

// File: src/classes/Field/FieldTypeInclude.d.ts
export declare class FieldTypeInclude {
    constructor(props: FieldAllProps, visibility?: FieldVisibilityInclude | undefined);
    get item(): FieldType;
    get(): FieldType;
}

// File: src/classes/Field/FieldValidationInclude.d.ts
export declare class FieldValidationInclude {
    constructor(props: FieldAllProps, attributes: FieldAttributesInclude, value: FieldValueInclude, change?: FieldChangeInclude | undefined, code?: FieldCodeInclude | undefined, match?: FieldMatchInclude | undefined);
    readonly item: ComputedRef<FieldValidationItem>;
    readonly message: ComputedRef<string>;
    isError(): boolean;
    readonly checkValidity: () => boolean;
    set(validation: Record<string, any> | FieldValidationItem): this;
}

// File: src/classes/Field/FieldValueInclude.d.ts
export declare class FieldValueInclude<Value = any> {
    readonly item: Ref<Value | undefined, Value | undefined>;
    readonly isFull: Ref<boolean, boolean>;
    constructor(props: FieldValueProps<Value>, refs: ToRefs<FieldValueProps<Value>>, element?: FieldElementInclude | undefined, original?: RefOrNormal<Value> | undefined);
    readonly is: ComputedRef<boolean>;
    readonly isValue: ComputedRef<boolean>;
    readonly itemByFull: ComputedRef<Value | undefined>;
    readonly number: ComputedRef<number>;
    readonly string: ComputedRef<string>;
    readonly boolean: ComputedRef<boolean>;
    readonly length: ComputedRef<number>;
    get(): Value | undefined;
    getToArray(): Value[];
    set(value: any): this;
    setByEvent(event: Event): this;
    setByEvent(value: Record<string, any>): this;
    setByEvent(value: any): this;
    setByTarget(target: HTMLInputElement): this;
    setByChecked(event: Event): this;
    setByRadio(event: Event): this;
    setFull(isFull: boolean): void;
    setHasEdit(hasEdit: boolean): void;
    setToOriginal(): this;
    clear(): this;
}

// File: src/classes/Field/FieldVisibilityInclude.d.ts
export declare class FieldVisibilityInclude {
    readonly item: Ref<boolean, boolean>;
    toggle(): this;
}

// File: src/classes/LabelHighlightInclude.d.ts
export declare class LabelHighlightInclude extends LabelInclude {
    constructor(props: Readonly<LabelHighlightProps>, className: string, classesExtra?: ConstrClass | undefined, slots?: LabelHighlightSlots | undefined, elementsExtra?: (() => VNode[]) | undefined, skeleton?: SkeletonInclude | undefined);
    isHighlight(): boolean;
}

// File: src/classes/LabelInclude.d.ts
export declare class LabelInclude {
    constructor(props: Readonly<LabelProps>, className: string, classesExtra?: ConstrClass | undefined, slots?: (LabelSlots | LabelAlternativeSlots) | undefined, elementsExtra?: (() => VNode[]) | undefined, labelReplacing?: Ref<string | number | undefined> | undefined, alternativeSlots?: boolean | undefined, skeleton?: SkeletonInclude | undefined, tag?: RefOrNormal<string>);
    readonly is: ComputedRef<boolean>;
    readonly id: ComputedRef<string>;
    render(childrenExtra?: any[], props?: Record<string, any>): VNode[];
}

// File: src/classes/LabelNumberInclude.d.ts
export declare class LabelNumberInclude extends LabelInclude {
    constructor(props: Readonly<LabelNumberProps>, className: string, classesExtra?: ConstrClass | undefined, slots?: LabelNumberSlots | undefined, elementsExtra?: (() => VNode[]) | undefined, skeleton?: SkeletonInclude | undefined);
}

// File: src/classes/ModelInclude.d.ts
export declare class ModelInclude<Value = string> {
    constructor(index: string, emits?: any | undefined, syncValue?: RefType<Value> | undefined);
    isValue(): this is {
        syncValue: Ref<Value>;
    };
    getBinds(): {
        [x: string]: Value | ((value: Value) => void);
    };
    readonly update: (value: Value) => void;
    emit(value: Value): void;
}

// File: src/classes/ModelValueInclude.d.ts
export declare class ModelValueInclude<Value = any> {
    readonly value: Ref<Value | undefined, Value | undefined>;
    constructor(index: string, emits?: any | undefined, event?: EventClickInclude | undefined, inputValue?: RefType<any> | undefined, readonly?: RefType<boolean | undefined> | undefined);
    getValue(): Value | undefined;
    readonly onClick: (event: MouseEvent, options?: EventClickValue) => void;
}

// File: src/classes/Plugin/Plugin.d.ts
export declare class Plugin {
    constructor(design: string, packageName: string, componentsReg: RegExp, styleVarsReg: RegExp, componentsList: PluginComponentImports, name?: string, options?: PluginOptions);
    init(): VitePlugin;
}

// File: src/classes/Plugin/PluginCode.d.ts
export declare class PluginCode {
    constructor(id: string, code: string);
    isVue(): boolean;
    isScss(): boolean;
    get(): string;
    getId(): string;
    getCode(): string;
    has(pattern: string | RegExp, flags?: string): boolean;
    addAfterScript(code: string): this;
    addStart(code: string): this;
    addStartIfNone(code: string, pattern?: string | RegExp): this;
    replace(pattern: string | RegExp, replacement: string | ((substring: string, ...args: any[]) => string)): this;
}

// File: src/classes/Plugin/PluginComponents.d.ts
export declare class PluginComponents {
    constructor(code: PluginCode, pluginData: PluginData);
    make(): void;
}

// File: src/classes/Plugin/PluginData.d.ts
export declare class PluginData {
    constructor(design: string, packageName: string, componentsReg: RegExp, styleVarsReg: RegExp, componentsList: PluginComponentImports);
    hasComponent(code: string): boolean;
    hasVars(code: string): boolean;
    getDesign(): string;
    getPackageName(): string;
    getComponents(code: string): PluginComponentImports;
    getStyleVarsReg(): RegExp;
    getStyleModification(): Record<string, string>;
}

// File: src/classes/Plugin/PluginImport.d.ts
export declare class PluginImport {
    constructor(packageName: string, code: string);
    get(): string;
    importStyle(): this;
}

// File: src/classes/Plugin/PluginStyle.d.ts
export declare class PluginStyle {
    constructor(code: PluginCode, data: PluginData, namespace?: string);
    make(): this;
}

// File: src/classes/Plugin/PluginTool.d.ts
export declare class PluginTool {
    static isSrc(id: string): boolean;
    static isJs(id: string): boolean;
    static isVue(id: string): boolean;
    static isCss(id: string): boolean;
    static isDev(mode: string): boolean;
}

// File: src/classes/PrefixInclude.d.ts
export declare class PrefixInclude {
    constructor(props: Readonly<PrefixProps>, className: string, slots?: PrefixSlots | undefined, skeleton?: SkeletonInclude | undefined);
    readonly is: ComputedRef<boolean>;
    readonly id: ComputedRef<string>;
    readonly describedby: ComputedRef<string>;
    render(): VNode[];
}

// File: src/classes/ScrollToXInclude.d.ts
export declare class ScrollToXInclude {
    constructor(element: Ref<HTMLElement | undefined>);
    readonly binds: ComputedRef<{
        onWheelPassive: (event: WheelEvent) => void;
    }>;
    readonly onScrollToX: (event: WheelEvent) => void;
}

// File: src/classes/SuffixInclude.d.ts
export declare class SuffixInclude {
    constructor(props: Readonly<SuffixProps>, className: string, slots?: SuffixSlots | undefined, skeleton?: SkeletonInclude | undefined);
    readonly is: ComputedRef<boolean>;
    readonly id: ComputedRef<string>;
    readonly describedby: ComputedRef<string>;
    render(): VNode[];
}

// File: src/classes/TabIndexInclude.d.ts
export declare class TabIndexInclude<E extends HTMLElement = HTMLElement> {
    constructor(element: Ref<E | undefined> | (() => E | undefined), active?: () => boolean, activeOpen?: () => boolean, activeClose?: () => boolean);
    goTo(): this;
    reset(): this;
    toggle(status: boolean): this;
    updateOldElement(): void;
    findFirstElement(): HTMLElement | undefined;
    findLastElement(): HTMLElement | undefined;
}

// File: src/classes/TeleportInclude.d.ts
export declare class TeleportInclude {
    constructor(toDefault?: RefOrNormal<string>);
    readonly to: ComputedRef<string>;
    isTeleportElement(element: HTMLElement): boolean;
    render(children?: RawChildren | RawSlots, props?: Record<string, any>): VNode[];
}

// File: src/classes/TextInclude.d.ts
export declare class TextInclude {
    static readonly list: ShallowRef<TextList, TextList>;
    readonly texts: Record<string, ComputedRef<string | undefined>>;
    static initText(texts: TextList): void;
    constructor(props: TextAllPropsInclude);
    get cancel(): ComputedRef<string | undefined>;
    get characterLimit(): ComputedRef<string | undefined>;
    get characterRemaining(): ComputedRef<string | undefined>;
    get close(): ComputedRef<string | undefined>;
    get copiedClipboard(): ComputedRef<string | undefined>;
    get decrement(): ComputedRef<string | undefined>;
    get entriesMatch(): ComputedRef<string | undefined>;
    get hide(): ComputedRef<string | undefined>;
    get increment(): ComputedRef<string | undefined>;
    get loading(): ComputedRef<string | undefined>;
    get next(): ComputedRef<string | undefined>;
    get notFound(): ComputedRef<string | undefined>;
    get notifications(): ComputedRef<string | undefined>;
    get ok(): ComputedRef<string | undefined>;
    get previous(): ComputedRef<string | undefined>;
    get show(): ComputedRef<string | undefined>;
    get(name: keyof TextAllPropsInclude): ComputedRef<string | undefined>;
}

// File: src/classes/TouchEventInclude.d.ts
export declare class TouchEventInclude {
    readonly touche: Ref<Touch | undefined, Touch | undefined>;
    readonly toucheMove: Ref<Touch | undefined, Touch | undefined>;
    readonly mouse: Ref<TouchEventClient | undefined, TouchEventClient | undefined>;
    readonly mouseMove: Ref<TouchEventClient | undefined, TouchEventClient | undefined>;
    constructor(start?: ((mouse: TouchEventClient, touche?: Touch) => void) | undefined, move?: TouchEventCallback | undefined, end?: TouchEventCallback | undefined, element?: Ref<HTMLElement | undefined> | undefined);
    readonly onTouch: {
        onTouchstart: (event: TouchEvent) => void;
        onTouchend: (event: TouchEvent) => void;
        onTouchcancel: (event: TouchEvent) => void;
        onTouchmove: (event: TouchEvent) => void;
    };
    readonly onMouse: {
        onMousedown: (event: MouseEvent) => void;
        onMouseup: (event: MouseEvent) => void;
        onMousemove: (event: MouseEvent) => void;
    };
}

// File: src/functions/getAreaValue.d.ts
export declare function getAreaValue(): string | undefined;

// File: src/functions/getClassTagAStatic.d.ts
export declare const getClassTagAStatic: (design: string) => string;

// File: src/functions/setAreaValue.d.ts
export declare function setAreaValue(value: string | Ref<string>): void;

// File: src/media/styleModification.d.ts
export declare const STYLE_MODIFICATION: string[];

// File: src/types/areaTypes.d.ts
export type AreaPropsInclude = {
    area?: string;
};
export declare const AREA_PROP_NAME = "UI_AREA_VALUE";

// File: src/types/ariaTypes.d.ts
export type AriaTrueOrFalse = 'true' | 'false' | boolean;
export type AriaList = {
    'aria-activedescendant'?: string;
    'aria-atomic'?: AriaTrueOrFalse;
    'aria-autocomplete'?: 'none' | 'inline' | 'list' | 'both';
    'aria-busy'?: AriaTrueOrFalse;
    'aria-checked'?: AriaTrueOrFalse | 'mixed';
    'aria-colcount'?: number;
    'aria-colindex'?: number;
    'aria-colspan'?: number;
    'aria-controls'?: string;
    'aria-current'?: AriaTrueOrFalse | 'page' | 'step' | 'location' | 'date' | 'time';
    'aria-describedby'?: string;
    'aria-details'?: string;
    'aria-disabled'?: AriaTrueOrFalse;
    'aria-errormessage'?: string;
    'aria-expanded'?: AriaTrueOrFalse;
    'aria-flowto'?: string;
    'aria-grabbed'?: AriaTrueOrFalse;
    'aria-haspopup'?: AriaTrueOrFalse | 'dialog' | 'menu' | 'listbox' | 'tree' | 'grid';
    'aria-hidden'?: AriaTrueOrFalse;
    'aria-invalid'?: AriaTrueOrFalse | 'grammar' | 'spelling';
    'aria-keyshortcuts'?: string;
    'aria-label'?: string;
    'aria-labelledby'?: string;
    'aria-level'?: number;
    'aria-live'?: 'off' | 'polite' | 'assertive';
    'aria-modal'?: AriaTrueOrFalse;
    'aria-multiline'?: AriaTrueOrFalse;
    'aria-multiselectable'?: AriaTrueOrFalse;
    'aria-orientation'?: 'horizontal' | 'vertical' | 'undefined';
    'aria-owns'?: string;
    'aria-placeholder'?: string;
    'aria-posinset'?: number;
    'aria-pressed'?: AriaTrueOrFalse | 'mixed';
    'aria-readonly'?: AriaTrueOrFalse;
    'aria-relevant'?: 'additions' | 'removals' | 'text' | 'all' | string;
    'aria-required'?: AriaTrueOrFalse;
    'aria-roledescription'?: string;
    'aria-rowcount'?: number;
    'aria-rowindex'?: number;
    'aria-rowspan'?: number;
    'aria-selected'?: AriaTrueOrFalse;
    'aria-setsize'?: number;
    'aria-sort'?: 'none' | 'ascending' | 'descending' | 'other';
    'aria-valuemax'?: string | number;
    'aria-valuemin'?: string | number;
    'aria-valuenow'?: string | number;
    'aria-valuetext'?: string;
    'id'?: string;
    'role'?: RoleType;
    'tabindex'?: NumberOrString;
};
export type AriaAtomicPropsInclude = {
    ariaAtomic?: AriaList['aria-atomic'];
};
export type AriaByPropsInclude = {
    ariaLabelledby?: string;
    ariaDescribedby?: string;
};
export type AriaDescriptionPropsInclude = {
    ariaDescription?: string;
};
export type AriaHaspopupPropsInclude = {
    ariaHaspopup?: AriaList['aria-haspopup'];
};
export type AriaLabelPropsInclude = {
    ariaLabel?: string;
};
export type AriaLivePropsInclude = {
    ariaLive?: AriaList['aria-live'];
};
export type AriaMultiselectablePropsInclude = {
    ariaMultiselectable?: boolean;
};
export type AriaRoleByPropsInclude = AriaRolePropsInclude & AriaByPropsInclude;
export type AriaRoleControlPropsInclude = AriaRolePropsInclude & AriaHaspopupPropsInclude & {
    id?: string;
    ariaControls?: string;
    ariaHaspopup?: AriaList['aria-haspopup'];
    ariaExpanded?: string;
};
export type AriaRolePropsInclude = {
    role?: RoleType;
};

// File: src/types/captionTypes.d.ts
export interface CaptionSlots {
    caption?(props: any): any;
}
export type CaptionProps = {
    caption?: string | number;
    captionDecorative?: boolean;
};

// File: src/types/clientOnlyTypes.d.ts
export type ClientOnlyPropsInclude = {
    clientOnly?: boolean;
};

// File: src/types/descriptionTypes.d.ts
export interface DescriptionSlots {
    description?(props: any): any;
}
export type DescriptionProps = {
    description?: string | number;
    descriptionId?: string;
};

// File: src/types/enabledTypes.d.ts
export type EnabledProps = {
    readonly?: boolean;
    disabled?: boolean;
};

// File: src/types/errorTypes.d.ts
export declare const CONSTRUCTOR_ERROR_GROUP = "constructor";

// File: src/types/eventClickTypes.d.ts
export type EventClickValue = {
    type: string;
    value: any;
    detail: Record<string, any> | undefined;
};
export type EventClickEmits = {
    click: [event: MouseEvent, value: EventClickValue];
    clickLite: [value: EventClickValue];
};
export interface EventClickExpose {
    value?: Ref<EventClickValue['value']>;
    detail?: Ref<EventClickValue['detail']>;
}
export type EventClickProps = {
    to?: string | RouteLocationRaw;
    href?: string;
    value?: EventClickValue['value'];
    detail?: EventClickValue['detail'];
};

// File: src/types/fieldTypes.d.ts
export type FieldType = 'text' | 'search' | 'number' | 'number-format' | 'currency' | 'email' | 'password' | 'datetime' | 'date' | 'year-month' | 'time' | 'hour-minute' | 'tel' | 'url' | 'checkbox' | 'radio';
export type FieldElementDom = HTMLInputElement | HTMLTextAreaElement;
export type FieldElementInput = FieldElementDom | HTMLElement | Record<string, any> | undefined;
export type FieldValidityCodeItem = {
    [K in keyof ValidityState]?: string;
};
export type FieldValidityCode = string | FieldValidityCodeItem;
export type FieldMaskItem = {
    group: string;
    value: string;
    maxLength: number;
    full: boolean;
    end: boolean;
    chars: string[];
};
export type FieldMasks = Record<string, FieldMaskItem>;
export type FieldPatternElement = Partial<HTMLInputElement>;
export type FieldPatternItem = string | FieldPatternElement;
export type FieldPatternItemOrFunction = FieldPatternItem | ((item: FieldMasks) => FieldPatternItem);
export type FieldPatternList = Record<string, FieldPatternItemOrFunction>;
export type FieldMatchItem = {
    name?: string | HTMLInputElement;
    validationMessage?: string;
};
export type FieldMatch = string | HTMLInputElement | FieldMatchItem;
export type FieldCheckMain = {
    group?: string;
    input?: FieldElementDom;
    pattern?: FieldPatternItemOrFunction;
};
export type FieldCheckItem<Value = any> = FieldCheckMain & {
    check(value: Value): FieldValidationItem<Value>;
};
export type FieldCheckList = Record<string, FieldCheckItem>;
export type FieldValidationItem<Value = any> = FieldCheckMain & {
    type?: string;
    status?: boolean;
    required?: boolean;
    isFull?: boolean;
    validationMessage?: string;
    validity?: ValidityState;
    validityMessage?: string;
    value: Value;
    valueInput?: Value;
    detail?: Record<string, any>;
};
export type FieldBasicEmits<T = any> = ModelEmits<T> & {
    input: [event: InputEvent | Event, value: FieldValidationItem<T>];
    inputLite: [value: FieldValidationItem<T>];
    change: [event: InputEvent | Event, value: FieldValidationItem<T>];
    changeLite: [value: FieldValidationItem<T>];
};
export type FieldBasicExpose<T = string> = {
    value: ShallowRef<T | undefined>;
    checkValidity: () => boolean;
    validationMessage: ComputedRef<string>;
};
export type FieldValueProps<Value = any> = ModelProps<Value> & {
    placeholder?: string;
    multiple?: boolean;
    maxlength?: NumberOrString;
    value?: Value;
    detail?: Record<string, any> | undefined;
};
export type FieldBasicProps<Value = any> = Omit<FieldValueProps<Value>, 'multiple' | 'maxlength'> & {
    type?: 'text' | 'search' | 'number' | 'number-format' | 'currency' | 'email' | 'password' | 'datetime' | 'date' | 'year-month' | 'time' | 'hour-minute' | 'tel' | 'url' | 'checkbox' | 'radio';
    name?: string;
    id?: string | number;
    required?: boolean;
    readonly?: boolean;
    disabled?: boolean;
    autofocus?: boolean;
    tabindex?: number;
    form?: string;
    validationCode?: FieldValidityCode;
    validationMessage?: string;
    match?: FieldMatch;
    inputAttrs?: Record<string, any>;
};
export type FieldStepProps = {
    step?: NumberOrString;
    min?: NumberOrString;
    max?: NumberOrString;
};
export type FieldArrowProps = {
    arrow?: 'auto' | 'carousel' | 'stepper' | 'none';
    arrowStep?: NumberOrString;
    arrowAlign?: 'center' | 'right' | 'left';
};
export type FieldLengthProps = {
    minlength?: NumberOrString;
    maxlength?: NumberOrString;
};
export type FieldPatternProps = {
    pattern?: string;
};
export type FieldUxProps = {
    autocomplete?: string;
    autocapitalize?: 'off' | 'none' | 'sentences' | 'words' | 'characters' | string;
    inputMode?: 'none' | 'text' | 'decimal' | 'numeric' | 'tel' | 'search' | 'email' | 'url' | string;
    enterKeyHint?: 'enter' | 'done' | 'go' | 'next' | 'previous' | 'search' | 'send' | string;
    spellcheck?: boolean | 'true' | 'false';
    autocorrect?: 'on' | 'off' | string;
};
export type FieldInputProps<Value = any> = FieldBasicProps<Value> & FieldStepProps & FieldArrowProps & FieldLengthProps & FieldPatternProps & FieldUxProps & {
    list?: string;
    iconVisibility?: string;
    iconVisibilityOff?: string;
};
export type FieldInputFileProps<Value = any> = Omit<FieldBasicProps<Value>, 'type'> & FieldLengthProps & FieldUxProps & {
    multiple?: boolean;
    accept?: string;
    capture?: string | boolean;
};
export type FieldInputCheckProps<Value = boolean> = Omit<FieldBasicProps<Value>, 'type'> & FieldUxProps & {
    valueVariant?: NumberOrStringOrBoolean;
    valueVariantHide?: NumberOrStringOrBoolean;
    indeterminate?: boolean;
};
export type FieldTextareaProps<Value = any> = Omit<FieldBasicProps<Value>, 'type'> & FieldLengthProps & FieldUxProps & {
    rows?: NumberOrString;
    cols?: NumberOrString;
    wrap?: 'soft' | 'hard' | 'off' | string;
    fieldSizing?: 'content' | 'fixed' | string;
};
export type FieldSelectProps<Value = any> = Omit<FieldBasicProps<Value>, 'type'> & Omit<FieldStepProps, 'min' | 'step'> & FieldArrowProps & FieldUxProps & {
    option?: ListRecord;
    multiple?: boolean;
    selectionStyle?: ListItemPropsBasic['selectionStyle'] | 'auto';
};
export type FieldSelectLiteProps<Value = any> = Omit<FieldSelectProps<Value>, 'placeholder' | 'validationMessage' | 'validationCode' | 'arrow' | 'arrowAlign' | 'arrowStep'>;
export type FieldAllProps<Value = any> = FieldInputProps<Value> & FieldInputFileProps<Value> & FieldInputCheckProps<Value> & FieldTextareaProps<Value> & FieldSelectProps<Value>;

// File: src/types/labelTypes.d.ts
export interface LabelSlots {
    default?(props: any): any;
}
export interface LabelAlternativeSlots {
    label?(props: any): any;
}
export interface LabelNumberSlots extends LabelSlots {}
export interface LabelHighlightSlots extends LabelSlots {}
export type LabelProps = {
    label?: NumberOrString;
    labelId?: string;
};
export type LabelNumberProps = LabelProps & {
    labelMax?: NumberOrString;
    formatting?: boolean;
};
export type LabelHighlightProps = LabelProps & {
    highlight?: string;
    highlightLengthStart?: number;
    value?: any;
};

// File: src/types/modelTypes.d.ts
export type ModelEmits<Value = string> = {
    'update:value': [value: Value];
    'update:modelValue': [value: Value];
};
export type ModelEmitsOpen<Value = boolean> = {
    'update:open': [value: Value];
    'update:modelOpen': [value: Value];
};
export type ModelEmitsSelected<Value = string> = {
    'update:selected': [value: Value];
    'update:modelSelected': [value: Value];
};
export type ModelProps<Value = string> = {
    'modelValue'?: Value;
    'onUpdate:value'?: (value: Value) => void;
    'onUpdate:modelValue'?: (value: Value) => void;
};
export type ModelPropsOpen<Value = boolean> = {
    'modelOpen'?: Value;
    'onUpdate:open'?: (value: Value) => void;
    'onUpdate:modelOpen'?: (value: Value) => void;
};
export type ModelPropsSelected<Value = string> = {
    'modelSelected'?: Value;
    'onUpdate:selected'?: (value: Value) => void;
    'onUpdate:modelSelected'?: (value: Value) => void;
};

// File: src/types/pluginTypes.d.ts
export type PluginComponentItem = {
    name: string;
    reg: RegExp;
};
export type PluginComponentList = Record<string, PluginComponentItem>;
export type PluginComponentImports = PluginComponentItem[];
export type PluginOptions = {
    style?: boolean;
    styleNamespace?: string;
    component?: boolean;
    viteOptions?: VitePlugin;
};

// File: src/types/prefixTypes.d.ts
export interface PrefixSlots {
    prefix?(props: any): any;
}
export type PrefixProps = {
    prefix?: string | number;
    prefixId?: string;
};

// File: src/types/roleTypes.d.ts
export type RoleType = string | 'alert' | 'alertdialog' | 'application' | 'article' | 'banner' | 'button' | 'cell' | 'checkbox' | 'columnheader' | 'combobox' | 'command' | 'comment' | 'complementary' | 'composite' | 'contentinfo' | 'definition' | 'dialog' | 'directory' | 'document' | 'feed' | 'figure' | 'form' | 'generic' | 'grid' | 'gridcell' | 'group' | 'heading' | 'img' | 'input' | 'landmark' | 'link' | 'list' | 'listbox' | 'listitem' | 'log' | 'main' | 'mark' | 'marquee' | 'math' | 'menu' | 'menubar' | 'menuitem' | 'menuitemcheckbox' | 'menuitemradio' | 'meter' | 'navigation' | 'none' | 'note' | 'option' | 'presentation' | 'progressbar' | 'radio' | 'radiogroup' | 'range' | 'region' | 'roletype' | 'row' | 'rowgroup' | 'rowheader' | 'scrollbar' | 'search' | 'searchbox' | 'section' | 'sectionhead' | 'select' | 'separator' | 'slider' | 'spinbutton' | 'status' | 'structure' | 'suggestion' | 'switch' | 'tab' | 'table' | 'tablist' | 'tabpanel' | 'term' | 'textbox' | 'timer' | 'toolbar' | 'tooltip' | 'tree' | 'treegrid' | 'treeitem' | 'widget' | 'window';

// File: src/types/suffixTypes.d.ts
export interface SuffixSlots {
    suffix?(props: any): any;
}
export type SuffixProps = {
    suffix?: string | number;
    suffixId?: string;
};

// File: src/types/textTypes.d.ts
export type TextValue = string | (() => string) | undefined;
export type TextIndex = 'cancel' | 'characterLimit' | 'characterRemaining' | 'close' | 'copiedClipboard' | 'decrement' | 'entriesMatch' | 'hide' | 'increment' | 'loading' | 'next' | 'notFound' | 'notifications' | 'ok' | 'previous' | 'show' | string;
export type TextList = Record<TextIndex, TextValue>;
export type TextCancelPropsInclude = {
    textCancel?: TextValue;
};
export type TextCharacterLimitPropsInclude = {
    textCharacterLimit?: TextValue;
};
export type TextCharacterRemainingPropsInclude = {
    textCharacterRemaining?: TextValue;
};
export type TextClosePropsInclude = {
    textClose?: TextValue;
};
export type TextCopiedClipboardPropsInclude = {
    textCopiedClipboard?: TextValue;
};
export type TextDecrementPropsInclude = {
    textDecrement?: TextValue;
};
export type TextEntriesMatchPropsInclude = {
    textEntriesMatch?: TextValue;
};
export type TextHidePropsInclude = {
    textHide?: TextValue;
};
export type TextIncrementPropsInclude = {
    textIncrement?: TextValue;
};
export type TextLoadingPropsInclude = {
    textLoading?: TextValue;
};
export type TextNextPropsInclude = {
    textNext?: TextValue;
};
export type TextNotFoundPropsInclude = {
    textNotFound?: TextValue;
};
export type TextNotificationsPropsInclude = {
    textNotifications?: TextValue;
};
export type TextOkPropsInclude = {
    textOk?: TextValue;
};
export type TextPreviousPropsInclude = {
    textPrevious?: TextValue;
};
export type TextShowPropsInclude = {
    textShow?: TextValue;
};
export type TextAllPropsInclude = TextCancelPropsInclude & TextCharacterLimitPropsInclude & TextCharacterRemainingPropsInclude & TextClosePropsInclude & TextCopiedClipboardPropsInclude & TextDecrementPropsInclude & TextEntriesMatchPropsInclude & TextHidePropsInclude & TextIncrementPropsInclude & TextLoadingPropsInclude & TextNextPropsInclude & TextNotFoundPropsInclude & TextNotificationsPropsInclude & TextOkPropsInclude & TextPreviousPropsInclude & TextShowPropsInclude;

// File: src/types/touchEventTypes.d.ts
export type TouchEventTypeX = 'left' | 'right' | 'none';
export type TouchEventTypeY = 'top' | 'bottom' | 'none';
export type TouchEventClient = {
    x: number;
    y: number;
};
export type TouchEventCallback = (typeX: TouchEventTypeX, typeY: TouchEventTypeY, clientX: number, clientY: number, mouse?: TouchEventClient, mouseMove?: TouchEventClient, touche?: Touch, toucheMove?: Touch) => Promise<boolean> | boolean;