## API Report File for "@jsplumb/browser-ui"

> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).

```ts

import { AbstractConnector } from '@jsplumb/core';
import { BehaviouralTypeDescriptor } from '@jsplumb/core';
import { BoundingBox } from '@jsplumb/util';
import { Component } from '@jsplumb/core';
import { Connection } from '@jsplumb/core';
import { ConnectionDragSelector } from '@jsplumb/core';
import { DeleteConnectionOptions } from '@jsplumb/core';
import { Endpoint } from '@jsplumb/core';
import { Extents } from '@jsplumb/util';
import { Grid } from '@jsplumb/util';
import { JsPlumbDefaults } from '@jsplumb/core';
import { jsPlumbElement } from '@jsplumb/core';
import { JsPlumbInstance } from '@jsplumb/core';
import { LabelOverlay } from '@jsplumb/core';
import { ManagedElement } from '@jsplumb/core';
import { Overlay } from '@jsplumb/core';
import { PaintStyle } from '@jsplumb/common';
import { PointXY } from '@jsplumb/util';
import { RedrawResult } from '@jsplumb/core';
import { Size } from '@jsplumb/util';
import { TypeDescriptor } from '@jsplumb/core';
import { UIGroup } from '@jsplumb/core';

// @public (undocumented)
export function addClass(el: Element | NodeListOf<Element>, clazz: string): void;

// @public (undocumented)
export const ATTRIBUTE_CONTAINER = "data-jtk-container";

// @public (undocumented)
export const ATTRIBUTE_GROUP_CONTENT = "data-jtk-group-content";

// @public (undocumented)
export const ATTRIBUTE_JTK_ENABLED = "data-jtk-enabled";

// @public (undocumented)
export const ATTRIBUTE_JTK_SCOPE = "data-jtk-scope";

// @public (undocumented)
export interface BeforeStartEventParams extends DragStartEventParams {
}

// @public
export interface BrowserJsPlumbDefaults extends JsPlumbDefaults<Element> {
    dragOptions?: DragOptions;
    elementsDraggable?: boolean;
    managedElementsSelector?: string;
    resizeObserver?: boolean;
}

// @public
export class BrowserJsPlumbInstance extends JsPlumbInstance<{
    E: Element;
}> {
    constructor(_instanceIndex: number, defaults?: BrowserJsPlumbDefaults);
    addClass(el: Element | NodeListOf<Element>, clazz: string): void;
    // @internal (undocumented)
    addConnectorClass(connector: AbstractConnector, clazz: string): void;
    addDragFilter(filter: Function | string, exclude?: boolean): void;
    // @internal (undocumented)
    addEndpointClass(ep: Endpoint, c: string): void;
    // @internal (undocumented)
    addOverlayClass(o: Overlay, clazz: string): void;
    addSourceSelector(selector: string, params?: BehaviouralTypeDescriptor, exclude?: boolean): ConnectionDragSelector;
    addToDragGroup(spec: DragGroupSpec, ...els: Array<Element>): void;
    addToDragSelection(...el: Array<Element>): void;
    // @internal (undocumented)
    _appendElement(el: Element, parent: Element): void;
    // @internal (undocumented)
    _appendElementToContainer(el: Element): void;
    // @internal (undocumented)
    _appendElementToGroup(group: UIGroup<any>, el: Element): void;
    // @internal (undocumented)
    applyConnectorType(connector: AbstractConnector, t: TypeDescriptor): void;
    // @internal (undocumented)
    applyEndpointType<C>(ep: Endpoint, t: TypeDescriptor): void;
    clearDragGroup(name: string): void;
    clearDragSelection(): void;
    // (undocumented)
    _connectorClick: Function;
    // (undocumented)
    _connectorContextmenu: Function;
    // (undocumented)
    _connectorDblClick: Function;
    // (undocumented)
    _connectorDblTap: Function;
    // (undocumented)
    _connectorMousedown: Function;
    // (undocumented)
    _connectorMouseout: Function;
    // (undocumented)
    _connectorMouseover: Function;
    // (undocumented)
    _connectorMouseup: Function;
    // (undocumented)
    _connectorTap: Function;
    consume(e: Event, doNotPreventDefault?: boolean): void;
    // (undocumented)
    containerType: ElementType;
    // @internal (undocumented)
    deleteConnection(connection: Connection, params?: DeleteConnectionOptions): boolean;
    destroy(): void;
    // @internal (undocumented)
    destroyConnector(connection: Connection): void;
    // @internal (undocumented)
    destroyEndpoint(ep: Endpoint): void;
    // @internal (undocumented)
    destroyOverlay(o: Overlay): void;
    // (undocumented)
    draggingClass: string;
    // (undocumented)
    dragManager: DragManager;
    // (undocumented)
    dragSelectClass: string;
    // @internal (undocumented)
    drawOverlay(o: Overlay, component: any, paintStyle: PaintStyle, absolutePosition?: PointXY): any;
    // (undocumented)
    _elementClick: Function;
    // (undocumented)
    _elementContextmenu: Function;
    // (undocumented)
    _elementDblTap: Function;
    // (undocumented)
    elementDraggingClass: string;
    // (undocumented)
    _elementMousedown: Function;
    // (undocumented)
    _elementMouseenter: Function;
    // (undocumented)
    _elementMouseexit: Function;
    // (undocumented)
    _elementMousemove: Function;
    // (undocumented)
    _elementMouseup: Function;
    elementsDraggable: boolean;
    // (undocumented)
    _elementTap: Function;
    // (undocumented)
    _endpointClick: Function;
    // (undocumented)
    _endpointDblClick: Function;
    // (undocumented)
    _endpointMousedown: Function;
    // (undocumented)
    _endpointMouseout: Function;
    // (undocumented)
    _endpointMouseover: Function;
    // (undocumented)
    _endpointMouseup: Function;
    // (undocumented)
    eventManager: EventManager;
    // @internal (undocumented)
    _getAssociatedElements(el: Element): Array<Element>;
    getAttribute(el: Element, name: string): string;
    getClass(el: Element): string;
    // @internal (undocumented)
    getConnectorClass(connector: AbstractConnector): string;
    // @internal (undocumented)
    getEndpointClass(ep: Endpoint): string;
    // @internal
    getGroupContentArea(group: UIGroup<any>): Element;
    // @internal
    getOffset(el: Element): PointXY;
    // @internal
    getOffsetRelativeToRoot(el: Element): PointXY;
    getPosition(el: Element): PointXY;
    // @internal
    getSelector(ctx: string | Element, spec?: string): ArrayLike<jsPlumbDOMElement>;
    // @internal
    getSize(el: Element): Size;
    // @internal
    getStyle(el: Element, prop: string): any;
    hasClass(el: Element, clazz: string): boolean;
    // (undocumented)
    hoverClass: string;
    // (undocumented)
    hoverSourceClass: string;
    // (undocumented)
    hoverTargetClass: string;
    // (undocumented)
    _instanceIndex: number;
    isDraggable(el: Element): boolean;
    manage(element: Element, internalId?: string, _recalc?: boolean): ManagedElement<Element>;
    // (undocumented)
    managedElementsSelector: string;
    off(el: Document | Element | NodeListOf<Element>, event: string, callback: Function): this;
    on(el: Document | Element | NodeListOf<Element>, event: string, callbackOrSelector: Function | string, callback?: Function): this;
    // (undocumented)
    _overlayClick: Function;
    // (undocumented)
    _overlayDblClick: Function;
    // (undocumented)
    _overlayDblTap: Function;
    // (undocumented)
    _overlayMouseout: Function;
    // (undocumented)
    _overlayMouseover: Function;
    // (undocumented)
    _overlayTap: Function;
    // @internal (undocumented)
    paintConnector(connector: AbstractConnector, paintStyle: PaintStyle, extents?: Extents): void;
    // @internal (undocumented)
    _paintOverlay(o: Overlay, params: any, extents: any): void;
    // @internal (undocumented)
    reattachOverlay(o: Overlay, c: Component): void;
    removeAttribute(el: Element, attName: string): void;
    removeClass(el: Element | NodeListOf<Element>, clazz: string): void;
    // @internal (undocumented)
    removeConnectorClass(connector: AbstractConnector, clazz: string): void;
    removeDragFilter(filter: Function | string): void;
    // @internal (undocumented)
    _removeElement(element: Element): void;
    // @internal (undocumented)
    removeEndpointClass(ep: Endpoint, c: string): void;
    removeFromDragGroup(...els: Array<Element>): void;
    removeFromDragSelection(...el: Array<Element>): void;
    // @internal (undocumented)
    removeOverlayClass(o: Overlay, clazz: string): void;
    removeSourceSelector(selector: ConnectionDragSelector): void;
    // @internal (undocumented)
    renderEndpoint(ep: Endpoint, paintStyle: PaintStyle): void;
    reset(): void;
    rotate(element: Element, rotation: number, doNotRepaint?: boolean): RedrawResult;
    setAttribute(el: Element, name: string, value: string): void;
    setAttributes(el: Element, atts: Record<string, string>): void;
    // @internal (undocumented)
    setConnectorHover(connector: AbstractConnector, hover: boolean, sourceEndpoint?: Endpoint): void;
    // @internal (undocumented)
    setConnectorVisible(connector: AbstractConnector, v: boolean): void;
    setContainer(newContainer: Element): void;
    setDragConstrainFunction(constrainFunction: ConstrainFunction): void;
    setDraggable(element: Element, draggable: boolean): void;
    setDragGrid(grid: Grid): void;
    setDragGroupState(state: boolean, ...els: Array<Element>): void;
    // @internal (undocumented)
    setEndpointHover(endpoint: Endpoint, hover: boolean, endpointIndex: -1 | 0 | 1, doNotCascade?: boolean): void;
    // @internal (undocumented)
    setEndpointVisible(ep: Endpoint, v: boolean): void;
    // @internal (undocumented)
    setGroupVisible(group: UIGroup<Element>, state: boolean): void;
    // @internal (undocumented)
    setHover(component: Component, hover: boolean): void;
    // @internal (undocumented)
    setOverlayHover(o: Overlay, hover: boolean): void;
    setOverlayVisible(o: Overlay, visible: boolean): void;
    // @internal
    setPosition(el: Element, p: PointXY): void;
    // (undocumented)
    shouldFireEvent(event: string, value: any, originalEvent?: Event): boolean;
    // (undocumented)
    sourceElementDraggingClass: string;
    // (undocumented)
    svg: {
        node: (name: string, attributes?: ElementAttributes) => SVGElement;
        attr: (node: SVGElement, attributes: ElementAttributes) => void;
        pos: (d: [number, number]) => string;
    };
    // (undocumented)
    targetElementDraggingClass: string;
    toggleClass(el: Element | NodeListOf<Element>, clazz: string): void;
    // (undocumented)
    toggleDraggable(el: Element): boolean;
    toggleDragSelection(...el: Array<Element>): void;
    trigger(el: Document | Element, event: string, originalEvent?: Event, payload?: any, detail?: number): void;
    unmanage(el: Element, removeElement?: boolean): void;
    // @internal (undocumented)
    updateLabel(o: LabelOverlay): void;
}

// @public (undocumented)
export const CLASS_DELEGATED_DRAGGABLE = "jtk-delegated-draggable";

// @public (undocumented)
export const CLASS_DRAG_ACTIVE = "jtk-drag-active";

// @public (undocumented)
export const CLASS_DRAG_CONTAINER = "jtk-drag";

// @public (undocumented)
export const CLASS_DRAG_HOVER = "jtk-drag-hover";

// @public (undocumented)
export const CLASS_DRAGGABLE = "jtk-draggable";

// @public (undocumented)
export const CLASS_DRAGGED = "jtk-dragged";

// @public (undocumented)
export const CLASS_GHOST_PROXY = "jtk-ghost-proxy";

// @public (undocumented)
export class Collicat implements jsPlumbDragManager {
    constructor(options?: CollicatOptions);
    // (undocumented)
    css: Record<string, string>;
    // (undocumented)
    destroyDraggable(el: jsPlumbDOMElement): void;
    // (undocumented)
    draggable(el: jsPlumbDOMElement, params: DragParams): Drag;
    // (undocumented)
    eventManager: EventManager;
    getInputFilterSelector(): string;
    // (undocumented)
    getPosition(el: Element): PointXY;
    // (undocumented)
    getSize(el: Element): Size;
    // (undocumented)
    getZoom(): number;
    // (undocumented)
    inputFilterSelector: string;
    // (undocumented)
    _positionGetter: GetPositionFunction;
    // (undocumented)
    positioningStrategy: PositioningStrategy;
    // (undocumented)
    _positionSetter: SetPositionFunction;
    setInputFilterSelector(selector: string): this;
    // (undocumented)
    setPosition(el: Element, p: PointXY): void;
    // (undocumented)
    setZoom(z: number): void;
    // (undocumented)
    _sizeGetter: GetSizeFunction;
    // (undocumented)
    _sizeSetter: SetSizeFunction;
}

// @public (undocumented)
export interface CollicatOptions {
    // (undocumented)
    css?: Record<string, string>;
    // (undocumented)
    inputFilterSelector?: string;
    // (undocumented)
    positioningStrategy?: PositioningStrategy;
    // (undocumented)
    zoom?: number;
}

// @public (undocumented)
export function compoundEvent(stem: string, event: string, subevent?: string): string;

// @public (undocumented)
export const CONNECTION = "connection";

// @public
export type ConstrainFunction = (desiredLoc: PointXY, dragEl: HTMLElement, constrainRect: Size, size: Size, e: MouseEvent) => PointXY;

// @public
export function consume(e: Event, doNotPreventDefault?: boolean): void;

// @public (undocumented)
export enum ContainmentType {
    // (undocumented)
    notNegative = "notNegative",
    // (undocumented)
    parent = "parent",
    // (undocumented)
    parentEnclosed = "parentEnclosed"
}

// @public (undocumented)
export function createElement(tag: string, style?: Record<string, any>, clazz?: string, atts?: Record<string, string>): jsPlumbDOMElement;

// @public (undocumented)
export function createElementNS(ns: string, tag: string, style?: Record<string, any>, clazz?: string, atts?: Record<string, string | number>): jsPlumbDOMElement;

// Warning: (ae-forgotten-export) The symbol "Base" needs to be exported by the entry point index.d.ts
//
// @public (undocumented)
export class Drag extends Base {
    constructor(el: jsPlumbDOMElement, params: DragParams, manager: Collicat);
    // (undocumented)
    abort(): void;
    // (undocumented)
    _activeSelectorParams: DragParams;
    // (undocumented)
    addFilter(f: Function | string, _exclude?: boolean): void;
    // (undocumented)
    addSelector(params: DragHandlerOptions, atStart?: boolean): void;
    // (undocumented)
    _availableSelectors: Array<DragParams>;
    // (undocumented)
    _canDrag: Function;
    // (undocumented)
    _class: string;
    // (undocumented)
    clearAllFilters(): void;
    // (undocumented)
    clone: boolean;
    // (undocumented)
    _constrainRect: {
        w: number;
        h: number;
    };
    // (undocumented)
    consumeStartEvent: boolean;
    // (undocumented)
    destroy(): void;
    // (undocumented)
    downListener: (e: MouseEvent) => void;
    // (undocumented)
    _elementToDrag: jsPlumbDOMElement;
    // (undocumented)
    _filters: Record<string, [Function, boolean]>;
    // @internal
    getDragDelta(): PointXY;
    // (undocumented)
    getDragElement(retrieveOriginalElement?: boolean): jsPlumbDOMElement;
    // (undocumented)
    _ghostProxyFunction: GhostProxyGenerator;
    // (undocumented)
    _ghostProxyParent: jsPlumbDOMElement;
    // (undocumented)
    _isConstrained: boolean;
    // (undocumented)
    listeners: Record<string, Array<Function>>;
    // (undocumented)
    moveBy(dx: number, dy: number, e?: MouseEvent): void;
    // (undocumented)
    moveListener: (e: MouseEvent) => void;
    // (undocumented)
    off(evt: string, fn: Function): void;
    // (undocumented)
    on(evt: string, fn: Function): void;
    // (undocumented)
    removeFilter(f: Function | string): void;
    // (undocumented)
    rightButtonCanDrag: boolean;
    // (undocumented)
    scroll: boolean;
    // (undocumented)
    scrollTracker: (e: Event) => void;
    // (undocumented)
    setUseGhostProxy(val: boolean): void;
    // (undocumented)
    _size: Size;
    // (undocumented)
    stop(e?: MouseEvent, force?: boolean): void;
    // (undocumented)
    _testFilter(e: any): boolean;
    // (undocumented)
    trackScroll: boolean;
    // (undocumented)
    upListener: (e?: MouseEvent) => void;
    // (undocumented)
    _useGhostProxy: Function;
}

// @public (undocumented)
export interface DragEventParams extends DragStartEventParams {
    // (undocumented)
    originalPos: PointXY;
}

// @public (undocumented)
export type DraggedElement = {
    el: jsPlumbDOMElement;
    id: string;
    pos: PointXY;
    originalPos: PointXY;
    originalGroup: UIGroup;
    redrawResult: RedrawResult;
    reverted: boolean;
    dropGroup: UIGroup;
};

// @public
export type DragGroupSpec = string | {
    id: string;
    active: boolean;
};

// @public (undocumented)
export interface DragHandler {
    // (undocumented)
    init: (drag: Drag) => void;
    // (undocumented)
    onBeforeStart?: (beforeStartParams: BeforeStartEventParams) => void;
    // (undocumented)
    onDrag: (params: DragEventParams) => void;
    // (undocumented)
    onDragAbort: (el: Element) => void;
    // (undocumented)
    onDragInit: (el: Element, e: MouseEvent) => Element;
    // (undocumented)
    onStart: (params: DragStartEventParams) => boolean;
    // (undocumented)
    onStop: (params: DragStopEventParams) => void;
    // (undocumented)
    reset: () => void;
    // (undocumented)
    selector: string;
}

// @public (undocumented)
export interface DragHandlerOptions {
    // (undocumented)
    beforeStart?: (beforeStartParams: BeforeStartEventParams) => void;
    // (undocumented)
    constrainFunction?: ConstrainFunction | boolean;
    // (undocumented)
    containment?: ContainmentType;
    // (undocumented)
    containmentPadding?: number;
    // (undocumented)
    drag?: (p: DragEventParams) => any;
    // (undocumented)
    dragAbort?: (el: Element) => any;
    // (undocumented)
    dragInit?: (el: Element, e: MouseEvent) => any;
    // (undocumented)
    filter?: string;
    // (undocumented)
    filterExclude?: boolean;
    // (undocumented)
    ghostProxy?: GhostProxyGenerator | boolean;
    // (undocumented)
    ghostProxyParent?: Element;
    // (undocumented)
    grid?: Grid;
    // (undocumented)
    makeGhostProxy?: GhostProxyGenerator;
    // (undocumented)
    revertFunction?: RevertFunction;
    // (undocumented)
    selector?: string;
    // (undocumented)
    snapThreshold?: number;
    // (undocumented)
    start?: (p: DragStartEventParams) => any;
    // (undocumented)
    stop?: (p: DragStopEventParams) => any;
    // (undocumented)
    useGhostProxy?: (container: any, dragEl: jsPlumbDOMElement) => boolean;
}

// @public (undocumented)
export class DragManager {
    constructor(instance: BrowserJsPlumbInstance, dragSelection: DragSelection, options?: DragManagerOptions);
    // (undocumented)
    addFilter(filter: Function | string, exclude?: boolean): void;
    // (undocumented)
    addHandler(handler: DragHandler, dragOptions?: DragHandlerOptions): void;
    // (undocumented)
    addSelector(params: DragHandlerOptions, atStart?: boolean): void;
    // (undocumented)
    _dlist: Array<any>;
    // (undocumented)
    _draggables: Record<string, any>;
    // (undocumented)
    _draggablesForElements: Record<string, any>;
    // Warning: (ae-forgotten-export) The symbol "DragSelection" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    protected dragSelection: DragSelection;
    // (undocumented)
    _elementsWithEndpoints: Record<string, any>;
    // (undocumented)
    handlers: Array<{
        handler: DragHandler;
        options: DragHandlerOptions;
    }>;
    // (undocumented)
    protected instance: BrowserJsPlumbInstance;
    // (undocumented)
    removeFilter(filter: Function | string): void;
    // (undocumented)
    reset(): Array<[string, boolean]>;
    // (undocumented)
    setFilters(filters: Array<[string, boolean]>): void;
    // (undocumented)
    setOption(handler: DragHandler, options: DragHandlerOptions): void;
}

// @public (undocumented)
export interface DragManagerOptions {
    // (undocumented)
    trackScroll?: boolean;
}

// @public
export interface DragMovePayload extends DragPayload {
}

// @public (undocumented)
export interface DragOptions {
    // (undocumented)
    beforeStart?: (params: BeforeStartEventParams) => void;
    // (undocumented)
    containment?: ContainmentType;
    // (undocumented)
    cursor?: string;
    // (undocumented)
    drag?: (params: DragEventParams) => void;
    // (undocumented)
    filter?: string;
    // (undocumented)
    grid?: Grid;
    // (undocumented)
    start?: (params: DragStartEventParams) => void;
    // (undocumented)
    stop?: (params: DragStopEventParams) => void;
    // (undocumented)
    trackScroll?: boolean;
    // (undocumented)
    zIndex?: number;
}

// @public (undocumented)
export interface DragParams extends DragHandlerOptions {
    // (undocumented)
    canDrag?: Function;
    // (undocumented)
    clone?: boolean;
    // (undocumented)
    consumeFilteredEvents?: boolean;
    // (undocumented)
    consumeStartEvent?: boolean;
    // (undocumented)
    events?: Record<string, Function>;
    // (undocumented)
    ignoreZoom?: boolean;
    // (undocumented)
    multipleDrop?: boolean;
    // (undocumented)
    parent?: any;
    // (undocumented)
    rightButtonCanDrag?: boolean;
    // (undocumented)
    scope?: string;
    // (undocumented)
    scroll?: boolean;
    // (undocumented)
    trackScroll?: boolean;
}

// @public
export interface DragPayload {
    // (undocumented)
    e: Event;
    // (undocumented)
    el: Element;
    // (undocumented)
    originalPosition: PointXY;
    // (undocumented)
    payload?: Record<string, any>;
    // (undocumented)
    pos: PointXY;
}

// @public (undocumented)
export interface DragStartEventParams {
    // (undocumented)
    drag: Drag;
    // (undocumented)
    e: MouseEvent;
    // (undocumented)
    el: jsPlumbDOMElement;
    // (undocumented)
    pos: PointXY;
    // (undocumented)
    size: Size;
}

// @public
export interface DragStartPayload extends DragPayload {
    // Warning: (ae-forgotten-export) The symbol "DragGroup" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    dragGroup?: DragGroup;
    // Warning: (ae-forgotten-export) The symbol "DragGroupMemberSpec" needs to be exported by the entry point index.d.ts
    //
    // (undocumented)
    dragGroupMemberSpec?: DragGroupMemberSpec;
}

// @public (undocumented)
export interface DragStopEventParams extends DragEventParams {
    // (undocumented)
    finalPos: PointXY;
    // (undocumented)
    selection: Array<[jsPlumbDOMElement, PointXY, Drag, Size]>;
}

// @public
export interface DragStopPayload {
    // (undocumented)
    e: Event;
    // (undocumented)
    el: Element;
    // (undocumented)
    elements: Array<DraggedElement>;
    // (undocumented)
    payload?: Record<string, any>;
}

// @public (undocumented)
export const ELEMENT = "element";

// @public (undocumented)
export const ELEMENT_DIV = "div";

// @public (undocumented)
export class ElementDragHandler implements DragHandler {
    constructor(instance: BrowserJsPlumbInstance, _dragSelection: DragSelection);
    // @internal (undocumented)
    addToDragGroup(spec: DragGroupSpec, ...els: Array<Element>): void;
    // @internal (undocumented)
    clearDragGroup(name: string): void;
    // (undocumented)
    protected drag: Drag;
    // (undocumented)
    protected _dragSelection: DragSelection;
    // (undocumented)
    protected getDropGroup(): IntersectingGroup | null;
    // (undocumented)
    init(drag: Drag): void;
    // (undocumented)
    protected instance: BrowserJsPlumbInstance;
    // (undocumented)
    protected _intersectingGroups: Array<IntersectingGroup>;
    // (undocumented)
    onDrag(params: DragEventParams): void;
    // (undocumented)
    onDragAbort(el: Element): void;
    // (undocumented)
    onDragInit(el: Element): Element;
    // (undocumented)
    onStart(params: {
        e: MouseEvent;
        el: jsPlumbDOMElement;
        pos: PointXY;
        drag: Drag;
    }): boolean;
    // (undocumented)
    onStop(params: DragStopEventParams): void;
    // (undocumented)
    originalPosition: PointXY;
    // @internal (undocumented)
    removeFromDragGroup(...els: Array<Element>): void;
    // (undocumented)
    reset(): void;
    // (undocumented)
    selector: string;
    // @internal (undocumented)
    setDragGroupState(active: boolean, ...els: Array<Element>): void;
}

// @public (undocumented)
export type ElementType = keyof typeof ElementTypes;

// @public (undocumented)
export enum ElementTypes {
    // (undocumented)
    HTML = "HTML",
    // (undocumented)
    SVG = "SVG"
}

// @public (undocumented)
export const ENDPOINT = "endpoint";

// @public (undocumented)
export type EndpointHelperFunctions<E> = {
    makeNode: (ep: E, paintStyle: PaintStyle) => void;
    updateNode: (ep: E, node: SVGElement) => void;
};

// @public (undocumented)
export const EVENT_BEFORE_START = "beforeStart";

// @public (undocumented)
export const EVENT_CLICK = "click";

// @public (undocumented)
export const EVENT_CONNECTION_ABORT = "connection:abort";

// @public (undocumented)
export const EVENT_CONNECTION_CLICK: string;

// @public (undocumented)
export const EVENT_CONNECTION_CONTEXTMENU: string;

// @public (undocumented)
export const EVENT_CONNECTION_DBL_CLICK: string;

// @public (undocumented)
export const EVENT_CONNECTION_DBL_TAP: string;

// @public (undocumented)
export const EVENT_CONNECTION_DRAG = "connection:drag";

// @public (undocumented)
export const EVENT_CONNECTION_MOUSEDOWN: string;

// @public (undocumented)
export const EVENT_CONNECTION_MOUSEOUT: string;

// @public (undocumented)
export const EVENT_CONNECTION_MOUSEOVER: string;

// @public (undocumented)
export const EVENT_CONNECTION_MOUSEUP: string;

// @public (undocumented)
export const EVENT_CONNECTION_TAP: string;

// @public (undocumented)
export const EVENT_CONTEXTMENU = "contextmenu";

// @public (undocumented)
export const EVENT_DBL_CLICK = "dblclick";

// @public (undocumented)
export const EVENT_DBL_TAP = "dbltap";

// @public (undocumented)
export const EVENT_DRAG = "drag";

// @public (undocumented)
export const EVENT_DRAG_MOVE = "drag:move";

// @public (undocumented)
export const EVENT_DRAG_START = "drag:start";

// @public (undocumented)
export const EVENT_DRAG_STOP = "drag:stop";

// @public (undocumented)
export const EVENT_DROP = "drop";

// @public (undocumented)
export const EVENT_ELEMENT_CLICK: string;

// @public (undocumented)
export const EVENT_ELEMENT_CONTEXTMENU: string;

// @public (undocumented)
export const EVENT_ELEMENT_DBL_CLICK: string;

// @public (undocumented)
export const EVENT_ELEMENT_DBL_TAP: string;

// @public (undocumented)
export const EVENT_ELEMENT_MOUSE_DOWN: string;

// @public (undocumented)
export const EVENT_ELEMENT_MOUSE_MOVE: string;

// @public (undocumented)
export const EVENT_ELEMENT_MOUSE_OUT: string;

// @public (undocumented)
export const EVENT_ELEMENT_MOUSE_OVER: string;

// @public (undocumented)
export const EVENT_ELEMENT_MOUSE_UP: string;

// @public (undocumented)
export const EVENT_ELEMENT_TAP: string;

// @public (undocumented)
export const EVENT_ENDPOINT_CLICK: string;

// @public (undocumented)
export const EVENT_ENDPOINT_DBL_CLICK: string;

// @public (undocumented)
export const EVENT_ENDPOINT_DBL_TAP: string;

// @public (undocumented)
export const EVENT_ENDPOINT_MOUSEDOWN: string;

// @public (undocumented)
export const EVENT_ENDPOINT_MOUSEOUT: string;

// @public (undocumented)
export const EVENT_ENDPOINT_MOUSEOVER: string;

// @public (undocumented)
export const EVENT_ENDPOINT_MOUSEUP: string;

// @public (undocumented)
export const EVENT_ENDPOINT_TAP: string;

// @public (undocumented)
export const EVENT_FOCUS = "focus";

// @public (undocumented)
export const EVENT_MOUSEDOWN = "mousedown";

// @public (undocumented)
export const EVENT_MOUSEENTER = "mouseenter";

// @public (undocumented)
export const EVENT_MOUSEEXIT = "mouseexit";

// @public (undocumented)
export const EVENT_MOUSEMOVE = "mousemove";

// @public (undocumented)
export const EVENT_MOUSEOUT = "mouseout";

// @public (undocumented)
export const EVENT_MOUSEOVER = "mouseover";

// @public (undocumented)
export const EVENT_MOUSEUP = "mouseup";

// @public (undocumented)
export const EVENT_OUT = "out";

// @public (undocumented)
export const EVENT_OVER = "over";

// @public (undocumented)
export const EVENT_REVERT = "revert";

// @public (undocumented)
export const EVENT_START = "start";

// @public (undocumented)
export const EVENT_STOP = "stop";

// @public (undocumented)
export const EVENT_TAP = "tap";

// @public (undocumented)
export const EVENT_TOUCHEND = "touchend";

// @public (undocumented)
export const EVENT_TOUCHMOVE = "touchmove";

// @public (undocumented)
export const EVENT_TOUCHSTART = "touchstart";

// @public (undocumented)
export class EventManager {
    // Warning: (ae-forgotten-export) The symbol "EventManagerOptions" needs to be exported by the entry point index.d.ts
    constructor(params?: EventManagerOptions);
    // (undocumented)
    clickThreshold: number;
    // (undocumented)
    dblClickThreshold: number;
    // (undocumented)
    off(el: any, event: string, fn: any): this;
    // (undocumented)
    on(el: any, event: string, children?: string | Function, fn?: Function, options?: {
        passive?: boolean;
        capture?: boolean;
        once?: boolean;
    }): this;
    // (undocumented)
    trigger(el: any, event: string, originalEvent: any, payload?: any, detail?: number): this;
}

// @public (undocumented)
export function findParent(el: jsPlumbDOMElement, selector: string, container: Element, matchOnElementAlso: boolean): jsPlumbDOMElement;

// @public (undocumented)
export function getClass(el: Element): string;

// Warning: (ae-internal-missing-underscore) The name "getElementPosition" should be prefixed with an underscore because the declaration is marked as @internal
//
// @internal
export function getElementPosition(el: Element, instance: BrowserJsPlumbInstance): {
    x: number;
    y: number;
};

// Warning: (ae-internal-missing-underscore) The name "getElementSize" should be prefixed with an underscore because the declaration is marked as @internal
//
// @internal
export function getElementSize(el: Element, instance: BrowserJsPlumbInstance): Size;

// @public (undocumented)
export function getElementType(el: Element): ElementType;

// @public (undocumented)
export function getEventSource(e: Event): jsPlumbDOMElement;

// @public
export function getPageLocation(e: any): PointXY;

// @public (undocumented)
export type GetPositionFunction = (el: Element) => PointXY;

// Warning: (ae-internal-missing-underscore) The name "getPositionOnElement" should be prefixed with an underscore because the declaration is marked as @internal
//
// @internal (undocumented)
export function getPositionOnElement(evt: Event, el: Element, zoom: number): PointXY;

// @public (undocumented)
export type GetSizeFunction = (el: Element) => Size;

// @public (undocumented)
export function getTouch(touches: TouchList, idx: number): Touch;

// @public (undocumented)
export type GhostProxyGenerator = (el: Element) => Element;

// @public (undocumented)
export interface GhostProxyingDragHandler extends DragHandler {
    // (undocumented)
    makeGhostProxy?: GhostProxyGenerator;
    // (undocumented)
    useGhostProxy: (container: any, dragEl: Element) => boolean;
}

// Warning: (ae-internal-missing-underscore) The name "groupDragConstrain" should be prefixed with an underscore because the declaration is marked as @internal
//
// @internal (undocumented)
export function groupDragConstrain(desiredLoc: PointXY, dragEl: jsPlumbDOMElement, constrainRect: BoundingBox, size: Size): PointXY;

// @public (undocumented)
export type GroupLocation = {
    el: Element;
    r: BoundingBox;
    group: UIGroup<Element>;
};

// @public (undocumented)
export function hasClass(el: Element, clazz: string): boolean;

// @public (undocumented)
export type IntersectingGroup = {
    groupLoc: GroupLocation;
    d: number;
    intersectingElement: Element;
};

// @public (undocumented)
export function isArrayLike(el: any): el is ArrayLike<Element>;

// @public (undocumented)
export function isInsideParent(instance: BrowserJsPlumbInstance, _el: HTMLElement, pos: PointXY): boolean;

// @public (undocumented)
export function isMouseDevice(): boolean;

// @public (undocumented)
export function isNodeList(el: any): el is NodeListOf<Element>;

// @public (undocumented)
export function isSVGElement(el: Element): boolean;

// @public (undocumented)
export function isTouchDevice(): boolean;

// @public (undocumented)
export interface jsPlumbDOMElement extends HTMLElement, jsPlumbElement<Element> {
    // (undocumented)
    cloneNode: (deep?: boolean) => jsPlumbDOMElement;
    // (undocumented)
    _isJsPlumbGroup: boolean;
    // (undocumented)
    _jsPlumbOrphanedEndpoints: Array<Endpoint>;
    // (undocumented)
    _jsPlumbScrollHandler?: Function;
    // Warning: (ae-incompatible-release-tags) The symbol "jtk" is marked as @public, but its signature references "jsPlumbDOMInformation" which is marked as @internal
    //
    // (undocumented)
    jtk: jsPlumbDOMInformation;
    // (undocumented)
    _katavorioDrag?: Drag;
    // (undocumented)
    offsetParent: jsPlumbDOMElement;
    // (undocumented)
    parentNode: jsPlumbDOMElement;
}

// Warning: (ae-internal-missing-underscore) The name "jsPlumbDOMInformation" should be prefixed with an underscore because the declaration is marked as @internal
//
// @internal (undocumented)
export interface jsPlumbDOMInformation {
    // (undocumented)
    connector?: AbstractConnector;
    // (undocumented)
    endpoint?: Endpoint;
    // (undocumented)
    overlay?: Overlay;
}

// @public (undocumented)
export interface jsPlumbDragManager {
    // (undocumented)
    destroyDraggable(el: jsPlumbDOMElement): void;
    // (undocumented)
    draggable(el: jsPlumbDOMElement, params: DragParams): Drag;
    // (undocumented)
    getInputFilterSelector(): string;
    // (undocumented)
    getPosition(el: Element): PointXY;
    // (undocumented)
    getSize(el: Element): Size;
    // (undocumented)
    getZoom(): number;
    // (undocumented)
    setInputFilterSelector(selector: string): void;
    // (undocumented)
    setZoom(z: number): void;
}

// @public (undocumented)
export function matchesSelector(el: jsPlumbDOMElement, selector: string, ctx?: Element): boolean;

// @public (undocumented)
export function newInstance(defaults?: BrowserJsPlumbDefaults): BrowserJsPlumbInstance;

// Warning: (ae-internal-missing-underscore) The name "offsetRelativeToRoot" should be prefixed with an underscore because the declaration is marked as @internal
//
// @internal
export function offsetRelativeToRoot(el: Element): PointXY;

// @public
export function offsetSize(el: Element): Size;

// @public (undocumented)
export function pageLocation(e: Event): PointXY;

// @public (undocumented)
export enum PositioningStrategies {
    // (undocumented)
    absolutePosition = "absolutePosition",
    // (undocumented)
    transform = "transform",
    // (undocumented)
    xyAttributes = "xyAttributes"
}

// @public (undocumented)
export type PositioningStrategy = keyof typeof PositioningStrategies;

// @public (undocumented)
export const PROPERTY_POSITION = "position";

// @public (undocumented)
export function ready(f: Function): void;

// @public (undocumented)
export function registerEndpointRenderer<C>(name: string, fns: EndpointHelperFunctions<C>): void;

// @public (undocumented)
export function removeClass(el: Element | NodeListOf<Element>, clazz: string): void;

// @public (undocumented)
export type RevertEventParams = jsPlumbDOMElement;

// @public (undocumented)
export type RevertFunction = (dragEl: HTMLElement, pos: PointXY) => boolean;

// @public (undocumented)
export const SELECTOR_CONNECTOR: string;

// @public (undocumented)
export const SELECTOR_ENDPOINT: string;

// @public (undocumented)
export const SELECTOR_GROUP: string;

// @public (undocumented)
export const SELECTOR_GROUP_CONTAINER: string;

// @public (undocumented)
export const SELECTOR_OVERLAY: string;

// @public (undocumented)
export function setForceMouseEvents(value: boolean): void;

// @public (undocumented)
export function setForceTouchEvents(value: boolean): void;

// @public (undocumented)
export type SetPositionFunction = (el: Element, p: PointXY) => void;

// @public (undocumented)
export type SetSizeFunction = (el: Element, s: Size) => void;

// @public (undocumented)
export const svg: {
    attr: typeof _attr;
    node: typeof _node;
    ns: {
        svg: string;
    };
};

// @public (undocumented)
export function svgWidthHeightSize(el: Element): Size;

// @public (undocumented)
export function svgXYPosition(el: Element): PointXY;

// @public (undocumented)
export function toggleClass(el: Element | NodeListOf<Element>, clazz: string): void;

// @public (undocumented)
export function touchCount(e: Event): number;

// @public (undocumented)
export function touches(e: any): TouchList;

// @public (undocumented)
export interface UIComponent {
    // (undocumented)
    canvas: HTMLElement;
    // (undocumented)
    svg: SVGElement;
}

// Warnings were encountered during analysis:
//
// /Users/simon/programming/jsplumb/jsplumb/dist/browser-ui/types/browser-jsplumb-instance.d.ts:495:9 - (ae-forgotten-export) The symbol "ElementAttributes" needs to be exported by the entry point index.d.ts
// /Users/simon/programming/jsplumb/jsplumb/dist/browser-ui/types/svg-util.d.ts:17:5 - (ae-forgotten-export) The symbol "_attr" needs to be exported by the entry point index.d.ts
// /Users/simon/programming/jsplumb/jsplumb/dist/browser-ui/types/svg-util.d.ts:18:5 - (ae-forgotten-export) The symbol "_node" needs to be exported by the entry point index.d.ts

```
