/**
 * Based on mxgraph 4.2.0.
 */
export declare function MxGraphFactory(opts: {
    /** Specifies the path in mxClient.basePath. */
    mxBasePath?: string;
    /** Specifies the path in mxClient.imageBasePath. */
    mxImageBasePath?: string;
    /** Specifies the language for resources in mxClient.language. */
    mxLanguage?: string;
    /** Array of all supported language extensions. */
    mxLanguages?: string[];
    /** Specifies the default language in mxClient.defaultLanguage. */
    mxDefaultLanguage?: string;
    /** Specifies if any resources should be loaded.  Default is true. */
    mxLoadResources?: boolean;
    /** Specifies if any stylesheets should be loaded.  Default is true. */
    mxLoadStylesheets?: boolean;
    /** Force loading the JavaScript files in development mode */
    mxForceIncludes?: boolean;
    /** Specify the extension of resource files. */
    mxResourceExtension?: string;
}): typeof MxGraphNS;
export declare module MxGraphNS {
    function escape(s: string): string;
    function unescape(s: string): string;
    var mxBasePath: string;
    var mxImageBasePath: string;
    var mxLanguage: string;
    var mxLanguages: string[];
    var mxDefaultLanguage: string;
    var mxLoadResources: boolean;
    var mxLoadStylesheets: boolean;
    var mxForceIncludes: boolean;
    var mxResourceExtension: string;
    var mxClient: {
        /**
         * Class: mxClient
         *
         * Bootstrapping mechanism for the mxGraph thin client. The production version
         * of this file contains all code required to run the mxGraph thin client, as
         * well as global constants to identify the browser and operating system in
         * use. You may have to load chrome://global/content/contentAreaUtils.js in
         * your page to disable certain security restrictions in Mozilla.
         *
         * Variable: VERSION
         *
         * Contains the current version of the mxGraph library. The strings that
         * communicate versions of mxGraph use the following format.
         *
         * versionMajor.versionMinor.buildNumber.revisionNumber
         *
         * Current version is 4.0.6.
         */
        VERSION: number;
        /**
         * Variable: IS_IE
         *
         * True if the current browser is Internet Explorer 10 or below. Use <mxClient.IS_IE11>
         * to detect IE 11.
         */
        IS_IE: boolean;
        /**
         * Variable: IS_IE6
         *
         * True if the current browser is Internet Explorer 6.x.
         */
        IS_IE6: boolean;
        /**
         * Variable: IS_IE11
         *
         * True if the current browser is Internet Explorer 11.x.
         */
        IS_IE11: boolean;
        /**
         * Variable: IS_EDGE
         *
         * True if the current browser is Microsoft Edge.
         */
        IS_EDGE: boolean;
        /**
         * Variable: IS_QUIRKS
         *
         * True if the current browser is Internet Explorer and it is in quirks mode.
         */
        IS_QUIRKS: boolean;
        /**
         * Variable: IS_EM
         *
         * True if the browser is IE11 in enterprise mode (IE8 standards mode).
         */
        IS_EM: boolean;
        /**
         * Variable: VML_PREFIX
         *
         * Prefix for VML namespace in node names. Default is 'v'.
         */
        VML_PREFIX: string;
        /**
         * Variable: OFFICE_PREFIX
         *
         * Prefix for VML office namespace in node names. Default is 'o'.
         */
        OFFICE_PREFIX: string;
        /**
         * Variable: IS_NS
         *
         * True if the current browser is Netscape (including Firefox).
         */
        IS_NS: boolean;
        /**
         * Variable: IS_OP
         *
         * True if the current browser is Opera.
         */
        IS_OP: boolean;
        /**
         * Variable: IS_OT
         *
         * True if -o-transform is available as a CSS style, ie for Opera browsers
         * based on a Presto engine with version 2.5 or later.
         */
        IS_OT: boolean;
        /**
         * Variable: IS_SF
         *
         * True if the current browser is Safari.
         */
        IS_SF: boolean;
        /**
         * Variable: IS_IOS
         *
         * Returns true if the user agent is an iPad, iPhone or iPod.
         */
        IS_IOS: boolean;
        /**
         * Variable: IS_GC
         *
         * True if the current browser is Google Chrome.
         */
        IS_GC: boolean;
        /**
         * Variable: IS_CHROMEAPP
         *
         * True if the this is running inside a Chrome App.
         */
        IS_CHROMEAPP: boolean;
        /**
         * Variable: IS_FF
         *
         * True if the current browser is Firefox.
         */
        IS_FF: boolean;
        /**
         * Variable: IS_MT
         *
         * True if -moz-transform is available as a CSS style. This is the case
         * for all Firefox-based browsers newer than or equal 3, such as Camino,
         * Iceweasel, Seamonkey and Iceape.
         */
        IS_MT: boolean;
        /**
         * Variable: IS_VML
         *
         * True if the browser supports VML.
         */
        IS_VML: boolean;
        /**
         * Variable: IS_SVG
         *
         * True if the browser supports SVG.
         */
        IS_SVG: boolean;
        /**
         * Variable: NO_FO
         *
         * True if foreignObject support is not available. This is the case for
         * Opera, older SVG-based browsers and all versions of IE.
         */
        NO_FO: boolean;
        /**
         * Variable: IS_WIN
         *
         * True if the client is a Windows.
         */
        IS_WIN: boolean;
        /**
         * Variable: IS_MAC
         *
         * True if the client is a Mac.
         */
        IS_MAC: boolean;
        /**
         * Variable: IS_CHROMEOS
         *
         * True if the client is a Chrome OS.
         */
        IS_CHROMEOS: boolean;
        /**
         * Variable: IS_TOUCH
         *
         * True if this device supports touchstart/-move/-end events (Apple iOS,
         * Android, Chromebook and Chrome Browser on touch-enabled devices).
         */
        IS_TOUCH: boolean;
        /**
         * Variable: IS_POINTER
         *
         * True if this device supports Microsoft pointer events (always false on Macs).
         */
        IS_POINTER: boolean;
        /**
         * Variable: IS_LOCAL
         *
         * True if the documents location does not start with http:// or https://.
         */
        IS_LOCAL: boolean;
        /**
         * Variable: defaultBundles
         *
         * Contains the base names of the default bundles if mxLoadResources is false.
         */
        defaultBundles: string[];
        /**
         * Function: isBrowserSupported
         *
         * Returns true if the current browser is supported, that is, if
         * <mxClient.IS_VML> or <mxClient.IS_SVG> is true.
         *
         * Example:
         *
         * (code)
         * if (!mxClient.isBrowserSupported())
         * {
         *   mxUtils.error('Browser is not supported!', 200, false);
         * }
         * (end)
         */
        isBrowserSupported: () => boolean;
        /**
         * Function: link
         *
         * Adds a link node to the head of the document. Use this
         * to add a stylesheet to the page as follows:
         *
         * (code)
         * mxClient.link('stylesheet', filename);
         * (end)
         *
         * where filename is the (relative) URL of the stylesheet. The charset
         * is hardcoded to ISO-8859-1 and the type is text/css.
         *
         * Parameters:
         *
         * rel - String that represents the rel attribute of the link node.
         * href - String that represents the href attribute of the link node.
         * doc - Optional parent document of the link node.
         * id - unique id for the link element to check if it already exists
         */
        link: (rel: string, href: string, doc?: XMLDocument, id?: string) => void;
        /**
         * Function: loadResources
         *
         * Helper method to load the default bundles if mxLoadResources is false.
         *
         * Parameters:
         *
         * fn - Function to call after all resources have been loaded.
         * lan - Optional string to pass to <mxResources.add>.
         */
        loadResources: (fn: any, lan?: string) => void;
        /**
         * Function: include
         *
         * Dynamically adds a script node to the document header.
         *
         * In production environments, the includes are resolved in the mxClient.js
         * file to reduce the number of requests required for client startup. This
         * function should only be used in development environments, but not in
         * production systems.
         */
        include: (src: string) => void;
        /**
         * Variable: basePath
         *
         * Basepath for all URLs in the core without trailing slash. Default is '.'.
         * Set mxBasePath prior to loading the mxClient library as follows to override
         * this setting:
         *
         * (code)
         * <script type="text/javascript">
         * 		mxBasePath = '/path/to/core/directory';
         * </script>
         * <script type="text/javascript" src="/path/to/core/directory/js/mxClient.js"></script>
         * (end)
         *
         * When using a relative path, the path is relative to the URL of the page that
         * contains the assignment. Trailing slashes are automatically removed.
         */
        basePath: string;
        /**
         * Variable: imageBasePath
         *
         * Basepath for all images URLs in the core without trailing slash. Default is
         * <mxClient.basePath> + '/images'. Set mxImageBasePath prior to loading the
         * mxClient library as follows to override this setting:
         *
         * (code)
         * <script type="text/javascript">
         * 		mxImageBasePath = '/path/to/image/directory';
         * </script>
         * <script type="text/javascript" src="/path/to/core/directory/js/mxClient.js"></script>
         * (end)
         *
         * When using a relative path, the path is relative to the URL of the page that
         * contains the assignment. Trailing slashes are automatically removed.
         */
        imageBasePath: string;
        /**
         * Variable: language
         *
         * Defines the language of the client, eg. en for english, de for german etc.
         * The special value 'none' will disable all built-in internationalization and
         * resource loading. See <mxResources.getSpecialBundle> for handling identifiers
         * with and without a dash.
         *
         * Set mxLanguage prior to loading the mxClient library as follows to override
         * this setting:
         *
         * (code)
         * <script type="text/javascript">
         * 		mxLanguage = 'en';
         * </script>
         * <script type="text/javascript" src="js/mxClient.js"></script>
         * (end)
         *
         * If internationalization is disabled, then the following variables should be
         * overridden to reflect the current language of the system. These variables are
         * cleared when i18n is disabled.
         * <mxEditor.askZoomResource>, <mxEditor.lastSavedResource>,
         * <mxEditor.currentFileResource>, <mxEditor.propertiesResource>,
         * <mxEditor.tasksResource>, <mxEditor.helpResource>, <mxEditor.outlineResource>,
         * <mxElbowEdgeHandler.doubleClickOrientationResource>, <mxUtils.errorResource>,
         * <mxUtils.closeResource>, <mxGraphSelectionModel.doneResource>,
         * <mxGraphSelectionModel.updatingSelectionResource>, <mxGraphView.doneResource>,
         * <mxGraphView.updatingDocumentResource>, <mxCellRenderer.collapseExpandResource>,
         * <mxGraph.containsValidationErrorsResource> and
         * <mxGraph.alreadyConnectedResource>.
         */
        language: string;
        /**
         * Variable: defaultLanguage
         *
         * Defines the default language which is used in the common resource files. Any
         * resources for this language will only load the common resource file, but not
         * the language-specific resource file. Default is 'en'.
         *
         * Set mxDefaultLanguage prior to loading the mxClient library as follows to override
         * this setting:
         *
         * (code)
         * <script type="text/javascript">
         * 		mxDefaultLanguage = 'de';
         * </script>
         * <script type="text/javascript" src="js/mxClient.js"></script>
         * (end)
         */
        defaultLanguage: string;
        /**
         * Variable: languages
         *
         * Defines the optional array of all supported language extensions. The default
         * language does not have to be part of this list. See
         * <mxResources.isLanguageSupported>.
         *
         * (code)
         * <script type="text/javascript">
         * 		mxLanguages = ['de', 'it', 'fr'];
         * </script>
         * <script type="text/javascript" src="js/mxClient.js"></script>
         * (end)
         *
         * This is used to avoid unnecessary requests to language files, ie. if a 404
         * will be returned.
         */
        languages: string[];
    };
    class mxStencil {
        /**
         * Static global variable that specifies the default value for the localized
         * attribute of the text element. Default is false.
         */
        static defaultLocalized: boolean;
        /**
         * Static global switch that specifies if the use of eval is allowed for
         * evaluating text content and images. Default is false. Set this to true
         * if stencils can not contain user input.
         */
        static allowEval: boolean;
        /**
         * Holds the XML node with the stencil description.
         */
        desc: Element;
        /**
         * Holds an array of <mxConnectionConstraints> as defined in the shape.
         */
        constraints: mxConnectionConstraint[];
        /**
         * Holds the aspect of the shape. Default is 'auto'.
         */
        aspect: string;
        /**
         * Holds the width of the shape. Default is 100.
         */
        w0: number;
        /**
         * Holds the height of the shape. Default is 100.
         */
        h0: number;
        /**
         * Holds the XML node with the stencil description.
         */
        bgNode: Element;
        /**
         * Holds the XML node with the stencil description.
         */
        fgNode: Element;
        /**
         * Holds the strokewidth direction from the description.
         */
        strokewidth: number | string;
        /**
         * Constructs a new generic shape by setting <desc> to the given XML node and
         * invoking <parseDescription> and <parseConstraints>.
         *
         * @param desc XML node that contains the stencil description.
         */
        constructor(desc: Element);
        /**
         * Reads <w0>, <h0>, <aspect>, <bgNodes> and <fgNodes> from <desc>.
         */
        parseDescription(): void;
        /**
         * Reads the constraints from <desc> into <constraints> using
         * <parseConstraint>.
         */
        parseConstraints(): void;
        /**
         * Parses the given XML node and returns its <mxConnectionConstraint>.
         */
        parseConstraint(node: Element): mxConnectionConstraint;
        /**
         * Gets the given attribute as a text. The return value from <evaluateAttribute>
         * is used as a key to <mxResources.get> if the localized attribute in the text
         * node is 1 or if <defaultLocalized> is true.
         */
        evaluateTextAttribute(node: Element, attribute: string, shape: any): string;
        /**
         * Gets the attribute for the given name from the given node. If the attribute
         * does not exist then the text content of the node is evaluated and if it is
         * a function it is invoked with <shape> as the only argument and the return
         * value is used as the attribute value to be returned.
         */
        evaluateAttribute(node: Element, attribute: string, shape: any): string;
        /**
         * Draws this stencil inside the given bounds.
         */
        drawShape(canvas: any, shape: any, x: any, y: any, w: any, h: any): void;
        /**
         * Draws this stencil inside the given bounds.
         */
        drawChildren(canvas: any, shape: any, x: any, y: any, w: any, h: any, node: any, aspect: any, disableShadow: any): void;
        /**
         * Returns a rectangle that contains the offset in x and y and the horizontal
         * and vertical scale in width and height used to draw this shape inside the
         * given <mxRectangle>.
         *
         * shape - <mxShape> to be drawn.
         * bounds - <mxRectangle> that should contain the stencil.
         * direction - Optional direction of the shape to be darwn.
         */
        computeAspect(shape: any, x: any, y: any, w: any, h: any, direction: any): mxRectangle;
        /**
         * Draws this stencil inside the given bounds.
         */
        drawNode(canvas: any, shape: any, node: any, aspect: any, disableShadow: any): void;
    }
    class mxShape {
        addPoints(c: any, pts?: mxPoint[], rounded?: boolean, arcSize?: number, close?: boolean, exclude?: any, initialMove?: boolean): void;
        getPorts(): any;
        /**
         * Holds the dialect in which the shape is to be painted.
         * This can be one of the DIALECT constants in <mxConstants>.
         */
        dialect: any;
        /**
         * Holds the scale in which the shape is being painted.
         */
        scale: number;
        /**
         * Rendering hint for configuring the canvas.
         */
        antiAlias: boolean;
        /**
         * Holds the <mxRectangle> that specifies the bounds of this shape.
         */
        bounds: mxRectangle;
        /**
         * Holds the array of <mxPoints> that specify the points of this shape.
         */
        points: mxPoint[];
        /**
         * Holds the outermost DOM node that represents this shape.
         */
        node: HTMLElement | SVGElement;
        /**
         * Optional reference to the corresponding <mxCellState>.
         */
        state: mxCellState;
        /**
         * Optional reference to the style of the corresponding <mxCellState>.
         */
        style: any[];
        /**
         * Contains the bounding box of the shape, that is, the smallest rectangle
         * that includes all pixels of the shape.
         */
        boundingBox: mxRectangle;
        /**
         * Holds the <mxStencil> that defines the shape.
         */
        stencil: mxStencil;
        /**
         * Event-tolerance for SVG strokes (in px). Default is 8. This is only passed
         * to the canvas in <createSvgCanvas> if <pointerEvents> is true.
         */
        svgStrokeTolerance: number;
        /**
         * Specifies if pointer events should be handled. Default is true.
         */
        pointerEvents: boolean;
        /**
         * Specifies if pointer events should be handled. Default is true.
         */
        svgPointerEvents: string;
        /**
         * Specifies if pointer events outside of shape should be handled. Default
         * is false.
         */
        shapePointerEvents: boolean;
        /**
         * Specifies if pointer events outside of stencils should be handled. Default
         * is false. Set this to true for backwards compatibility with the 1.x branch.
         */
        stencilPointerEvents: boolean;
        /**
         * Scale for improving the precision of VML rendering. Default is 1.
         */
        vmlScale: number;
        /**
         * Specifies if the shape should be drawn as an outline. This disables all
         * fill colors and can be used to disable other drawing states that should
         * not be painted for outlines. Default is false. This should be set before
         * calling <apply>.
         */
        outline: boolean;
        /**
         * Specifies if the shape is visible. Default is true.
         */
        visible: boolean;
        /**
         * Allows to use the SVG bounding box in SVG. Default is false for performance
         * reasons.
         */
        useSvgBoundingBox: boolean;
        /**
         * Implicit variable declarations
         */
        strokewidth: number;
        rotation: number;
        opacity: number;
        fillOpacity: number;
        strokeOpacity: number;
        flipH: boolean;
        flipV: boolean;
        spacing: any;
        fill: any;
        gradient: any;
        gradientDirection: any;
        stroke: any;
        startSize: any;
        endSize: any;
        startArrow: any;
        endArrow: any;
        direction: any;
        isShadow: any;
        isDashed: any;
        isRounded: any;
        glass: any;
        cursor: string;
        constructor(stencil?: any);
        /**
         * Initializes the shape by creaing the DOM node using <create>
         * and adding it into the given container.
         *
         * @param container - DOM node that will contain the shape.
         */
        init(container: HTMLElement): void;
        /**
         * Specifies if any VML should be added via insertAdjacentHtml to the DOM. This
         * is only needed in IE8 and only if the shape contains VML markup. This method
         * returns true.
         */
        isParseVml(): boolean;
        /**
         * Returns true if HTML is allowed for this shape. This implementation always
         * returns false.
         */
        isHtmlAllowed(): boolean;
        /**
         * Returns 0, or 0.5 if <strokewidth> % 2 == 1.
         */
        getSvgScreenOffset(): 0 | 0.5;
        /**
         * Creates and returns the DOM node(s) for the shape in
         * the given container. This implementation invokes
         * <createSvg>, <createHtml> or <createVml> depending
         * on the <dialect> and style settings.
         *
         * @param container - DOM node that will contain the shape.
         */
        create(container: Element): HTMLElement | SVGGElement;
        /**
         * Creates and returns the SVG node(s) to represent this shape.
         */
        createSvg(...args: any[]): SVGGElement;
        /**
         * Creates and returns the VML node to represent this shape.
         */
        createVml(...args: any[]): HTMLElement;
        /**
         * Creates and returns the HTML DOM node(s) to represent
         * this shape. This implementation falls back to <createVml>
         * so that the HTML creation is optional.
         */
        createHtml(...args: any[]): HTMLDivElement;
        /**
         * Reconfigures this shape. This will update the colors etc in
         * addition to the bounds or points.
         */
        reconfigure(): void;
        /**
         * Creates and returns the SVG node(s) to represent this shape.
         */
        redraw(): void;
        /**
         * Removes all child nodes and resets all CSS.
         */
        clear(): void;
        /**
         * Updates the bounds based on the points.
         */
        updateBoundsFromPoints(): void;
        /**
         * Returns the <mxRectangle> for the label bounds of this shape, based on the
         * given scaled and translated bounds of the shape. This method should not
         * change the rectangle in-place. This implementation returns the given rect.
         */
        getLabelBounds(rect: any): any;
        /**
         * Returns the scaled top, left, bottom and right margin to be used for
         * computing the label bounds as an <mxRectangle>, where the bottom and right
         * margin are defined in the width and height of the rectangle, respectively.
         */
        getLabelMargins(rect: any): any;
        /**
         * Returns true if the bounds are not null and all of its variables are numeric.
         */
        checkBounds(): boolean;
        /**
         * Returns the temporary element used for rendering in IE8 standards mode.
         */
        createVmlGroup(): HTMLElement;
        /**
         * Updates the SVG or VML shape.
         */
        redrawShape(): void;
        /**
         * Creates a new canvas for drawing this shape. May return null.
         */
        createCanvas(): mxSvgCanvas2D | mxVmlCanvas2D;
        /**
         * Creates and returns an <mxSvgCanvas2D> for rendering this shape.
         */
        createSvgCanvas(): mxSvgCanvas2D;
        /**
         * Creates and returns an <mxVmlCanvas2D> for rendering this shape.
         */
        createVmlCanvas(): any;
        /**
         * Updates the bounds of the VML container.
         */
        updateVmlContainer(): void;
        /**
         * Allow optimization by replacing VML with HTML.
         */
        redrawHtmlShape(): void;
        /**
         * Allow optimization by replacing VML with HTML.
         */
        updateHtmlFilters(node: any): void;
        /**
         * Allow optimization by replacing VML with HTML.
         */
        updateHtmlColors(node: any): void;
        /**
         * Allow optimization by replacing VML with HTML.
         */
        updateHtmlBounds(node: any): void;
        /**
         * Destroys the given canvas which was used for drawing. This implementation
         * increments the reference counts on all shared gradients used in the canvas.
         */
        destroyCanvas(canvas: any): void;
        /**
         * Generic rendering code.
         */
        paint(c: any): void;
        /**
         * Sets the state of the canvas for drawing the shape.
         */
        configureCanvas(c: any, x: any, y: any, w: any, h: any): void;
        /**
         * Returns the bounding box for the gradient box for this shape.
         */
        getGradientBounds(c: any, x: any, y: any, w: any, h: any): mxRectangle;
        /**
         * Sets the scale and rotation on the given canvas.
         */
        updateTransform(c: any, x: any, y: any, w: any, h: any): void;
        /**
         * Paints the vertex shape.
         */
        paintVertexShape(c: mxAbstractCanvas2D, x: number, y: number, w: number, h: number): void;
        /**
         * Hook for subclassers. This implementation is empty.
         */
        paintBackground(c: mxAbstractCanvas2D, x: number, y: number, w: number, h: number): void;
        /**
         * Hook for subclassers. This implementation is empty.
         */
        paintForeground(c: mxAbstractCanvas2D, x: number, y: number, w: number, h: number): void;
        /**
         * Hook for subclassers. This implementation is empty.
         */
        paintEdgeShape(c: any, pts: any): void;
        /**
         * Returns the arc size for the given dimension.
         */
        getArcSize(w: any, h: any): number;
        /**
         * Paints the glass gradient effect.
         */
        paintGlassEffect(c: any, x: any, y: any, w: any, h: any, arc: any): void;
        /**
         * Paints the given points with rounded corners.
         */
        addPoints(c: any, pts: any, rounded: any, arcSize: any, close: any, exclude: any, initialMove: any): void;
        /**
         * Resets all styles.
         */
        resetStyles(): void;
        /**
         * Applies the style of the given <mxCellState> to the shape. This
         * implementation assigns the following styles to local fields:
         *
         * - <mxConstants.STYLE_FILLCOLOR> => fill
         * - <mxConstants.STYLE_GRADIENTCOLOR> => gradient
         * - <mxConstants.STYLE_GRADIENT_DIRECTION> => gradientDirection
         * - <mxConstants.STYLE_OPACITY> => opacity
         * - <mxConstants.STYLE_FILL_OPACITY> => fillOpacity
         * - <mxConstants.STYLE_STROKE_OPACITY> => strokeOpacity
         * - <mxConstants.STYLE_STROKECOLOR> => stroke
         * - <mxConstants.STYLE_STROKEWIDTH> => strokewidth
         * - <mxConstants.STYLE_SHADOW> => isShadow
         * - <mxConstants.STYLE_DASHED> => isDashed
         * - <mxConstants.STYLE_SPACING> => spacing
         * - <mxConstants.STYLE_STARTSIZE> => startSize
         * - <mxConstants.STYLE_ENDSIZE> => endSize
         * - <mxConstants.STYLE_ROUNDED> => isRounded
         * - <mxConstants.STYLE_STARTARROW> => startArrow
         * - <mxConstants.STYLE_ENDARROW> => endArrow
         * - <mxConstants.STYLE_ROTATION> => rotation
         * - <mxConstants.STYLE_DIRECTION> => direction
         * - <mxConstants.STYLE_GLASS> => glass
         *
         * This keeps a reference to the <style>. If you need to keep a reference to
         * the cell, you can override this method and store a local reference to
         * state.cell or the <mxCellState> itself. If <outline> should be true, make
         * sure to set it before calling this method.
         *
         * state - <mxCellState> of the corresponding cell.
         */
        apply(state: any): void;
        /**
         * Sets the cursor on the given shape.
         *
         * cursor - The cursor to be used.
         */
        setCursor(cursor: any): void;
        /**
         * Returns the current cursor.
         */
        getCursor(): string;
        /**
         * Updates the <boundingBox> for this shape using <createBoundingBox> and
         * <augmentBoundingBox> and stores the result in <boundingBox>.
         */
        updateBoundingBox(): void;
        /**
         * Returns a new rectangle that represents the bounding box of the bare shape
         * with no shadows or strokewidths.
         */
        createBoundingBox(): any;
        /**
         * Augments the bounding box with the strokewidth and shadow offsets.
         */
        augmentBoundingBox(bbox: any): void;
        /**
         * Returns true if the bounds should be inverted.
         */
        isPaintBoundsInverted(): boolean;
        /**
         * Returns the rotation from the style.
         */
        getRotation(): number;
        /**
         * Returns the rotation for the text label.
         */
        getTextRotation(): number;
        /**
         * Returns the actual rotation of the shape.
         */
        getShapeRotation(): number;
        /**
         * Adds a transparent rectangle that catches all events.
         */
        createTransparentSvgRectangle(x: any, y: any, w: any, h: any): Element;
        /**
         * Sets a transparent background CSS style to catch all events.
         *
         * Paints the line shape.
         */
        setTransparentBackgroundImage(node: any): void;
        /**
         * Paints the line shape.
         */
        releaseSvgGradients(grads: any): void;
        /**
         * Destroys the shape by removing it from the DOM and releasing the DOM
         * node associated with the shape using <mxEvent.release>.
         */
        destroy(): void;
    }
    /**
     * Code to add stencils.
     *
     * (code)
     * var req = mxUtils.load('test/stencils.xml');
     * var root = req.getDocumentElement();
     * var shape = root.firstChild;
     *
     * while (shape != null)
     * {
     * 	 if (shape.nodeType == mxConstants.NODETYPE_ELEMENT)
     *   {
     *     mxStencilRegistry.addStencil(shape.getAttribute('name'), new mxStencil(shape));
     *   }
     *
     *   shape = shape.nextSibling;
     * }
     * (end)
     */
    var mxStencilRegistry: {
        stencils: {};
        addStencil(name: any, stencil: any): void;
        getStencil(name: any): any;
    };
    var mxMarker: {
        markers: any[];
        addMarker(type: any, funct: any): void;
        createMarker(canvas: any, shape: any, type: any, pe: any, unitX: any, unitY: any, size: any, source: any, sw: any, filled: any): any;
    };
    /**
     * Extends <mxShape> to implement an actor shape. If a custom shape with one
     * filled area is needed, then this shape's <redrawPath> should be overridden.
     *
     * Example:
     *
     * (code)
     * function SampleShape() { }
     *
     * SampleShape.prototype = new mxActor();
     * SampleShape.prototype.constructor = vsAseShape;
     *
     * mxCellRenderer.registerShape('sample', SampleShape);
     * SampleShape.prototype.redrawPath = function(path, x, y, w, h)
     * {
     *   path.moveTo(0, 0);
     *   path.lineTo(w, h);
     *   // ...
     *   path.close();
     * }
     * (end)
     *
     * This shape is registered under <mxConstants.SHAPE_ACTOR> in
     * <mxCellRenderer>.
     *
     * Constructor: mxActor
     *
     * Constructs a new actor shape.
     *
     * Parameters:
     *
     * bounds - <mxRectangle> that defines the bounds. This is stored in
     * <mxShape.bounds>.
     * fill - String that defines the fill color. This is stored in <fill>.
     * stroke - String that defines the stroke color. This is stored in <stroke>.
     * strokewidth - Optional integer that defines the stroke width. Default is
     * 1. This is stored in <strokewidth>.
     */
    class mxActor extends mxShape {
        constructor(bounds: mxRectangle, fill: string, stroke: string, strokewidth?: number);
        /**
         * Redirects to redrawPath for subclasses to work.
         */
        paintVertexShape(c: mxAbstractCanvas2D, x: number, y: number, w: number, h: number): void;
        /**
         * Draws the path for this shape.
         */
        redrawPath(c: mxAbstractCanvas2D, x: number, y: number, w: number, h: number): void;
    }
    /**
     * Extends <mxActor> to implement a cloud shape.
     *
     * This shape is registered under <mxConstants.SHAPE_CLOUD> in
     * <mxCellRenderer>.
     *
     * Constructor: mxCloud
     *
     * Constructs a new cloud shape.
     *
     * Parameters:
     *
     * bounds - <mxRectangle> that defines the bounds. This is stored in
     * <mxShape.bounds>.
     * fill - String that defines the fill color. This is stored in <fill>.
     * stroke - String that defines the stroke color. This is stored in <stroke>.
     * strokewidth - Optional integer that defines the stroke width. Default is
     * 1. This is stored in <strokewidth>.
     */
    class mxCloud extends mxActor {
        constructor(bounds: any, fill: any, stroke: any, strokewidth: any);
        /**
         * Draws the path for this shape.
         */
        redrawPath(c: any, x: any, y: any, w: any, h: any): void;
    }
    /**
     * Extends <mxShape> to implement a rectangle shape.
     * This shape is registered under <mxConstants.SHAPE_RECTANGLE>
     * in <mxCellRenderer>.
     */
    class mxRectangleShape extends mxShape {
        /**
         * Constructs a new rectangle shape.
         *
         * @param bounds - <mxRectangle> that defines the bounds. This is stored in
         * <mxShape.bounds>.
         * @param fill - String that defines the fill color. This is stored in <fill>.
         * @param stroke - String that defines the stroke color. This is stored in <stroke>.
         * @param strokewidth - Optional integer that defines the stroke width. Default is
         * 1. This is stored in <strokewidth>.
         */
        constructor(bounds: mxRectangle, fill: string, stroke: string, strokewidth?: number);
        /**
         * Returns true for non-rounded, non-rotated shapes with no glass gradient.
         */
        isHtmlAllowed(): boolean;
        /**
         * Generic background painting implementation.
         */
        paintBackground(c: mxAbstractCanvas2D, x: number, y: number, w: number, h: number): void;
        /**
         * Generic background painting implementation.
         */
        paintForeground(c: mxAbstractCanvas2D, x: number, y: number, w: number, h: number): void;
    }
    /**
     * Extends <mxShape> to implement an ellipse shape.
     * This shape is registered under <mxConstants.SHAPE_ELLIPSE>
     * in <mxCellRenderer>.
     *
     * Constructor: mxEllipse
     *
     * Constructs a new ellipse shape.
     *
     * Parameters:
     *
     * bounds - <mxRectangle> that defines the bounds. This is stored in
     * <mxShape.bounds>.
     * fill - String that defines the fill color. This is stored in <fill>.
     * stroke - String that defines the stroke color. This is stored in <stroke>.
     * strokewidth - Optional integer that defines the stroke width. Default is
     * 1. This is stored in <strokewidth>.
     */
    class mxEllipse extends mxShape {
        constructor(bounds: any, fill: any, stroke: any, strokewidth?: any);
        /**
         * Paints the ellipse shape.
         */
        paintVertexShape(c: any, x: any, y: any, w: any, h: any): void;
    }
    /**
     * Extends <mxShape> to implement a double ellipse shape. This shape is
     * registered under <mxConstants.SHAPE_DOUBLE_ELLIPSE> in <mxCellRenderer>.
     * Use the following override to only fill the inner ellipse in this shape:
     *
     * (code)
     * mxDoubleEllipse.prototype.paintVertexShape = function(c, x, y, w, h)
     * {
     *   c.ellipse(x, y, w, h);
     *   c.stroke();
     *
     *   var inset = mxUtils.getValue(this.style, mxConstants.STYLE_MARGIN, Math.min(3 + this.strokewidth, Math.min(w / 5, h / 5)));
     *   x += inset;
     *   y += inset;
     *   w -= 2 * inset;
     *   h -= 2 * inset;
     *
     *   if (w > 0 && h > 0)
     *   {
     *     c.ellipse(x, y, w, h);
     *   }
     *
     *   c.fillAndStroke();
     * };
     * (end)
     *
     * Constructor: mxDoubleEllipse
     *
     * Constructs a new ellipse shape.
     *
     * Parameters:
     *
     * bounds - <mxRectangle> that defines the bounds. This is stored in
     * <mxShape.bounds>.
     * fill - String that defines the fill color. This is stored in <fill>.
     * stroke - String that defines the stroke color. This is stored in <stroke>.
     * strokewidth - Optional integer that defines the stroke width. Default is
     * 1. This is stored in <strokewidth>.
     */
    class mxDoubleEllipse extends mxShape {
        constructor(bounds: any, fill: any, stroke: any, strokewidth: any);
        /**
         * Paints the background.
         */
        paintBackground(c: mxAbstractCanvas2D, x: number, y: number, w: number, h: number): void;
        /**
         * Paints the foreground.
         */
        paintForeground(c: mxAbstractCanvas2D, x: number, y: number, w: number, h: number): void;
        /**
         * Returns the bounds for the label.
         */
        getLabelBounds(rect: any): mxRectangle;
    }
    /**
     * Extends <mxShape> to implement a rhombus (aka diamond) shape.
     * This shape is registered under <mxConstants.SHAPE_RHOMBUS>
     * in <mxCellRenderer>.
     *
     * Constructor: mxRhombus
     *
     * Constructs a new rhombus shape.
     *
     * Parameters:
     *
     * bounds - <mxRectangle> that defines the bounds. This is stored in
     * <mxShape.bounds>.
     * fill - String that defines the fill color. This is stored in <fill>.
     * stroke - String that defines the stroke color. This is stored in <stroke>.
     * strokewidth - Optional integer that defines the stroke width. Default is
     * 1. This is stored in <strokewidth>.
     */
    class mxRhombus extends mxShape {
        constructor(bounds: any, fill: any, stroke: any, strokewidth: any);
        /**
         * Generic painting implementation.
         */
        paintVertexShape(c: any, x: any, y: any, w: any, h: any): void;
    }
    /**
     * Extends <mxShape> to implement a polyline (a line with multiple points).
     * This shape is registered under <mxConstants.SHAPE_POLYLINE> in
     * <mxCellRenderer>.
     *
     * Constructor: mxPolyline
     *
     * Constructs a new polyline shape.
     *
     * Parameters:
     *
     * points - Array of <mxPoints> that define the points. This is stored in
     * <mxShape.points>.
     * stroke - String that defines the stroke color. Default is 'black'. This is
     * stored in <stroke>.
     * strokewidth - Optional integer that defines the stroke width. Default is
     * 1. This is stored in <strokewidth>.
     */
    class mxPolyline extends mxShape {
        constructor(points: mxPoint[], stroke: string, strokewidth?: number);
        /**
         * Returns 0.
         */
        getRotation(): number;
        /**
         * Returns 0.
         */
        getShapeRotation(): number;
        /**
         * Returns false.
         */
        isPaintBoundsInverted(): boolean;
        /**
         * Paints the line shape.
         */
        paintEdgeShape(c: any, pts: any): void;
        /**
         * Paints the line shape.
         */
        paintLine(c: any, pts: any, rounded: any): void;
        /**
         * Paints the line shape.
         */
        paintCurvedLine(c: any, pts: any): void;
    }
    /**
     * Extends <mxShape> to implement an arrow shape. (The shape
     * is used to represent edges, not vertices.)
     * This shape is registered under <mxConstants.SHAPE_ARROW>
     * in <mxCellRenderer>.
     *
     * Constructor: mxArrow
     *
     * Constructs a new arrow shape.
     *
     * Parameters:
     *
     * points - Array of <mxPoints> that define the points. This is stored in
     * <mxShape.points>.
     * fill - String that defines the fill color. This is stored in <fill>.
     * stroke - String that defines the stroke color. This is stored in <stroke>.
     * strokewidth - Optional integer that defines the stroke width. Default is
     * 1. This is stored in <strokewidth>.
     * arrowWidth - Optional integer that defines the arrow width. Default is
     * <mxConstants.ARROW_WIDTH>. This is stored in <arrowWidth>.
     * spacing - Optional integer that defines the spacing between the arrow shape
     * and its endpoints. Default is <mxConstants.ARROW_SPACING>. This is stored in
     * <spacing>.
     * endSize - Optional integer that defines the size of the arrowhead. Default
     * is <mxConstants.ARROW_SIZE>. This is stored in <endSize>.
     */
    class mxArrow extends mxShape {
        constructor(points: any, fill: any, stroke: any, strokewidth: any, arrowWidth: any, spacing: any, endSize: any);
        /**
         * Augments the bounding box with the edge width and markers.
         */
        augmentBoundingBox(bbox: any): void;
        /**
         * Paints the line shape.
         */
        paintEdgeShape(c: any, pts: any): void;
    }
    /**
     * Extends <mxShape> to implement an new rounded arrow shape with support for
     * waypoints and double arrows. (The shape is used to represent edges, not
     * vertices.) This shape is registered under <mxConstants.SHAPE_ARROW_CONNECTOR>
     * in <mxCellRenderer>.
     *
     * Constructor: mxArrowConnector
     *
     * Constructs a new arrow shape.
     *
     * Parameters:
     *
     * points - Array of <mxPoints> that define the points. This is stored in
     * <mxShape.points>.
     * fill - String that defines the fill color. This is stored in <fill>.
     * stroke - String that defines the stroke color. This is stored in <stroke>.
     * strokewidth - Optional integer that defines the stroke width. Default is
     * 1. This is stored in <strokewidth>.
     * arrowWidth - Optional integer that defines the arrow width. Default is
     * <mxConstants.ARROW_WIDTH>. This is stored in <arrowWidth>.
     * spacing - Optional integer that defines the spacing between the arrow shape
     * and its endpoints. Default is <mxConstants.ARROW_SPACING>. This is stored in
     * <spacing>.
     * endSize - Optional integer that defines the size of the arrowhead. Default
     * is <mxConstants.ARROW_SIZE>. This is stored in <endSize>.
     */
    class mxArrowConnector extends mxShape {
        constructor(points: any, fill: any, stroke: any, strokewidth: any, arrowWidth: any, spacing: any, endSize: any);
        /**
         * Overrides mxShape to reset spacing.
         */
        resetStyles(): void;
        /**
         * Overrides apply to get smooth transition from default start- and endsize.
         */
        apply(state: any): void;
        /**
         * Augments the bounding box with the edge width and markers.
         */
        augmentBoundingBox(bbox: any): void;
        /**
         * Paints the line shape.
         */
        paintEdgeShape(c: any, pts: any): void;
        /**
         * Paints the line shape.
         */
        paintMarker(c: any, ptX: any, ptY: any, nx: any, ny: any, size: any, arrowWidth: any, edgeWidth: any, spacing: any, initialMove: any): void;
        /**
         * Returns wether the arrow is rounded
         */
        isArrowRounded(): any;
        /**
         * Returns the width of the start arrow
         */
        getStartArrowWidth(): number;
        /**
         * Returns the width of the end arrow
         */
        getEndArrowWidth(): number;
        /**
         * Returns the width of the body of the edge
         */
        getEdgeWidth(): number;
        /**
         * Returns whether the ends of the shape are drawn
         */
        isOpenEnded(): boolean;
        /**
         * Returns whether the start marker is drawn
         */
        isMarkerStart(): boolean;
        /**
         * Returns whether the end marker is drawn
         */
        isMarkerEnd(): boolean;
    }
    /**
     * Extends <mxShape> to implement a text shape. To change vertical text from
     * bottom to top to top to bottom, the following code can be used:
     *
     * @example
     * mxText.prototype.verticalTextRotation = 90;
     */
    class mxText extends mxShape {
        /**
         * Specifies the spacing to be added to the top spacing. Default is 0. Use the
         * value 5 here to get the same label positions as in mxGraph 1.x.
         */
        baseSpacingTop: number;
        /**
         * Specifies the spacing to be added to the bottom spacing. Default is 0. Use the
         * value 1 here to get the same label positions as in mxGraph 1.x.
         */
        baseSpacingBottom: number;
        /**
         * Specifies the spacing to be added to the left spacing. Default is 0.
         */
        baseSpacingLeft: number;
        /**
         * Specifies the spacing to be added to the right spacing. Default is 0.
         */
        baseSpacingRight: number;
        /**
         * Specifies if linefeeds in HTML labels should be replaced with BR tags.
         * Default is true.
         */
        replaceLinefeeds: boolean;
        /**
         * Rotation for vertical text. Default is -90 (bottom to top).
         */
        verticalTextRotation: number;
        /**
         * Specifies if the string size should be measured in <updateBoundingBox> if
         * the label is clipped and the label position is center and middle. If this is
         * true, then the bounding box will be set to <bounds>. Default is true.
         * <ignoreStringSize> has precedence over this switch.
         */
        ignoreClippedStringSize: boolean;
        /**
         * Specifies if the actual string size should be measured. If disabled the
         * boundingBox will not ignore the actual size of the string, otherwise
         * <bounds> will be used instead. Default is false.
         */
        ignoreStringSize: boolean;
        /**
         * Specifies the padding to be added to the text width for the bounding box.
         * This is needed to make sure no clipping is applied to borders. Default is 4
         * for IE 8 standards mode and 3 for all others.
         */
        textWidthPadding: number;
        /**
         * Contains the last rendered text value. Used for caching.
         */
        lastValue: any;
        /**
         * Specifies if caching for HTML labels should be enabled. Default is true.
         */
        cacheEnabled: boolean;
        /**
         * Implicitly defined variables
         */
        textDirection: any;
        labelPadding: any;
        overflow: any;
        clipped: any;
        wrap: any;
        border: any;
        background: any;
        horizontal: any;
        spacingLeft: any;
        spacingBottom: any;
        spacingRight: any;
        spacingTop: any;
        fontStyle: any;
        size: any;
        family: any;
        valign: any;
        align: any;
        color: any;
        value: any;
        /**
         * Constructs a new text shape.
         *
         * @param value - String that represents the text to be displayed. This is stored in
         * <value>.
         * @param bounds - <mxRectangle> that defines the bounds. This is stored in
         * <mxShape.bounds>.
         * @param align - Specifies the horizontal alignment. Default is ''. This is stored in
         * <align>.
         * @param valign - Specifies the vertical alignment. Default is ''. This is stored in
         * <valign>.
         * @param color - String that specifies the text color. Default is 'black'. This is
         * stored in <color>.
         * @param family - String that specifies the font family. Default is
         * <mxConstants.DEFAULT_FONTFAMILY>. This is stored in <family>.
         * @param size - Integer that specifies the font size. Default is
         * <mxConstants.DEFAULT_FONTSIZE>. This is stored in <size>.
         * @param fontStyle - Specifies the font style. Default is 0. This is stored in
         * <fontStyle>.
         * @param spacing - Integer that specifies the global spacing. Default is 2. This is
         * stored in <spacing>.
         * @param spacingTop - Integer that specifies the top spacing. Default is 0. The
         * sum of the spacing and this is stored in <spacingTop>.
         * @param spacingRight - Integer that specifies the right spacing. Default is 0. The
         * sum of the spacing and this is stored in <spacingRight>.
         * @param spacingBottom - Integer that specifies the bottom spacing. Default is 0.The
         * sum of the spacing and this is stored in <spacingBottom>.
         * @param spacingLeft - Integer that specifies the left spacing. Default is 0. The
         * sum of the spacing and this is stored in <spacingLeft>.
         * @param horizontal - Boolean that specifies if the label is horizontal. Default is
         * true. This is stored in <horizontal>.
         * @param background - String that specifies the background color. Default is null.
         * This is stored in <background>.
         * @param border - String that specifies the label border color. Default is null.
         * This is stored in <border>.
         * @param wrap - Specifies if word-wrapping should be enabled. Default is false.
         * This is stored in <wrap>.
         * @param clipped - Specifies if the label should be clipped. Default is false.
         * This is stored in <clipped>.
         * @param overflow - Value of the overflow style. Default is 'visible'.
         */
        constructor(value: any, bounds: any, align: any, valign: any, color: any, family: any, size: any, fontStyle: any, spacing: any, spacingTop: any, spacingRight: any, spacingBottom: any, spacingLeft: any, horizontal: any, background: any, border: any, wrap: any, clipped: any, overflow: any, labelPadding: any, textDirection: any);
        /**
         * Text shapes do not contain VML markup and do not need to be parsed. This
         * method returns false to speed up rendering in IE8.
         */
        isParseVml(): boolean;
        /**
         * Returns true if HTML is allowed for this shape. This implementation returns
         * true if the browser is not in IE8 standards mode.
         */
        isHtmlAllowed(): boolean;
        /**
         * Disables offset in IE9 for crisper image output.
         */
        getSvgScreenOffset(): 0;
        /**
         * Returns true if the bounds are not null and all of its variables are numeric.
         */
        checkBounds(): boolean;
        /**
         * Generic rendering code.
         */
        paint(c: any, update?: boolean): void;
        /**
         * Renders the text using the given DOM nodes.
         */
        redraw(): void;
        /**
         * Resets all styles.
         */
        resetStyles(): void;
        /**
         * Extends mxShape to update the text styles.
         *
         * state - <mxCellState> of the corresponding cell.
         */
        apply(state: any): void;
        /**
         * Used to determine the automatic text direction. Returns
         * <mxConstants.TEXT_DIRECTION_LTR> or <mxConstants.TEXT_DIRECTION_RTL>
         * depending on the contents of <value>. This is not invoked for HTML, wrapped
         * content or if <value> is a DOM node.
         */
        getAutoDirection(): string;
        /**
         * Updates the <boundingBox> for this shape using the given node and position.
         */
        updateBoundingBox(): void;
        /**
         * Returns 0 to avoid using rotation in the canvas via updateTransform.
         */
        getShapeRotation(): number;
        /**
         * Returns the rotation for the text label of the corresponding shape.
         */
        getTextRotation(): number;
        /**
         * Inverts the bounds if <mxShape.isBoundsInverted> returns true or if the
         * horizontal style is false.
         */
        isPaintBoundsInverted(): boolean;
        /**
         * Sets the state of the canvas for drawing the shape.
         */
        configureCanvas(c: any, x: any, y: any, w: any, h: any): void;
        /**
         * Sets the width and height of the container to 1px.
         */
        updateVmlContainer(): void;
        /**
         * Updates the HTML node(s) to reflect the latest bounds and scale.
         */
        redrawHtmlShape(): void;
        /**
         * Returns the spacing as an <mxPoint>.
         */
        updateHtmlTransform(): void;
        /**
         * Sets the inner HTML of the given element to the <value>.
         */
        updateInnerHtml(elt: any): void;
        /**
         * Rotated text rendering quality is bad for IE9 quirks/IE8 standards
         */
        updateHtmlFilter(): void;
        /**
         * Updates the HTML node(s) to reflect the latest bounds and scale.
         */
        updateValue(): void;
        /**
         * Updates the HTML node(s) to reflect the latest bounds and scale.
         */
        updateFont(node: any): void;
        /**
         * Updates the HTML node(s) to reflect the latest bounds and scale.
         */
        updateSize(node: any, enableWrap: any): void;
        /**
         * Returns the spacing as an <mxPoint>.
         */
        updateMargin(): void;
        /**
         * Returns the spacing as an <mxPoint>.
         */
        getSpacing(): mxPoint;
    }
    /**
     * Implementation of the triangle shape.
     *
     * Constructor: mxTriangle
     *
     * Constructs a new triangle shape.
     */
    class mxTriangle extends mxActor {
        constructor();
        /**
         * Draws the path for this shape.
         */
        redrawPath(c: any, x: any, y: any, w: any, h: any): void;
    }
    /**
     * Implementation of the hexagon shape.
     *
     * Constructor: mxHexagon
     *
     * Constructs a new hexagon shape.
     */
    class mxHexagon extends mxActor {
        constructor();
        /**
         * Draws the path for this shape.
         */
        redrawPath(c: any, x: any, y: any, w: any, h: any): void;
    }
    /**
     * Class: mxLine
     *
     * Extends <mxShape> to implement a horizontal line shape.
     * This shape is registered under <mxConstants.SHAPE_LINE> in
     * <mxCellRenderer>.
     *
     * Constructor: mxLine
     *
     * Constructs a new line shape.
     *
     * Parameters:
     *
     * bounds - <mxRectangle> that defines the bounds. This is stored in
     * <mxShape.bounds>.
     * stroke - String that defines the stroke color. Default is 'black'. This is
     * stored in <stroke>.
     * strokewidth - Optional integer that defines the stroke width. Default is
     * 1. This is stored in <strokewidth>.
     */
    class mxLine extends mxShape {
        constructor(bounds: any, stroke: any, strokewidth: any, vertical?: boolean);
        /**
         * Redirects to redrawPath for subclasses to work.
         */
        paintVertexShape(c: any, x: any, y: any, w: any, h: any): void;
    }
    /**
     * Extends <mxShape> to implement an image shape. This shape is registered
     * under <mxConstants.SHAPE_IMAGE> in <mxCellRenderer>.
     */
    class mxImageShape extends mxRectangleShape {
        /**
         * Switch to preserve image aspect. Default is true.
         */
        preserveImageAspect: boolean;
        /** URL of the image */
        image: string;
        shadow: boolean;
        /**
         * Constructs a new image shape.
         *
         * @param bounds - <mxRectangle> that defines the bounds. This is stored in
         * <mxShape.bounds>.
         * @param image - String that specifies the URL of the image. This is stored in
         * <image>.
         * @param fill - String that defines the fill color. This is stored in <fill>.
         * @param stroke - String that defines the stroke color. This is stored in <stroke>.
         * @param strokewidth - Optional integer that defines the stroke width. Default is
         * 0. This is stored in <strokewidth>.
         */
        constructor(bounds: mxRectangle, image: string, fill: string, stroke: string, strokewidth?: number);
        /**
         * Disables offset in IE9 for crisper image output.
         */
        getSvgScreenOffset(): 0;
        /**
         * Overrides <mxShape.apply> to replace the fill and stroke colors with the
         * respective values from <mxConstants.STYLE_IMAGE_BACKGROUND> and
         * <mxConstants.STYLE_IMAGE_BORDER>.
         *
         * Applies the style of the given <mxCellState> to the shape. This
         * implementation assigns the following styles to local fields:
         *
         * - <mxConstants.STYLE_IMAGE_BACKGROUND> => fill
         * - <mxConstants.STYLE_IMAGE_BORDER> => stroke
         *
         * @param state - <mxCellState> of the corresponding cell.
         */
        apply(state: mxCellState): void;
        /**
         * Returns true if HTML is allowed for this shape. This implementation always
         * returns false.
         */
        isHtmlAllowed(): boolean;
        /**
         * Creates and returns the HTML DOM node(s) to represent
         * this shape. This implementation falls back to <createVml>
         * so that the HTML creation is optional.
         */
        createHtml(): HTMLDivElement;
        /**
         * Generic background painting implementation.
         */
        paintVertexShape(c: any, x: any, y: any, w: any, h: any): void;
        /**
         * Overrides <mxShape.redraw> to preserve the aspect ratio of images.
         */
        redrawHtmlShape(): void;
    }
    /**
     * Extends <mxShape> to implement an image shape with a label.
     * This shape is registered under <mxConstants.SHAPE_LABEL> in
     * <mxCellRenderer>.
     *
     * Constructor: mxLabel
     *
     * Constructs a new label shape.
     *
     * Parameters:
     *
     * bounds - <mxRectangle> that defines the bounds. This is stored in
     * <mxShape.bounds>.
     * fill - String that defines the fill color. This is stored in <fill>.
     * stroke - String that defines the stroke color. This is stored in <stroke>.
     * strokewidth - Optional integer that defines the stroke width. Default is
     * 1. This is stored in <strokewidth>.
     */
    class mxLabel extends mxRectangleShape {
        constructor(bounds: any, fill: any, stroke: any, strokewidth: any);
        /**
         * Initializes the shape and the <indicator>.
         */
        init(container: any): void;
        /**
         * Reconfigures this shape. This will update the colors of the indicator
         * and reconfigure it if required.
         */
        redraw(): void;
        /**
         * Returns true for non-rounded, non-rotated shapes with no glass gradient and
         * no indicator shape.
         */
        isHtmlAllowed(): boolean;
        /**
         * Generic background painting implementation.
         */
        paintForeground(c: any, x: any, y: any, w: any, h: any): void;
        /**
         * Generic background painting implementation.
         */
        paintImage(c: any, x: any, y: any, w: any, h: any): void;
        /**
         * Generic background painting implementation.
         */
        getImageBounds(x: any, y: any, w: any, h: any): mxRectangle;
        /**
         * Generic background painting implementation.
         */
        paintIndicator(c: any, x: any, y: any, w: any, h: any): void;
        /**
         * Generic background painting implementation.
         */
        getIndicatorBounds(x: any, y: any, w: any, h: any): mxRectangle;
        /**
         * Generic background painting implementation.
         */
        redrawHtmlShape(): void;
    }
    /**
     * Extends <mxShape> to implement an cylinder shape. If a
     * custom shape with one filled area and an overlay path is
     * needed, then this shape's <redrawPath> should be overridden.
     * This shape is registered under <mxConstants.SHAPE_CYLINDER>
     * in <mxCellRenderer>.
     *
     * Constructor: mxCylinder
     *
     * Constructs a new cylinder shape.
     *
     * Parameters:
     *
     * bounds - <mxRectangle> that defines the bounds. This is stored in
     * <mxShape.bounds>.
     * fill - String that defines the fill color. This is stored in <fill>.
     * stroke - String that defines the stroke color. This is stored in <stroke>.
     * strokewidth - Optional integer that defines the stroke width. Default is
     * 1. This is stored in <strokewidth>.
     */
    class mxCylinder extends mxShape {
        constructor(bounds: any, fill: any, stroke: any, strokewidth: any);
        /**
         * Redirects to redrawPath for subclasses to work.
         */
        paintVertexShape(c: any, x: any, y: any, w: any, h: any): void;
        /**
         * Draws the path for this shape.
         */
        redrawPath(c: any, x: any, y: any, w: any, h: any, isForeground: any): void;
    }
    /**
     * Extends <mxShape> to implement a connector shape. The connector
     * shape allows for arrow heads on either side.
     *
     * This shape is registered under <mxConstants.SHAPE_CONNECTOR> in
     * <mxCellRenderer>.
     *
     * Constructor: mxConnector
     *
     * Constructs a new connector shape.
     *
     * Parameters:
     *
     * points - Array of <mxPoints> that define the points. This is stored in
     * <mxShape.points>.
     * stroke - String that defines the stroke color. This is stored in <stroke>.
     * Default is 'black'.
     * strokewidth - Optional integer that defines the stroke width. Default is
     * 1. This is stored in <strokewidth>.
     */
    class mxConnector extends mxPolyline {
        constructor(points: any, stroke: any, strokewidth: any);
        /**
         * Updates the <boundingBox> for this shape using <createBoundingBox> and
         * <augmentBoundingBox> and stores the result in <boundingBox>.
         */
        updateBoundingBox(): void;
        /**
         * Paints the line shape.
         */
        paintEdgeShape(c: any, pts: any): void;
        /**
         * Prepares the marker by adding offsets in pts and returning a function to
         * paint the marker.
         */
        createMarker(c: any, pts: any, source: any): any;
        /**
         * Augments the bounding box with the strokewidth and shadow offsets.
         */
        augmentBoundingBox(bbox: any): void;
    }
    /**
     * Extends <mxShape> to implement a swimlane shape. This shape is registered
     * under <mxConstants.SHAPE_SWIMLANE> in <mxCellRenderer>. Use the
     * <mxConstants.STYLE_STYLE_STARTSIZE> to define the size of the title
     * region, <mxConstants.STYLE_SWIMLANE_FILLCOLOR> for the content area fill,
     * <mxConstants.STYLE_SEPARATORCOLOR> to draw an additional vertical separator
     * and <mxConstants.STYLE_SWIMLANE_LINE> to hide the line between the title
     * region and the content area. The <mxConstants.STYLE_HORIZONTAL> affects
     * the orientation of this shape, not only its label.
     *
     * Constructor: mxSwimlane
     *
     * Constructs a new swimlane shape.
     *
     * Parameters:
     *
     * bounds - <mxRectangle> that defines the bounds. This is stored in
     * <mxShape.bounds>.
     * fill - String that defines the fill color. This is stored in <fill>.
     * stroke - String that defines the stroke color. This is stored in <stroke>.
     * strokewidth - Optional integer that defines the stroke width. Default is
     * 1. This is stored in <strokewidth>.
     */
    class mxSwimlane extends mxShape {
        constructor(bounds: any, fill: any, stroke: any, strokewidth: any);
        /**
         * Returns the bounding box for the gradient box for this shape.
         */
        getTitleSize(): number;
        /**
         * Returns the bounding box for the gradient box for this shape.
         */
        getLabelBounds(rect: any): mxRectangle;
        /**
         * Returns the bounding box for the gradient box for this shape.
         */
        getGradientBounds(c: any, x: any, y: any, w: any, h: any): mxRectangle;
        /**
         * Returns the arcsize for the swimlane.
         */
        getArcSize(w: any, h: any, start?: any): number;
        /**
         * Paints the swimlane vertex shape.
         */
        isHorizontal(): boolean;
        /**
         * Paints the swimlane vertex shape.
         */
        paintVertexShape(c: any, x: any, y: any, w: any, h: any): void;
        /**
         * Paints the swimlane vertex shape.
         */
        paintSwimlane(c: any, x: any, y: any, w: any, h: any, start: any, fill: any, swimlaneLine: any): void;
        /**
         * Paints the swimlane vertex shape.
         */
        paintRoundedSwimlane(c: any, x: any, y: any, w: any, h: any, start: any, r: any, fill: any, swimlaneLine: any): void;
        /**
         * Paints the swimlane vertex shape.
         */
        paintSeparator(c: any, x: any, y: any, w: any, h: any, start: any, color: any): void;
        /**
         * Paints the swimlane vertex shape.
         */
        getImageBounds(x: any, y: any, w: any, h: any): mxRectangle;
    }
    var mxLog: {
        consoleName: string;
        TRACE: boolean;
        DEBUG: boolean;
        WARN: boolean;
        buffer: string;
        init(): void;
        info(): void;
        addButton(lab: any, funct: any): void;
        isVisible(): any;
        show(): void;
        setVisible(visible: any): void;
        enter(string: any): number;
        leave(string: any, t0: any): void;
        debug(string: any, t0: any): void;
        warn(string: any, t0: any): void;
        write(string: any, t0: any): void;
        writeln(string: any, t0: any): void;
    };
    var mxObjectIdentity: {
        FIELD_NAME: string;
        counter: number;
        get(obj: any): any;
        clear(obj: any): void;
    };
    /**
     * A wrapper class for an associative array with object keys. Note: This
     * implementation uses <mxObjectIdentitiy> to turn object keys into strings.
     *
     * Constructor: mxEventSource
     *
     * Constructs a new dictionary which allows object to be used as keys.
     */
    class mxDictionary {
        /**
         * Function: map
         *
         * Stores the (key, value) pairs in this dictionary.
         */
        map: any;
        constructor();
        /**
         * Clears the dictionary.
         */
        clear(): void;
        /**
         * Returns the value for the given key.
         */
        get(key: any): any;
        /**
         * Stores the value under the given key and returns the previous
         * value for that key.
         */
        put(key: any, value: any): any;
        /**
         * Removes the value for the given key and returns the value that
         * has been removed.
         */
        remove(key: any): any;
        /**
         * Returns all keys as an array.
         */
        getKeys(): any[];
        /**
         * Returns all values as an array.
         */
        getValues(): any[];
        /**
         * Visits all entries in the dictionary using the given function with the
         * following signature: function(key, value) where key is a string and
         * value is an object.
         *
         * Parameters:
         *
         * visitor - A function that takes the key and value as arguments.
         */
        visit(visitor: any): void;
    }
    var mxResources: {
        resources: any[];
        extension: string;
        resourcesEncoded: boolean;
        loadDefaultBundle: boolean;
        loadSpecialBundle: boolean;
        isLanguageSupported(lan: any): boolean;
        getDefaultBundle(basename: any, lan: any): string;
        getSpecialBundle(basename: string, lan: string): string;
        add(basename: string, lan?: string, callback?: () => void): void;
        parse(text: string): void;
        get(key: string, params?: string[], defaultValue?: string): string;
        replacePlaceholders(value: string, params: string[]): string;
        loadResources(callback?: () => void): void;
    };
    /**
     * Implements a 2-dimensional vector with double precision coordinates.
     */
    class mxPoint {
        /**
         * Holds the x-coordinate of the point. Default is 0.
         * @desc Relative to left corner.
         */
        x: number;
        /**
         * Holds the y-coordinate of the point. Default is 0.
         * @desc Relative to top.
         */
        y: number;
        /**
         * Constructs a new point for the optional x and y coordinates, relative to
         * the top left corner. If no coordinates are given, then the default values
         * for <x> and <y> are used.
         */
        constructor(x?: number, y?: number);
        /**
         * Returns true if the given object equals this point.
         */
        equals(obj: mxPoint): boolean;
        /**
         * Returns a clone of this <mxPoint>.
         */
        clone(): any;
    }
    /**
     * Extends <mxPoint> to implement a 2-dimensional rectangle with double
     * precision coordinates.
     */
    class mxRectangle extends mxPoint {
        /**
         * Holds the width of the rectangle. Default is 0.
         */
        width: number;
        /**
         * Holds the height of the rectangle. Default is 0.
         */
        height: number;
        /**
         * Constructs a new rectangle for the optional parameters. If no parameters
         * are given then the respective default values are used.
         *
         * @param x X-coordinate of the rectangle origin (top left corner)
         * @param y Y-coordinate of the rectangle origin (top left corner)
         * @param w Width of the rectangle
         * @param h Height of the rectangle
         */
        constructor(x?: number, y?: number, width?: number, height?: number);
        /**
         * Sets this rectangle to the specified values
         *
         * @param x X-coordinate of the rectangle origin (top left corner)
         * @param y Y-coordinate of the rectangle origin (top left corner)
         * @param w Width of the rectangle
         * @param h Height of the rectangle
         */
        setRect(x: number, y: number, w: number, h: number): void;
        /**
         * Returns the x-coordinate of the center point.
         */
        getCenterX(): number;
        /**
         * Returns the y-coordinate of the center point.
         */
        getCenterY(): number;
        /**
         * Adds the given rectangle to this rectangle, i.e. such that it just
         * about contains the supplied rectangle.
         *
         * @param rect
         */
        add(rect: mxRectangle): void;
        /**
         * Changes this rectangle to where it overlaps with the given rectangle.
         *
         * @param rect
         */
        intersect(rect: mxRectangle): void;
        /**
         * Grows the rectangle by the given amount, that is, this method subtracts
         * the given amount from the x- and y-coordinates and adds twice the amount
         * to the width and height.
         */
        grow(amount: number): void;
        /**
         * Returns the top, left corner as a new <mxPoint>.
         */
        getPoint(): mxPoint;
        /**
         * Rotates this rectangle by 90 degree around its center point.
         */
        rotate90(): void;
        /**
         * Returns true if the given object equals this rectangle.
         */
        equals(obj: mxRectangle): boolean;
        /**
         * Returns a new <mxRectangle> which is a copy of the given rectangle.
         */
        static fromRectangle(rect: mxRectangle): mxRectangle;
    }
    var mxEffects: {
        animateChanges(graph: any, changes: any, done: any): void;
        cascadeOpacity(graph: any, cell: any, opacity: any): void;
        fadeOut(node: any, from: any, remove: any, step: any, delay: any, isEnabled: any): void;
    };
    var mxUtils: {
        errorResource: string;
        closeResource: string;
        errorImage: string;
        removeCursors(element: HTMLElement): void;
        getCurrentStyle(elt: HTMLElement): CSSStyleDeclaration;
        parseCssNumber(value: string): number;
        setPrefixedStyle(style: any, name: string, value: any): void;
        htmlEntities(s: string, newline?: boolean): any;
        hasScrollbars(elt: HTMLElement): boolean;
        getOffset(container: HTMLElement, scrollOffset?: boolean): mxPoint;
        /**
         * Function: makeDraggable
         *
         * Configures the given DOM element to act as a drag source for the
         * specified graph. Returns a a new <mxDragSource>. If
         * <mxDragSource.guideEnabled> is enabled then the x and y arguments must
         * be used in funct to match the preview location.
         *
         * Example:
         *
         * (code)
         * var funct = function(graph, evt, cell, x, y)
         * {
         *   if (graph.canImportCell(cell))
         *   {
         *     var parent = graph.getDefaultParent();
         *     var vertex = null;
         *
         *     graph.getModel().beginUpdate();
         *     try
         *     {
         * 	     vertex = graph.insertVertex(parent, null, 'Hello', x, y, 80, 30);
         *     }
         *     finally
         *     {
         *       graph.getModel().endUpdate();
         *     }
         *
         *     graph.setSelectionCell(vertex);
         *   }
         * }
         *
         * var img = document.createElement('img');
         * img.setAttribute('src', 'editors/images/rectangle.gif');
         * img.style.position = 'absolute';
         * img.style.left = '0px';
         * img.style.top = '0px';
         * img.style.width = '16px';
         * img.style.height = '16px';
         *
         * var dragImage = img.cloneNode(true);
         * dragImage.style.width = '32px';
         * dragImage.style.height = '32px';
         * mxUtils.makeDraggable(img, graph, funct, dragImage);
         * document.body.appendChild(img);
         * (end)
         *
         * Parameters:
         *
         * element - DOM element to make draggable.
         * graphF - <mxGraph> that acts as the drop target or a function that takes a
         * mouse event and returns the current <mxGraph>.
         * funct - Function to execute on a successful drop.
         * dragElement - Optional DOM node to be used for the drag preview.
         * dx - Optional horizontal offset between the cursor and the drag
         * preview.
         * dy - Optional vertical offset between the cursor and the drag
         * preview.
         * autoscroll - Optional boolean that specifies if autoscroll should be
         * used. Default is mxGraph.autoscroll.
         * scalePreview - Optional boolean that specifies if the preview element
         * should be scaled according to the graph scale. If this is true, then
         * the offsets will also be scaled. Default is false.
         * highlightDropTargets - Optional boolean that specifies if dropTargets
         * should be highlighted. Default is true.
         * getDropTarget - Optional function to return the drop target for a given
         * location (x, y). Default is mxGraph.getCellAt.
         */
        makeDraggable(element: HTMLElement, graphF: mxGraph, funct: Function, dragElement?: HTMLElement, dx?: number, dy?: number, autoscroll?: boolean, scalePreview?: boolean, highlightDropTargets?: boolean, getDropTarget?: (x: number, y: number) => mxCell): mxDragSource;
        /**
         * Function: setOpacity
         *
         * Sets the opacity of the specified DOM node to the given value in %.
         *
         * Parameters:
         *
         * node - DOM node to set the opacity for.
         * value - Opacity in %. Possible values are between 0 and 100.
         */
        setOpacity(node: HTMLElement, value: number): void;
        /**
         * Function: convertPoint
         *
         * Converts the specified point (x, y) using the offset of the specified
         * container and returns a new <mxPoint> with the result.
         *
         * (code)
         * var pt = mxUtils.convertPoint(graph.container,
         *   mxEvent.getClientX(evt), mxEvent.getClientY(evt));
         * (end)
         *
         * Parameters:
         *
         * container - DOM node to use for the offset.
         * x - X-coordinate of the point to be converted.
         * y - Y-coordinate of the point to be converted.
         */
        convertPoint(container: HTMLElement, x: number, y: number): mxPoint;
        /**
         * Function: getValue
         *
         * Returns the value for the given key in the given associative array or
         * the given default value if the value is null.
         *
         * Parameters:
         *
         * array - Associative array that contains the value for the key.
         * key - Key whose value should be returned.
         * defaultValue - Value to be returned if the value for the given
         * key is null.
         */
        getValue(array: any[], key: any, defaultValue?: any): any;
        /**
         * Function: indexOf
         *
         * Returns the index of obj in array or -1 if the array does not contain
         * the given object.
         *
         * Parameters:
         *
         * array - Array to check for the given obj.
         * obj - Object to find in the given array.
         */
        indexOf(array: any[], obj: any): number;
        [key: string]: any;
    };
    class mxConstants {
        static DEFAULT_HOTSPOT: number;
        static MIN_HOTSPOT_SIZE: number;
        static MAX_HOTSPOT_SIZE: number;
        static RENDERING_HINT_EXACT: string;
        static RENDERING_HINT_FASTER: string;
        static RENDERING_HINT_FASTEST: string;
        static DIALECT_SVG: string;
        static DIALECT_VML: string;
        static DIALECT_MIXEDHTML: string;
        static DIALECT_PREFERHTML: string;
        static DIALECT_STRICTHTML: string;
        static NS_SVG: string;
        static NS_XHTML: string;
        static NS_XLINK: string;
        static SHADOWCOLOR: string;
        static VML_SHADOWCOLOR: string;
        static SHADOW_OFFSET_X: number;
        static SHADOW_OFFSET_Y: number;
        static SHADOW_OPACITY: number;
        static NODETYPE_ELEMENT: number;
        static NODETYPE_ATTRIBUTE: number;
        static NODETYPE_TEXT: number;
        static NODETYPE_CDATA: number;
        static NODETYPE_ENTITY_REFERENCE: number;
        static NODETYPE_ENTITY: number;
        static NODETYPE_PROCESSING_INSTRUCTION: number;
        static NODETYPE_COMMENT: number;
        static NODETYPE_DOCUMENT: number;
        static NODETYPE_DOCUMENTTYPE: number;
        static NODETYPE_DOCUMENT_FRAGMENT: number;
        static NODETYPE_NOTATION: number;
        static TOOLTIP_VERTICAL_OFFSET: number;
        static DEFAULT_VALID_COLOR: string;
        static DEFAULT_INVALID_COLOR: string;
        static OUTLINE_HIGHLIGHT_COLOR: string;
        static OUTLINE_HIGHLIGHT_STROKEWIDTH: number;
        static HIGHLIGHT_STROKEWIDTH: number;
        static HIGHLIGHT_SIZE: number;
        static HIGHLIGHT_OPACITY: number;
        static CURSOR_MOVABLE_VERTEX: string;
        static CURSOR_MOVABLE_EDGE: string;
        static CURSOR_LABEL_HANDLE: string;
        static CURSOR_TERMINAL_HANDLE: string;
        static CURSOR_BEND_HANDLE: string;
        static CURSOR_VIRTUAL_BEND_HANDLE: string;
        static CURSOR_CONNECT: string;
        static HIGHLIGHT_COLOR: string;
        static CONNECT_TARGET_COLOR: string;
        static INVALID_CONNECT_TARGET_COLOR: string;
        static DROP_TARGET_COLOR: string;
        static VALID_COLOR: string;
        static INVALID_COLOR: string;
        static EDGE_SELECTION_COLOR: string;
        static VERTEX_SELECTION_COLOR: string;
        static VERTEX_SELECTION_STROKEWIDTH: number;
        static EDGE_SELECTION_STROKEWIDTH: number;
        static VERTEX_SELECTION_DASHED: boolean;
        static EDGE_SELECTION_DASHED: boolean;
        static GUIDE_COLOR: string;
        static GUIDE_STROKEWIDTH: number;
        static OUTLINE_COLOR: string;
        static OUTLINE_STROKEWIDTH: number;
        static HANDLE_SIZE: number;
        static LABEL_HANDLE_SIZE: number;
        static HANDLE_FILLCOLOR: string;
        static HANDLE_STROKECOLOR: string;
        static LABEL_HANDLE_FILLCOLOR: string;
        static CONNECT_HANDLE_FILLCOLOR: string;
        static LOCKED_HANDLE_FILLCOLOR: string;
        static OUTLINE_HANDLE_FILLCOLOR: string;
        static OUTLINE_HANDLE_STROKECOLOR: string;
        static DEFAULT_FONTFAMILY: string;
        static DEFAULT_FONTSIZE: number;
        static DEFAULT_TEXT_DIRECTION: string;
        static LINE_HEIGHT: number;
        static WORD_WRAP: string;
        static ABSOLUTE_LINE_HEIGHT: boolean;
        static DEFAULT_FONTSTYLE: number;
        static DEFAULT_STARTSIZE: number;
        static DEFAULT_MARKERSIZE: number;
        static DEFAULT_IMAGESIZE: number;
        static ENTITY_SEGMENT: number;
        static RECTANGLE_ROUNDING_FACTOR: number;
        static LINE_ARCSIZE: number;
        static ARROW_SPACING: number;
        static ARROW_WIDTH: number;
        static ARROW_SIZE: number;
        static PAGE_FORMAT_A4_PORTRAIT: mxRectangle;
        static PAGE_FORMAT_A4_LANDSCAPE: mxRectangle;
        static PAGE_FORMAT_LETTER_PORTRAIT: mxRectangle;
        static PAGE_FORMAT_LETTER_LANDSCAPE: mxRectangle;
        static NONE: string;
        static STYLE_PERIMETER: string;
        static STYLE_SOURCE_PORT: string;
        static STYLE_TARGET_PORT: string;
        static STYLE_PORT_CONSTRAINT: string;
        static STYLE_PORT_CONSTRAINT_ROTATION: string;
        static STYLE_SOURCE_PORT_CONSTRAINT: string;
        static STYLE_TARGET_PORT_CONSTRAINT: string;
        static STYLE_OPACITY: string;
        static STYLE_FILL_OPACITY: string;
        static STYLE_STROKE_OPACITY: string;
        static STYLE_TEXT_OPACITY: string;
        static STYLE_TEXT_DIRECTION: string;
        static STYLE_OVERFLOW: string;
        static STYLE_ORTHOGONAL: string;
        static STYLE_EXIT_X: string;
        static STYLE_EXIT_Y: string;
        static STYLE_EXIT_PERIMETER: string;
        static STYLE_ENTRY_X: string;
        static STYLE_ENTRY_Y: string;
        static STYLE_ENTRY_PERIMETER: string;
        static STYLE_WHITE_SPACE: string;
        static STYLE_ROTATION: string;
        static STYLE_FILLCOLOR: string;
        static STYLE_POINTER_EVENTS: string;
        static STYLE_SWIMLANE_FILLCOLOR: string;
        static STYLE_MARGIN: string;
        static STYLE_GRADIENTCOLOR: string;
        static STYLE_GRADIENT_DIRECTION: string;
        static STYLE_STROKECOLOR: string;
        static STYLE_SEPARATORCOLOR: string;
        static STYLE_STROKEWIDTH: string;
        static STYLE_ALIGN: string;
        static STYLE_VERTICAL_ALIGN: string;
        static STYLE_LABEL_WIDTH: string;
        static STYLE_LABEL_POSITION: string;
        static STYLE_VERTICAL_LABEL_POSITION: string;
        static STYLE_IMAGE_ASPECT: string;
        static STYLE_IMAGE_ALIGN: string;
        static STYLE_IMAGE_VERTICAL_ALIGN: string;
        static STYLE_GLASS: string;
        static STYLE_IMAGE: string;
        static STYLE_IMAGE_WIDTH: string;
        static STYLE_IMAGE_HEIGHT: string;
        static STYLE_IMAGE_BACKGROUND: string;
        static STYLE_IMAGE_BORDER: string;
        static STYLE_FLIPH: string;
        static STYLE_FLIPV: string;
        static STYLE_NOLABEL: string;
        static STYLE_NOEDGESTYLE: string;
        static STYLE_LABEL_BACKGROUNDCOLOR: string;
        static STYLE_LABEL_BORDERCOLOR: string;
        static STYLE_LABEL_PADDING: string;
        static STYLE_INDICATOR_SHAPE: string;
        static STYLE_INDICATOR_IMAGE: string;
        static STYLE_INDICATOR_COLOR: string;
        static STYLE_INDICATOR_STROKECOLOR: string;
        static STYLE_INDICATOR_GRADIENTCOLOR: string;
        static STYLE_INDICATOR_SPACING: string;
        static STYLE_INDICATOR_WIDTH: string;
        static STYLE_INDICATOR_HEIGHT: string;
        static STYLE_INDICATOR_DIRECTION: string;
        static STYLE_SHADOW: string;
        static STYLE_SEGMENT: string;
        static STYLE_ENDARROW: string;
        static STYLE_STARTARROW: string;
        static STYLE_ENDSIZE: string;
        static STYLE_STARTSIZE: string;
        static STYLE_SWIMLANE_LINE: string;
        static STYLE_ENDFILL: string;
        static STYLE_STARTFILL: string;
        static STYLE_DASHED: string;
        static STYLE_DASH_PATTERN: string;
        static STYLE_FIX_DASH: string;
        static STYLE_ROUNDED: string;
        static STYLE_CURVED: string;
        static STYLE_ARCSIZE: string;
        static STYLE_ABSOLUTE_ARCSIZE: string;
        static STYLE_SOURCE_PERIMETER_SPACING: string;
        static STYLE_TARGET_PERIMETER_SPACING: string;
        static STYLE_PERIMETER_SPACING: string;
        static STYLE_SPACING: string;
        static STYLE_SPACING_TOP: string;
        static STYLE_SPACING_LEFT: string;
        static STYLE_SPACING_BOTTOM: string;
        static STYLE_SPACING_RIGHT: string;
        static STYLE_HORIZONTAL: string;
        static STYLE_DIRECTION: string;
        static STYLE_ELBOW: string;
        static STYLE_FONTCOLOR: string;
        static STYLE_FONTFAMILY: string;
        static STYLE_FONTSIZE: string;
        static STYLE_FONTSTYLE: string;
        static STYLE_ASPECT: string;
        static STYLE_AUTOSIZE: string;
        static STYLE_FOLDABLE: string;
        static STYLE_EDITABLE: string;
        static STYLE_BENDABLE: string;
        static STYLE_MOVABLE: string;
        static STYLE_RESIZABLE: string;
        static STYLE_RESIZE_WIDTH: string;
        static STYLE_RESIZE_HEIGHT: string;
        static STYLE_ROTATABLE: string;
        static STYLE_CLONEABLE: string;
        static STYLE_DELETABLE: string;
        static STYLE_SHAPE: string;
        static STYLE_EDGE: string;
        static STYLE_JETTY_SIZE: string;
        static STYLE_SOURCE_JETTY_SIZE: string;
        static STYLE_TARGET_JETTY_SIZE: string;
        static STYLE_LOOP: string;
        static STYLE_ORTHOGONAL_LOOP: string;
        static STYLE_ROUTING_CENTER_X: string;
        static STYLE_ROUTING_CENTER_Y: string;
        static FONT_BOLD: number;
        static FONT_ITALIC: number;
        static FONT_UNDERLINE: number;
        static SHAPE_RECTANGLE: string;
        static SHAPE_ELLIPSE: string;
        static SHAPE_DOUBLE_ELLIPSE: string;
        static SHAPE_RHOMBUS: string;
        static SHAPE_LINE: string;
        static SHAPE_IMAGE: string;
        static SHAPE_ARROW: string;
        static SHAPE_ARROW_CONNECTOR: string;
        static SHAPE_LABEL: string;
        static SHAPE_CYLINDER: string;
        static SHAPE_SWIMLANE: string;
        static SHAPE_CONNECTOR: string;
        static SHAPE_ACTOR: string;
        static SHAPE_CLOUD: string;
        static SHAPE_TRIANGLE: string;
        static SHAPE_HEXAGON: string;
        static ARROW_CLASSIC: string;
        static ARROW_CLASSIC_THIN: string;
        static ARROW_BLOCK: string;
        static ARROW_BLOCK_THIN: string;
        static ARROW_OPEN: string;
        static ARROW_OPEN_THIN: string;
        static ARROW_OVAL: string;
        static ARROW_DIAMOND: string;
        static ARROW_DIAMOND_THIN: string;
        static ALIGN_LEFT: string;
        static ALIGN_CENTER: string;
        static ALIGN_RIGHT: string;
        static ALIGN_TOP: string;
        static ALIGN_MIDDLE: string;
        static ALIGN_BOTTOM: string;
        static DIRECTION_NORTH: string;
        static DIRECTION_SOUTH: string;
        static DIRECTION_EAST: string;
        static DIRECTION_WEST: string;
        static TEXT_DIRECTION_DEFAULT: string;
        static TEXT_DIRECTION_AUTO: string;
        static TEXT_DIRECTION_LTR: string;
        static TEXT_DIRECTION_RTL: string;
        static DIRECTION_MASK_NONE: number;
        static DIRECTION_MASK_WEST: number;
        static DIRECTION_MASK_NORTH: number;
        static DIRECTION_MASK_SOUTH: number;
        static DIRECTION_MASK_EAST: number;
        static DIRECTION_MASK_ALL: number;
        static ELBOW_VERTICAL: string;
        static ELBOW_HORIZONTAL: string;
        static EDGESTYLE_ELBOW: string;
        static EDGESTYLE_ENTITY_RELATION: string;
        static EDGESTYLE_LOOP: string;
        static EDGESTYLE_SIDETOSIDE: string;
        static EDGESTYLE_TOPTOBOTTOM: string;
        static EDGESTYLE_ORTHOGONAL: string;
        static EDGESTYLE_SEGMENT: string;
        static PERIMETER_ELLIPSE: string;
        static PERIMETER_RECTANGLE: string;
        static PERIMETER_RHOMBUS: string;
        static PERIMETER_HEXAGON: string;
        static PERIMETER_TRIANGLE: string;
    }
    /**
     * The mxEventObject is a wrapper for all properties of a single event.
     * Additionally, it also offers functions to consume the event and check if it
     * was consumed as follows:
     *
     * @example
     * evt.consume();
     * INV: evt.isConsumed() == true
     */
    class mxEventObject {
        /**
         * Holds the name.
         */
        name: string;
        /**
         * Holds the properties as an associative array.
         */
        properties: any;
        /**
         * Holds the consumed state. Default is false.
         */
        consumed: boolean;
        /**
         * Constructs a new event object with the specified name. An optional
         * sequence of key, value pairs can be appended to define properties.
         *
         * @example
         * new mxEventObject("eventName", key1, val1, .., keyN, valN)
         */
        constructor(name?: any, ...args: any[]);
        /**
         * Returns <name>.
         */
        getName(): string;
        /**
         * Returns <properties>.
         */
        getProperties(): any;
        /**
         * Returns the property for the given key.
         */
        getProperty(key: any): any;
        /**
         * Returns true if the event has been consumed.
         */
        isConsumed(): boolean;
        /**
         * Consumes the event.
         */
        consume(): void;
    }
    /**
     * Base class for all mouse events in mxGraph. A listener for this event should
     * implement the following methods:
     *
     * (code)
     * graph.addMouseListener(
     * {
     *   mouseDown: function(sender, evt)
     *   {
     *     mxLog.debug('mouseDown');
     *   },
     *   mouseMove: function(sender, evt)
     *   {
     *     mxLog.debug('mouseMove');
     *   },
     *   mouseUp: function(sender, evt)
     *   {
     *     mxLog.debug('mouseUp');
     *   }
     * });
     * (end)
     *
     * Constructor: mxMouseEvent
     *
     * Constructs a new event object for the given arguments.
     *
     * Parameters:
     *
     * evt - Native mouse event.
     * state - Optional <mxCellState> under the mouse.
     *
     */
    class mxMouseEvent {
        constructor(evt: any, state?: any);
        /**
         * Returns <evt>.
         */
        getEvent(): any;
        /**
         * Returns the target DOM element using <mxEvent.getSource> for <evt>.
         */
        getSource(): any;
        /**
         * Returns true if the given <mxShape> is the source of <evt>.
         */
        isSource(shape: any): any;
        /**
         * Returns <evt.clientX>.
         */
        getX(): any;
        /**
         * Returns <evt.clientY>.
         */
        getY(): any;
        /**
         * Returns <graphX>.
         */
        getGraphX(): any;
        /**
         * Returns <graphY>.
         */
        getGraphY(): any;
        /**
         * Returns <state>.
         */
        getState(): any;
        /**
         * Returns the <mxCell> in <state> is not null.
         */
        getCell(): any;
        /**
         * Returns true if the event is a popup trigger.
         */
        isPopupTrigger(): boolean;
        /**
         * Returns <consumed>.
         */
        isConsumed(): any;
        /**
         * Sets <consumed> to true and invokes preventDefault on the native event
         * if such a method is defined. This is used mainly to avoid the cursor from
         * being changed to a text cursor in Webkit. You can use the preventDefault
         * flag to disable this functionality.
         *
         * Parameters:
         *
         * preventDefault - Specifies if the native event should be canceled. Default
         * is true.
         */
        consume(preventDefault?: any): void;
    }
    /**
     * Base class for objects that dispatch named events. To create a subclass that
     * inherits from mxEventSource, the following code is used.
     *
     * (code)
     * function MyClass(): void;
     *
     * MyClass.prototype = new mxEventSource();
     * MyClass.prototype.constructor = MyClass;
     * (end)
     *
     * Known Subclasses:
     *
     * <mxGraphModel>, <mxGraph>, <mxGraphView>, <mxEditor>, <mxCellOverlay>,
     * <mxToolbar>, <mxWindow>
     */
    class mxEventSource {
        /**
         * Holds the event names and associated listeners in an array. The array
         * contains the event name followed by the respective listener for each
         * registered listener.
         */
        eventListeners: any;
        /**
         * Specifies if events can be fired. Default is true.
         */
        eventsEnabled: boolean;
        /**
         * Optional source for events. Default is null.
         */
        eventSource: any;
        /**
         * Constructs a new event source.
         */
        constructor(eventSource?: any);
        /**
         * Returns <eventsEnabled>.
         */
        isEventsEnabled(): boolean;
        /**
         * Sets <eventsEnabled>.
         */
        setEventsEnabled(value: any): void;
        /**
         * Returns <eventSource>.
         */
        getEventSource(): any;
        /**
         * Sets <eventSource>.
         */
        setEventSource(value: any): void;
        /**
         * Binds the specified function to the given event name. If no event name
         * is given, then the listener is registered for all events.
         *
         * The parameters of the listener are the sender and an <mxEventObject>.
         */
        addListener(name: any, funct: any): void;
        /**
         * Removes all occurrences of the given listener from <eventListeners>.
         */
        removeListener(funct: any): void;
        /**
         * Dispatches the given event to the listeners which are registered for
         * the event. The sender argument is optional. The current execution scope
         * ("this") is used for the listener invocation (see <mxUtils.bind>).
         *
         * Example:
         *
         * (code)
         * fireEvent(new mxEventObject("eventName", key1, val1, .., keyN, valN))
         * (end)
         *
         * Parameters:
         *
         * evt - <mxEventObject> that represents the event.
         * sender - Optional sender to be passed to the listener. Default value is
         * the return value of <getEventSource>.
         */
        fireEvent(evt: mxEventObject, sender?: mxEventSource): void;
    }
    var mxEvent: {
        EVENT_SCALE: string;
        EVENT_HIDE: string;
        objects: any[];
        addListener: (element: any, eventName: any, funct: any) => void;
        removeListener: (element: any, eventName: any, funct: any) => void;
        removeAllListeners(element: any): void;
        addGestureListeners(node: any, startListener: any, moveListener?: any, endListener?: any): void;
        removeGestureListeners(node: any, startListener: any, moveListener?: any, endListener?: any): void;
        redirectMouseEvents(node: any, graph: any, state: any, down?: any, move?: any, up?: any, dblClick?: any): void;
        release(element: any): void;
        addMouseWheelListener(funct: (evt: any, up: boolean) => void, target?: HTMLElement): void;
        disableContextMenu: (element: any) => void;
        getSource(evt: any): any;
        isConsumed(evt: any): boolean;
        isTouchEvent(evt: any): boolean;
        isPenEvent(evt: any): boolean;
        isMultiTouchEvent(evt: any): boolean;
        isMouseEvent(evt: any): boolean;
        isLeftMouseButton(evt: any): boolean;
        isMiddleMouseButton(evt: any): boolean;
        isRightMouseButton(evt: any): boolean;
        isPopupTrigger(evt: any): boolean;
        isShiftDown(evt: any): boolean;
        isAltDown(evt: any): boolean;
        isControlDown(evt: any): boolean;
        isMetaDown(evt: any): boolean;
        getMainEvent(e: any): any;
        getClientX(e: PointerEvent): number;
        getClientY(e: PointerEvent): number;
        consume(evt: any, preventDefault?: boolean, stopPropagation?: boolean): void;
        LABEL_HANDLE: number;
        ROTATION_HANDLE: number;
        CUSTOM_HANDLE: number;
        VIRTUAL_HANDLE: number;
        MOUSE_DOWN: string;
        MOUSE_MOVE: string;
        MOUSE_UP: string;
        ACTIVATE: string;
        RESIZE_START: string;
        RESIZE: string;
        RESIZE_END: string;
        MOVE_START: string;
        MOVE: string;
        MOVE_END: string;
        PAN_START: string;
        PAN: string;
        PAN_END: string;
        MINIMIZE: string;
        NORMALIZE: string;
        MAXIMIZE: string;
        HIDE: string;
        SHOW: string;
        CLOSE: string;
        DESTROY: string;
        REFRESH: string;
        SIZE: string;
        SELECT: string;
        FIRED: string;
        FIRE_MOUSE_EVENT: string;
        GESTURE: string;
        TAP_AND_HOLD: string;
        GET: string;
        RECEIVE: string;
        CONNECT: string;
        DISCONNECT: string;
        SUSPEND: string;
        RESUME: string;
        MARK: string;
        ROOT: string;
        POST: string;
        OPEN: string;
        SAVE: string;
        BEFORE_ADD_VERTEX: string;
        ADD_VERTEX: string;
        AFTER_ADD_VERTEX: string;
        DONE: string;
        EXECUTE: string;
        EXECUTED: string;
        BEGIN_UPDATE: string;
        START_EDIT: string;
        END_UPDATE: string;
        END_EDIT: string;
        BEFORE_UNDO: string;
        UNDO: string;
        REDO: string;
        CHANGE: string;
        NOTIFY: string;
        LAYOUT_CELLS: string;
        CLICK: string;
        SCALE: string;
        TRANSLATE: string;
        SCALE_AND_TRANSLATE: string;
        UP: string;
        DOWN: string;
        ADD: string;
        REMOVE: string;
        CLEAR: string;
        ADD_CELLS: string;
        CELLS_ADDED: string;
        MOVE_CELLS: string;
        CELLS_MOVED: string;
        RESIZE_CELLS: string;
        CELLS_RESIZED: string;
        TOGGLE_CELLS: string;
        CELLS_TOGGLED: string;
        ORDER_CELLS: string;
        CELLS_ORDERED: string;
        REMOVE_CELLS: string;
        CELLS_REMOVED: string;
        GROUP_CELLS: string;
        UNGROUP_CELLS: string;
        REMOVE_CELLS_FROM_PARENT: string;
        FOLD_CELLS: string;
        CELLS_FOLDED: string;
        ALIGN_CELLS: string;
        LABEL_CHANGED: string;
        CONNECT_CELL: string;
        CELL_CONNECTED: string;
        SPLIT_EDGE: string;
        FLIP_EDGE: string;
        START_EDITING: string;
        EDITING_STARTED: string;
        EDITING_STOPPED: string;
        ADD_OVERLAY: string;
        REMOVE_OVERLAY: string;
        UPDATE_CELL_SIZE: string;
        ESCAPE: string;
        DOUBLE_CLICK: string;
        START: string;
        RESET: string;
    };
    /**
     * XML HTTP request wrapper. See also: <mxUtils.get>, <mxUtils.post> and
     * <mxUtils.load>. This class provides a cross-browser abstraction for Ajax
     * requests.
     *
     * Encoding:
     *
     * For encoding parameter values, the built-in encodeURIComponent JavaScript
     * method must be used. For automatic encoding of post data in <mxEditor> the
     * <mxEditor.escapePostData> switch can be set to true (default). The encoding
     * will be carried out using the conte type of the page. That is, the page
     * containting the editor should contain a meta tag in the header, eg.
     * <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
     *
     * Example:
     *
     * (code)
     * var onload = function(req)
     * {
     *   mxUtils.alert(req.getDocumentElement());
     * }
     *
     * var onerror = function(req)
     * {
     *   mxUtils.alert('Error');
     * }
     * new mxXmlRequest(url, 'key=value').send(onload, onerror);
     * (end)
     *
     * Sends an asynchronous POST request to the specified URL.
     *
     * Example:
     *
     * (code)
     * var req = new mxXmlRequest(url, 'key=value', 'POST', false);
     * req.send();
     * mxUtils.alert(req.getDocumentElement());
     * (end)
     *
     * Sends a synchronous POST request to the specified URL.
     *
     * Example:
     *
     * (code)
     * var encoder = new mxCodec();
     * var result = encoder.encode(graph.getModel());
     * var xml = encodeURIComponent(mxUtils.getXml(result));
     * new mxXmlRequest(url, 'xml='+xml).send();
     * (end)
     *
     * Sends an encoded graph model to the specified URL using xml as the
     * parameter name. The parameter can then be retrieved in C# as follows:
     *
     * (code)
     * string xml = HttpUtility.UrlDecode(context.Request.Params["xml"]);
     * (end)
     *
     * Or in Java as follows:
     *
     * (code)
     * String xml = URLDecoder.decode(request.getParameter("xml"), "UTF-8").replace("\n", "&#xa;");
     * (end)
     *
     * Note that the linefeeds should only be replaced if the XML is
     * processed in Java, for example when creating an image.
     *
     * Constructor: mxXmlRequest
     *
     * Constructs an XML HTTP request.
     *
     * Parameters:
     *
     * url - Target URL of the request.
     * params - Form encoded parameters to send with a POST request.
     * method - String that specifies the request method. Possible values are
     * POST and GET. Default is POST.
     * async - Boolean specifying if an asynchronous request should be used.
     * Default is true.
     * username - String specifying the username to be used for the request.
     * password - String specifying the password to be used for the request.
     */
    class mxXmlRequest {
        constructor(url: any, params: any, method: any, async: any, username: any, password: any);
        /**
         * Returns <binary>.
         */
        isBinary(): any;
        /**
         * Sets <binary>.
         */
        setBinary(value: any): void;
        /**
         * Returns true if the response is ready.
         */
        isReady(): boolean;
        /**
         * Returns the document element of the response XML document.
         */
        getDocumentElement(): any;
        /**
         * Returns the response as an XML document. Use <getDocumentElement> to get
         * the document element of the XML document.
         */
        getXml(): any;
        /**
         * Returns the response as a string.
         */
        getText(): any;
        /**
         * Returns the status as a number, eg. 404 for "Not found" or 200 for "OK".
         * Note: The NS_ERROR_NOT_AVAILABLE for invalid responses cannot be cought.
         */
        getStatus(): any;
        /**
         * Send the <request> to the target URL using the specified functions to
         * process the response asychronously.
         *
         * Parameters:
         *
         * onload - Function to be invoked if a successful response was received.
         * onerror - Function to be called on any error.
         * timeout - Optional timeout in ms before calling ontimeout.
         * ontimeout - Optional function to execute on timeout.
         */
        send(onload: any, onerror: any, timeout: any, ontimeout: any): void;
        /**
         * Sets the headers for the given request and parameters. This sets the
         * content-type to application/x-www-form-urlencoded if any params exist.
         *
         * Example:
         *
         * (code)
         * request.setRequestHeaders = function(request, params)
         * {
         *   if (params != null)
         *   {
         *     request.setRequestHeader('Content-Type',
         *             'multipart/form-data');
         *     request.setRequestHeader('Content-Length',
         *             params.length);
         *   }
         * };
         * (end)
         *
         * Use the code above before calling <send> if you require a
         * multipart/form-data request.
         */
        setRequestHeaders(request: any, params: any): void;
        /**
         * Creates and posts a request to the given target URL using a dynamically
         * created form inside the given document.
         *
         * Parameters:
         *
         * docs - Document that contains the form element.
         * target - Target to send the form result to.
         */
        simulate(doc: any, target: any): void;
    }
    var mxClipboard: {
        STEPSIZE: number;
        insertCount: number;
        cells: any;
        setCells(cells: any): void;
        getCells(): any;
        isEmpty(): boolean;
        cut(graph: any, cells?: any): any;
        removeCells(graph: any, cells: any): void;
        copy(graph: any, cells?: any): any;
        paste(graph: any): any;
    };
    /**
     * Basic window inside a document.
     *
     * Examples:
     *
     * Creating a simple window.
     *
     * (code)
     * var tb = document.createElement('div');
     * var wnd = new mxWindow('Title', tb, 100, 100, 200, 200, true, true);
     * wnd.setVisible(true);
     * (end)
     *
     * Creating a window that contains an iframe.
     *
     * (code)
     * var frame = document.createElement('iframe');
     * frame.setAttribute('width', '192px');
     * frame.setAttribute('height', '172px');
     * frame.setAttribute('src', 'http://www.example.com/');
     * frame.style.backgroundColor = 'white';
     *
     * var w = document.body.clientWidth;
     * var h = (document.body.clientHeight || document.documentElement.clientHeight);
     * var wnd = new mxWindow('Title', frame, (w-200)/2, (h-200)/3, 200, 200);
     * wnd.setVisible(true);
     * (end)
     *
     * To limit the movement of a window, eg. to keep it from being moved beyond
     * the top, left corner the following method can be overridden (recommended):
     *
     * (code)
     * wnd.setLocation = function(x, y)
     * {
     *   x = Math.max(0, x);
     *   y = Math.max(0, y);
     *   mxWindow.prototype.setLocation.apply(this, arguments);
     * };
     * (end)
     *
     * Or the following event handler can be used:
     *
     * (code)
     * wnd.addListener(mxEvent.MOVE, function(e)
     * {
     *   wnd.setLocation(Math.max(0, wnd.getX()), Math.max(0, wnd.getY()));
     * });
     * (end)
     *
     * To keep a window inside the current window:
     *
     * (code)
     * mxEvent.addListener(window, 'resize', mxUtils.bind(this, function()
     * {
     *   var iw = window.innerWidth || document.documentElement.clientWidth || document.body.clientWidth;
     *   var ih = window.innerHeight || document.documentElement.clientHeight || document.body.clientHeight;
     *
     *   var x = this.window.getX();
     *   var y = this.window.getY();
     *
     *   if (x + this.window.table.clientWidth > iw)
     *   {
     *     x = Math.max(0, iw - this.window.table.clientWidth);
     *   }
     *
     *   if (y + this.window.table.clientHeight > ih)
     *   {
     *     y = Math.max(0, ih - this.window.table.clientHeight);
     *   }
     *
     *   if (this.window.getX() != x || this.window.getY() != y)
     *   {
     *     this.window.setLocation(x, y);
     *   }
     * }));
     * (end)
     *
     * Event: mxEvent.MOVE_START
     *
     * Fires before the window is moved. The <code>event</code> property contains
     * the corresponding mouse event.
     *
     * Event: mxEvent.MOVE
     *
     * Fires while the window is being moved. The <code>event</code> property
     * contains the corresponding mouse event.
     *
     * Event: mxEvent.MOVE_END
     *
     * Fires after the window is moved. The <code>event</code> property contains
     * the corresponding mouse event.
     *
     * Event: mxEvent.RESIZE_START
     *
     * Fires before the window is resized. The <code>event</code> property contains
     * the corresponding mouse event.
     *
     * Event: mxEvent.RESIZE
     *
     * Fires while the window is being resized. The <code>event</code> property
     * contains the corresponding mouse event.
     *
     * Event: mxEvent.RESIZE_END
     *
     * Fires after the window is resized. The <code>event</code> property contains
     * the corresponding mouse event.
     *
     * Event: mxEvent.MAXIMIZE
     *
     * Fires after the window is maximized. The <code>event</code> property
     * contains the corresponding mouse event.
     *
     * Event: mxEvent.MINIMIZE
     *
     * Fires after the window is minimized. The <code>event</code> property
     * contains the corresponding mouse event.
     *
     * Event: mxEvent.NORMALIZE
     *
     * Fires after the window is normalized, that is, it returned from
     * maximized or minimized state. The <code>event</code> property contains the
     * corresponding mouse event.
     *
     * Event: mxEvent.ACTIVATE
     *
     * Fires after a window is activated. The <code>previousWindow</code> property
     * contains the previous window. The event sender is the active window.
     *
     * Event: mxEvent.SHOW
     *
     * Fires after the window is shown. This event has no properties.
     *
     * Event: mxEvent.HIDE
     *
     * Fires after the window is hidden. This event has no properties.
     *
     * Event: mxEvent.CLOSE
     *
     * Fires before the window is closed. The <code>event</code> property contains
     * the corresponding mouse event.
     *
     * Event: mxEvent.DESTROY
     *
     * Fires before the window is destroyed. This event has no properties.
     *
     * Constructor: mxWindow
     *
     * Constructs a new window with the given dimension and title to display
     * the specified content. The window elements use the given style as a
     * prefix for the classnames of the respective window elements, namely,
     * the window title and window pane. The respective postfixes are appended
     * to the given stylename as follows:
     *
     *   style - Base style for the window.
     *   style+Title - Style for the window title.
     *   style+Pane - Style for the window pane.
     *
     * The default value for style is mxWindow, resulting in the following
     * classnames for the window elements: mxWindow, mxWindowTitle and
     * mxWindowPane.
     *
     * If replaceNode is given then the window replaces the given DOM node in
     * the document.
     *
     * Parameters:
     *
     * title - String that represents the title of the new window.
     * content - DOM node that is used as the window content.
     * x - X-coordinate of the window location.
     * y - Y-coordinate of the window location.
     * width - Width of the window.
     * height - Optional height of the window. Default is to match the height
     * of the content at the specified width.
     * minimizable - Optional boolean indicating if the window is minimizable.
     * Default is true.
     * movable - Optional boolean indicating if the window is movable. Default
     * is true.
     * replaceNode - Optional DOM node that the window should replace.
     * style - Optional base classname for the window elements. Default is
     * mxWindow.
     */
    class mxWindow extends mxEventSource {
        table: HTMLTableElement;
        destroyOnClose: boolean;
        constructor(title: any, content: any, x: any, y: any, width: any, height: any, minimizable: any, movable: any, replaceNode?: any, style?: any);
        /**
         * Initializes the DOM tree that represents the window.
         */
        init(x: any, y: any, width: any, height: any, style: any): void;
        /**
         * Sets the window title to the given string. HTML markup inside the title
         * will be escaped.
         */
        setTitle(title: any): void;
        /**
         * Sets if the window contents should be scrollable.
         */
        setScrollable(scrollable: any): void;
        /**
         * Puts the window on top of all other windows.
         */
        activate(): void;
        /**
         * Returuns the outermost DOM node that makes up the window.
         */
        getElement(): HTMLElement;
        /**
         * Makes sure the window is inside the client area of the window.
         */
        fit(): void;
        /**
         * Returns true if the window is resizable.
         */
        isResizable(): boolean;
        /**
         * Sets if the window should be resizable. To avoid interference with some
         * built-in features of IE10 and later, the use of the following code is
         * recommended if there are resizable <mxWindow>s in the page:
         *
         * (code)
         * if (mxClient.IS_POINTER)
         * {
         *   document.body.style.msTouchAction = 'none';
         * }
         * (end)
         */
        setResizable(resizable: any): void;
        /**
         * Sets the size of the window.
         */
        setSize(width: any, height: any): void;
        /**
         * Sets if the window is minimizable.
         */
        setMinimizable(minimizable: any): void;
        /**
         * Returns an <mxRectangle> that specifies the size for the minimized window.
         * A width or height of 0 means keep the existing width or height. This
         * implementation returns the height of the window title and keeps the width.
         */
        getMinimumSize(): mxRectangle;
        /**
         * Installs the event listeners required for minimizing the window.
         */
        installMinimizeHandler(): void;
        /**
         * Sets if the window is maximizable.
         */
        setMaximizable(maximizable: any): void;
        /**
         * Installs the event listeners required for maximizing the window.
         */
        installMaximizeHandler(): void;
        /**
         * Installs the event listeners required for moving the window.
         */
        installMoveHandler(): void;
        /**
         * Sets the upper, left corner of the window.
         */
        setLocation(x: any, y: any): void;
        /**
         * Returns the current position on the x-axis.
         */
        getX(): number;
        /**
         * Returns the current position on the y-axis.
         */
        getY(): number;
        /**
         * Adds the <closeImage> as a new image node in <closeImg> and installs the
         * <close> event.
         */
        installCloseHandler(): void;
        /**
         * Sets the image associated with the window.
         *
         * Parameters:
         *
         * image - URL of the image to be used.
         */
        setImage(image: any): void;
        /**
         * Sets the image associated with the window.
         *
         * Parameters:
         *
         * closable - Boolean specifying if the window should be closable.
         */
        setClosable(closable: any): void;
        /**
         * Returns true if the window is visible.
         */
        isVisible(): boolean;
        /**
         * Shows or hides the window depending on the given flag.
         *
         * Parameters:
         *
         * visible - Boolean indicating if the window should be made visible.
         */
        setVisible(visible: any): void;
        /**
         * Shows the window.
         */
        show(): void;
        /**
         * Hides the window.
         */
        hide(): void;
        /**
         * Destroys the window and removes all associated resources. Fires a
         * <destroy> event prior to destroying the window.
         */
        destroy(): void;
    }
    /**
     * A simple class for creating HTML forms.
     *
     * Constructor: mxForm
     *
     * Creates a HTML table using the specified classname.
     */
    class mxForm {
        constructor(className: any);
        /**
         * Returns the table that contains this form.
         */
        getTable(): any;
        /**
         * Helper method to add an OK and Cancel button using the respective
         * functions.
         */
        addButtons(okFunct: any, cancelFunct: any): void;
        /**
         * Adds an input for the given name, type and value and returns it.
         */
        addText(name: any, value: any, type: any): any;
        /**
         * Adds a checkbox for the given name and value and returns the textfield.
         */
        addCheckbox(name: any, value: any): HTMLInputElement;
        /**
         * Adds a textarea for the given name and value and returns the textarea.
         */
        addTextarea(name: any, value: any, rows: any): any;
        /**
         * Adds a combo for the given name and returns the combo.
         */
        addCombo(name: any, isMultiSelect: any, size: any): any;
        /**
         * Adds an option for the given label to the specified combo.
         */
        addOption(combo: any, label: any, value: any, isSelected: any): void;
        /**
         * Adds a new row with the name and the input field in two columns and
         * returns the given input.
         */
        addField(name: any, input: any): any;
    }
    /**
     * Encapsulates the URL, width and height of an image.
     */
    class mxImage {
        /**
         * String that specifies the URL of the image.
         */
        src: string;
        /**
         * Integer that specifies the width of the image.
         */
        width: number;
        /**
         * Integer that specifies the height of the image.
         */
        height: number;
        /**
         * Constructs a new image.
         * @param src String that specifies the URL of the image.
         * @param width Integer that specifies the width of the image.
         * @param height Integer that specifies the height of the image.
         */
        constructor(src: any, width: any, height: any);
    }
    /**
     * Maintains the size of a div element in Internet Explorer. This is a
     * workaround for the right and bottom style being ignored in IE.
     *
     * If you need a div to cover the scrollwidth and -height of a document,
     * then you can use this class as follows:
     *
     * (code)
     * var resizer = new mxDivResizer(background);
     * resizer.getDocumentHeight = function()
     * {
     *   return document.body.scrollHeight;
     * }
     * resizer.getDocumentWidth = function()
     * {
     *   return document.body.scrollWidth;
     * }
     * resizer.resize();
     * (end)
     *
     * Constructor: mxDivResizer
     *
     * Constructs an object that maintains the size of a div
     * element when the window is being resized. This is only
     * required for Internet Explorer as it ignores the respective
     * stylesheet information for DIV elements.
     *
     * Parameters:
     *
     * div - Reference to the DOM node whose size should be maintained.
     * container - Optional Container that contains the div. Default is the
     * window.
     */
    class mxDivResizer {
        constructor(div: any, container: any);
        /**
         * Updates the style of the DIV after the window has been resized.
         */
        resize(): void;
        /**
         * Hook for subclassers to return the width of the document (without
         * scrollbars).
         */
        getDocumentWidth(): number;
        /**
         * Hook for subclassers to return the height of the document (without
         * scrollbars).
         */
        getDocumentHeight(): number;
    }
    /**
     * Wrapper to create a drag source from a DOM element so that the element can
     * be dragged over a graph and dropped into the graph as a new cell.
     *
     * Problem is that in the dropHandler the current preview location is not
     * available, so the preview and the dropHandler must match.
     *
     * Constructor: mxDragSource
     *
     * Constructs a new drag source for the given element.
     */
    class mxDragSource {
        previewElement: HTMLDivElement;
        currentGuide: mxGuide;
        previewElementHeight: string;
        previewElementWidth: string;
        currentHighlight: mxCellHighlight;
        dragElementZIndex: number;
        /**
         * Holds the DOM node that is used to represent the drag preview.  If this is null then the source element will be cloned and used for the drag preview.
         */
        dragElement: HTMLElement;
        /**
         * Reference to the mxGraph that is the current drop target.
         */
        currentGraph: mxGraph;
        constructor(element: any, dropHandler: any);
        /**
         * Returns <enabled>.
         */
        isEnabled(): any;
        /**
         * Sets <enabled>.
         */
        setEnabled(value: any): void;
        /**
         * Returns <guidesEnabled>.
         */
        isGuidesEnabled(): boolean;
        /**
         * Sets <guidesEnabled>.
         */
        setGuidesEnabled(value: any): void;
        /**
         * Returns <gridEnabled>.
         */
        isGridEnabled(): any;
        /**
         * Sets <gridEnabled>.
         */
        setGridEnabled(value: any): void;
        /**
         * Returns the graph for the given mouse event. This implementation returns
         * null.
         */
        getGraphForEvent(evt: any): any;
        /**
         * Returns the drop target for the given graph and coordinates. This
         * implementation uses <mxGraph.getCellAt>.
         */
        getDropTarget(graph: any, x: any, y: any, evt: any): any;
        /**
         * Creates and returns a clone of the <dragElementPrototype> or the <element>
         * if the former is not defined.
         */
        createDragElement(evt: any): any;
        /**
         * Creates and returns an element which can be used as a preview in the given
         * graph.
         */
        createPreviewElement(graph: any): any;
        /**
         * Returns true if this drag source is active.
         */
        isActive(): boolean;
        /**
         * Stops and removes everything and restores the state of the object.
         */
        reset(): void;
        /**
         * Returns the drop target for the given graph and coordinates. This
         * implementation uses <mxGraph.getCellAt>.
         *
         * To ignore popup menu events for a drag source, this function can be
         * overridden as follows.
         *
         * (code)
         * var mouseDown = dragSource.mouseDown;
         *
         * dragSource.mouseDown = function(evt)
         * {
         *   if (!mxEvent.isPopupTrigger(evt))
         *   {
         *     mouseDown.apply(this, arguments);
         *   }
         * };
         * (end)
         */
        mouseDown(evt: any): void;
        /**
         * Creates the <dragElement> using <createDragElement>.
         */
        startDrag(evt: any): void;
        /**
         * Invokes <removeDragElement>.
         */
        stopDrag(): void;
        /**
         * Removes and destroys the <dragElement>.
         */
        removeDragElement(): void;
        /**
         * Returns true if the given graph contains the given event.
         */
        graphContainsEvent(graph: any, evt: any): boolean;
        /**
         * Gets the graph for the given event using <getGraphForEvent>, updates the
         * <currentGraph>, calling <dragEnter> and <dragExit> on the new and old graph,
         * respectively, and invokes <dragOver> if <currentGraph> is not null.
         */
        mouseMove(evt: any): void;
        /**
         * Processes the mouse up event and invokes <drop>, <dragExit> and <stopDrag>
         * as required.
         */
        mouseUp(evt: any): void;
        /**
         * Actives the given graph as a drop target.
         */
        removeListeners(): void;
        /**
         * Actives the given graph as a drop target.
         */
        dragEnter(graph: any, evt: any): void;
        /**
         * Deactivates the given graph as a drop target.
         */
        dragExit(graph: any, evt: any): void;
        /**
         * Implements autoscroll, updates the <currentPoint>, highlights any drop
         * targets and updates the preview.
         */
        dragOver(graph: any, evt: any): void;
        /**
         * Returns the drop target for the given graph and coordinates. This
         * implementation uses <mxGraph.getCellAt>.
         */
        drop(graph: any, evt: any, dropTarget: any, x: any, y: any): void;
    }
    /**
     * Creates a toolbar inside a given DOM node. The toolbar may contain icons,
     * buttons and combo boxes.
     *
     * Event: mxEvent.SELECT
     *
     * Fires when an item was selected in the toolbar. The <code>function</code>
     * property contains the function that was selected in <selectMode>.
     *
     * Constructor: mxToolbar
     *
     * Constructs a toolbar in the specified container.
     *
     * Parameters:
     *
     * container - DOM node that contains the toolbar.
     */
    class mxToolbar extends mxEventSource {
        constructor(container: any);
        /**
         * Adds the given function as an image with the specified title and icon
         * and returns the new image node.
         *
         * Parameters:
         *
         * title - Optional string that is used as the tooltip.
         * icon - Optional URL of the image to be used. If no URL is given, then a
         * button is created.
         * funct - Function to execute on a mouse click.
         * pressedIcon - Optional URL of the pressed image. Default is a gray
         * background.
         * style - Optional style classname. Default is mxToolbarItem.
         * factoryMethod - Optional factory method for popup menu, eg.
         * function(menu, evt, cell) { menu.addItem('Hello, World!'); }
         */
        addItem(title: any, icon: any, funct: any, pressedIcon: any, style: any, factoryMethod: any): HTMLImageElement | HTMLButtonElement;
        /**
         * Adds and returns a new SELECT element using the given style. The element
         * is placed inside a DIV with the mxToolbarComboContainer style classname.
         *
         * Parameters:
         *
         * style - Optional style classname. Default is mxToolbarCombo.
         */
        addCombo(style: any): HTMLSelectElement;
        /**
         * Adds and returns a new SELECT element using the given title as the
         * default element. The selection is reset to this element after each
         * change.
         *
         * Parameters:
         *
         * title - String that specifies the title of the default element.
         * style - Optional style classname. Default is mxToolbarCombo.
         */
        addActionCombo(title: any, style: any): HTMLSelectElement;
        /**
         * Adds and returns a new OPTION element inside the given SELECT element.
         * If the given value is a function then it is stored in the option's funct
         * field.
         *
         * Parameters:
         *
         * combo - SELECT element that will contain the new entry.
         * title - String that specifies the title of the option.
         * value - Specifies the value associated with this option.
         */
        addOption(combo: any, title: any, value: any): HTMLOptionElement;
        /**
         * Adds a new selectable item to the toolbar. Only one switch mode item may
         * be selected at a time. The currently selected item is the default item
         * after a reset of the toolbar.
         */
        addSwitchMode(title: any, icon: any, funct: any, pressedIcon: any, style: any): HTMLImageElement;
        /**
         * Adds a new item to the toolbar. The selection is typically reset after
         * the item has been consumed, for example by adding a new vertex to the
         * graph. The reset is not carried out if the item is double clicked.
         *
         * The function argument uses the following signature: funct(evt, cell) where
         * evt is the native mouse event and cell is the cell under the mouse.
         */
        addMode(title: any, icon: any, funct: any, pressedIcon?: any, style?: any, toggle?: any): HTMLImageElement | HTMLButtonElement;
        /**
         * Resets the state of the previously selected mode and displays the given
         * DOM node as selected. This function fires a select event with the given
         * function as a parameter.
         */
        selectMode(domNode: any, funct: any): void;
        /**
         * Selects the default mode and resets the state of the previously selected
         * mode.
         */
        resetMode(forced: any): void;
        /**
         * Adds the specifies image as a separator.
         *
         * Parameters:
         *
         * icon - URL of the separator icon.
         */
        addSeparator(icon: any): any;
        /**
         * Adds a break to the container.
         */
        addBreak(): void;
        /**
         * Adds a horizontal line to the container.
         */
        addLine(): void;
        /**
         * Removes the toolbar and all its associated resources.
         */
        destroy(): void;
    }
    /**
     * Implements a composite undoable edit. Here is an example for a custom change
     * which gets executed via the model:
     *
     * (code)
     * function CustomChange(model, name)
     * {
     *   this.model = model;
     *   this.name = name;
     *   this.previous = name;
     * };
     *
     * CustomChange.prototype.execute = function()
     * {
     *   var tmp = this.model.name;
     *   this.model.name = this.previous;
     *   this.previous = tmp;
     * };
     *
     * var name = prompt('Enter name');
     * graph.model.execute(new CustomChange(graph.model, name));
     * (end)
     *
     * Event: mxEvent.EXECUTED
     *
     * Fires between START_EDIT and END_EDIT after an atomic change was executed.
     * The <code>change</code> property contains the change that was executed.
     *
     * Event: mxEvent.START_EDIT
     *
     * Fires before a set of changes will be executed in <undo> or <redo>.
     * This event contains no properties.
     *
     * Event: mxEvent.END_EDIT
     *
     * Fires after a set of changeswas executed in <undo> or <redo>.
     * This event contains no properties.
     */
    class mxUndoableEdit {
        /**
         * Specifies the source of the edit.
         */
        source: any;
        /**
         * Array that contains the changes that make up this edit. The changes are
         * expected to either have an undo and redo function, or an execute
         * function. Default is an empty array.
         */
        changes: any[];
        /**
         * Specifies if the undoable change is significant.
         * Default is true.
         */
        significant: boolean;
        /**
         * Specifies if this edit has been undone. Default is false.
         */
        undone: boolean;
        /**
         * Specifies if this edit has been redone. Default is false.
         */
        redone: boolean;
        /**
         * Constructs a new undoable edit for the given source.
         * @param source
         * @param significant
         */
        constructor(source: any, significant?: boolean);
        /**
         * Returns true if the this edit contains no changes.
         */
        isEmpty(): boolean;
        /**
         * Returns <significant>.
         */
        isSignificant(): boolean;
        /**
         * Adds the specified change to this edit. The change is an object that is
         * expected to either have an undo and redo, or an execute function.
         */
        add(change: any): void;
        /**
         * Hook to notify any listeners of the changes after an <undo> or <redo>
         * has been carried out. This implementation is empty.
         */
        notify(): void;
        /**
         * Hook to free resources after the edit has been removed from the command
         * history. This implementation is empty.
         */
        die(): void;
        /**
         * Undoes all changes in this edit.
         */
        undo(): void;
        /**
         * Redoes all changes in this edit.
         */
        redo(): void;
    }
    /**
     * Implements a command history. When changing the graph model, an
     * <mxUndoableChange> object is created at the start of the transaction (when
     * model.beginUpdate is called). All atomic changes are then added to this
     * object until the last model.endUpdate call, at which point the
     * <mxUndoableEdit> is dispatched in an event, and added to the history inside
     * <mxUndoManager>. This is done by an event listener in
     * <mxEditor.installUndoHandler>.
     *
     * Each atomic change of the model is represented by an object (eg.
     * <mxRootChange>, <mxChildChange>, <mxTerminalChange> etc) which contains the
     * complete undo information. The <mxUndoManager> also listens to the
     * <mxGraphView> and stores it's changes to the current root as insignificant
     * undoable changes, so that drilling (step into, step up) is undone.
     *
     * This means when you execute an atomic change on the model, then change the
     * current root on the view and click undo, the change of the root will be
     * undone together with the change of the model so that the display represents
     * the state at which the model was changed. However, these changes are not
     * transmitted for sharing as they do not represent a state change.
     *
     * Example:
     *
     * When adding an undo manager to a graph, make sure to add it
     * to the model and the view as well to maintain a consistent
     * display across multiple undo/redo steps.
     *
     * (code)
     * var undoManager = new mxUndoManager();
     * var listener = function(sender, evt)
     * {
     *   undoManager.undoableEditHappened(evt.getProperty('edit'));
     * };
     * graph.getModel().addListener(mxEvent.UNDO, listener);
     * graph.getView().addListener(mxEvent.UNDO, listener);
     * (end)
     *
     * The code creates a function that informs the undoManager
     * of an undoable edit and binds it to the undo event of
     * <mxGraphModel> and <mxGraphView> using
     * <mxEventSource.addListener>.
     *
     * Event: mxEvent.CLEAR
     *
     * Fires after <clear> was invoked. This event has no properties.
     *
     * Event: mxEvent.UNDO
     *
     * Fires afer a significant edit was undone in <undo>. The <code>edit</code>
     * property contains the <mxUndoableEdit> that was undone.
     *
     * Event: mxEvent.REDO
     *
     * Fires afer a significant edit was redone in <redo>. The <code>edit</code>
     * property contains the <mxUndoableEdit> that was redone.
     *
     * Event: mxEvent.ADD
     *
     * Fires after an undoable edit was added to the history. The <code>edit</code>
     * property contains the <mxUndoableEdit> that was added.
     *
     * Constructor: mxUndoManager
     *
     * Constructs a new undo manager with the given history size. If no history
     * size is given, then a default size of 100 steps is used.
     */
    class mxUndoManager extends mxEventSource {
        constructor(size?: number);
        /**
         * Returns true if the history is empty.
         */
        isEmpty(): boolean;
        /**
         * Clears the command history.
         */
        clear(): void;
        /**
         * Returns true if an undo is possible.
         */
        canUndo(): boolean;
        /**
         * Undoes the last change.
         */
        undo(): void;
        /**
         * Returns true if a redo is possible.
         */
        canRedo(): boolean;
        /**
         * Redoes the last change.
         */
        redo(): void;
        /**
         * Method to be called to add new undoable edits to the <history>.
         */
        undoableEditHappened(undoableEdit: any): void;
        /**
         * Removes all pending steps after <indexOfNextAdd> from the history,
         * invoking die on each edit. This is called from <undoableEditHappened>.
         */
        trim(): void;
    }
    /**
     *
     * Converts relative and absolute URLs to absolute URLs with protocol and domain.
     */
    class mxUrlConverter {
        /**
         * Private helper function to update the base URL.
         */
        updateBaseUrl(): void;
        /**
         * Returns <enabled>.
         */
        isEnabled(): any;
        /**
         * Sets <enabled>.
         */
        setEnabled(value: any): void;
        /**
         * Returns <baseUrl>.
         */
        getBaseUrl(): any;
        /**
         * Sets <baseUrl>.
         */
        setBaseUrl(value: any): void;
        /**
         * Converts the given URL to an absolute URL with protol and domain.
         * Relative URLs are first converted to absolute URLs.
         */
        convert(url: any): any;
    }
    /**
     * Implements a handler for panning.
     */
    function mxPanningManager(graph: any): void;
    /**
     * Basic popup menu. To add a vertical scrollbar to a given submenu, the
     * following code can be used.
     *
     * (code)
     * var mxPopupMenuShowMenu = mxPopupMenu.prototype.showMenu;
     * mxPopupMenu.prototype.showMenu = function()
     * {
     *   mxPopupMenuShowMenu.apply(this, arguments);
     *
     *   this.div.style.overflowY = 'auto';
     *   this.div.style.overflowX = 'hidden';
     *   this.div.style.maxHeight = '160px';
     * };
     * (end)
     *
     * Constructor: mxPopupMenu
     *
     * Constructs a popupmenu.
     *
     * Event: mxEvent.SHOW
     *
     * Fires after the menu has been shown in <popup>.
     */
    class mxPopupMenu extends mxEventSource {
        labels: boolean;
        autoExpand: boolean;
        showDisabled: boolean;
        smartSeparators: boolean;
        div: HTMLDivElement;
        zIndex: number;
        submenuImage: string;
        constructor(factoryMethod?: any);
        /**
         * Initializes the shapes required for this vertex handler.
         */
        init(): void;
        /**
         * Returns true if events are handled. This implementation
         * returns <enabled>.
         */
        isEnabled(): any;
        /**
         * Enables or disables event handling. This implementation
         * updates <enabled>.
         */
        setEnabled(enabled: any): void;
        /**
         * Returns true if the given event is a popupmenu trigger for the optional
         * given cell.
         *
         * Parameters:
         *
         * me - <mxMouseEvent> that represents the mouse event.
         */
        isPopupTrigger(me: any): any;
        /**
         * Adds the given item to the given parent item. If no parent item is specified
         * then the item is added to the top-level menu. The return value may be used
         * as the parent argument, ie. as a submenu item. The return value is the table
         * row that represents the item.
         *
         * Paramters:
         *
         * title - String that represents the title of the menu item.
         * image - Optional URL for the image icon.
         * funct - Function associated that takes a mouseup or touchend event.
         * parent - Optional item returned by <addItem>.
         * iconCls - Optional string that represents the CSS class for the image icon.
         * IconsCls is ignored if image is given.
         * enabled - Optional boolean indicating if the item is enabled. Default is true.
         * active - Optional boolean indicating if the menu should implement any event handling.
         * Default is true.
         */
        addItem(title: any, image: any, funct: any, parent?: any, iconCls?: any, enabled?: any, active?: any): HTMLTableRowElement;
        /**
         * Adds a checkmark to the given menuitem.
         */
        addCheckmark(item: any, img: any): void;
        /**
         * Creates the nodes required to add submenu items inside the given parent
         * item. This is called in <addItem> if a parent item is used for the first
         * time. This adds various DOM nodes and a <submenuImage> to the parent.
         *
         * Parameters:
         *
         * parent - An item returned by <addItem>.
         */
        createSubmenu(parent: any): void;
        /**
         * Shows the submenu inside the given parent row.
         */
        showSubmenu(parent: any, row: any): void;
        /**
         * Adds a horizontal separator in the given parent item or the top-level menu
         * if no parent is specified.
         *
         * Parameters:
         *
         * parent - Optional item returned by <addItem>.
         * force - Optional boolean to ignore <smartSeparators>. Default is false.
         */
        addSeparator(parent?: mxPopupMenu | HTMLTableRowElement, force?: any): void;
        /**
         * Shows the popup menu for the given event and cell.
         *
         * Example:
         *
         * (code)
         * graph.panningHandler.popup = function(x, y, cell, evt)
         * {
         *   mxUtils.alert('Hello, World!');
         * }
         * (end)
         */
        popup(x: any, y: any, cell: any, evt: any): void;
        /**
         * Returns true if the menu is showing.
         */
        isMenuShowing(): boolean;
        /**
         * Shows the menu.
         */
        showMenu(): void;
        /**
         * Removes the menu and all submenus.
         */
        hideMenu(): void;
        /**
         * Removes all submenus inside the given parent.
         *
         * Parameters:
         *
         * parent - An item returned by <addItem>.
         */
        hideSubmenu(parent: any): void;
        /**
         * Destroys the handler and all its resources and DOM nodes.
         */
        destroy(): void;
    }
    /**
     * Manager for automatically saving diagrams. The <save> hook must be
     * implemented.
     *
     * Example:
     *
     * (code)
     * var mgr = new mxAutoSaveManager(editor.graph);
     * mgr.save = function()
     * {
     *   mxLog.show();
     *   mxLog.debug('save');
     * };
     * (end)
     *
     * Constructor: mxAutoSaveManager
     *
     * Constructs a new automatic layout for the given graph.
     *
     * Arguments:
     *
     * graph - Reference to the enclosing graph.
     */
    class mxAutoSaveManager extends mxEventSource {
        constructor(graph: any);
        /**
         * Returns true if events are handled. This implementation
         * returns <enabled>.
         */
        isEnabled(): any;
        /**
         * Enables or disables event handling. This implementation
         * updates <enabled>.
         *
         * Parameters:
         *
         * enabled - Boolean that specifies the new enabled state.
         */
        setEnabled(value: any): void;
        /**
         * Sets the graph that the layouts operate on.
         */
        setGraph(graph: any): void;
        /**
         * Empty hook that is called if the graph should be saved.
         */
        save(): void;
        /**
         * Invoked when the graph model has changed.
         */
        graphModelChanged(changes: any): void;
        /**
         * Resets all counters.
         */
        reset(): void;
        /**
         * Removes all handlers from the <graph> and deletes the reference to it.
         */
        destroy(): void;
    }
    /**
     *
     * Implements a basic animation in JavaScript.
     *
     * Constructor: mxAnimation
     *
     * Constructs an animation.
     *
     * Parameters:
     *
     * graph - Reference to the enclosing <mxGraph>.
     */
    class mxAnimation extends mxEventSource {
        constructor(delay: any);
        /**
         * Returns true if the animation is running.
         */
        isRunning(): boolean;
        /**
         * Starts the animation by repeatedly invoking updateAnimation.
         */
        startAnimation(): void;
        /**
         * Hook for subclassers to implement the animation. Invoke stopAnimation
         * when finished, startAnimation to resume. This is called whenever the
         * timer fires and fires an mxEvent.EXECUTE event with no properties.
         */
        updateAnimation(): void;
        /**
         * Stops the animation by deleting the timer and fires an <mxEvent.DONE>.
         */
        stopAnimation(): void;
    }
    /**
     *
     * Implements animation for morphing cells. Here is an example of
     * using this class for animating the result of a layout algorithm:
     *
     * (code)
     * graph.getModel().beginUpdate();
     * try
     * {
     *   var circleLayout = new mxCircleLayout(graph);
     *   circleLayout.execute(graph.getDefaultParent());
     * }
     * finally
     * {
     *   var morph = new mxMorphing(graph);
     *   morph.addListener(mxEvent.DONE, function()
     *   {
     *     graph.getModel().endUpdate();
     *   });
     *
     *   morph.startAnimation();
     * }
     * (end)
     *
     * Constructor: mxMorphing
     *
     * Constructs an animation.
     *
     * Parameters:
     *
     * graph - Reference to the enclosing <mxGraph>.
     * steps - Optional number of steps in the morphing animation. Default is 6.
     * ease - Optional easing constant for the animation. Default is 1.5.
     * delay - Optional delay between the animation steps. Passed to <mxAnimation>.
     */
    class mxMorphing extends mxAnimation {
        constructor(graph: any, steps: any, ease: any, delay: any);
        /**
         * Animation step.
         */
        updateAnimation(): void;
        /**
         * Shows the changes in the given <mxCellStatePreview>.
         */
        show(move: any): void;
        /**
         * Animates the given cell state using <mxCellStatePreview.moveState>.
         */
        animateCell(cell: any, move: any, recurse: any): void;
        /**
         * Returns true if the animation should not recursively find more
         * deltas for children if the given parent state has been animated.
         */
        stopRecursion(state: any, delta: any): boolean;
        /**
         * Returns the vector between the current rendered state and the future
         * location of the state after the display will be updated.
         */
        getDelta(state: any): mxPoint;
        /**
         * Returns the top, left corner of the given cell. TODO: Improve performance
         * by using caching inside this method as the result per cell never changes
         * during the lifecycle of this object.
         */
        getOriginForCell(cell: any): any;
    }
    /**
     * Maps from keys to base64 encoded images or file locations. All values must
     * be URLs or use the format data:image/format followed by a comma and the base64
     * encoded image data, eg. "data:image/gif,XYZ", where XYZ is the base64 encoded
     * image data.
     *
     * To add a new image bundle to an existing graph, the following code is used:
     *
     * (code)
     * var bundle = new mxImageBundle(alt);
     * bundle.putImage('myImage', 'data:image/gif,R0lGODlhEAAQAMIGAAAAAICAAICAgP' +
     *   '//AOzp2O3r2////////yH+FUNyZWF0ZWQgd2l0aCBUaGUgR0lNUAAh+QQBCgAHACwAAAAA' +
     *   'EAAQAAADTXi63AowynnAMDfjPUDlnAAJhmeBFxAEloliKltWmiYCQvfVr6lBPB1ggxN1hi' +
     *   'laSSASFQpIV5HJBDyHpqK2ejVRm2AAgZCdmCGO9CIBADs=', fallback);
     * bundle.putImage('mySvgImage', 'data:image/svg+xml,' + encodeURIComponent(
     *   '<svg xmlns="http://www.w3.org/2000/svg" width="100%" height="100%">' +
     *   '<linearGradient id="gradient"><stop offset="10%" stop-color="#F00"/>' +
     *   '<stop offset="90%" stop-color="#fcc"/></linearGradient>' +
     *   '<rect fill="url(#gradient)" width="100%" height="100%"/></svg>'), fallback);
     * graph.addImageBundle(bundle);
     * (end);
     *
     * Alt is an optional boolean (default is false) that specifies if the value
     * or the fallback should be returned in <getImage>.
     *
     * The image can then be referenced in any cell style using image=myImage.
     * If you are using mxOutline, you should use the same image bundles in the
     * graph that renders the outline.
     *
     * The keys for images are resolved in <mxGraph.postProcessCellStyle> and
     * turned into a data URI if the returned value has a short data URI format
     * as specified above.
     *
     * A typical value for the fallback is a MTHML link as defined in RFC 2557.
     * Note that this format requires a file to be dynamically created on the
     * server-side, or the page that contains the graph to be modified to contain
     * the resources, this can be done by adding a comment that contains the
     * resource in the HEAD section of the page after the title tag.
     *
     * This type of fallback mechanism should be used in IE6 and IE7. IE8 does
     * support data URIs, but the maximum size is limited to 32 KB, which means
     * all data URIs should be limited to 32 KB.
     */
    class mxImageBundle {
        constructor(alt: any);
        /**
         * Adds the specified entry to the map. The entry is an object with a value and
         * fallback property as specified in the arguments.
         */
        putImage(key: any, value: any, fallback: any): void;
        /**
         * Returns the value for the given key. This returns the value
         * or fallback, depending on <alt>. The fallback is returned if
         * <alt> is true, the value is returned otherwise.
         */
        getImage(key: any): any;
    }
    /**
     * Creates a new image export declare instance to be used with an export declare canvas. Here
     * is an example that uses this class to create an image via a backend using
     * <mxXmlExportCanvas>.
     *
     * (code)
     * var xmlDoc = mxUtils.createXmlDocument();
     * var root = xmlDoc.createElement('output');
     * xmlDoc.appendChild(root);
     *
     * var xmlCanvas = new mxXmlCanvas2D(root);
     * var imgExport = new mxImageExport();
     * imgExport.drawState(graph.getView().getState(graph.model.root), xmlCanvas);
     *
     * var bounds = graph.getGraphBounds();
     * var w = Math.ceil(bounds.x + bounds.width);
     * var h = Math.ceil(bounds.y + bounds.height);
     *
     * var xml = mxUtils.getXml(root);
     * new mxXmlRequest('declare', 'format=png&w=' + w +
     * 		'&h=' + h + '&bg=#F9F7ED&xml=' + encodeURIComponent(xml))
     * 		.simulate(document, '_blank');
     * (end)
     *
     * Constructor: mxImageExport
     *
     * Constructs a new image declare.
     */
    class mxImageExport {
        /**
         * Draws the given state and all its descendants to the given canvas.
         */
        drawState(state: any, canvas: any): void;
        /**
         * Draws the given state and all its descendants to the given canvas.
         */
        visitStatesRecursive(state: any, canvas: any, visitor: any): void;
        /**
         * Returns the link for the given cell state and canvas. This returns null.
         */
        getLinkForCellState(state: any, canvas: any): any;
        /**
         * Draws the given state to the given canvas.
         */
        drawCellState(state: any, canvas: any): void;
        /**
         * Draws the shape of the given state.
         */
        drawShape(state: any, canvas: any): void;
        /**
         * Draws the text of the given state.
         */
        drawText(state: any, canvas: any): void;
        /**
         * Draws the overlays for the given state. This is called if <includeOverlays>
         * is true.
         */
        drawOverlays(state: any, canvas: any): void;
    }
    /**
     * Base class for all canvases. A description of the public API is available in <mxXmlCanvas2D>.
     * All color values of <mxConstants.NONE> will be converted to null in the state.
     *
     * Constructor: mxAbstractCanvas2D
     *
     * Constructs a new abstract canvas.
     */
    class mxAbstractCanvas2D {
        constructor();
        /**
         * 具体实现在其子类中，此处仅声明此方法
         */
        stroke?(): void;
        /**
         * Create a new <mxUrlConverter> and returns it.
         */
        createUrlConverter(): mxUrlConverter;
        /**
         * Resets the state of this canvas.
         */
        reset(): void;
        /**
         * Creates the state of the this canvas.
         */
        createState(): {
            dx: number;
            dy: number;
            scale: number;
            alpha: number;
            fillAlpha: number;
            strokeAlpha: number;
            fillColor: any;
            gradientFillAlpha: number;
            gradientColor: any;
            gradientAlpha: number;
            gradientDirection: any;
            strokeColor: any;
            strokeWidth: number;
            dashed: boolean;
            dashPattern: string;
            fixDash: boolean;
            lineCap: string;
            lineJoin: string;
            miterLimit: number;
            fontColor: string;
            fontBackgroundColor: any;
            fontBorderColor: any;
            fontSize: number;
            fontFamily: string;
            fontStyle: number;
            shadow: boolean;
            shadowColor: string;
            shadowAlpha: number;
            shadowDx: number;
            shadowDy: number;
            rotation: number;
            rotationCx: number;
            rotationCy: number;
        };
        /**
         * Rounds all numbers to integers.
         */
        format(value: any): number;
        /**
         * Adds the given operation to the path.
         */
        addOp(): void;
        /**
         * Rotates the given point and returns the result as an <mxPoint>.
         */
        rotatePoint(x: any, y: any, theta: any, cx: any, cy: any): any;
        /**
         * Saves the current state.
         */
        save(): void;
        /**
         * Restores the current state.
         */
        restore(): void;
        /**
         * Sets the current link. Hook for subclassers.
         */
        setLink(link: any): void;
        /**
         * Scales the current state.
         */
        scale(value: any): void;
        /**
         * Translates the current state.
         */
        translate(dx: any, dy: any): void;
        /**
         * Rotates the current state.
         */
        rotate(theta: any, flipH: any, flipV: any, cx: any, cy: any): void;
        /**
         * Sets the current alpha.
         */
        setAlpha(value: any): void;
        /**
         * Sets the current solid fill alpha.
         */
        setFillAlpha(value: any): void;
        /**
         * Sets the current stroke alpha.
         */
        setStrokeAlpha(value: any): void;
        /**
         * Sets the current fill color.
         */
        setFillColor(value: any): void;
        /**
         * Sets the current gradient.
         */
        setGradient(color1: any, color2: any, x: any, y: any, w: any, h: any, direction: any, alpha1: any, alpha2: any): void;
        /**
         * Sets the current stroke color.
         */
        setStrokeColor(value: any): void;
        /**
         * Sets the current stroke width.
         */
        setStrokeWidth(value: any): void;
        /**
         * Enables or disables dashed lines.
         */
        setDashed(value: any, fixDash?: any): void;
        /**
         * Sets the current dash pattern.
         */
        setDashPattern(value: any): void;
        /**
         * Sets the current line cap.
         */
        setLineCap(value: any): void;
        /**
         * Sets the current line join.
         */
        setLineJoin(value: any): void;
        /**
         * Sets the current miter limit.
         */
        setMiterLimit(value: any): void;
        /**
         * Sets the current font color.
         */
        setFontColor(value: any): void;
        /**
         * Sets the current font color.
         */
        setFontBackgroundColor(value: any): void;
        /**
         * Sets the current font color.
         */
        setFontBorderColor(value: any): void;
        /**
         * Sets the current font size.
         */
        setFontSize(value: any): void;
        /**
         * Sets the current font family.
         */
        setFontFamily(value: any): void;
        /**
         * Sets the current font style.
         */
        setFontStyle(value: any): void;
        /**
         * Enables or disables and configures the current shadow.
         */
        setShadow(enabled: any): void;
        /**
         * Enables or disables and configures the current shadow.
         */
        setShadowColor(value: any): void;
        /**
         * Enables or disables and configures the current shadow.
         */
        setShadowAlpha(value: any): void;
        /**
         * Enables or disables and configures the current shadow.
         */
        setShadowOffset(dx: any, dy: any): void;
        /**
         * Starts a new path.
         */
        begin(): void;
        /**
         *  Moves the current path the given coordinates.
         */
        moveTo(x: any, y: any): void;
        /**
         * Draws a line to the given coordinates. Uses moveTo with the op argument.
         */
        lineTo(x: any, y: any): void;
        /**
         * Adds a quadratic curve to the current path.
         */
        quadTo(x1: any, y1: any, x2: any, y2: any): void;
        /**
         * Adds a bezier curve to the current path.
         */
        curveTo(x1: any, y1: any, x2: any, y2: any, x3: any, y3: any): void;
        /**
         * Adds the given arc to the current path. This is a synthetic operation that
         * is broken down into curves.
         */
        arcTo(rx: any, ry: any, angle: any, largeArcFlag: any, sweepFlag: any, x: any, y: any): void;
        /**
         * Closes the current path.
         */
        close(x1?: any, y1?: any, x2?: any, y2?: any, x3?: any, y3?: any): void;
        /**
         * Empty implementation for backwards compatibility. This will be removed.
         */
        end(): void;
    }
    /**
     * Base class for all canvases. The following methods make up the public
     * interface of the canvas 2D for all painting in mxGraph:
     *
     * - <save>, <restore>
     * - <scale>, <translate>, <rotate>
     * - <setAlpha>, <setFillAlpha>, <setStrokeAlpha>, <setFillColor>, <setGradient>,
     *   <setStrokeColor>, <setStrokeWidth>, <setDashed>, <setDashPattern>, <setLineCap>,
     *   <setLineJoin>, <setMiterLimit>
     * - <setFontColor>, <setFontBackgroundColor>, <setFontBorderColor>, <setFontSize>,
     *   <setFontFamily>, <setFontStyle>
     * - <setShadow>, <setShadowColor>, <setShadowAlpha>, <setShadowOffset>
     * - <rect>, <roundrect>, <ellipse>, <image>, <text>
     * - <begin>, <moveTo>, <lineTo>, <quadTo>, <curveTo>
     * - <stroke>, <fill>, <fillAndStroke>
     *
     * <mxAbstractCanvas2D.arcTo> is an additional method for drawing paths. This is
     * a synthetic method, meaning that it is turned into a sequence of curves by
     * default. Subclassers may add native support for arcs.
     *
     * Constructor: mxXmlCanvas2D
     *
     * Constructs a new abstract canvas.
     */
    class mxXmlCanvas2D extends mxAbstractCanvas2D {
        constructor(root: any);
        /**
         * Writes the rendering defaults to <root>:
         */
        writeDefaults(): void;
        /**
         * Returns a formatted number with 2 decimal places.
         */
        format(value: any): number;
        /**
         * Creates the given element using the owner document of <root>.
         */
        createElement(name: any): any;
        /**
         * Saves the drawing state.
         */
        save(): void;
        /**
         * Restores the drawing state.
         */
        restore(): void;
        /**
         * Scales the output.
         *
         * Parameters:
         *
         * scale - Number that represents the scale where 1 is equal to 100%.
         */
        scale(value: any): void;
        /**
         * Translates the output.
         *
         * Parameters:
         *
         * dx - Number that specifies the horizontal translation.
         * dy - Number that specifies the vertical translation.
         */
        translate(dx: any, dy: any): void;
        /**
         * Rotates and/or flips the output around a given center. (Note: Due to
         * limitations in VML, the rotation cannot be concatenated.)
         *
         * Parameters:
         *
         * theta - Number that represents the angle of the rotation (in degrees).
         * flipH - Boolean indicating if the output should be flipped horizontally.
         * flipV - Boolean indicating if the output should be flipped vertically.
         * cx - Number that represents the x-coordinate of the rotation center.
         * cy - Number that represents the y-coordinate of the rotation center.
         */
        rotate(theta: any, flipH: any, flipV: any, cx: any, cy: any): void;
        /**
         * Sets the current alpha.
         *
         * Parameters:
         *
         * value - Number that represents the new alpha. Possible values are between
         * 1 (opaque) and 0 (transparent).
         */
        setAlpha(value: any): void;
        /**
         * Sets the current fill alpha.
         *
         * Parameters:
         *
         * value - Number that represents the new fill alpha. Possible values are between
         * 1 (opaque) and 0 (transparent).
         */
        setFillAlpha(value: any): void;
        /**
         * Sets the current stroke alpha.
         *
         * Parameters:
         *
         * value - Number that represents the new stroke alpha. Possible values are between
         * 1 (opaque) and 0 (transparent).
         */
        setStrokeAlpha(value: any): void;
        /**
         * Sets the current fill color.
         *
         * Parameters:
         *
         * value - Hexadecimal representation of the color or 'none'.
         */
        setFillColor(value: any): void;
        /**
         * Sets the gradient. Note that the coordinates may be ignored by some implementations.
         *
         * Parameters:
         *
         * color1 - Hexadecimal representation of the start color.
         * color2 - Hexadecimal representation of the end color.
         * x - X-coordinate of the gradient region.
         * y - y-coordinate of the gradient region.
         * w - Width of the gradient region.
         * h - Height of the gradient region.
         * direction - One of <mxConstants.DIRECTION_NORTH>, <mxConstants.DIRECTION_EAST>,
         * <mxConstants.DIRECTION_SOUTH> or <mxConstants.DIRECTION_WEST>.
         * alpha1 - Optional alpha of the start color. Default is 1. Possible values
         * are between 1 (opaque) and 0 (transparent).
         * alpha2 - Optional alpha of the end color. Default is 1. Possible values
         * are between 1 (opaque) and 0 (transparent).
         */
        setGradient(color1: any, color2: any, x: any, y: any, w: any, h: any, direction: any, alpha1: any, alpha2: any): void;
        /**
         * Sets the current stroke color.
         *
         * Parameters:
         *
         * value - Hexadecimal representation of the color or 'none'.
         */
        setStrokeColor(value: any): void;
        /**
         * Sets the current stroke width.
         *
         * Parameters:
         *
         * value - Numeric representation of the stroke width.
         */
        setStrokeWidth(value: any): void;
        /**
         * Enables or disables dashed lines.
         *
         * Parameters:
         *
         * value - Boolean that specifies if dashed lines should be enabled.
         * value - Boolean that specifies if the stroke width should be ignored
         * for the dash pattern. Default is false.
         */
        setDashed(value: any, fixDash: any): void;
        /**
         * Sets the current dash pattern. Default is '3 3'.
         *
         * Parameters:
         *
         * value - String that represents the dash pattern, which is a sequence of
         * numbers defining the length of the dashes and the length of the spaces
         * between the dashes. The lengths are relative to the line width - a length
         * of 1 is equals to the line width.
         */
        setDashPattern(value: any): void;
        /**
         * Sets the line cap. Default is 'flat' which corresponds to 'butt' in SVG.
         *
         * Parameters:
         *
         * value - String that represents the line cap. Possible values are flat, round
         * and square.
         */
        setLineCap(value: any): void;
        /**
         * Sets the line join. Default is 'miter'.
         *
         * Parameters:
         *
         * value - String that represents the line join. Possible values are miter,
         * round and bevel.
         */
        setLineJoin(value: any): void;
        /**
         * Sets the miter limit. Default is 10.
         *
         * Parameters:
         *
         * value - Number that represents the miter limit.
         */
        setMiterLimit(value: any): void;
        /**
         * Sets the current font color. Default is '#000000'.
         *
         * Parameters:
         *
         * value - Hexadecimal representation of the color or 'none'.
         */
        setFontColor(value: any): void;
        /**
         * Sets the current font background color.
         *
         * Parameters:
         *
         * value - Hexadecimal representation of the color or 'none'.
         */
        setFontBackgroundColor(value: any): void;
        /**
         * Sets the current font border color.
         *
         * Parameters:
         *
         * value - Hexadecimal representation of the color or 'none'.
         */
        setFontBorderColor(value: any): void;
        /**
         * Sets the current font size. Default is <mxConstants.DEFAULT_FONTSIZE>.
         *
         * Parameters:
         *
         * value - Numeric representation of the font size.
         */
        setFontSize(value: any): void;
        /**
         * Sets the current font family. Default is <mxConstants.DEFAULT_FONTFAMILY>.
         *
         * Parameters:
         *
         * value - String representation of the font family. This handles the same
         * values as the CSS font-family property.
         */
        setFontFamily(value: any): void;
        /**
         * Sets the current font style.
         *
         * Parameters:
         *
         * value - Numeric representation of the font family. This is the sum of the
         * font styles from <mxConstants>.
         */
        setFontStyle(value: any): void;
        /**
         * Enables or disables shadows.
         *
         * Parameters:
         *
         * value - Boolean that specifies if shadows should be enabled.
         */
        setShadow(value: any): void;
        /**
         * Sets the current shadow color. Default is <mxConstants.SHADOWCOLOR>.
         *
         * Parameters:
         *
         * value - Hexadecimal representation of the color or 'none'.
         */
        setShadowColor(value: any): void;
        /**
         * Sets the current shadows alpha. Default is <mxConstants.SHADOW_OPACITY>.
         *
         * Parameters:
         *
         * value - Number that represents the new alpha. Possible values are between
         * 1 (opaque) and 0 (transparent).
         */
        setShadowAlpha(value: any): void;
        /**
         * Sets the current shadow offset.
         *
         * Parameters:
         *
         * dx - Number that represents the horizontal offset of the shadow.
         * dy - Number that represents the vertical offset of the shadow.
         */
        setShadowOffset(dx: any, dy: any): void;
        /**
         * Puts a rectangle into the drawing buffer.
         *
         * Parameters:
         *
         * x - Number that represents the x-coordinate of the rectangle.
         * y - Number that represents the y-coordinate of the rectangle.
         * w - Number that represents the width of the rectangle.
         * h - Number that represents the height of the rectangle.
         */
        rect(x: any, y: any, w: any, h: any): void;
        /**
         * Puts a rounded rectangle into the drawing buffer.
         *
         * Parameters:
         *
         * x - Number that represents the x-coordinate of the rectangle.
         * y - Number that represents the y-coordinate of the rectangle.
         * w - Number that represents the width of the rectangle.
         * h - Number that represents the height of the rectangle.
         * dx - Number that represents the horizontal rounding.
         * dy - Number that represents the vertical rounding.
         */
        roundrect(x: any, y: any, w: any, h: any, dx: any, dy: any): void;
        /**
         * Puts an ellipse into the drawing buffer.
         *
         * Parameters:
         *
         * x - Number that represents the x-coordinate of the ellipse.
         * y - Number that represents the y-coordinate of the ellipse.
         * w - Number that represents the width of the ellipse.
         * h - Number that represents the height of the ellipse.
         */
        ellipse(x: any, y: any, w: any, h: any): void;
        /**
         * Paints an image.
         *
         * Parameters:
         *
         * x - Number that represents the x-coordinate of the image.
         * y - Number that represents the y-coordinate of the image.
         * w - Number that represents the width of the image.
         * h - Number that represents the height of the image.
         * src - String that specifies the URL of the image.
         * aspect - Boolean indicating if the aspect of the image should be preserved.
         * flipH - Boolean indicating if the image should be flipped horizontally.
         * flipV - Boolean indicating if the image should be flipped vertically.
         */
        image(x: any, y: any, w: any, h: any, src: any, aspect: any, flipH: any, flipV: any): void;
        /**
         * Starts a new path and puts it into the drawing buffer.
         */
        begin(): void;
        /**
         * Moves the current path the given point.
         *
         * Parameters:
         *
         * x - Number that represents the x-coordinate of the point.
         * y - Number that represents the y-coordinate of the point.
         */
        moveTo(x: any, y: any): void;
        /**
         * Draws a line to the given coordinates.
         *
         * Parameters:
         *
         * x - Number that represents the x-coordinate of the endpoint.
         * y - Number that represents the y-coordinate of the endpoint.
         */
        lineTo(x: any, y: any): void;
        /**
         * Adds a quadratic curve to the current path.
         *
         * Parameters:
         *
         * x1 - Number that represents the x-coordinate of the control point.
         * y1 - Number that represents the y-coordinate of the control point.
         * x2 - Number that represents the x-coordinate of the endpoint.
         * y2 - Number that represents the y-coordinate of the endpoint.
         */
        quadTo(x1: any, y1: any, x2: any, y2: any): void;
        /**
         * Adds a bezier curve to the current path.
         *
         * Parameters:
         *
         * x1 - Number that represents the x-coordinate of the first control point.
         * y1 - Number that represents the y-coordinate of the first control point.
         * x2 - Number that represents the x-coordinate of the second control point.
         * y2 - Number that represents the y-coordinate of the second control point.
         * x3 - Number that represents the x-coordinate of the endpoint.
         * y3 - Number that represents the y-coordinate of the endpoint.
         */
        curveTo(x1: any, y1: any, x2: any, y2: any, x3: any, y3: any): void;
        /**
         * Closes the current path.
         */
        close(): void;
        /**
         * Paints the given text. Possible values for format are empty string for
         * plain text and html for HTML markup. Background and border color as well
         * as clipping is not available in plain text labels for VML. HTML labels
         * are not available as part of shapes with no foreignObject support in SVG
         * (eg. IE9, IE10).
         *
         * Parameters:
         *
         * x - Number that represents the x-coordinate of the text.
         * y - Number that represents the y-coordinate of the text.
         * w - Number that represents the available width for the text or 0 for automatic width.
         * h - Number that represents the available height for the text or 0 for automatic height.
         * str - String that specifies the text to be painted.
         * align - String that represents the horizontal alignment.
         * valign - String that represents the vertical alignment.
         * wrap - Boolean that specifies if word-wrapping is enabled. Requires w > 0.
         * format - Empty string for plain text or 'html' for HTML markup.
         * overflow - Specifies the overflow behaviour of the label. Requires w > 0 and/or h > 0.
         * clip - Boolean that specifies if the label should be clipped. Requires w > 0 and/or h > 0.
         * rotation - Number that specifies the angle of the rotation around the anchor point of the text.
         * dir - Optional string that specifies the text direction. Possible values are rtl and lrt.
         */
        text(x: any, y: any, w: any, h: any, str: any, align: any, valign: any, wrap: any, format: any, overflow: any, clip: any, rotation: any, dir: any): void;
        /**
         * Paints the outline of the current drawing buffer.
         */
        stroke(): void;
        /**
         * Fills the current drawing buffer.
         */
        fill(): void;
        /**
         * Fills the current drawing buffer and its outline.
         */
        fillAndStroke(): void;
    }
    /**
     * Extends <mxAbstractCanvas2D> to implement a canvas for SVG. This canvas writes all
     * calls as SVG output to the given SVG root node.
     *
     * (code)
     * var svgDoc = mxUtils.createXmlDocument();
     * var root = (svgDoc.createElementNS != null) ?
     * 		svgDoc.createElementNS(mxConstants.NS_SVG, 'svg') : svgDoc.createElement('svg');
     *
     * if (svgDoc.createElementNS == null)
     * {
     *   root.setAttribute('xmlns', mxConstants.NS_SVG);
     *   root.setAttribute('xmlns:xlink', mxConstants.NS_XLINK);
     * }
     * else
     * {
     *   root.setAttributeNS('http://www.w3.org/2000/xmlns/', 'xmlns:xlink', mxConstants.NS_XLINK);
     * }
     *
     * var bounds = graph.getGraphBounds();
     * root.setAttribute('width', (bounds.x + bounds.width + 4) + 'px');
     * root.setAttribute('height', (bounds.y + bounds.height + 4) + 'px');
     * root.setAttribute('version', '1.1');
     *
     * svgDoc.appendChild(root);
     *
     * var svgCanvas = new mxSvgCanvas2D(root);
     * (end)
     *
     * A description of the public API is available in <mxXmlCanvas2D>.
     *
     * To disable anti-aliasing in the output, use the following code.
     *
     * (code)
     * graph.view.canvas.ownerSVGElement.setAttribute('shape-rendering', 'crispEdges');
     * (end)
     *
     * Or set the respective attribute in the SVG element directly.
     */
    class mxSvgCanvas2D extends mxAbstractCanvas2D {
        /**
         * Holds the current DOM node.
         */
        node: Element;
        /**
         * Specifies if plain text output should match the vertical HTML alignment.
         * Defaul is true.
         */
        matchHtmlAlignment: boolean;
        /**
         * Specifies if text output should be enabled. Default is true.
         */
        textEnabled: boolean;
        /**
         * Specifies if use of foreignObject for HTML markup is allowed. Default is true.
         */
        foEnabled: boolean;
        /**
         * Specifies the fallback text for unsupported foreignObjects in exported
         * documents. Default is '[Object]'. If this is set to null then no fallback
         * text is added to the exported document.
         */
        foAltText: string;
        /**
         * Offset to be used for foreignObjects.
         */
        foOffset: number;
        /**
         * Offset to be used for text elements.
         */
        textOffset: number;
        /**
         * Offset to be used for image elements.
         */
        imageOffset: number;
        /**
         * Adds transparent paths for strokes.
         */
        strokeTolerance: number;
        /**
         * Local counter for references in SVG declare.
         */
        refCount: number;
        /**
         * Specifies if a transparent rectangle should be added on top of images to absorb
         * all pointer events. Default is false. This is only needed in Firefox to disable
         * control-clicks on images.
         */
        blockImagePointerEvents: boolean;
        /**
         * Correction factor for <mxConstants.LINE_HEIGHT> in HTML output. Default is 1.
         */
        lineHeightCorrection: number;
        /**
         * Default value for active pointer events. Default is all.
         */
        pointerEventsValue: string;
        /**
         * Padding to be added for text that is not wrapped to account for differences
         * in font metrics on different platforms in pixels. Default is 10.
         */
        fontMetricsPadding: number;
        /**
         * Specifies if offsetWidth and offsetHeight should be cached. Default is true.
         * This is used to speed up repaint of text in <updateText>.
         */
        cacheOffsetSize: boolean;
        /**
         * Implicit variable declarations
         */
        root: SVGElement;
        gradients: any[];
        defs: SVGDefsElement;
        styleEnabled: boolean;
        state: any;
        pointerEvents: any;
        originalRoot: any;
        path: any;
        closeOp: any;
        useDomParser: boolean;
        rotateHtml: boolean;
        /**
         * Constructs a new SVG canvas.
         *
         * @param root - SVG container for the output.
         * @param styleEnabled - Optional boolean that specifies if a style section should be
         * added. The style section sets the default font-size, font-family and
         * stroke-miterlimit globally. Default is false.
         */
        constructor(root: any, styleEnabled: any);
        /**
         * Rounds all numbers to 2 decimal points.
         */
        format(value: any): number;
        /**
         * Returns the URL of the page without the hash part. This needs to use href to
         * include any search part with no params (ie question mark alone). This is a
         * workaround for the fact that window.location.search is empty if there is
         * no search string behind the question mark.
         */
        getBaseUrl(): string;
        /**
         * Returns any offsets for rendering pixels.
         */
        reset(): void;
        /**
         * Creates the optional style section.
         */
        createStyle(x?: any): any;
        /**
         * Returns the alternate content for the given foreignObject.
         */
        createAlternateContent(fo: any, x: any, y: any, w: any, h: any, str: any, align: any, valign: any, wrap: any, format: any, overflow: any, clip: any, rotation: any): any;
        /**
         * Private helper function to create SVG elements
         */
        createGradientId(start: any, end: any, alpha1: any, alpha2: any, direction: any): string;
        /**
         * Private helper function to create SVG elements
         */
        getSvgGradient(start: any, end: any, alpha1: any, alpha2: any, direction: any): any;
        /**
         * Creates the given SVG gradient.
         */
        createSvgGradient(start: any, end: any, alpha1: any, alpha2: any, direction: any): any;
        /**
         * Private helper function to create SVG elements
         */
        addNode(filled: any, stroked: any): void;
        /**
         * Transfers the stroke attributes from <state> to <node>.
         */
        updateFill(): void;
        /**
         * Returns the current stroke width (>= 1), ie. max(1, this.format(this.state.strokeWidth * this.state.scale)).
         */
        getCurrentStrokeWidth(): number;
        /**
         * Transfers the stroke attributes from <state> to <node>.
         */
        updateStroke(): void;
        /**
         * Transfers the stroke attributes from <state> to <node>.
         */
        updateStrokeAttributes(): void;
        /**
         * Creates the SVG dash pattern for the given state.
         */
        createDashPattern(scale: any): string;
        /**
         * Creates a hit detection tolerance shape for the given node.
         */
        createTolerance(node: any): any;
        /**
         * Creates a shadow for the given node.
         */
        createShadow(node: any): any;
        /**
         * Experimental implementation for hyperlinks.
         */
        setLink(link: any): void;
        /**
         * Sets the rotation of the canvas. Note that rotation cannot be concatenated.
         */
        rotate(theta: any, flipH: any, flipV: any, cx: any, cy: any): void;
        /**
         * Extends superclass to create path.
         */
        begin(): void;
        /**
         * Private helper function to create SVG elements
         */
        rect(x: any, y: any, w: any, h: any): void;
        /**
         * Private helper function to create SVG elements
         */
        roundrect(x: any, y: any, w: any, h: any, dx: any, dy: any): void;
        /**
         * Private helper function to create SVG elements
         */
        ellipse(x: any, y: any, w: any, h: any): void;
        /**
         * Private helper function to create SVG elements
         */
        image(x: any, y: any, w: any, h: any, src: any, aspect: any, flipH: any, flipV: any): void;
        /**
         * Converts the given HTML string to XHTML.
         */
        convertHtml(val: any): any;
        /**
         * Private helper function to create SVG elements
         */
        createDiv(str: any, align: any, valign: any, style: any, overflow: any): any;
        /**
         * Invalidates the cached offset size for the given node.
         */
        invalidateCachedOffsetSize(node: any): void;
        /**
         * Updates existing DOM nodes for text rendering. LATER: Merge common parts with text function below.
         */
        updateText(x: any, y: any, w: any, h: any, align: any, valign: any, wrap: any, overflow: any, clip: any, rotation: any, node: any): void;
        /**
         * Paints the given text. Possible values for format are empty string for plain
         * text and html for HTML markup. Note that HTML markup is only supported if
         * foreignObject is supported and <foEnabled> is true. (This means IE9 and later
         * does currently not support HTML text as part of shapes.)
         */
        text(x: any, y: any, w: any, h: any, str: any, align: any, valign: any, wrap: any, format: any, overflow: any, clip: any, rotation: any, dir: any): void;
        /**
         * Creates a clip for the given coordinates.
         */
        createClip(x: any, y: any, w: any, h: any): any;
        /**
         * Paints the given text. Possible values for format are empty string for
         * plain text and html for HTML markup.
         */
        plainText(x: any, y: any, w: any, h: any, str: any, align: any, valign: any, wrap: any, overflow: any, clip: any, rotation: any, dir: any): void;
        /**
         * Updates the text properties for the given node. (NOTE: For this to work in
         * IE, the given node must be a text or tspan element.)
         */
        updateFont(node: any): void;
        /**
         * Background color and border
         */
        addTextBackground(node: any, str: any, x: any, y: any, w: any, h: any, align: any, valign: any, overflow: any): void;
        /**
         * Paints the outline of the current path.
         */
        stroke(): void;
        /**
         * Fills the current path.
         */
        fill(): void;
        /**
         * Fills and paints the outline of the current path.
         */
        fillAndStroke(): void;
    }
    /**
     *
     * Implements a canvas to be used for rendering VML. Here is an example of implementing a
     * fallback for SVG images which are not supported in VML-based browsers.
     *
     * (code)
     * var mxVmlCanvas2DImage = mxVmlCanvas2D.prototype.image;
     * mxVmlCanvas2D.prototype.image = function(x, y, w, h, src, aspect, flipH, flipV)
     * {
     *   if (src.substring(src.length - 4, src.length) == '.svg')
     *   {
     *     src = 'http://www.jgraph.com/images/mxgraph.gif';
     *   }
     *
     *   mxVmlCanvas2DImage.apply(this, arguments);
     * };
     * (end)
     *
     * To disable anti-aliasing in the output, use the following code.
     *
     * (code)
     * document.createStyleSheet().cssText = mxClient.VML_PREFIX + '\\:*{antialias:false;)}';
     * (end)
     *
     * A description of the public API is available in <mxXmlCanvas2D>. Note that
     * there is a known issue in VML where gradients are painted using the outer
     * bounding box of rotated shapes, not the actual bounds of the shape. See
     * also <text> for plain text label restrictions in shapes for VML.
     */
    class mxVmlCanvas2D extends mxAbstractCanvas2D {
        constructor(root: any);
        /**
         * Creates the given element using the document.
         */
        createElement(name: any): any;
        /**
         * Creates a new element using <createElement> and prefixes the given name with
         * <mxClient.VML_PREFIX>.
         */
        createVmlElement(name: any): any;
        /**
         * Adds the current node to the <root>.
         */
        addNode(filled: any, stroked: any): void;
        /**
         * Creates a transparent fill.
         */
        createTransparentFill(): any;
        /**
         * Creates a fill for the current state.
         */
        createFill(): any;
        /**
         * Creates a fill for the current state.
         */
        createStroke(): any;
        /**
         * Returns a VML dash pattern for the current dashPattern.
         * See http://msdn.microsoft.com/en-us/library/bb264085(v=vs.85).aspx
         */
        getVmlDashStyle(): string;
        /**
         * Creates a shadow for the given node.
         */
        createShadow(node: any, filled: any, stroked: any): any;
        /**
         * Creates the fill for the shadow.
         */
        createShadowFill(): any;
        /**
         * Creates the stroke for the shadow.
         */
        createShadowStroke(): any;
        /**
         * Sets the rotation of the canvas. Note that rotation cannot be concatenated.
         */
        rotate(theta: any, flipH: any, flipV: any, cx: any, cy: any): void;
        /**
         * Extends superclass to create path.
         */
        begin(): void;
        /**
         * Replaces quadratic curve with bezier curve in VML.
         */
        quadTo(x1: any, y1: any, x2: any, y2: any): void;
        /**
         * Sets the glass gradient.
         */
        createRect(nodeName: any, x: any, y: any, w: any, h: any): any;
        /**
         * Sets the current path to a rectangle.
         */
        rect(x: any, y: any, w: any, h: any): void;
        /**
         * Sets the current path to a rounded rectangle.
         */
        roundrect(x: any, y: any, w: any, h: any, dx: any, dy: any): void;
        /**
         * Sets the current path to an ellipse.
         */
        ellipse(x: any, y: any, w: any, h: any): void;
        /**
         * Paints an image.
         */
        image(x: any, y: any, w: any, h: any, src: any, aspect: any, flipH: any, flipV: any): void;
        /**
         * Creates the innermost element that contains the HTML text.
         */
        createDiv(str: any, align: any, valign: any, overflow: any): any;
        /**
         * Paints the given text. Possible values for format are empty string for plain
         * text and html for HTML markup. Clipping, text background and border are not
         * supported for plain text in VML.
         */
        text(x: any, y: any, w: any, h: any, str: any, align: any, valign: any, wrap: any, format: any, overflow: any, clip: any, rotation: any, dir: any): void;
        /**
         * Paints the outline of the current path.
         */
        plainText(x: any, y: any, w: any, h: any, str: any, align: any, valign: any, wrap: any, format: any, overflow: any, clip: any, rotation: any, dir: any): void;
        /**
         * Paints the outline of the current path.
         */
        stroke(): void;
        /**
         * Fills the current path.
         */
        fill(): void;
        /**
         * Fills and paints the outline of the current path.
         */
        fillAndStroke(): void;
    }
    /**
     * Implements the alignment of selection cells to other cells in the graph.
     *
     * Constructor: mxGuide
     *
     * Constructs a new guide object.
     */
    class mxGuide {
        constructor(graph: any, states: any);
        /**
         * Sets the <mxCellStates> that should be used for alignment.
         */
        setStates(states: any): void;
        /**
         * Returns true if the guide should be enabled for the given native event. This
         * implementation always returns true.
         */
        isEnabledForEvent(evt: any): boolean;
        /**
         * Returns the tolerance for the guides. Default value is gridSize / 2.
         */
        getGuideTolerance(): number;
        /**
         * Returns the mxShape to be used for painting the respective guide. This
         * implementation returns a new, dashed and crisp <mxPolyline> using
         * <mxConstants.GUIDE_COLOR> and <mxConstants.GUIDE_STROKEWIDTH> as the format.
         *
         * Parameters:
         *
         * horizontal - Boolean that specifies which guide should be created.
         */
        createGuideShape(horizontal: any): mxPolyline;
        /**
         * Moves the <bounds> by the given <mxPoint> and returnt the snapped point.
         */
        move(bounds: any, delta: any, gridEnabled: any): any;
        /**
         * Hides all current guides.
         */
        getGuideColor(state: any, horizontal: any): string;
        /**
         * Hides all current guides.
         */
        hide(): void;
        /**
         * Shows or hides the current guides.
         */
        setVisible(visible: any): void;
        /**
         * Destroys all resources that this object uses.
         */
        destroy(): void;
    }
    /**
     * Base class for all layout algorithms in mxGraph. Main public functions are
     * <move> for handling a moved cell within a layouted parent, and <execute> for
     * running the layout on a given parent cell.
     *
     * Known Subclasses:
     *
     * <mxCircleLayout>, <mxCompactTreeLayout>, <mxCompositeLayout>,
     * <mxFastOrganicLayout>, <mxParallelEdgeLayout>, <mxPartitionLayout>,
     * <mxStackLayout>
     *
     * Constructor: mxGraphLayout
     *
     * Constructs a new layout using the given layouts.
     *
     * Arguments:
     *
     * graph - Enclosing
     */
    class mxGraphLayout {
        /**
         * Variable: useBoundingBox
         *
         * Boolean indicating if the bounding box of the label should be used if
         * its available. Default is true.
         */
        useBoundingBox: boolean;
        /**
         * Variable: graph
         *
         * Reference to the enclosing <mxGraph>.
         */
        graph: mxGraph;
        constructor(graph: mxGraph);
        /**
         * Notified when a cell is being moved in a parent that has automatic
         * layout to update the cell state (eg. index) so that the outcome of the
         * layout will position the vertex as close to the point (x, y) as
         * possible.
         *
         * Empty implementation.
         *
         * Parameters:
         *
         * cell - <mxCell> which has been moved.
         * x - X-coordinate of the new cell location.
         * y - Y-coordinate of the new cell location.
         */
        moveCell(cell: any, x: any, y: any): void;
        /**
         * Function: resizeCell
         *
         * Notified when a cell is being resized in a parent that has automatic
         * layout to update the other cells in the layout.
         *
         * Empty implementation.
         *
         * Parameters:
         *
         * cell - <mxCell> which has been moved.
         * bounds - <mxRectangle> that represents the new cell bounds.
         */
        resizeCell(cell: mxCell, bounds: mxRectangle): void;
        /**
         * Executes the layout algorithm for the children of the given parent.
         *
         * Parameters:
         *
         * parent - <mxCell> whose children should be layed out.
         */
        execute(parent: any): void;
        /**
         * Returns the graph that this layout operates on.
         */
        getGraph(): any;
        /**
         * Returns the constraint for the given key and cell. The optional edge and
         * source arguments are used to return inbound and outgoing routing-
         * constraints for the given edge and vertex. This implementation always
         * returns the value for the given key in the style of the given cell.
         *
         * Parameters:
         *
         * key - Key of the constraint to be returned.
         * cell - <mxCell> whose constraint should be returned.
         * edge - Optional <mxCell> that represents the connection whose constraint
         * should be returned. Default is null.
         * source - Optional boolean that specifies if the connection is incoming
         * or outgoing. Default is null.
         */
        getConstraint(key: any, cell: any, edge: any, source: any): any;
        /**
         * Traverses the (directed) graph invoking the given function for each
         * visited vertex and edge. The function is invoked with the current vertex
         * and the incoming edge as a parameter. This implementation makes sure
         * each vertex is only visited once. The function may return false if the
         * traversal should stop at the given vertex.
         *
         * Example:
         *
         * (code)
         * mxLog.show();
         * var cell = graph.getSelectionCell();
         * graph.traverse(cell, false, function(vertex, edge)
         * {
         *   mxLog.debug(graph.getLabel(vertex));
         * });
         * (end)
         *
         * Parameters:
         *
         * vertex - <mxCell> that represents the vertex where the traversal starts.
         * directed - Optional boolean indicating if edges should only be traversed
         * from source to target. Default is true.
         * func - Visitor function that takes the current vertex and the incoming
         * edge as arguments. The traversal stops if the function returns false.
         * edge - Optional <mxCell> that represents the incoming edge. This is
         * null for the first step of the traversal.
         * visited - Optional <mxDictionary> of cell paths for the visited cells.
         */
        static traverse(vertex: any, directed: any, func: any, edge: any, visited: any): void;
        /**
         * Returns a boolean indicating if the given <mxCell> is movable or
         * bendable by the algorithm. This implementation returns true if the given
         * cell is movable in the graph.
         *
         * Parameters:
         *
         * cell - <mxCell> whose movable state should be returned.
         */
        isVertexMovable(cell: any): any;
        /**
         * Returns a boolean indicating if the given <mxCell> should be ignored by
         * the algorithm. This implementation returns false for all vertices.
         *
         * Parameters:
         *
         * vertex - <mxCell> whose ignored state should be returned.
         */
        isVertexIgnored(vertex: any): boolean;
        /**
         * Returns a boolean indicating if the given <mxCell> should be ignored by
         * the algorithm. This implementation returns false for all vertices.
         *
         * Parameters:
         *
         * cell - <mxCell> whose ignored state should be returned.
         */
        isEdgeIgnored(edge: any): boolean;
        /**
         * Disables or enables the edge style of the given edge.
         */
        setEdgeStyleEnabled(edge: any, value: any): void;
        /**
         * Disables or enables orthogonal end segments of the given edge.
         */
        setOrthogonalEdge(edge: any, value: any): void;
        /**
         * Determines the offset of the given parent to the parent
         * of the layout
         */
        getParentOffset(parent: any): mxPoint;
        /**
         * Replaces the array of mxPoints in the geometry of the given edge
         * with the given array of mxPoints.
         */
        setEdgePoints(edge: any, points: any): void;
        /**
         * Sets the new position of the given cell taking into account the size of
         * the bounding box if <useBoundingBox> is true. The change is only carried
         * out if the new location is not equal to the existing location, otherwise
         * the geometry is not replaced with an updated instance. The new or old
         * bounds are returned (including overlapping labels).
         *
         * Parameters:
         *
         * cell - <mxCell> whose geometry is to be set.
         * x - Integer that defines the x-coordinate of the new location.
         * y - Integer that defines the y-coordinate of the new location.
         */
        setVertexLocation(cell: any, x: any, y: any): any;
        /**
         * Returns an <mxRectangle> that defines the bounds of the given cell or
         * the bounding box if <useBoundingBox> is true.
         */
        getVertexBounds(cell: any): mxRectangle;
        /**
         * Shortcut to <mxGraph.updateGroupBounds> with moveGroup set to true.
         */
        arrangeGroups(cells: any, border: any, topBorder: any, rightBorder: any, bottomBorder: any, leftBorder: any): any;
    }
    /**
     * Extends <mxGraphLayout> to create a horizontal or vertical stack of the
     * child vertices. The children do not need to be connected for this layout
     * to work.
     *
     * Example:
     *
     * (code)
     * var layout = new mxStackLayout(graph, true);
     * layout.execute(graph.getDefaultParent());
     * (end)
     *
     * Constructor: mxStackLayout
     *
     * Constructs a new stack layout layout for the specified graph,
     * spacing, orientation and offset.
     */
    class mxStackLayout extends mxGraphLayout {
        fill: boolean;
        marginBottom: number;
        marginTop: number;
        marginRight: number;
        marginLeft: number;
        border: any;
        spacing: any;
        resizeLast: boolean;
        resizeParent: boolean;
        horizontal: boolean;
        resizeParentMax: boolean;
        /**
         * Variable: allowGaps
         *
         * If gaps should be allowed in the stack. Default is false.
         */
        allowGaps: boolean;
        /**
         * Variable: gridSize
         *
         * Grid size for alignment of position and size. Default is 0.
         */
        gridSize: number;
        constructor(graph: any, horizontal?: any, spacing?: any, x0?: any, y0?: any, border?: any);
        /**
         * Returns <horizontal>.
         */
        isHorizontal(): any;
        /**
         * Implements <mxGraphLayout.moveCell>.
         */
        moveCell(cell: any, x: any, y: any): void;
        /**
         * Returns the size for the parent container or the size of the graph
         * container if the parent is a layer or the root of the model.
         */
        getParentSize(parent: any): any;
        /**
         * Implements <mxGraphLayout.execute>.
         *
         * Only children where <isVertexIgnored> returns false are taken into
         * account.
         */
        execute(parent: any): void;
        /**
         * Implements <mxGraphLayout.execute>.
         *
         * Only children where <isVertexIgnored> returns false are taken into
         * account.
         */
        setChildGeometry(child: any, geo: any): void;
        /**
         * Implements <mxGraphLayout.execute>.
         *
         * Only children where <isVertexIgnored> returns false are taken into
         * account.
         */
        updateParentGeometry(parent: any, pgeo: any, last: any): void;
    }
    /**
     * Extends <mxGraphLayout> for partitioning the parent cell vertically or
     * horizontally by filling the complete area with the child cells. A horizontal
     * layout partitions the height of the given parent whereas a a non-horizontal
     * layout partitions the width. If the parent is a layer (that is, a child of
     * the root node), then the current graph size is partitioned. The children do
     * not need to be connected for this layout to work.
     *
     * Example:
     *
     * (code)
     * var layout = new mxPartitionLayout(graph, true, 10, 20);
     * layout.execute(graph.getDefaultParent());
     * (end)
     *
     * Constructor: mxPartitionLayout
     *
     * Constructs a new stack layout layout for the specified graph,
     * spacing, orientation and offset.
     */
    class mxPartitionLayout extends mxGraphLayout {
        constructor(graph: any, horizontal: any, spacing: any, border: any);
        /**
         * Returns <horizontal>.
         */
        isHorizontal(): any;
        /**
         * Implements <mxGraphLayout.moveCell>.
         */
        moveCell(cell: any, x: any, y: any): void;
        /**
         * Implements <mxGraphLayout.execute>. All children where <isVertexIgnored>
         * returns false and <isVertexMovable> returns true are modified.
         */
        execute(parent: any): void;
    }
    /**
     * Class: mxCompactTreeLayout
     *
     * Extends <mxGraphLayout> to implement a compact tree (Moen) algorithm. This
     * layout is suitable for graphs that have no cycles (trees). Vertices that are
     * not connected to the tree will be ignored by this layout.
     *
     * Example:
     *
     * (code)
     * var layout = new mxCompactTreeLayout(graph);
     * layout.execute(graph.getDefaultParent());
     * (end)
     *
     * Constructor: mxCompactTreeLayout
     *
     * Constructs a new compact tree layout for the specified graph
     * and orientation.
     */
    class mxCompactTreeLayout extends mxGraphLayout {
        resetEdges: boolean;
        edgeRouting: boolean;
        /**
         * Variable: maintainParentLocation
         *
         * Specifies if the parent location should be maintained, so that the
         * top, left corner stays the same before and after execution of
         * the layout. Default is false for backwards compatibility.
         */
        maintainParentLocation: boolean;
        levelDistance: number;
        nodeDistance: number;
        /**
         * Variable: groupPadding
         *
         * Padding added to resized parents. Default is 10.
         */
        groupPadding: any;
        /**
         * Variable: resizeParent
         *
         * If the parents should be resized to match the width/height of the
         * children. Default is true.
         */
        resizeParent: boolean;
        /**
         * Variable: horizontal
         *
         * Specifies the orientation of the layout. Default is true.
         */
        horizontal: boolean;
        root: any;
        /**
         * Variable: invert
         *
         * Specifies if edge directions should be inverted. Default is false.
         */
        invert: boolean;
        constructor(graph: any, horizontal?: any, invert?: any);
        /**
         * Returns a boolean indicating if the given <mxCell> should be ignored as a
         * vertex. This returns true if the cell has no connections.
         *
         * Parameters:
         *
         * vertex - <mxCell> whose ignored state should be returned.
         */
        isVertexIgnored(vertex: any): any;
        /**
         * Returns <horizontal>.
         */
        isHorizontal(): any;
        /**
         * Implements <mxGraphLayout.execute>.
         *
         * If the parent has any connected edges, then it is used as the root of
         * the tree. Else, <mxGraph.findTreeRoots> will be used to find a suitable
         * root node within the set of children of the given parent.
         *
         * Parameters:
         *
         * parent - <mxCell> whose children should be laid out.
         * root - Optional <mxCell> that will be used as the root of the tree.
         * Overrides <root> if specified.
         */
        execute(parent: any, root?: any): void;
        /**
         * Moves the specified node and all of its children by the given amount.
         */
        moveNode(node: any, dx: any, dy: any): void;
        /**
         * Called if <sortEdges> is true to sort the array of outgoing edges in place.
         */
        sortOutgoingEdges(source: any, edges: any): void;
        /**
         * Stores the maximum height (relative to the layout
         * direction) of cells in each rank
         */
        findRankHeights(node: any, rank: any): void;
        /**
         * Set the cells heights (relative to the layout
         * direction) when the tops of each rank are to be aligned
         */
        setCellHeights(node: any, rank: any): void;
        /**
         * Does a depth first search starting at the specified cell.
         * Makes sure the specified parent is never left by the
         * algorithm.
         */
        dfs(cell: any, parent: any): any;
        /**
         * Starts the actual compact tree layout algorithm
         * at the given node.
         */
        layout(node: any): void;
        /**
         * Function: horizontalLayout
         */
        horizontalLayout(node: any, x0: any, y0: any, bounds?: any): any;
        /**
         * Function: verticalLayout
         */
        verticalLayout(node: any, parent: any, x0: any, y0: any, bounds?: any): any;
        /**
         * Function: attachParent
         */
        attachParent(node: any, height: any): void;
        /**
         * Function: layoutLeaf
         */
        layoutLeaf(node: any): void;
        /**
         * Function: join
         */
        join(node: any): any;
        /**
         * Function: merge
         */
        merge(p1: any, p2: any): number;
        /**
         * Function: offset
         */
        offset(p1: any, p2: any, a1: any, a2: any, b1: any, b2: any): number;
        /**
         * Function: bridge
         */
        bridge(line1: any, x1: any, y1: any, line2: any, x2: any, y2: any): Object;
        /**
         * Function: createNode
         */
        createNode(cell: any): Object;
        /**
         * Function: apply
         */
        apply(node: any, bounds: any): any;
        /**
         * Function: createLine
         */
        createLine(dx: any, dy: any, next?: any): Object;
        /**
         * Adjust parent cells whose child geometries have changed. The default
         * implementation adjusts the group to just fit around the children with
         * a padding.
         */
        adjustParents(): void;
        /**
         * Moves the specified node and all of its children by the given amount.
         */
        localEdgeProcessing(node: any): void;
        /**
         * Separates the x position of edges as they connect to vertices
         */
        processNodeOutgoing(node: any): void;
    }
    /**
     * A utility class used to track cells whilst sorting occurs on the weighted
     * sum of their connected edges. Does not violate (x.compareTo(y)==0) ==
     * (x.equals(y))
     *
     * Constructor: WeightedCellSorter
     *
     * Constructs a new weighted cell sorted for the given cell and weight.
     */
    class WeightedCellSorter {
        constructor(cell: any, weightedValue: any);
        /**
         * Compares two WeightedCellSorters.
         */
        compare(a: any, b: any): 1 | 0 | -1;
    }
    /**
     * Extends <mxGraphLayout> to implement a radial tree algorithm. This
     * layout is suitable for graphs that have no cycles (trees). Vertices that are
     * not connected to the tree will be ignored by this layout.
     *
     * Example:
     *
     * (code)
     * var layout = new mxRadialTreeLayout(graph);
     * layout.execute(graph.getDefaultParent());
     * (end)
     *
     * Constructor: mxRadialTreeLayout
     *
     * Constructs a new radial tree layout for the specified graph
     */
    class mxRadialTreeLayout extends mxCompactTreeLayout {
        constructor(graph: any);
        /**
         * Returns a boolean indicating if the given <mxCell> should be ignored as a
         * vertex. This returns true if the cell has no connections.
         *
         * Parameters:
         *
         * vertex - <mxCell> whose ignored state should be returned.
         */
        isVertexIgnored(vertex: any): any;
        /**
         * Implements <mxGraphLayout.execute>.
         *
         * If the parent has any connected edges, then it is used as the root of
         * the tree. Else, <mxGraph.findTreeRoots> will be used to find a suitable
         * root node within the set of children of the given parent.
         *
         * Parameters:
         *
         * parent - <mxCell> whose children should be laid out.
         * root - Optional <mxCell> that will be used as the root of the tree.
         */
        execute(parent: any, root: any): void;
        /**
         * Recursive function to calculate the dimensions of each row
         *
         * Parameters:
         *
         * row - Array of internal nodes, the children of which are to be processed.
         * rowNum - Integer indicating which row is being processed.
         */
        calcRowDims(row: any, rowNum: any): void;
    }
    /**
     * Extends <mxGraphLayout> to implement a fast organic layout algorithm.
     * The vertices need to be connected for this layout to work, vertices
     * with no connections are ignored.
     *
     * Example:
     *
     * (code)
     * var layout = new mxFastOrganicLayout(graph);
     * layout.execute(graph.getDefaultParent());
     * (end)
     *
     * Constructor: mxCompactTreeLayout
     *
     * Constructs a new fast organic layout for the specified graph.
     */
    class mxFastOrganicLayout extends mxGraphLayout {
        constructor(graph: any);
        /**
         * Returns a boolean indicating if the given <mxCell> should be ignored as a
         * vertex. This returns true if the cell has no connections.
         *
         * Parameters:
         *
         * vertex - <mxCell> whose ignored state should be returned.
         */
        isVertexIgnored(vertex: any): any;
        /**
         * Implements <mxGraphLayout.execute>. This operates on all children of the
         * given parent where <isVertexIgnored> returns false.
         */
        execute(parent: any): void;
        /**
         * Takes the displacements calculated for each cell and applies them to the
         * local cache of cell positions. Limits the displacement to the current
         * temperature.
         */
        calcPositions(): void;
        /**
         * Calculates the attractive forces between all laid out nodes linked by
         * edges
         */
        calcAttraction(): void;
        /**
         * Calculates the repulsive forces between all laid out nodes
         */
        calcRepulsion(): void;
        /**
         * Reduces the temperature of the layout from an initial setting in a linear
         * fashion to zero.
         */
        reduceTemperature(): void;
    }
    /**
     * Extends <mxGraphLayout> to implement a circluar layout for a given radius.
     * The vertices do not need to be connected for this layout to work and all
     * connections between vertices are not taken into account.
     *
     * Example:
     *
     * (code)
     * var layout = new mxCircleLayout(graph);
     * layout.execute(graph.getDefaultParent());
     * (end)
     *
     * Constructor: mxCircleLayout
     *
     * Constructs a new circular layout for the specified radius.
     *
     * Arguments:
     *
     * graph - <mxGraph> that contains the cells.
     * radius - Optional radius as an int. Default is 100.
     */
    class mxCircleLayout extends mxGraphLayout {
        constructor(graph: any, radius?: any);
        /**
         * Implements <mxGraphLayout.execute>.
         */
        execute(parent: any): void;
        /**
         * Returns the radius to be used for the given vertex count. Max is the maximum
         * width or height of all vertices in the layout.
         */
        getRadius(count: any, max: any): number;
        /**
         * Executes the circular layout for the specified array
         * of vertices and the given radius. This is called from
         * <execute>.
         */
        circle(vertices: any, r: any, left: any, top: any): void;
    }
    /**
     * Extends <mxGraphLayout> for arranging parallel edges. This layout works
     * on edges for all pairs of vertices where there is more than one edge
     * connecting the latter.
     *
     * Example:
     *
     * (code)
     * var layout = new mxParallelEdgeLayout(graph);
     * layout.execute(graph.getDefaultParent());
     * (end)
     *
     * To run the layout for the parallel edges of a changed edge only, the
     * following code can be used.
     *
     * (code)
     * var layout = new mxParallelEdgeLayout(graph);
     *
     * graph.addListener(mxEvent.CELL_CONNECTED, function(sender, evt)
     * {
     *   var model = graph.getModel();
     *   var edge = evt.getProperty('edge');
     *   var src = model.getTerminal(edge, true);
     *   var trg = model.getTerminal(edge, false);
     *
     *   layout.isEdgeIgnored = function(edge2)
     *   {
     *     var src2 = model.getTerminal(edge2, true);
     *     var trg2 = model.getTerminal(edge2, false);
     *
     *     return !(model.isEdge(edge2) && ((src == src2 && trg == trg2) || (src == trg2 && trg == src2)));
     *   };
     *
     *   layout.execute(graph.getDefaultParent());
     * });
     * (end)
     *
     * Constructor: mxCompactTreeLayout
     *
     * Constructs a new fast organic layout for the specified graph.
     */
    class mxParallelEdgeLayout extends mxGraphLayout {
        constructor(graph: any);
        /**
         * Implements <mxGraphLayout.execute>.
         */
        execute(parent: any): void;
        /**
         * Finds the parallel edges in the given parent.
         */
        findParallels(parent: any): any[];
        /**
         * Returns a unique ID for the given edge. The id is independent of the
         * edge direction and is built using the visible terminal of the given
         * edge.
         */
        getEdgeId(edge: any): string;
        /**
         * Lays out the parallel edges in the given array.
         */
        layout(parallels: any): void;
        /**
         * Routes the given edge via the given point.
         */
        route(edge: any, x: any, y: any): void;
    }
    /**
     * Allows to compose multiple layouts into a single layout. The master layout
     * is the layout that handles move operations if another layout than the first
     * element in <layouts> should be used. The <master> layout is not executed as
     * the code assumes that it is part of <layouts>.
     *
     * Example:
     * (code)
     * var first = new mxFastOrganicLayout(graph);
     * var second = new mxParallelEdgeLayout(graph);
     * var layout = new mxCompositeLayout(graph, [first, second], first);
     * layout.execute(graph.getDefaultParent());
     * (end)
     *
     * Constructor: mxCompositeLayout
     *
     * Constructs a new layout using the given layouts. The graph instance is
     * required for creating the transaction that contains all layouts.
     *
     * Arguments:
     *
     * graph - Reference to the enclosing <mxGraph>.
     * layouts - Array of <mxGraphLayouts>.
     * master - Optional layout that handles moves. If no layout is given then
     * the first layout of the above array is used to handle moves.
     */
    class mxCompositeLayout extends mxGraphLayout {
        constructor(graph: any, layouts: any, master: any);
        /**
         * Implements <mxGraphLayout.moveCell> by calling move on <master> or the first
         * layout in <layouts>.
         */
        moveCell(cell: any, x: any, y: any): void;
        /**
         * Implements <mxGraphLayout.execute> by executing all <layouts> in a
         * single transaction.
         */
        execute(parent: any): void;
    }
    /**
     * Extends <mxGraphLayout> to implement an edge label layout. This layout
     * makes use of cell states, which means the graph must be validated in
     * a graph view (so that the label bounds are available) before this layout
     * can be executed.
     *
     * Example:
     *
     * (code)
     * var layout = new mxEdgeLabelLayout(graph);
     * layout.execute(graph.getDefaultParent());
     * (end)
     *
     * Constructor: mxEdgeLabelLayout
     *
     * Constructs a new edge label layout.
     *
     * Arguments:
     *
     * graph - <mxGraph> that contains the cells.
     */
    class mxEdgeLabelLayout extends mxGraphLayout {
        constructor(graph: any, radius: any);
        /**
         * Implements <mxGraphLayout.execute>.
         */
        execute(parent: any): void;
        /**
         * Places the labels of the given edges.
         */
        placeLabels(v: any, e: any): void;
        /**
         * Places the labels of the given edges.
         */
        avoid(edge: any, vertex: any): void;
    }
    /**
     * Class: mxGraphModel
     *
     * Extends <mxEventSource> to implement a graph model. The graph model acts as
     * a wrapper around the cells which are in charge of storing the actual graph
     * datastructure. The model acts as a transactional wrapper with event
     * notification for all changes, whereas the cells contain the atomic
     * operations for updating the actual datastructure.
     *
     * Layers:
     *
     * The cell hierarchy in the model must have a top-level root cell which
     * contains the layers (typically one default layer), which in turn contain the
     * top-level cells of the layers. This means each cell is contained in a layer.
     * If no layers are required, then all new cells should be added to the default
     * layer.
     *
     * Layers are useful for hiding and showing groups of cells, or for placing
     * groups of cells on top of other cells in the display. To identify a layer,
     * the <isLayer> function is used. It returns true if the parent of the given
     * cell is the root of the model.
     *
     * Events:
     *
     * See events section for more details. There is a new set of events for
     * tracking transactional changes as they happen. The events are called
     * startEdit for the initial beginUpdate, executed for each executed change
     * and endEdit for the terminal endUpdate. The executed event contains a
     * property called change which represents the change after execution.
     *
     * Encoding the model:
     *
     * To encode a graph model, use the following code:
     *
     * (code)
     * var enc = new mxCodec();
     * var node = enc.encode(graph.getModel());
     * (end)
     *
     * This will create an XML node that contains all the model information.
     *
     * Encoding and decoding changes:
     *
     * For the encoding of changes, a graph model listener is required that encodes
     * each change from the given array of changes.
     *
     * (code)
     * model.addListener(mxEvent.CHANGE, function(sender, evt)
     * {
     *   var changes = evt.getProperty('edit').changes;
     *   var nodes = [];
     *   var codec = new mxCodec();
     *
     *   for (var i = 0; i < changes.length; i++)
     *   {
     *     nodes.push(codec.encode(changes[i]));
     *   }
     *   // do something with the nodes
     * });
     * (end)
     *
     * For the decoding and execution of changes, the codec needs a lookup function
     * that allows it to resolve cell IDs as follows:
     *
     * (code)
     * var codec = new mxCodec();
     * codec.lookup = function(id)
     * {
     *   return model.getCell(id);
     * }
     * (end)
     *
     * For each encoded change (represented by a node), the following code can be
     * used to carry out the decoding and create a change object.
     *
     * (code)
     * var changes = [];
     * var change = codec.decode(node);
     * change.model = model;
     * change.execute();
     * changes.push(change);
     * (end)
     *
     * The changes can then be dispatched using the model as follows.
     *
     * (code)
     * var edit = new mxUndoableEdit(model, false);
     * edit.changes = changes;
     *
     * edit.notify = function()
     * {
     *   edit.source.fireEvent(new mxEventObject(mxEvent.CHANGE,
     *   	'edit', edit, 'changes', edit.changes));
     *   edit.source.fireEvent(new mxEventObject(mxEvent.NOTIFY,
     *   	'edit', edit, 'changes', edit.changes));
     * }
     *
     * model.fireEvent(new mxEventObject(mxEvent.UNDO, 'edit', edit));
     * model.fireEvent(new mxEventObject(mxEvent.CHANGE,
     * 		'edit', edit, 'changes', changes));
     * (end)
     *
     * Event: mxEvent.CHANGE
     *
     * Fires when an undoable edit is dispatched. The <code>edit</code> property
     * contains the <mxUndoableEdit>. The <code>changes</code> property contains
     * the array of atomic changes inside the undoable edit. The changes property
     * is <strong>deprecated</strong>, please use edit.changes instead.
     *
     * Example:
     *
     * For finding newly inserted cells, the following code can be used:
     *
     * (code)
     * graph.model.addListener(mxEvent.CHANGE, function(sender, evt)
     * {
     *   var changes = evt.getProperty('edit').changes;
     *
     *   for (var i = 0; i < changes.length; i++)
     *   {
     *     var change = changes[i];
     *
     *     if (change instanceof mxChildChange &&
     *       change.change.previous == null)
     *     {
     *       graph.startEditingAtCell(change.child);
     *       break;
     *     }
     *   }
     * });
     * (end)
     *
     *
     * Event: mxEvent.NOTIFY
     *
     * Same as <mxEvent.CHANGE>, this event can be used for classes that need to
     * implement a sync mechanism between this model and, say, a remote model. In
     * such a setup, only local changes should trigger a notify event and all
     * changes should trigger a change event.
     *
     * Event: mxEvent.EXECUTE
     *
     * Fires between begin- and endUpdate and after an atomic change was executed
     * in the model. The <code>change</code> property contains the atomic change
     * that was executed.
     *
     * Event: mxEvent.EXECUTED
     *
     * Fires between START_EDIT and END_EDIT after an atomic change was executed.
     * The <code>change</code> property contains the change that was executed.
     *
     * Event: mxEvent.BEGIN_UPDATE
     *
     * Fires after the <updateLevel> was incremented in <beginUpdate>. This event
     * contains no properties.
     *
     * Event: mxEvent.START_EDIT
     *
     * Fires after the <updateLevel> was changed from 0 to 1. This event
     * contains no properties.
     *
     * Event: mxEvent.END_UPDATE
     *
     * Fires after the <updateLevel> was decreased in <endUpdate> but before any
     * notification or change dispatching. The <code>edit</code> property contains
     * the <currentEdit>.
     *
     * Event: mxEvent.END_EDIT
     *
     * Fires after the <updateLevel> was changed from 1 to 0. This event
     * contains no properties.
     *
     * Event: mxEvent.BEFORE_UNDO
     *
     * Fires before the change is dispatched after the update level has reached 0
     * in <endUpdate>. The <code>edit</code> property contains the <curreneEdit>.
     *
     * Event: mxEvent.UNDO
     *
     * Fires after the change was dispatched in <endUpdate>. The <code>edit</code>
     * property contains the <currentEdit>.
     *
     * Constructor: mxGraphModel
     *
     * Constructs a new graph model. If no root is specified then a new root
     * <mxCell> with a default layer is created.
     *
     * Parameters:
     *
     * root - <mxCell> that represents the root cell.
     */
    class mxGraphModel extends mxEventSource {
        constructor(root?: mxCell);
        /**
         * Variable: root
         *
         * Holds the root cell, which in turn contains the cells that represent the
         * layers of the diagram as child cells. That is, the actual elements of the
         * diagram are supposed to live in the third generation of cells and below.
         */
        root: mxCell;
        /**
         * Variable: cells
         *
         * Maps from Ids to cells.
         */
        cells: {
            [id: string]: mxCell;
        };
        /**
         * Variable: maintainEdgeParent
         *
         * Specifies if edges should automatically be moved into the nearest common
         * ancestor of their terminals. Default is true.
         */
        maintainEdgeParent: boolean;
        /**
         * Variable: ignoreRelativeEdgeParent
         *
         * Specifies if relative edge parents should be ignored for finding the nearest
         * common ancestors of an edge's terminals. Default is true.
         */
        ignoreRelativeEdgeParent: boolean;
        /**
         * Variable: createIds
         *
         * Specifies if the model should automatically create Ids for new cells.
         * Default is true.
         */
        createIds: boolean;
        /**
         * Variable: prefix
         *
         * Defines the prefix of new Ids. Default is an empty string.
         */
        prefix: string;
        /**
         * Variable: postfix
         *
         * Defines the postfix of new Ids. Default is an empty string.
         */
        postfix: string;
        /**
         * Variable: nextId
         *
         * Specifies the next Id to be created. Initial value is 0.
         */
        nextId: number;
        /**
         * Variable: currentEdit
         *
         * Holds the changes for the current transaction. If the transaction is
         * closed then a new object is created for this variable using
         * <createUndoableEdit>.
         */
        currentEdit: any;
        /**
         * Variable: updateLevel
         *
         * Counter for the depth of nested transactions. Each call to <beginUpdate>
         * will increment this number and each call to <endUpdate> will decrement
         * it. When the counter reaches 0, the transaction is closed and the
         * respective events are fired. Initial value is 0.
         */
        updateLevel: number;
        /**
         * Variable: endingUpdate
         *
         * True if the program flow is currently inside endUpdate.
         */
        endingUpdate: boolean;
        /**
         * Function: clear
         *
         * Sets a new root using <createRoot>.
         */
        clear(): void;
        /**
         * Function: isCreateIds
         *
         * Returns <createIds>.
         */
        isCreateIds(): boolean;
        /**
         * Function: setCreateIds
         *
         * Sets <createIds>.
         */
        setCreateIds(value: any): void;
        /**
         * Function: createRoot
         *
         * Creates a new root cell with a default layer (child 0).
         */
        createRoot(): mxCell;
        /**
         * Function: getCell
         *
         * Returns the <mxCell> for the specified Id or null if no cell can be
         * found for the given Id.
         *
         * Parameters:
         *
         * id - A string representing the Id of the cell.
         */
        getCell(id: string): mxCell;
        /**
         * Function: filterCells
         *
         * Returns the cells from the given array where the given filter function
         * returns true.
         */
        filterCells(cells: mxCell[], filter: (cell: mxCell) => boolean): mxCell[];
        /**
         * Function: getDescendants
         *
         * Returns all descendants of the given cell and the cell itself in an array.
         *
         * Parameters:
         *
         * parent - <mxCell> whose descendants should be returned.
         */
        getDescendants(parent: mxCell): mxCell[];
        /**
         * Function: filterDescendants
         *
         * Visits all cells recursively and applies the specified filter function
         * to each cell. If the function returns true then the cell is added
         * to the resulting array. The parent and result paramters are optional.
         * If parent is not specified then the recursion starts at <root>.
         *
         * Example:
         * The following example extracts all vertices from a given model:
         * (code)
         * var filter = function(cell)
         * {
         * 	return model.isVertex(cell);
         * }
         * var vertices = model.filterDescendants(filter);
         * (end)
         *
         * Parameters:
         *
         * filter - JavaScript function that takes an <mxCell> as an argument
         * and returns a boolean.
         * parent - Optional <mxCell> that is used as the root of the recursion.
         */
        filterDescendants(filter: (cell: mxCell) => boolean, parent?: mxCell): mxCell[];
        /**
         * Function: getRoot
         *
         * Returns the root of the model or the topmost parent of the given cell.
         *
         * Parameters:
         *
         * cell - Optional <mxCell> that specifies the child.
         */
        getRoot(cell?: mxCell): mxCell;
        /**
         * Function: setRoot
         *
         * Sets the <root> of the model using <mxRootChange> and adds the change to
         * the current transaction. This resets all datastructures in the model and
         * is the preferred way of clearing an existing model. Returns the new
         * root.
         *
         * Example:
         *
         * (code)
         * var root = new mxCell();
         * root.insert(new mxCell());
         * model.setRoot(root);
         * (end)
         *
         * Parameters:
         *
         * root - <mxCell> that specifies the new root.
         */
        setRoot(root: mxCell): mxCell;
        /**
         * Function: rootChanged
         *
         * Inner callback to change the root of the model and update the internal
         * datastructures, such as <cells> and <nextId>. Returns the previous root.
         *
         * Parameters:
         *
         * root - <mxCell> that specifies the new root.
         */
        rootChanged(root: mxCell): mxCell;
        /**
         * Function: isRoot
         *
         * Returns true if the given cell is the root of the model and a non-null
         * value.
         *
         * Parameters:
         *
         * cell - <mxCell> that represents the possible root.
         */
        isRoot(cell: mxCell): boolean;
        /**
         * Function: isLayer
         *
         * Returns true if <isRoot> returns true for the parent of the given cell.
         *
         * Parameters:
         *
         * cell - <mxCell> that represents the possible layer.
         */
        isLayer(cell: mxCell): boolean;
        /**
         * Function: isAncestor
         *
         * Returns true if the given parent is an ancestor of the given child. Note
         * returns true if child == parent.
         *
         * Parameters:
         *
         * parent - <mxCell> that specifies the parent.
         * child - <mxCell> that specifies the child.
         */
        isAncestor(parent: mxCell, child: mxCell): boolean;
        /**
         * Function: contains
         *
         * Returns true if the model contains the given <mxCell>.
         *
         * Parameters:
         *
         * cell - <mxCell> that specifies the cell.
         */
        contains(cell: mxCell): boolean;
        /**
         * Function: getParent
         *
         * Returns the parent of the given cell.
         *
         * Parameters:
         *
         * cell - <mxCell> whose parent should be returned.
         */
        getParent(cell: mxCell): mxCell;
        /**
         * Function: add
         *
         * Adds the specified child to the parent at the given index using
         * <mxChildChange> and adds the change to the current transaction. If no
         * index is specified then the child is appended to the parent's array of
         * children. Returns the inserted child.
         *
         * Parameters:
         *
         * parent - <mxCell> that specifies the parent to contain the child.
         * child - <mxCell> that specifies the child to be inserted.
         * index - Optional integer that specifies the index of the child.
         */
        add(parent: mxCell, child: mxCell, index?: number): mxCell;
        /**
         * Function: cellAdded
         *
         * Inner callback to update <cells> when a cell has been added. This
         * implementation resolves collisions by creating new Ids. To change the
         * ID of a cell after it was inserted into the model, use the following
         * code:
         *
         * (code
         * delete model.cells[cell.getId()];
         * cell.setId(newId);
         * model.cells[cell.getId()] = cell;
         * (end)
         *
         * If the change of the ID should be part of the command history, then the
         * cell should be removed from the model and a clone with the new ID should
         * be reinserted into the model instead.
         *
         * Parameters:
         *
         * cell - <mxCell> that specifies the cell that has been added.
         */
        cellAdded(cell: mxCell): void;
        /**
         * Function: createId
         *
         * Hook method to create an Id for the specified cell. This implementation
         * concatenates <prefix>, id and <postfix> to create the Id and increments
         * <nextId>. The cell is ignored by this implementation, but can be used in
         * overridden methods to prefix the Ids with eg. the cell type.
         *
         * Parameters:
         *
         * cell - <mxCell> to create the Id for.
         */
        createId(cell: mxCell): string;
        /**
         * Function: updateEdgeParents
         *
         * Updates the parent for all edges that are connected to cell or one of
         * its descendants using <updateEdgeParent>.
         */
        updateEdgeParents(cell: mxCell, root?: mxCell): void;
        /**
         * Function: updateEdgeParent
         *
         * Inner callback to update the parent of the specified <mxCell> to the
         * nearest-common-ancestor of its two terminals.
         *
         * Parameters:
         *
         * edge - <mxCell> that specifies the edge.
         * root - <mxCell> that represents the current root of the model.
         */
        updateEdgeParent(edge: mxCell, root: mxCell): void;
        /**
         * Function: getOrigin
         *
         * Returns the absolute, accumulated origin for the children inside the
         * given parent as an <mxPoint>.
         */
        getOrigin(cell: mxCell): mxPoint;
        /**
         * Function: getNearestCommonAncestor
         *
         * Returns the nearest common ancestor for the specified cells.
         *
         * Parameters:
         *
         * cell1 - <mxCell> that specifies the first cell in the tree.
         * cell2 - <mxCell> that specifies the second cell in the tree.
         */
        getNearestCommonAncestor(cell1: mxCell, cell2: mxCell): mxCell;
        /**
         * Function: remove
         *
         * Removes the specified cell from the model using <mxChildChange> and adds
         * the change to the current transaction. This operation will remove the
         * cell and all of its children from the model. Returns the removed cell.
         *
         * Parameters:
         *
         * cell - <mxCell> that should be removed.
         */
        remove(cell: mxCell): mxCell;
        /**
         * Function: cellRemoved
         *
         * Inner callback to update <cells> when a cell has been removed.
         *
         * Parameters:
         *
         * cell - <mxCell> that specifies the cell that has been removed.
         */
        cellRemoved(cell: mxCell): void;
        /**
         * Function: parentForCellChanged
         *
         * Inner callback to update the parent of a cell using <mxCell.insert>
         * on the parent and return the previous parent.
         *
         * Parameters:
         *
         * cell - <mxCell> to update the parent for.
         * parent - <mxCell> that specifies the new parent of the cell.
         * index - Optional integer that defines the index of the child
         * in the parent's child array.
         */
        parentForCellChanged(cell: mxCell, parent: mxCell, index?: number): mxCell;
        /**
         * Function: getChildCount
         *
         * Returns the number of children in the given cell.
         *
         * Parameters:
         *
         * cell - <mxCell> whose number of children should be returned.
         */
        getChildCount(cell: mxCell): number;
        /**
         * Function: getChildAt
         *
         * Returns the child of the given <mxCell> at the given index.
         *
         * Parameters:
         *
         * cell - <mxCell> that represents the parent.
         * index - Integer that specifies the index of the child to be returned.
         */
        getChildAt(cell: mxCell, index: number): mxCell;
        /**
         * Function: getChildren
         *
         * Returns all children of the given <mxCell> as an array of <mxCells>. The
         * return value should be only be read.
         *
         * Parameters:
         *
         * cell - <mxCell> the represents the parent.
         */
        getChildren(cell: mxCell): mxCell[];
        /**
         * Function: getChildVertices
         *
         * Returns the child vertices of the given parent.
         *
         * Parameters:
         *
         * cell - <mxCell> whose child vertices should be returned.
         */
        getChildVertices(parent: mxCell): mxCell[];
        /**
         * Function: getChildEdges
         *
         * Returns the child edges of the given parent.
         *
         * Parameters:
         *
         * cell - <mxCell> whose child edges should be returned.
         */
        getChildEdges(parent: mxCell): mxCell[];
        /**
         * Function: getChildCells
         *
         * Returns the children of the given cell that are vertices and/or edges
         * depending on the arguments.
         *
         * Parameters:
         *
         * cell - <mxCell> the represents the parent.
         * vertices - Boolean indicating if child vertices should be returned.
         * Default is false.
         * edges - Boolean indicating if child edges should be returned.
         * Default is false.
         */
        getChildCells(parent: mxCell, vertices?: boolean, edges?: boolean): mxCell[];
        /**
         * Function: getTerminal
         *
         * Returns the source or target <mxCell> of the given edge depending on the
         * value of the boolean parameter.
         *
         * Parameters:
         *
         * edge - <mxCell> that specifies the edge.
         * isSource - Boolean indicating which end of the edge should be returned.
         */
        getTerminal(edge: mxCell, isSource: boolean): mxCell;
        /**
         * Function: setTerminal
         *
         * Sets the source or target terminal of the given <mxCell> using
         * <mxTerminalChange> and adds the change to the current transaction.
         * This implementation updates the parent of the edge using <updateEdgeParent>
         * if required.
         *
         * Parameters:
         *
         * edge - <mxCell> that specifies the edge.
         * terminal - <mxCell> that specifies the new terminal.
         * isSource - Boolean indicating if the terminal is the new source or
         * target terminal of the edge.
         */
        setTerminal(edge: mxCell, terminal: mxCell, isSource: boolean): mxCell;
        /**
         * Function: setTerminals
         *
         * Sets the source and target <mxCell> of the given <mxCell> in a single
         * transaction using <setTerminal> for each end of the edge.
         *
         * Parameters:
         *
         * edge - <mxCell> that specifies the edge.
         * source - <mxCell> that specifies the new source terminal.
         * target - <mxCell> that specifies the new target terminal.
         */
        setTerminals(edge: mxCell, source: mxCell, target: mxCell): void;
        /**
         * Function: terminalForCellChanged
         *
         * Inner helper function to update the terminal of the edge using
         * <mxCell.insertEdge> and return the previous terminal.
         *
         * Parameters:
         *
         * edge - <mxCell> that specifies the edge to be updated.
         * terminal - <mxCell> that specifies the new terminal.
         * isSource - Boolean indicating if the terminal is the new source or
         * target terminal of the edge.
         */
        terminalForCellChanged(edge: mxCell, terminal: mxCell, isSource: boolean): mxCell;
        /**
         * Function: getEdgeCount
         *
         * Returns the number of distinct edges connected to the given cell.
         *
         * Parameters:
         *
         * cell - <mxCell> that represents the vertex.
         */
        getEdgeCount(cell: mxCell): number;
        /**
         * Function: getEdgeAt
         *
         * Returns the edge of cell at the given index.
         *
         * Parameters:
         *
         * cell - <mxCell> that specifies the vertex.
         * index - Integer that specifies the index of the edge
         * to return.
         */
        getEdgeAt(cell: mxCell, index: number): mxCell;
        /**
         * Function: getDirectedEdgeCount
         *
         * Returns the number of incoming or outgoing edges, ignoring the given
         * edge.
         *
         * Parameters:
         *
         * cell - <mxCell> whose edge count should be returned.
         * outgoing - Boolean that specifies if the number of outgoing or
         * incoming edges should be returned.
         * ignoredEdge - <mxCell> that represents an edge to be ignored.
         */
        getDirectedEdgeCount(cell: mxCell, outgoing: boolean, ignoredEdge?: mxCell): number;
        /**
         * Function: getConnections
         *
         * Returns all edges of the given cell without loops.
         *
         * Parameters:
         *
         * cell - <mxCell> whose edges should be returned.
         *
         */
        getConnections(cell: mxCell): mxCell[];
        /**
         * Function: getIncomingEdges
         *
         * Returns the incoming edges of the given cell without loops.
         *
         * Parameters:
         *
         * cell - <mxCell> whose incoming edges should be returned.
         *
         */
        getIncomingEdges(cell: mxCell): mxCell[];
        /**
         * Function: getOutgoingEdges
         *
         * Returns the outgoing edges of the given cell without loops.
         *
         * Parameters:
         *
         * cell - <mxCell> whose outgoing edges should be returned.
         *
         */
        getOutgoingEdges(cell: mxCell): mxCell[];
        /**
         * Function: getEdges
         *
         * Returns all distinct edges connected to this cell as a new array of
         * <mxCells>. If at least one of incoming or outgoing is true, then loops
         * are ignored, otherwise if both are false, then all edges connected to
         * the given cell are returned including loops.
         *
         * Parameters:
         *
         * cell - <mxCell> that specifies the cell.
         * incoming - Optional boolean that specifies if incoming edges should be
         * returned. Default is true.
         * outgoing - Optional boolean that specifies if outgoing edges should be
         * returned. Default is true.
         * includeLoops - Optional boolean that specifies if loops should be returned.
         * Default is true.
         */
        getEdges(cell: mxCell, incoming?: boolean, outgoing?: boolean, includeLoops?: boolean): mxCell[];
        /**
         * Function: getEdgesBetween
         *
         * Returns all edges between the given source and target pair. If directed
         * is true, then only edges from the source to the target are returned,
         * otherwise, all edges between the two cells are returned.
         *
         * Parameters:
         *
         * source - <mxCell> that defines the source terminal of the edge to be
         * returned.
         * target - <mxCell> that defines the target terminal of the edge to be
         * returned.
         * directed - Optional boolean that specifies if the direction of the
         * edge should be taken into account. Default is false.
         */
        getEdgesBetween(source: mxCell, target: mxCell, directed?: boolean): mxCell[];
        /**
         * Function: getOpposites
         *
         * Returns all opposite vertices wrt terminal for the given edges, only
         * returning sources and/or targets as specified. The result is returned
         * as an array of <mxCells>.
         *
         * Parameters:
         *
         * edges - Array of <mxCells> that contain the edges to be examined.
         * terminal - <mxCell> that specifies the known end of the edges.
         * sources - Boolean that specifies if source terminals should be contained
         * in the result. Default is true.
         * targets - Boolean that specifies if target terminals should be contained
         * in the result. Default is true.
         */
        getOpposites(edges: mxCell[], terminal: mxCell, sources?: boolean, targets?: boolean): mxCell[];
        /**
         * Function: getTopmostCells
         *
         * Returns the topmost cells of the hierarchy in an array that contains no
         * descendants for each <mxCell> that it contains. Duplicates should be
         * removed in the cells array to improve performance.
         *
         * Parameters:
         *
         * cells - Array of <mxCells> whose topmost ancestors should be returned.
         */
        getTopmostCells(cells: mxCell[]): mxCell[];
        /**
         * Function: isVertex
         *
         * Returns true if the given cell is a vertex.
         *
         * Parameters:
         *
         * cell - <mxCell> that represents the possible vertex.
         */
        isVertex(cell: mxCell): boolean;
        /**
         * Function: isEdge
         *
         * Returns true if the given cell is an edge.
         *
         * Parameters:
         *
         * cell - <mxCell> that represents the possible edge.
         */
        isEdge(cell: mxCell): boolean;
        /**
         * Function: isConnectable
         *
         * Returns true if the given <mxCell> is connectable. If <edgesConnectable>
         * is false, then this function returns false for all edges else it returns
         * the return value of <mxCell.isConnectable>.
         *
         * Parameters:
         *
         * cell - <mxCell> whose connectable state should be returned.
         */
        isConnectable(cell: mxCell): boolean;
        /**
         * Function: getValue
         *
         * Returns the user object of the given <mxCell> using <mxCell.getValue>.
         *
         * Parameters:
         *
         * cell - <mxCell> whose user object should be returned.
         */
        getValue(cell: mxCell): any;
        /**
         * Function: setValue
         *
         * Sets the user object of then given <mxCell> using <mxValueChange>
         * and adds the change to the current transaction.
         *
         * Parameters:
         *
         * cell - <mxCell> whose user object should be changed.
         * value - Object that defines the new user object.
         */
        setValue(cell: mxCell, value: any): any;
        /**
         * Function: valueForCellChanged
         *
         * Inner callback to update the user object of the given <mxCell>
         * using <mxCell.valueChanged> and return the previous value,
         * that is, the return value of <mxCell.valueChanged>.
         *
         * To change a specific attribute in an XML node, the following code can be
         * used.
         *
         * (code)
         * graph.getModel().valueForCellChanged = function(cell, value)
         * {
         *   var previous = cell.value.getAttribute('label');
         *   cell.value.setAttribute('label', value);
         *
         *   return previous;
         * };
         * (end)
         */
        valueForCellChanged(cell: mxCell, value: any): any;
        /**
         * Function: getGeometry
         *
         * Returns the <mxGeometry> of the given <mxCell>.
         *
         * Parameters:
         *
         * cell - <mxCell> whose geometry should be returned.
         */
        getGeometry(cell: mxCell): mxGeometry;
        /**
         * Function: setGeometry
         *
         * Sets the <mxGeometry> of the given <mxCell>. The actual update
         * of the cell is carried out in <geometryForCellChanged>. The
         * <mxGeometryChange> action is used to encapsulate the change.
         *
         * Parameters:
         *
         * cell - <mxCell> whose geometry should be changed.
         * geometry - <mxGeometry> that defines the new geometry.
         */
        setGeometry(cell: mxCell, geometry: mxGeometry): mxGeometry;
        /**
         * Function: geometryForCellChanged
         *
         * Inner callback to update the <mxGeometry> of the given <mxCell> using
         * <mxCell.setGeometry> and return the previous <mxGeometry>.
         */
        geometryForCellChanged(cell: mxCell, geometry: mxGeometry): mxGeometry;
        /**
         * Function: getStyle
         *
         * Returns the style of the given <mxCell>.
         *
         * Parameters:
         *
         * cell - <mxCell> whose style should be returned.
         */
        getStyle(cell: mxCell): string;
        /**
         * Function: setStyle
         *
         * Sets the style of the given <mxCell> using <mxStyleChange> and
         * adds the change to the current transaction.
         *
         * Parameters:
         *
         * cell - <mxCell> whose style should be changed.
         * style - String of the form [stylename;|key=value;] to specify
         * the new cell style.
         */
        setStyle(cell: mxCell, style: string): string;
        /**
         * Function: styleForCellChanged
         *
         * Inner callback to update the style of the given <mxCell>
         * using <mxCell.setStyle> and return the previous style.
         *
         * Parameters:
         *
         * cell - <mxCell> that specifies the cell to be updated.
         * style - String of the form [stylename;|key=value;] to specify
         * the new cell style.
         */
        styleForCellChanged(cell: mxCell, style: string): string;
        /**
         * Function: isCollapsed
         *
         * Returns true if the given <mxCell> is collapsed.
         *
         * Parameters:
         *
         * cell - <mxCell> whose collapsed state should be returned.
         */
        isCollapsed(cell: mxCell): boolean;
        /**
         * Function: setCollapsed
         *
         * Sets the collapsed state of the given <mxCell> using <mxCollapseChange>
         * and adds the change to the current transaction.
         *
         * Parameters:
         *
         * cell - <mxCell> whose collapsed state should be changed.
         * collapsed - Boolean that specifies the new collpased state.
         */
        setCollapsed(cell: mxCell, collapsed: boolean): boolean;
        /**
         * Function: collapsedStateForCellChanged
         *
         * Inner callback to update the collapsed state of the
         * given <mxCell> using <mxCell.setCollapsed> and return
         * the previous collapsed state.
         *
         * Parameters:
         *
         * cell - <mxCell> that specifies the cell to be updated.
         * collapsed - Boolean that specifies the new collpased state.
         */
        collapsedStateForCellChanged(cell: mxCell, collapsed: boolean): boolean;
        /**
         * Function: isVisible
         *
         * Returns true if the given <mxCell> is visible.
         *
         * Parameters:
         *
         * cell - <mxCell> whose visible state should be returned.
         */
        isVisible(cell: mxCell): boolean;
        /**
         * Function: setVisible
         *
         * Sets the visible state of the given <mxCell> using <mxVisibleChange> and
         * adds the change to the current transaction.
         *
         * Parameters:
         *
         * cell - <mxCell> whose visible state should be changed.
         * visible - Boolean that specifies the new visible state.
         */
        setVisible(cell: mxCell, visible: boolean): boolean;
        /**
         * Function: visibleStateForCellChanged
         *
         * Inner callback to update the visible state of the
         * given <mxCell> using <mxCell.setCollapsed> and return
         * the previous visible state.
         *
         * Parameters:
         *
         * cell - <mxCell> that specifies the cell to be updated.
         * visible - Boolean that specifies the new visible state.
         */
        visibleStateForCellChanged(cell: mxCell, visible: boolean): boolean;
        /**
         * Function: execute
         *
         * Executes the given edit and fires events if required. The edit object
         * requires an execute function which is invoked. The edit is added to the
         * <currentEdit> between <beginUpdate> and <endUpdate> calls, so that
         * events will be fired if this execute is an individual transaction, that
         * is, if no previous <beginUpdate> calls have been made without calling
         * <endUpdate>. This implementation fires an <execute> event before
         * executing the given change.
         *
         * Parameters:
         *
         * change - Object that described the change.
         */
        execute(change: any): void;
        /**
         * Function: beginUpdate
         *
         * Increments the <updateLevel> by one. The event notification
         * is queued until <updateLevel> reaches 0 by use of
         * <endUpdate>.
         *
         * All changes on <mxGraphModel> are transactional,
         * that is, they are executed in a single undoable change
         * on the model (without transaction isolation).
         * Therefore, if you want to combine any
         * number of changes into a single undoable change,
         * you should group any two or more API calls that
         * modify the graph model between <beginUpdate>
         * and <endUpdate> calls as shown here:
         *
         * (code)
         * var model = graph.getModel();
         * var parent = graph.getDefaultParent();
         * var index = model.getChildCount(parent);
         * model.beginUpdate();
         * try
         * {
         *   model.add(parent, v1, index);
         *   model.add(parent, v2, index+1);
         * }
         * finally
         * {
         *   model.endUpdate();
         * }
         * (end)
         *
         * Of course there is a shortcut for appending a
         * sequence of cells into the default parent:
         *
         * (code)
         * graph.addCells([v1, v2]).
         * (end)
         */
        beginUpdate(): void;
        /**
         * Function: endUpdate
         *
         * Decrements the <updateLevel> by one and fires an <undo>
         * event if the <updateLevel> reaches 0. This function
         * indirectly fires a <change> event by invoking the notify
         * function on the <currentEdit> und then creates a new
         * <currentEdit> using <createUndoableEdit>.
         *
         * The <undo> event is fired only once per edit, whereas
         * the <change> event is fired whenever the notify
         * function is invoked, that is, on undo and redo of
         * the edit.
         */
        endUpdate(): void;
        /**
         * Function: createUndoableEdit
         *
         * Creates a new <mxUndoableEdit> that implements the
         * notify function to fire a <change> and <notify> event
         * through the <mxUndoableEdit>'s source.
         *
         * Parameters:
         *
         * significant - Optional boolean that specifies if the edit to be created is
         * significant. Default is true.
         */
        createUndoableEdit(): mxUndoableEdit;
        /**
         * Function: mergeChildren
         *
         * Merges the children of the given cell into the given target cell inside
         * this model. All cells are cloned unless there is a corresponding cell in
         * the model with the same id, in which case the source cell is ignored and
         * all edges are connected to the corresponding cell in this model. Edges
         * are considered to have no identity and are always cloned unless the
         * cloneAllEdges flag is set to false, in which case edges with the same
         * id in the target model are reconnected to reflect the terminals of the
         * source edges.
         */
        mergeChildren(from: any, to: any, cloneAllEdges?: boolean): void;
        /**
         * Function: mergeChildrenImpl
         *
         * Clones the children of the source cell into the given target cell in
         * this model and adds an entry to the mapping that maps from the source
         * cell to the target cell with the same id or the clone of the source cell
         * that was inserted into this model.
         */
        mergeChildrenImpl(from: any, to: any, cloneAllEdges: any, mapping: any): void;
        /**
         * Function: getParents
         *
         * Returns an array that represents the set (no duplicates) of all parents
         * for the given array of cells.
         *
         * Parameters:
         *
         * cells - Array of cells whose parents should be returned.
         */
        getParents(cells: any): any[];
        /**
         * Function: cloneCell
         *
         * Returns a deep clone of the given <mxCell> (including
         * the children) which is created using <cloneCells>.
         *
         * Parameters:
         *
         * cell - <mxCell> to be cloned.
         * includeChildren - Optional boolean indicating if the cells should be cloned
         * with all descendants. Default is true.
         */
        cloneCell(cell: mxCell, includeChildren?: boolean): mxCell;
        /**
         * Function: cloneCells
         *
         * Returns an array of clones for the given array of <mxCells>.
         * Depending on the value of includeChildren, a deep clone is created for
         * each cell. Connections are restored based if the corresponding
         * cell is contained in the passed in array.
         *
         * Parameters:
         *
         * cells - Array of <mxCell> to be cloned.
         * includeChildren - Optional boolean indicating if the cells should be cloned
         * with all descendants. Default is true.
         * mapping - Optional mapping for existing clones.
         */
        cloneCells(cells: mxCell[], includeChildren?: boolean, mapping?: any): mxCell[];
        /**
         * Function: cloneCellImpl
         *
         * Inner helper method for cloning cells recursively.
         */
        cloneCellImpl(cell: any, mapping: any, includeChildren: any): mxCell[];
        /**
         * Function: cellCloned
         *
         * Hook for cloning the cell. This returns cell.clone() or
         * any possible exceptions.
         */
        cellCloned(cell: mxCell): mxCell;
        /**
         * Function: restoreClone
         *
         * Inner helper method for restoring the connections in
         * a network of cloned cells.
         */
        restoreClone(clone: any, cell: any, mapping: any): void;
    }
    /**
     * Class: mxRootChange
     *
     * Action to change the root in a model.
     *
     * Constructor: mxRootChange
     *
     * Constructs a change of the root in the
     * specified model.
     */
    class mxRootChange {
        model: mxGraphModel;
        root: any;
        previous: any;
        constructor(model: any, root: any);
        /**
         * Function: execute
         *
         * Carries out a change of the root using
         * <mxGraphModel.rootChanged>.
         */
        execute(): void;
    }
    /**
     * Class: mxChildChange
     *
     * Action to add or remove a child in a model.
     *
     * Constructor: mxChildChange
     *
     * Constructs a change of a child in the
     * specified model.
     */
    class mxChildChange {
        mode: mxGraphModel;
        parent: any;
        previous: any;
        child: any;
        index: any;
        previousIndex: any;
        constructor(model: any, parent: any, child: any, index?: number);
        /**
         * Function: execute
         *
         * Changes the parent of <child> using
         * <mxGraphModel.parentForCellChanged> and
         * removes or restores the cell's
         * connections.
         */
        execute(): void;
        /**
         * Function: disconnect
         *
         * Disconnects the given cell recursively from its
         * terminals and stores the previous terminal in the
         * cell's terminals.
         */
        connect(cell: any, isConnect: any): void;
    }
    /**
     * Class: mxTerminalChange
     *
     * Action to change a terminal in a model.
     *
     * Constructor: mxTerminalChange
     *
     * Constructs a change of a terminal in the
     * specified model.
     */
    class mxTerminalChange {
        model: mxGraphModel;
        cell: any;
        terminal: any;
        previous: any;
        source: any;
        constructor(model: any, cell: any, terminal: any, source: any);
        /**
         * Function: execute
         *
         * Changes the terminal of <cell> to <previous> using
         * <mxGraphModel.terminalForCellChanged>.
         */
        execute(): void;
    }
    /**
     * Class: mxValueChange
     *
     * Action to change a user object in a model.
     *
     * Constructor: mxValueChange
     *
     * Constructs a change of a user object in the
     * specified model.
     */
    class mxValueChange {
        model: mxGraphModel;
        cell: any;
        value: any;
        previous: any;
        constructor(model: mxGraphModel, cell: any, value: any);
        /**
         * Function: execute
         *
         * Changes the value of <cell> to <previous> using
         * <mxGraphModel.valueForCellChanged>.
         */
        execute(): void;
    }
    /**
     * Class: mxStyleChange
     *
     * Action to change a cell's style in a model.
     *
     * Constructor: mxStyleChange
     *
     * Constructs a change of a style in the
     * specified model.
     */
    class mxStyleChange {
        model: mxGraphModel;
        cell: any;
        style: any;
        previous: any;
        constructor(model: mxGraphModel, cell: any, style: any);
        /**
         * Function: execute
         *
         * Changes the style of <cell> to <previous> using
         * <mxGraphModel.styleForCellChanged>.
         */
        execute(): void;
    }
    /**
     * Class: mxGeometryChange
     *
     * Action to change a cell's geometry in a model.
     *
     * Constructor: mxGeometryChange
     *
     * Constructs a change of a geometry in the
     * specified model.
     */
    class mxGeometryChange {
        model: mxGraphModel;
        cell: any;
        geometry: mxGeometry;
        previous: mxGeometry;
        constructor(model: mxGraphModel, mxCell: any, geometry: mxGeometry);
        /**
         * Function: execute
         *
         * Changes the geometry of <cell> ro <previous> using
         * <mxGraphModel.geometryForCellChanged>.
         */
        execute(): void;
    }
    /**
     * Class: mxCollapseChange
     *
     * Action to change a cell's collapsed state in a model.
     *
     * Constructor: mxCollapseChange
     *
     * Constructs a change of a collapsed state in the
     * specified model.
     */
    class mxCollapseChange {
        model: mxGraphModel;
        cell: any;
        collapsed: boolean;
        previous: boolean;
        constructor(model: mxGraphModel, cell: any, collapsed: boolean);
        /**
         * Function: execute
         *
         * Changes the collapsed state of <cell> to <previous> using
         * <mxGraphModel.collapsedStateForCellChanged>.
         */
        execute(): void;
    }
    /**
     * Class: mxVisibleChange
     *
     * Action to change a cell's visible state in a model.
     *
     * Constructor: mxVisibleChange
     *
     * Constructs a change of a visible state in the
     * specified model.
     */
    class mxVisibleChange {
        model: mxGraphModel;
        cell: any;
        visible: boolean;
        previous: boolean;
        constructor(model: mxGraphModel, cell: any, visible: boolean);
        /**
         * Function: execute
         *
         * Changes the visible state of <cell> to <previous> using
         * <mxGraphModel.visibleStateForCellChanged>.
         */
        execute(): void;
    }
    /**
     * Class: mxCellAttributeChange
     *
     * Action to change the attribute of a cell's user object.
     * There is no method on the graph model that uses this
     * action. To use the action, you can use the code shown
     * in the example below.
     *
     * Example:
     *
     * To change the attributeName in the cell's user object
     * to attributeValue, use the following code:
     *
     * (code)
     * model.beginUpdate();
     * try
     * {
     *   var edit = new mxCellAttributeChange(
     *     cell, attributeName, attributeValue);
     *   model.execute(edit);
     * }
     * finally
     * {
     *   model.endUpdate();
     * }
     * (end)
     *
     * Constructor: mxCellAttributeChange
     *
     * Constructs a change of a attribute of the DOM node
     * stored as the value of the given <mxCell>.
     */
    class mxCellAttributeChange {
        cell: any;
        attribute: any;
        value: any;
        previous: any;
        constructor(cell: any, attribute: any, value: any);
        /**
         * Function: execute
         *
         * Changes the attribute of the cell's user object by
         * using <mxCell.setAttribute>.
         */
        execute(): void;
    }
    interface Value extends Object {
        nodeName: string;
    }
    /**
     * Class: mxCell
     *
     * Cells are the elements of the graph model. They represent the state
     * of the groups, vertices and edges in a graph.
     *
     * Custom attributes:
     *
     * For custom attributes we recommend using an XML node as the value of a cell.
     * The following code can be used to create a cell with an XML node as the
     * value:
     *
     * (code)
     * var doc = mxUtils.createXmlDocument();
     * var node = doc.createElement('MyNode')
     * node.setAttribute('label', 'MyLabel');
     * node.setAttribute('attribute1', 'value1');
     * graph.insertVertex(graph.getDefaultParent(), null, node, 40, 40, 80, 30);
     * (end)
     *
     * For the label to work, <mxGraph.convertValueToString> and
     * <mxGraph.cellLabelChanged> should be overridden as follows:
     *
     * (code)
     * graph.convertValueToString = function(cell)
     * {
     *   if (mxUtils.isNode(cell.value))
     *   {
     *     return cell.getAttribute('label', '')
     *   }
     * };
     *
     * var cellLabelChanged = graph.cellLabelChanged;
     * graph.cellLabelChanged = function(cell, newValue, autoSize)
     * {
     *   if (mxUtils.isNode(cell.value))
     *   {
     *     // Clones the value for correct undo/redo
     *     var elt = cell.value.cloneNode(true);
     *     elt.setAttribute('label', newValue);
     *     newValue = elt;
     *   }
     *
     *   cellLabelChanged.apply(this, arguments);
     * };
     * (end)
     *
     * Callback: onInit
     *
     * Called from within the constructor.
     *
     * Constructor: mxCell
     *
     * Constructs a new cell to be used in a graph model.
     * This method invokes <onInit> upon completion.
     *
     * Parameters:
     *
     * value - Optional object that represents the cell value.
     * geometry - Optional <mxGeometry> that specifies the geometry.
     * style - Optional formatted string that defines the style.
     */
    class mxCell {
        constructor(value?: any, geometry?: mxGeometry, style?: string);
        /**
         * Variable: id
         *
         * Holds the Id. Default is null.
         */
        id: string;
        /**
         * Variable: value
         *
         * Holds the user object. Default is null.
         */
        value: any;
        /**
         * Variable: geometry
         *
         * Holds the <mxGeometry>. Default is null.
         */
        geometry: mxGeometry;
        /**
         * Variable: style
         *
         * Holds the style as a string of the form [(stylename|key=value);]. Default is
         * null.
         */
        style: string;
        /**
         * Variable: vertex
         *
         * Specifies whether the cell is a vertex. Default is false.
         */
        vertex: boolean;
        /**
         * Variable: edge
         *
         * Specifies whether the cell is an edge. Default is false.
         */
        edge: boolean;
        /**
         * Variable: connectable
         *
         * Specifies whether the cell is connectable. Default is true.
         */
        connectable: boolean;
        /**
         * Variable: visible
         *
         * Specifies whether the cell is visible. Default is true.
         */
        visible: boolean;
        /**
         * Variable: collapsed
         *
         * Specifies whether the cell is collapsed. Default is false.
         */
        collapsed: boolean;
        /**
         * Variable: parent
         *
         * Reference to the parent cell.
         */
        parent: mxCell;
        /**
         * Variable: source
         *
         * Reference to the source terminal.
         */
        source: mxCell;
        /**
         * Variable: target
         *
         * Reference to the target terminal.
         */
        target: mxCell;
        /**
         * Variable: children
         *
         * Holds the child cells.
         */
        children: mxCell[];
        /**
         * Variable: edges
         *
         * Holds the edges.
         */
        edges: mxCell[];
        /**
         * Variable: mxTransient
         *
         * List of members that should not be cloned inside <clone>. This field is
         * passed to <mxUtils.clone> and is not made persistent in <mxCellCodec>.
         * This is not a convention for all classes, it is only used in this class
         * to mark transient fields since transient modifiers are not supported by
         * the language.
         */
        mxTransient: string[];
        /**
         * Implicit variable declarations
         */
        overlays: mxCellOverlay[];
        /**
         * Function: getId
         *
         * Returns the Id of the cell as a string.
         */
        getId(): string;
        /**
         * Function: setId
         *
         * Sets the Id of the cell to the given string.
         */
        setId(id: string): void;
        /**
         * Function: getValue
         *
         * Returns the user object of the cell. The user
         * object is stored in <value>.
         */
        getValue(): Value;
        /**
         * Function: setValue
         *
         * Sets the user object of the cell. The user object
         * is stored in <value>.
         */
        setValue(value: any): void;
        /**
         * Function: valueChanged
         *
         * Changes the user object after an in-place edit
         * and returns the previous value. This implementation
         * replaces the user object with the given value and
         * returns the old user object.
         */
        valueChanged(newValue: any): any;
        /**
         * Function: getGeometry
         *
         * Returns the <mxGeometry> that describes the <geometry>.
         */
        getGeometry(): mxGeometry;
        /**
         * Function: setGeometry
         *
         * Sets the <mxGeometry> to be used as the <geometry>.
         */
        setGeometry(geometry: mxGeometry): void;
        /**
         * Function: getStyle
         *
         * Returns a string that describes the <style>.
         */
        getStyle(): string;
        /**
         * Function: setStyle
         *
         * Sets the string to be used as the <style>.
         */
        setStyle(style: string): void;
        /**
         * Function: isVertex
         *
         * Returns true if the cell is a vertex.
         */
        isVertex(): boolean;
        /**
         * Function: setVertex
         *
         * Specifies if the cell is a vertex. This should only be assigned at
         * construction of the cell and not be changed during its lifecycle.
         *
         * Parameters:
         *
         * vertex - Boolean that specifies if the cell is a vertex.
         */
        setVertex(vertex: boolean): void;
        /**
         * Function: isEdge
         *
         * Returns true if the cell is an edge.
         */
        isEdge(): boolean;
        /**
         * Function: setEdge
         *
         * Specifies if the cell is an edge. This should only be assigned at
         * construction of the cell and not be changed during its lifecycle.
         *
         * Parameters:
         *
         * edge - Boolean that specifies if the cell is an edge.
         */
        setEdge(edge: boolean): void;
        /**
         * Function: isConnectable
         *
         * Returns true if the cell is connectable.
         */
        isConnectable(): boolean;
        /**
         * Function: setConnectable
         *
         * Sets the connectable state.
         *
         * Parameters:
         *
         * connectable - Boolean that specifies the new connectable state.
         */
        setConnectable(connectable: boolean): void;
        /**
         * Function: isVisible
         *
         * Returns true if the cell is visibile.
         */
        isVisible(): boolean;
        /**
         * Function: setVisible
         *
         * Specifies if the cell is visible.
         *
         * Parameters:
         *
         * visible - Boolean that specifies the new visible state.
         */
        setVisible(visible: boolean): void;
        /**
         * Function: isCollapsed
         *
         * Returns true if the cell is collapsed.
         */
        isCollapsed(): boolean;
        /**
         * Function: setCollapsed
         *
         * Sets the collapsed state.
         *
         * Parameters:
         *
         * collapsed - Boolean that specifies the new collapsed state.
         */
        setCollapsed(collapsed: boolean): void;
        /**
         * Function: getParent
         *
         * Returns the cell's parent.
         */
        getParent(): mxCell;
        /**
         * Function: setParent
         *
         * Sets the parent cell.
         *
         * Parameters:
         *
         * parent - <mxCell> that represents the new parent.
         */
        setParent(parent: mxCell): void;
        /**
         * Function: getTerminal
         *
         * Returns the source or target terminal.
         *
         * Parameters:
         *
         * source - Boolean that specifies if the source terminal should be
         * returned.
         */
        getTerminal(source: boolean): mxCell;
        /**
         * Function: setTerminal
         *
         * Sets the source or target terminal and returns the new terminal.
         *
         * Parameters:
         *
         * terminal - <mxCell> that represents the new source or target terminal.
         * isSource - Boolean that specifies if the source or target terminal
         * should be set.
         */
        setTerminal(terminal: mxCell, isSource: boolean): mxCell;
        /**
         * Function: getChildCount
         *
         * Returns the number of child cells.
         */
        getChildCount(): number;
        /**
         * Function: getIndex
         *
         * Returns the index of the specified child in the child array.
         *
         * Parameters:
         *
         * child - Child whose index should be returned.
         */
        getIndex(child: mxCell): any;
        /**
         * Function: getChildAt
         *
         * Returns the child at the specified index.
         *
         * Parameters:
         *
         * index - Integer that specifies the child to be returned.
         */
        getChildAt(index: number): mxCell;
        /**
         * Function: insert
         *
         * Inserts the specified child into the child array at the specified index
         * and updates the parent reference of the child. If not childIndex is
         * specified then the child is appended to the child array. Returns the
         * inserted child.
         *
         * Parameters:
         *
         * child - <mxCell> to be inserted or appended to the child array.
         * index - Optional integer that specifies the index at which the child
         * should be inserted into the child array.
         */
        insert(child: mxCell, index?: number): mxCell;
        /**
         * Function: remove
         *
         * Removes the child at the specified index from the child array and
         * returns the child that was removed. Will remove the parent reference of
         * the child.
         *
         * Parameters:
         *
         * index - Integer that specifies the index of the child to be
         * removed.
         */
        remove(index: number): any;
        /**
         * Function: removeFromParent
         *
         * Removes the cell from its parent.
         */
        removeFromParent(): void;
        /**
         * Function: getEdgeCount
         *
         * Returns the number of edges in the edge array.
         */
        getEdgeCount(): number;
        /**
         * Function: getEdgeIndex
         *
         * Returns the index of the specified edge in <edges>.
         *
         * Parameters:
         *
         * edge - <mxCell> whose index in <edges> should be returned.
         */
        getEdgeIndex(edge: mxCell): any;
        /**
         * Function: getEdgeAt
         *
         * Returns the edge at the specified index in <edges>.
         *
         * Parameters:
         *
         * index - Integer that specifies the index of the edge to be returned.
         */
        getEdgeAt(index: number): mxCell;
        /**
         * Function: insertEdge
         *
         * Inserts the specified edge into the edge array and returns the edge.
         * Will update the respective terminal reference of the edge.
         *
         * Parameters:
         *
         * edge - <mxCell> to be inserted into the edge array.
         * isOutgoing - Boolean that specifies if the edge is outgoing.
         */
        insertEdge(edge: mxCell, isOutgoing: boolean): mxCell;
        /**
         * Function: removeEdge
         *
         * Removes the specified edge from the edge array and returns the edge.
         * Will remove the respective terminal reference from the edge.
         *
         * Parameters:
         *
         * edge - <mxCell> to be removed from the edge array.
         * isOutgoing - Boolean that specifies if the edge is outgoing.
         */
        removeEdge(edge: mxCell, isOutgoing: boolean): mxCell;
        /**
         * Function: removeFromTerminal
         *
         * Removes the edge from its source or target terminal.
         *
         * Parameters:
         *
         * isSource - Boolean that specifies if the edge should be removed from its
         * source or target terminal.
         */
        removeFromTerminal(isSource: boolean): void;
        /**
         * Function: hasAttribute
         *
         * Returns true if the user object is an XML node that contains the given
         * attribute.
         *
         * Parameters:
         *
         * name - Name of the attribute.
         */
        hasAttribute(name: string): any;
        /**
         * Function: getAttribute
         *
         * Returns the specified attribute from the user object if it is an XML
         * node.
         *
         * Parameters:
         *
         * name - Name of the attribute whose value should be returned.
         * defaultValue - Optional default value to use if the attribute has no
         * value.
         */
        getAttribute(name: string, defaultValue?: string): any;
        /**
         * Function: setAttribute
         *
         * Sets the specified attribute on the user object if it is an XML node.
         *
         * Parameters:
         *
         * name - Name of the attribute whose value should be set.
         * value - New value of the attribute.
         */
        setAttribute(name: string, value: string): void;
        /**
         * Function: clone
         *
         * Returns a clone of the cell. Uses <cloneValue> to clone
         * the user object. All fields in <mxTransient> are ignored
         * during the cloning.
         */
        clone(): any;
        /**
         * Function: cloneValue
         *
         * Returns a clone of the cell's user object.
         */
        cloneValue(): any;
    }
    /**
     * Class: mxGeometry
     *
     * Extends <mxRectangle> to represent the geometry of a cell.
     *
     * For vertices, the geometry consists of the x- and y-location, and the width
     * and height. For edges, the geometry consists of the optional terminal- and
     * control points. The terminal points are only required if an edge is
     * unconnected, and are stored in the <sourcePoint> and <targetPoint>
     * variables, respectively.
     *
     * Example:
     *
     * If an edge is unconnected, that is, it has no source or target terminal,
     * then a geometry with terminal points for a new edge can be defined as
     * follows.
     *
     * (code)
     * geometry.setTerminalPoint(new mxPoint(x1, y1), true);
     * geometry.points = [new mxPoint(x2, y2)];
     * geometry.setTerminalPoint(new mxPoint(x3, y3), false);
     * (end)
     *
     * Control points are used regardless of the connected state of an edge and may
     * be ignored or interpreted differently depending on the edge's <mxEdgeStyle>.
     *
     * To disable automatic reset of control points after a cell has been moved or
     * resized, the the <mxGraph.resizeEdgesOnMove> and
     * <mxGraph.resetEdgesOnResize> may be used.
     *
     * Edge Labels:
     *
     * Using the x- and y-coordinates of a cell's geometry, it is possible to
     * position the label on edges on a specific location on the actual edge shape
     * as it appears on the screen. The x-coordinate of an edge's geometry is used
     * to describe the distance from the center of the edge from -1 to 1 with 0
     * being the center of the edge and the default value. The y-coordinate of an
     * edge's geometry is used to describe the absolute, orthogonal distance in
     * pixels from that point. In addition, the <mxGeometry.offset> is used as an
     * absolute offset vector from the resulting point.
     *
     * This coordinate system is applied if <relative> is true, otherwise the
     * offset defines the absolute vector from the edge's center point to the
     * label and the values for <x> and <y> are ignored.
     *
     * The width and height parameter for edge geometries can be used to set the
     * label width and height (eg. for word wrapping).
     *
     * Ports:
     *
     * The term "port" refers to a relatively positioned, connectable child cell,
     * which is used to specify the connection between the parent and another cell
     * in the graph. Ports are typically modeled as vertices with relative
     * geometries.
     *
     * Offsets:
     *
     * The <offset> field is interpreted in 3 different ways, depending on the cell
     * and the geometry. For edges, the offset defines the absolute offset for the
     * edge label. For relative geometries, the offset defines the absolute offset
     * for the origin (top, left corner) of the vertex, otherwise the offset
     * defines the absolute offset for the label inside the vertex or group.
     *
     * Constructor: mxGeometry
     *
     * Constructs a new object to describe the size and location of a vertex or
     * the control points of an edge.
     */
    class mxGeometry extends mxRectangle {
        constructor(x?: number, y?: number, width?: number, height?: number);
        /**
         * Variable: TRANSLATE_CONTROL_POINTS
         *
         * Global switch to translate the points in translate. Default is true.
         */
        TRANSLATE_CONTROL_POINTS: boolean;
        /**
         * Variable: alternateBounds
         *
         * Stores alternate values for x, y, width and height in a rectangle. See
         * <swap> to exchange the values. Default is null.
         */
        alternateBounds: any;
        /**
         * Variable: sourcePoint
         *
         * Defines the source <mxPoint> of the edge. This is used if the
         * corresponding edge does not have a source vertex. Otherwise it is
         * ignored. Default is  null.
         */
        sourcePoint: any;
        /**
         * Variable: targetPoint
         *
         * Defines the target <mxPoint> of the edge. This is used if the
         * corresponding edge does not have a target vertex. Otherwise it is
         * ignored. Default is null.
         */
        targetPoint: any;
        /**
         * Variable: points
         *
         * Array of <mxPoints> which specifies the control points along the edge.
         * These points are the intermediate points on the edge, for the endpoints
         * use <targetPoint> and <sourcePoint> or set the terminals of the edge to
         * a non-null value. Default is null.
         */
        points: mxPoint[];
        /**
         * Variable: offset
         *
         * For edges, this holds the offset (in pixels) from the position defined
         * by <x> and <y> on the edge. For relative geometries (for vertices), this
         * defines the absolute offset from the point defined by the relative
         * coordinates. For absolute geometries (for vertices), this defines the
         * offset for the label. Default is null.
         */
        offset: any;
        /**
         * Variable: relative
         *
         * Specifies if the coordinates in the geometry are to be interpreted as
         * relative coordinates. For edges, this is used to define the location of
         * the edge label relative to the edge as rendered on the display. For
         * vertices, this specifies the relative location inside the bounds of the
         * parent cell.
         *
         * If this is false, then the coordinates are relative to the origin of the
         * parent cell or, for edges, the edge label position is relative to the
         * center of the edge as rendered on screen.
         *
         * Default is false.
         */
        relative: boolean;
        /**
         * Function: swap
         *
         * Swaps the x, y, width and height with the values stored in
         * <alternateBounds> and puts the previous values into <alternateBounds> as
         * a rectangle. This operation is carried-out in-place, that is, using the
         * existing geometry instance. If this operation is called during a graph
         * model transactional change, then the geometry should be cloned before
         * calling this method and setting the geometry of the cell using
         * <mxGraphModel.setGeometry>.
         */
        swap(): void;
        /**
         * Function: getTerminalPoint
         *
         * Returns the <mxPoint> representing the source or target point of this
         * edge. This is only used if the edge has no source or target vertex.
         *
         * Parameters:
         *
         * isSource - Boolean that specifies if the source or target point
         * should be returned.
         */
        getTerminalPoint(isSource: boolean): mxPoint;
        /**
         * Function: setTerminalPoint
         *
         * Sets the <sourcePoint> or <targetPoint> to the given <mxPoint> and
         * returns the new point.
         *
         * Parameters:
         *
         * point - Point to be used as the new source or target point.
         * isSource - Boolean that specifies if the source or target point
         * should be set.
         */
        setTerminalPoint(point: mxPoint, isSource: boolean): any;
        /**
         * Function: rotate
         *
         * Rotates the geometry by the given angle around the given center. That is,
         * <x> and <y> of the geometry, the <sourcePoint>, <targetPoint> and all
         * <points> are translated by the given amount. <x> and <y> are only
         * translated if <relative> is false.
         *
         * Parameters:
         *
         * angle - Number that specifies the rotation angle in degrees.
         * cx - <mxPoint> that specifies the center of the rotation.
         */
        rotate(angle: number, cx: mxPoint): void;
        /**
         * Function: translate
         *
         * Translates the geometry by the specified amount. That is, <x> and <y> of the
         * geometry, the <sourcePoint>, <targetPoint> and all <points> are translated
         * by the given amount. <x> and <y> are only translated if <relative> is false.
         * If <TRANSLATE_CONTROL_POINTS> is false, then <points> are not modified by
         * this function.
         *
         * Parameters:
         *
         * dx - Number that specifies the x-coordinate of the translation.
         * dy - Number that specifies the y-coordinate of the translation.
         */
        translate(dx: number, dy: number): void;
        /**
         * Function: scale
         *
         * Scales the geometry by the given amount. That is, <x> and <y> of the
         * geometry, the <sourcePoint>, <targetPoint> and all <points> are scaled
         * by the given amount. <x>, <y>, <width> and <height> are only scaled if
         * <relative> is false. If <fixedAspect> is true, then the smaller value
         * is used to scale the width and the height.
         *
         * Parameters:
         *
         * sx - Number that specifies the horizontal scale factor.
         * sy - Number that specifies the vertical scale factor.
         * fixedAspect - Optional boolean to keep the aspect ratio fixed.
         */
        scale(sx: number, sy: number, fixedAspect?: boolean): void;
        /**
         * Function: equals
         *
         * Returns true if the given object equals this geometry.
         */
        equals(obj: any): boolean;
    }
    /**
     * Class: mxCellPath
     *
     * Implements a mechanism for temporary cell Ids.
     */
    var mxCellPath: {
        /**
         * Class: mxCellPath
         *
         * Implements a mechanism for temporary cell Ids.
         *
         * Variable: PATH_SEPARATOR
         *
         * Defines the separator between the path components. Default is ".".
         */
        PATH_SEPARATOR: string;
        /**
         * Function: create
         *
         * Creates the cell path for the given cell. The cell path is a
         * concatenation of the indices of all ancestors on the (finite) path to
         * the root, eg. "0.0.0.1".
         *
         * Parameters:
         *
         * cell - Cell whose path should be returned.
         */
        create(cell: any): string;
        /**
         * Function: getParentPath
         *
         * Returns the path for the parent of the cell represented by the given
         * path. Returns null if the given path has no parent.
         *
         * Parameters:
         *
         * path - Path whose parent path should be returned.
         */
        getParentPath(path: any): any;
        /**
         * Function: resolve
         *
         * Returns the cell for the specified cell path using the given root as the
         * root of the path.
         *
         * Parameters:
         *
         * root - Root cell of the path to be resolved.
         * path - String that defines the path.
         */
        resolve(root: any, path: any): any;
        /**
         * Function: compare
         *
         * Compares the given cell paths and returns -1 if p1 is smaller, 0 if
         * p1 is equal and 1 if p1 is greater than p2.
         */
        compare(p1: any, p2: any): number;
    };
    var mxPerimeter: {
        RectanglePerimeter(bounds: mxRectangle, vertex: mxCellState, next: mxPoint, orthogonal: boolean): mxPoint;
        EllipsePerimeter(bounds: mxRectangle, vertex: mxCellState, next: mxPoint, orthogonal: boolean): mxPoint;
        RhombusPerimeter(bounds: mxRectangle, vertex: mxCellState, next: mxPoint, orthogonal: boolean): mxPoint;
        TrianglePerimeter(bounds: mxRectangle, vertex: mxCellState, next: mxPoint, orthogonal: boolean): mxPoint;
        HexagonPerimeter(bounds: mxRectangle, vertex: mxCellState, next: mxPoint, orthogonal: boolean): mxPoint;
    };
    /**
     * Implements printing of a diagram across multiple pages. The following opens
     * a print preview for an existing graph:
     *
     * (code)
     * var preview = new mxPrintPreview(graph);
     * preview.open();
     * (end)
     *
     * Use <mxUtils.getScaleForPageCount> as follows in order to print the graph
     * across a given number of pages:
     *
     * (code)
     * var pageCount = mxUtils.prompt('Enter page count', '1');
     *
     * if (pageCount != null)
     * {
     *   var scale = mxUtils.getScaleForPageCount(pageCount, graph);
     *   var preview = new mxPrintPreview(graph, scale);
     *   preview.open();
     * }
     * (end)
     *
     * Additional pages:
     *
     * To add additional pages before and after the output, <getCoverPages> and
     * <getAppendices> can be used, respectively.
     *
     * (code)
     * var preview = new mxPrintPreview(graph, 1);
     *
     * preview.getCoverPages = function(w, h)
     * {
     *   return [this.renderPage(w, h, 0, 0, mxUtils.bind(this, function(div)
     *   {
     *     div.innerHTML = '<div style="position:relative;margin:4px;">Cover Page</p>'
     *   }))];
     * };
     *
     * preview.getAppendices = function(w, h)
     * {
     *   return [this.renderPage(w, h, 0, 0, mxUtils.bind(this, function(div)
     *   {
     *     div.innerHTML = '<div style="position:relative;margin:4px;">Appendix</p>'
     *   }))];
     * };
     *
     * preview.open();
     * (end)
     *
     * CSS:
     *
     * The CSS from the original page is not carried over to the print preview.
     * To add CSS to the page, use the css argument in the <open> function or
     * override <writeHead> to add the respective link tags as follows:
     *
     * (code)
     * var writeHead = preview.writeHead;
     * preview.writeHead = function(doc, css)
     * {
     *   writeHead.apply(this, arguments);
     *   doc.writeln('<link rel="stylesheet" type="text/css" href="style.css">');
     * };
     * (end)
     *
     * Padding:
     *
     * To add a padding to the page in the preview (but not the print output), use
     * the following code:
     *
     * (code)
     * preview.writeHead = function(doc)
     * {
     *   writeHead.apply(this, arguments);
     *
     *   doc.writeln('<style type="text/css">');
     *   doc.writeln('@media screen {');
     *   doc.writeln('  body > div { padding-top:30px;padding-left:40px;box-sizing:content-box; }');
     *   doc.writeln('}');
     *   doc.writeln('</style>');
     * };
     * (end)
     *
     * Headers:
     *
     * Apart from setting the title argument in the mxPrintPreview constructor you
     * can override <renderPage> as follows to add a header to any page:
     *
     * (code)
     * var oldRenderPage = mxPrintPreview.prototype.renderPage;
     * mxPrintPreview.prototype.renderPage = function(w, h, x, y, content, pageNumber)
     * {
     *   var div = oldRenderPage.apply(this, arguments);
     *
     *   var header = document.createElement('div');
     *   header.style.position = 'absolute';
     *   header.style.top = '0px';
     *   header.style.width = '100%';
     *   header.style.textAlign = 'right';
     *   mxUtils.write(header, 'Your header here');
     *   div.firstChild.appendChild(header);
     *
     *   return div;
     * };
     * (end)
     *
     * The pageNumber argument contains the number of the current page, starting at
     * 1. To display a header on the first page only, check pageNumber and add a
     * vertical offset in the constructor call for the height of the header.
     *
     * Page Format:
     *
     * For landscape printing, use <mxConstants.PAGE_FORMAT_A4_LANDSCAPE> as
     * the pageFormat in <mxUtils.getScaleForPageCount> and <mxPrintPreview>.
     * Keep in mind that one can not set the defaults for the print dialog
     * of the operating system from JavaScript so the user must manually choose
     * a page format that matches this setting.
     *
     * You can try passing the following CSS directive to <open> to set the
     * page format in the print dialog to landscape. However, this CSS
     * directive seems to be ignored in most major browsers, including IE.
     *
     * (code)
     * @page {
     *   size: landscape;
     * }
     * (end)
     *
     * Note that the print preview behaves differently in IE when used from the
     * filesystem or via HTTP so printing should always be tested via HTTP.
     *
     * If you are using a DOCTYPE in the source page you can override <getDoctype>
     * and provide the same DOCTYPE for the print preview if required. Here is
     * an example for IE8 standards mode.
     *
     * (code)
     * var preview = new mxPrintPreview(graph);
     * preview.getDoctype = function()
     * {
     *   return '<!--[if IE]><meta http-equiv="X-UA-Compatible" content="IE=5,IE=8" ><![endif]-->';
     * };
     * preview.open();
     * (end)
     *
     * Constructor: mxPrintPreview
     *
     * Constructs a new print preview for the given parameters.
     *
     * Parameters:
     *
     * graph - <mxGraph> to be previewed.
     * scale - Optional scale of the output. Default is 1 / <mxGraph.pageScale>.
     * border - Border in pixels along each side of every page. Note that the
     * actual print function in the browser will add another border for
     * printing.
     * pageFormat - <mxRectangle> that specifies the page format (in pixels).
     * This should match the page format of the printer. Default uses the
     * <mxGraph.pageFormat> of the given graph.
     * x0 - Optional left offset of the output. Default is 0.
     * y0 - Optional top offset of the output. Default is 0.
     * borderColor - Optional color of the page border. Default is no border.
     * Note that a border is sometimes useful to highlight the printed page
     * border in the print preview of the browser.
     * title - Optional string that is used for the window title. Default
     * is 'Printer-friendly version'.
     * pageSelector - Optional boolean that specifies if the page selector
     * should appear in the window with the print preview. Default is true.
     */
    class mxPrintPreview {
        printOverlays: boolean;
        printControls: boolean;
        printBackgroundImage: boolean;
        constructor(graph: any, scale?: any, pageFormat?: any, border?: any, x0?: any, y0?: any, borderColor?: any, title?: any, pageSelector?: any);
        /**
         * Returns <wnd>.
         */
        getWindow(): any;
        /**
         * Returns the string that should go before the HTML tag in the print preview
         * page. This implementation returns an X-UA meta tag for IE5 in quirks mode,
         * IE8 in IE8 standards mode and edge in IE9 standards mode.
         */
        getDoctype(): string;
        /**
         * Adds the given graph to the existing print preview.
         *
         * Parameters:
         *
         * css - Optional CSS string to be used in the head section.
         * targetWindow - Optional window that should be used for rendering. If
         * this is specified then no HEAD tag, CSS and BODY tag will be written.
         */
        appendGraph(graph: any, scale: any, x0: any, y0: any, forcePageBreaks: any, keepOpen: any): void;
        /**
         * Shows the print preview window. The window is created here if it does
         * not exist.
         *
         * Parameters:
         *
         * css - Optional CSS string to be used in the head section.
         * targetWindow - Optional window that should be used for rendering. If
         * this is specified then no HEAD tag, CSS and BODY tag will be written.
         */
        open(css?: any, targetWindow?: any, forcePageBreaks?: any, keepOpen?: any): any;
        /**
         * Adds a page break to the given document.
         */
        addPageBreak(doc: any): void;
        /**
         * Writes the closing tags for body and page after calling <writePostfix>.
         */
        closeDocument(): void;
        /**
         * Writes the HEAD section into the given document, without the opening
         * and closing HEAD tags.
         */
        writeHead(doc: any, css: any): void;
        /**
         * Called before closing the body of the page. This implementation is empty.
         */
        writePostfix(doc: any): void;
        /**
         * Creates the page selector table.
         */
        createPageSelector(vpages: any, hpages: any): any;
        /**
         * Creates a DIV that prints a single page of the given
         * graph using the given scale and returns the DIV that
         * represents the page.
         *
         * Parameters:
         *
         * w - Width of the page in pixels.
         * h - Height of the page in pixels.
         * dx - Optional horizontal page offset in pixels (used internally).
         * dy - Optional vertical page offset in pixels (used internally).
         * content - Callback that adds the HTML content to the inner div of a page.
         * Takes the inner div as the argument.
         * pageNumber - Integer representing the page number.
         */
        renderPage(w: any, h: any, dx: any, dy: any, content: any, pageNumber: any): HTMLDivElement;
        /**
         * Returns the root cell for painting the graph.
         */
        getRoot(): any;
        /**
         * Adds a graph fragment to the given div.
         *
         * Parameters:
         *
         * dx - Horizontal translation for the diagram.
         * dy - Vertical translation for the diagram.
         * scale - Scale for the diagram.
         * pageNumber - Number of the page to be rendered.
         * div - Div that contains the output.
         * clip - Contains the clipping rectangle as an <mxRectangle>.
         */
        addGraphFragment(dx: any, dy: any, scale: any, pageNumber: any, div: any, clip: any): void;
        /**
         * Returns the link for the given cell state. This returns null.
         */
        getLinkForCellState(state: any): any;
        /**
         * Inserts the background image into the given div.
         */
        insertBackgroundImage(div: any, dx: any, dy: any): void;
        /**
         * Returns the pages to be added before the print output. This returns null.
         */
        getCoverPages(): any;
        /**
         * Returns the pages to be added after the print output. This returns null.
         */
        getAppendices(): any;
        /**
         * Opens the print preview and shows the print dialog.
         *
         * Parameters:
         *
         * css - Optional CSS string to be used in the head section.
         */
        print(css: any): void;
        /**
         * Closes the print preview window.
         */
        close(): void;
    }
    /**
     * Defines the appearance of the cells in a graph. See <putCellStyle> for an
     * example of creating a new cell style. It is recommended to use objects, not
     * arrays for holding cell styles. Existing styles can be cloned using
     * <mxUtils.clone> and turned into a string for debugging using
     * <mxUtils.toString>.
     *
     * Default Styles:
     *
     * The stylesheet contains two built-in styles, which are used if no style is
     * defined for a cell:
     *
     *   defaultVertex - Default style for vertices
     *   defaultEdge - Default style for edges
     *
     * Example:
     *
     * (code)
     * var vertexStyle = stylesheet.getDefaultVertexStyle();
     * vertexStyle[mxConstants.ROUNDED] = true;
     * var edgeStyle = stylesheet.getDefaultEdgeStyle();
     * edgeStyle[mxConstants.STYLE_EDGE] = mxEdgeStyle.EntityRelation;
     * (end)
     *
     * Modifies the built-in default styles.
     *
     * To avoid the default style for a cell, add a leading semicolon
     * to the style definition, eg.
     *
     * (code)
     * ;shadow=1
     * (end)
     *
     * Removing keys:
     *
     * For removing a key in a cell style of the form [stylename;|key=value;] the
     * special value none can be used, eg. highlight;fillColor=none
     *
     * See also the helper methods in mxUtils to modify strings of this format,
     * namely <mxUtils.setStyle>, <mxUtils.indexOfStylename>,
     * <mxUtils.addStylename>, <mxUtils.removeStylename>,
     * <mxUtils.removeAllStylenames> and <mxUtils.setStyleFlag>.
     *
     * Constructor: mxStylesheet
     *
     * Constructs a new stylesheet and assigns default styles.
     */
    class mxStylesheet {
        constructor();
        /**
         * Creates and returns the default vertex style.
         */
        createDefaultVertexStyle(): Object;
        /**
         * Creates and returns the default edge style.
         */
        createDefaultEdgeStyle(): Object;
        /**
         * Sets the default style for vertices using defaultVertex as the
         * stylename.
         *
         * Parameters:
         * style - Key, value pairs that define the style.
         */
        putDefaultVertexStyle(style: any): void;
        /**
         * Sets the default style for edges using defaultEdge as the stylename.
         */
        putDefaultEdgeStyle(style: any): void;
        /**
         * Returns the default style for vertices.
         */
        getDefaultVertexStyle(): any;
        /**
         * Sets the default style for edges.
         */
        getDefaultEdgeStyle(): any;
        /**
         * Stores the given map of key, value pairs under the given name in
         * <styles>.
         *
         * Example:
         *
         * The following example adds a new style called 'rounded' into an
         * existing stylesheet:
         *
         * (code)
         * var style = new Object();
         * style[mxConstants.STYLE_SHAPE] = mxConstants.SHAPE_RECTANGLE;
         * style[mxConstants.STYLE_PERIMETER] = mxPerimeter.RectanglePerimeter;
         * style[mxConstants.STYLE_ROUNDED] = true;
         * graph.getStylesheet().putCellStyle('rounded', style);
         * (end)
         *
         * In the above example, the new style is an object. The possible keys of
         * the object are all the constants in <mxConstants> that start with STYLE
         * and the values are either JavaScript objects, such as
         * <mxPerimeter.RightAngleRectanglePerimeter> (which is in fact a function)
         * or expressions, such as true. Note that not all keys will be
         * interpreted by all shapes (eg. the line shape ignores the fill color).
         * The final call to this method associates the style with a name in the
         * stylesheet. The style is used in a cell with the following code:
         *
         * (code)
         * model.setStyle(cell, 'rounded');
         * (end)
         *
         * Parameters:
         *
         * name - Name for the style to be stored.
         * style - Key, value pairs that define the style.
         */
        putCellStyle(name: any, style: any): void;
        /**
         * Returns the cell style for the specified stylename or the given
         * defaultStyle if no style can be found for the given stylename.
         *
         * Parameters:
         *
         * name - String of the form [(stylename|key=value);] that represents the
         * style.
         * defaultStyle - Default style to be returned if no style can be found.
         */
        getCellStyle(name: any, defaultStyle: any): any;
    }
    /**
     * Represents the current state of a cell in a given <mxGraphView>.
     *
     * For edges, the edge label position is stored in <absoluteOffset>.
     *
     * The size for oversize labels can be retrieved using the boundingBox property
     * of the <text> field as shown below.
     *
     * @example
     * var bbox = (state.text != null) ? state.text.boundingBox : null;
     */
    class mxCellState extends mxRectangle {
        /**
         * Reference to the enclosing <mxGraphView>.
         */
        view: mxGraphView;
        /**
         * Reference to the <mxCell> that is represented by this state.
         */
        cell: mxCell;
        /**
         * Contains an array of key, value pairs that represent the style of the
         * cell.
         */
        style: any;
        /**
         * Specifies if the state is invalid. Default is true.
         */
        invalid: boolean;
        /**
         * <mxPoint> that holds the origin for all child cells. Default is a new
         * empty <mxPoint>.
         */
        origin: mxPoint;
        /**
         * Holds an array of <mxPoints> that represent the absolute points of an
         * edge.
         */
        absolutePoints: mxPoint[];
        /**
         * <mxPoint> that holds the absolute offset. For edges, this is the
         * absolute coordinates of the label position. For vertices, this is the
         * offset of the label relative to the top, left corner of the vertex.
         */
        absoluteOffset: mxPoint;
        /**
         * Caches the visible source terminal state.
         */
        visibleSourceState: any;
        /**
         * Caches the visible target terminal state.
         */
        visibleTargetState: any;
        /**
         * Caches the distance between the end points for an edge.
         */
        terminalDistance: number;
        /**
         * Caches the length of an edge.
         */
        length: number;
        /**
         * Array of numbers that represent the cached length of each segment of the
         * edge.
         */
        segments: number[];
        /**
         * Holds the <mxShape> that represents the cell graphically.
         */
        shape: mxShape;
        /**
         * Holds the <mxText> that represents the label of the cell. Thi smay be
         * null if the cell has no label.
         */
        text: mxText;
        /**
         * Holds the unscaled width of the state.
         */
        unscaledWidth: any;
        /**
         * Implicit variable declarations
         */
        cellBounds: mxRectangle;
        paintBounds: mxRectangle;
        /**
         * Constructs a new object that represents the current state of the given
         * cell in the specified view.
         *
         * @param view - <mxGraphView> that contains the state.
         * @param cell - <mxCell> that this state represents.
         * @param style - Array of key, value pairs that constitute the style.
         */
        constructor(view: mxGraphView, cell: mxCell, style: any[]);
        /**
         * Returns the <mxRectangle> that should be used as the perimeter of the
         * cell.
         *
         * @param border - Optional border to be added around the perimeter bounds.
         * @param bounds - Optional <mxRectangle> to be used as the initial bounds.
         */
        getPerimeterBounds(border?: number, bounds?: mxRectangle): mxRectangle;
        /**
         * Sets the first or last point in <absolutePoints> depending on isSource.
         *
         * @param point - <mxPoint> that represents the terminal point.
         * @param isSource - Boolean that specifies if the first or last point should
         * be assigned.
         */
        setAbsoluteTerminalPoint(point: mxPoint, isSource: boolean): void;
        /**
         * Sets the given cursor on the shape and text shape.
         */
        setCursor(cursor: any): void;
        /**
         * Returns the visible source or target terminal cell.
         *
         * @param source - Boolean that specifies if the source or target cell should be
         * returned.
         */
        getVisibleTerminal(source: boolean): any;
        /**
         * Returns the visible source or target terminal state.
         *
         * @param source - Boolean that specifies if the source or target state should be
         * returned.
         */
        getVisibleTerminalState(source: boolean): any;
        /**
         * Sets the visible source or target terminal state.
         *
         * @param terminalState - <mxCellState> that represents the terminal.
         * @param source - Boolean that specifies if the source or target state should be set.
         */
        setVisibleTerminalState(terminalState: mxCellState, source: boolean): void;
        /**
         * Returns the unscaled, untranslated bounds.
         */
        getCellBounds(): mxRectangle;
        /**
         * Returns the unscaled, untranslated paint bounds. This is the same as
         * <getCellBounds> but with a 90 degree rotation if the shape's
         * isPaintBoundsInverted returns true.
         */
        getPaintBounds(): mxRectangle;
        /**
         * Updates the cellBounds and paintBounds.
         */
        updateCachedBounds(): void;
        /**
         * Destructor: setState
         *
         * Copies all fields from the given state to this state.
         */
        setState(state: mxCellState): void;
        /**
         * Returns a clone of this <mxCellState>.
         */
        clone(): mxCellState;
        /**
         * Destructor: destroy
         *
         * Destroys the state and all associated resources.
         */
        destroy(): void;
    }
    /**
     * Implements the selection model for a graph. Here is a listener that handles
     * all removed selection cells.
     *
     * (code)
     * graph.getSelectionModel().addListener(mxEvent.CHANGE, function(sender, evt)
     * {
     *   var cells = evt.getProperty('added');
     *
     *   for (var i = 0; i < cells.length; i++)
     *   {
     *     // Handle cells[i]...
     *   }
     * });
     * (end)
     *
     * Event: mxEvent.UNDO
     *
     * Fires after the selection was changed in <changeSelection>. The
     * <code>edit</code> property contains the <mxUndoableEdit> which contains the
     * <mxSelectionChange>.
     *
     * Event: mxEvent.CHANGE
     *
     * Fires after the selection changes by executing an <mxSelectionChange>. The
     * <code>added</code> and <code>removed</code> properties contain arrays of
     * cells that have been added to or removed from the selection, respectively.
     * The names are inverted due to historic reasons. This cannot be changed.
     */
    class mxGraphSelectionModel extends mxEventSource {
        /**
         * Specifies the resource key for the status message after a long operation.
         * If the resource for this key does not exist then the value is used as
         * the status message. Default is 'done'.
         */
        doneResource: string;
        /**
         * Specifies the resource key for the status message while the selection is
         * being updated. If the resource for this key does not exist then the
         * value is used as the status message. Default is 'updatingSelection'.
         */
        updatingSelectionResource: string;
        /**
         * Reference to the enclosing <mxGraph>.
         */
        graph: mxGraph;
        /**
         * Specifies if only one selected item at a time is allowed.
         * Default is false.
         */
        singleSelection: boolean;
        /**
         * Implicit variable declarations
         */
        cells: mxCell[];
        /**
         * Constructs a new graph selection model for the given <mxGraph>.
         *
         * @param graph - Reference to the enclosing <mxGraph>.
         */
        constructor(graph: mxGraph);
        /**
         * Returns <singleSelection> as a boolean.
         */
        isSingleSelection(): boolean;
        /**
         * Sets the <singleSelection> flag.
         *
         * @param singleSelection - Boolean that specifies the new value for
         * <singleSelection>.
         */
        setSingleSelection(singleSelection: boolean): void;
        /**
         * Returns true if the given <mxCell> is selected.
         */
        isSelected(cell: mxCell): boolean;
        /**
         * Returns true if no cells are currently selected.
         */
        isEmpty(): boolean;
        /**
         * Clears the selection and fires a <change> event if the selection was not
         * empty.
         */
        clear(): void;
        /**
         * Selects the specified <mxCell> using <setCells>.
         *
         * @param cell - <mxCell> to be selected.
         */
        setCell(cell: mxCell): void;
        /**
         * Selects the given array of <mxCells> and fires a <change> event.
         *
         * @param cells - Array of <mxCells> to be selected.
         */
        setCells(cells: mxCell[]): void;
        /**
         * Returns the first selectable cell in the given array of cells.
         */
        getFirstSelectableCell(cells: mxCell[]): mxCell;
        /**
         * Adds the given <mxCell> to the selection and fires a <select> event.
         *
         * @param cell - <mxCell> to add to the selection.
         */
        addCell(cell: mxCell): void;
        /**
         * Adds the given array of <mxCells> to the selection and fires a <select>
         * event.
         *
         * @param cells - Array of <mxCells> to add to the selection.
         */
        addCells(cells: mxCell[]): void;
        /**
         * Removes the specified <mxCell> from the selection and fires a <select>
         * event for the remaining cells.
         *
         * @param cell - <mxCell> to remove from the selection.
         */
        removeCell(cell: mxCell): void;
        /**
         * Function: removeCells
         */
        removeCells(cells: mxCell[]): void;
        /**
         * Inner callback to add the specified <mxCell> to the selection. No event
         * is fired in this implementation.
         */
        changeSelection(added: mxCell[], removed: mxCell[]): void;
        /**
         * Inner callback to add the specified <mxCell> to the selection. No event
         * is fired in this implementation.
         *
         * @param cell - <mxCell> to add to the selection.
         */
        cellAdded(cell: mxCell): void;
        /**
         * Inner callback to remove the specified <mxCell> from the selection. No
         * event is fired in this implementation.
         *
         * @param cell - <mxCell> to remove from the selection.
         */
        cellRemoved(cell: mxCell): void;
    }
    /**
     * Action to change the current root in a view.
     */
    class mxSelectionChange {
        selectionModel: mxGraphSelectionModel;
        added: mxCell[];
        removed: mxCell[];
        /**
         * Constructs a change of the current root in the given view.
         */
        constructor(selectionModel: mxGraphSelectionModel, added: mxCell[], removed: mxCell[]);
        /**
         * Changes the current root of the view.
         */
        execute(): void;
    }
    /**
     * In-place editor for the graph. To control this editor, use
     * <mxGraph.invokesStopCellEditing>, <mxGraph.enterStopsCellEditing> and
     * <mxGraph.escapeEnabled>. If <mxGraph.enterStopsCellEditing> is true then
     * ctrl-enter or shift-enter can be used to create a linefeed. The F2 and
     * escape keys can always be used to stop editing.
     *
     * To customize the location of the textbox in the graph, override
     * <getEditorBounds> as follows:
     *
     * (code)
     * graph.cellEditor.getEditorBounds = function(state)
     * {
     *   var result = mxCellEditor.prototype.getEditorBounds.apply(this, arguments);
     *
     *   if (this.graph.getModel().isEdge(state.cell))
     *   {
     *     result.x = state.getCenterX() - result.width / 2;
     *     result.y = state.getCenterY() - result.height / 2;
     *   }
     *
     *   return result;
     * };
     * (end)
     *
     * Note that this hook is only called if <autoSize> is false. If <autoSize> is true,
     * then <mxShape.getLabelBounds> is used to compute the current bounds of the textbox.
     *
     * The textarea uses the mxCellEditor CSS class. You can modify this class in
     * your custom CSS. Note: You should modify the CSS after loading the client
     * in the page.
     *
     * Example:
     *
     * To only allow numeric input in the in-place editor, use the following code.
     *
     * (code)
     * var text = graph.cellEditor.textarea;
     *
     * mxEvent.addListener(text, 'keydown', function (evt)
     * {
     *   if (!(evt.keyCode >= 48 && evt.keyCode <= 57) &&
     *       !(evt.keyCode >= 96 && evt.keyCode <= 105))
     *   {
     *     mxEvent.consume(evt);
     *   }
     * });
     * (end)
     *
     * Placeholder:
     *
     * To implement a placeholder for cells without a label, use the
     * <emptyLabelText> variable.
     *
     * Resize in Chrome:
     *
     * Resize of the textarea is disabled by default. If you want to enable
     * this feature extend <init> and set this.textarea.style.resize = ''.
     *
     * To start editing on a key press event, the container of the graph
     * should have focus or a focusable parent should be used to add the
     * key press handler as follows.
     *
     * (code)
     * mxEvent.addListener(graph.container, 'keypress', mxUtils.bind(this, function(evt)
     * {
     *   if (!graph.isEditing() && !graph.isSelectionEmpty() && evt.which !== 0 &&
     *       !mxEvent.isAltDown(evt) && !mxEvent.isControlDown(evt) && !mxEvent.isMetaDown(evt))
     *   {
     *     graph.startEditing();
     *
     *     if (mxClient.IS_FF)
     *     {
     *       graph.cellEditor.textarea.value = String.fromCharCode(evt.which);
     *     }
     *   }
     * }));
     * (end)
     *
     * To allow focus for a DIV, and hence to receive key press events, some browsers
     * require it to have a valid tabindex attribute. In this case the following
     * code may be used to keep the container focused.
     *
     * (code)
     * var graphFireMouseEvent = graph.fireMouseEvent;
     * graph.fireMouseEvent = function(evtName, me, sender)
     * {
     *   if (evtName == mxEvent.MOUSE_DOWN)
     *   {
     *     this.container.focus();
     *   }
     *
     *   graphFireMouseEvent.apply(this, arguments);
     * };
     * (end)
     *
     * Constructor: mxCellEditor
     *
     * Constructs a new in-place editor for the specified graph.
     *
     * Parameters:
     *
     * graph - Reference to the enclosing <mxGraph>.
     */
    class mxCellEditor {
        graph: mxGraph;
        editingCell: mxCell;
        constructor(graph: any);
        textarea: HTMLElement;
        /**
         * Creates the <textarea> and installs the event listeners. The key handler
         * updates the <modified> state.
         */
        init(): void;
        /**
         * Called in <stopEditing> if cancel is false to invoke <mxGraph.labelChanged>.
         */
        applyValue(state: any, value: any): void;
        /**
         * Gets the initial editing value for the given cell.
         */
        getInitialValue(state: any, trigger: any): any;
        /**
         * Returns the current editing value.
         */
        getCurrentValue(state: any): any;
        /**
         * Installs listeners for focus, change and standard key event handling.
         */
        installListeners(elt: any): void;
        /**
         * Returns true if the given keydown event should stop cell editing. This
         * returns true if F2 is pressed of if <mxGraph.enterStopsCellEditing> is true
         * and enter is pressed without control or shift.
         */
        isStopEditingEvent(evt: any): boolean;
        /**
         * Returns true if this editor is the source for the given native event.
         */
        isEventSource(evt: any): boolean;
        /**
         * Returns <modified>.
         */
        resize(): void;
        /**
         * Called if the textarea has lost focus.
         */
        focusLost(): void;
        /**
         * Returns the background color for the in-place editor. This implementation
         * always returns null.
         */
        getBackgroundColor(state: any): any;
        /**
         * Starts the editor for the given cell.
         *
         * Parameters:
         *
         * cell - <mxCell> to start editing.
         * trigger - Optional mouse event that triggered the editor.
         */
        startEditing(cell: any, trigger: any): void;
        /**
         * Returns <selectText>.
         */
        isSelectText(): any;
        /**
         * Stops the editor and applies the value if cancel is false.
         */
        stopEditing(cancel: any): void;
        /**
         * Prepares the textarea for getting its value in <stopEditing>.
         * This implementation removes the extra trailing linefeed in Firefox.
         */
        prepareTextarea(): void;
        /**
         * Returns true if the label should be hidden while the cell is being
         * edited.
         */
        isHideLabel(state: any): boolean;
        /**
         * Returns the minimum width and height for editing the given state.
         */
        getMinimumSize(state: any): mxRectangle;
        /**
         * Returns the <mxRectangle> that defines the bounds of the editor.
         */
        getEditorBounds(state: any): mxRectangle;
        /**
         * Returns the initial label value to be used of the label of the given
         * cell is empty. This label is displayed and cleared on the first keystroke.
         * This implementation returns <emptyLabelText>.
         *
         * Parameters:
         *
         * cell - <mxCell> for which a text for an empty editing box should be
         * returned.
         */
        getEmptyLabelText(cell: any): any;
        /**
         * Returns the cell that is currently being edited or null if no cell is
         * being edited.
         */
        getEditingCell(): any;
        /**
         * Destroys the editor and removes all associated resources.
         */
        destroy(): void;
    }
    /**
     * Renders cells into a document object model. The <defaultShapes> is a global
     * map of shapename, constructor pairs that is used in all instances. You can
     * get a list of all available shape names using the following code.
     *
     * In general the cell renderer is in charge of creating, redrawing and
     * destroying the shape and label associated with a cell state, as well as
     * some other graphical objects, namely controls and overlays. The shape
     * hieararchy in the display (ie. the hierarchy in which the DOM nodes
     * appear in the document) does not reflect the cell hierarchy. The shapes
     * are a (flat) sequence of shapes and labels inside the draw pane of the
     * graph view, with some exceptions, namely the HTML labels being placed
     * directly inside the graph container for certain browsers.
     *
     * (code)
     * mxLog.show();
     * for (var i in mxCellRenderer.defaultShapes)
     * {
     *   mxLog.debug(i);
     * }
     * (end)
     *
     * Constructor: mxCellRenderer
     *
     * Constructs a new cell renderer with the following built-in shapes:
     * arrow, rectangle, ellipse, rhombus, image, line, label, cylinder,
     * swimlane, connector, actor and cloud.
     */
    class mxCellRenderer {
        /**
         * Variable: defaultShapes
         *
         * Static array that contains the globally registered shapes which are
         * known to all instances of this class. For adding new shapes you should
         * use the static <mxCellRenderer.registerShape> function.
         */
        static defaultShapes: any;
        antiAlias: boolean;
        /**
         * Registers the given constructor under the specified key in this instance
         * of the renderer.
         *
         * Example:
         *
         * (code)
         * mxCellRenderer.registerShape(mxConstants.SHAPE_RECTANGLE, mxRectangleShape);
         * (end)
         *
         * Parameters:
         *
         * key - String representing the shape name.
         * shape - Constructor of the <mxShape> subclass.
         */
        static registerShape(key: any, shape: any): void;
        /**
         * Initializes the shape in the given state by calling its init method with
         * the correct container after configuring it using <configureShape>.
         *
         * Parameters:
         *
         * state - <mxCellState> for which the shape should be initialized.
         */
        initializeShape(state: any): void;
        /**
         * Creates and returns the shape for the given cell state.
         *
         * Parameters:
         *
         * state - <mxCellState> for which the shape should be created.
         */
        createShape(state: any): any;
        /**
         * Creates the indicator shape for the given cell state.
         *
         * Parameters:
         *
         * state - <mxCellState> for which the indicator shape should be created.
         */
        createIndicatorShape(state: any): void;
        /**
         * Returns the shape for the given name from <defaultShapes>.
         */
        getShape(name: any): any;
        /**
         * Returns the constructor to be used for creating the shape.
         */
        getShapeConstructor(state: any): any;
        /**
         * Configures the shape for the given cell state.
         *
         * Parameters:
         *
         * state - <mxCellState> for which the shape should be configured.
         */
        configureShape(state: any): void;
        /**
         * Replaces any reserved words used for attributes, eg. inherit,
         * indicated or swimlane for colors in the shape for the given state.
         * This implementation resolves these keywords on the fill, stroke
         * and gradient color keys.
         */
        postConfigureShape(state: any): void;
        /**
         * Resolves special keywords 'inherit', 'indicated' and 'swimlane' and sets
         * the respective color on the shape.
         */
        checkPlaceholderStyles(state: any): boolean;
        /**
         * Resolves special keywords 'inherit', 'indicated' and 'swimlane' and sets
         * the respective color on the shape.
         */
        resolveColor(state: any, field: any, key: any): void;
        /**
         * Returns the value to be used for the label.
         *
         * Parameters:
         *
         * state - <mxCellState> for which the label should be created.
         */
        getLabelValue(state: any): any;
        /**
         * Creates the label for the given cell state.
         *
         * Parameters:
         *
         * state - <mxCellState> for which the label should be created.
         */
        createLabel(state: any, value: any): void;
        /**
         * Initiailzes the label with a suitable container.
         *
         * Parameters:
         *
         * state - <mxCellState> whose label should be initialized.
         */
        initializeLabel(state: any, shape: any): void;
        /**
         * Creates the actual shape for showing the overlay for the given cell state.
         *
         * Parameters:
         *
         * state - <mxCellState> for which the overlay should be created.
         */
        createCellOverlays(state: any): void;
        /**
         * Initializes the given overlay.
         *
         * Parameters:
         *
         * state - <mxCellState> for which the overlay should be created.
         * overlay - <mxImageShape> that represents the overlay.
         */
        initializeOverlay(state: any, overlay: any): void;
        /**
         * Installs the listeners for the given <mxCellState>, <mxCellOverlay> and
         * <mxShape> that represents the overlay.
         */
        installCellOverlayListeners(state: any, overlay: any, shape: any): void;
        /**
         * Creates the control for the given cell state.
         *
         * Parameters:
         *
         * state - <mxCellState> for which the control should be created.
         */
        createControl(state: any): void;
        /**
         * Hook for creating the click handler for the folding icon.
         *
         * Parameters:
         *
         * state - <mxCellState> whose control click handler should be returned.
         */
        createControlClickHandler(state: any): any;
        /**
         * Initializes the given control and returns the corresponding DOM node.
         *
         * Parameters:
         *
         * state - <mxCellState> for which the control should be initialized.
         * control - <mxShape> to be initialized.
         * handleEvents - Boolean indicating if mousedown and mousemove should fire events via the graph.
         * clickHandler - Optional function to implement clicks on the control.
         */
        initControl(state: any, control: any, handleEvents: any, clickHandler: any): any;
        /**
         * Returns true if the event is for the shape of the given state. This
         * implementation always returns true.
         *
         * Parameters:
         *
         * state - <mxCellState> whose shape fired the event.
         * evt - Mouse event which was fired.
         */
        isShapeEvent(state: any, evt: any): boolean;
        /**
         * Returns true if the event is for the label of the given state. This
         * implementation always returns true.
         *
         * Parameters:
         *
         * state - <mxCellState> whose label fired the event.
         * evt - Mouse event which was fired.
         */
        isLabelEvent(state: any, evt: any): boolean;
        /**
         * Installs the event listeners for the given cell state.
         *
         * Parameters:
         *
         * state - <mxCellState> for which the event listeners should be isntalled.
         */
        installListeners(state: any): void;
        /**
         * Redraws the label for the given cell state.
         *
         * Parameters:
         *
         * state - <mxCellState> whose label should be redrawn.
         */
        redrawLabel(state: any, forced: any): void;
        /**
         * Returns true if the style for the text shape has changed.
         *
         * Parameters:
         *
         * state - <mxCellState> whose label should be checked.
         * shape - <mxText> shape to be checked.
         */
        isTextShapeInvalid(state: any, shape: any): any;
        /**
         * Called to invoked redraw on the given text shape.
         *
         * Parameters:
         *
         * shape - <mxText> shape to be redrawn.
         */
        redrawLabelShape(shape: any): void;
        /**
         * Returns the scaling used for the label of the given state
         *
         * Parameters:
         *
         * state - <mxCellState> whose label scale should be returned.
         */
        getTextScale(state: any): any;
        /**
         * Returns the bounds to be used to draw the label of the given state.
         *
         * Parameters:
         *
         * state - <mxCellState> whose label bounds should be returned.
         */
        getLabelBounds(state: any): mxRectangle;
        /**
         * Adds the shape rotation to the given label bounds and
         * applies the alignment and offsets.
         *
         * Parameters:
         *
         * state - <mxCellState> whose label bounds should be rotated.
         * bounds - <mxRectangle> the rectangle to be rotated.
         */
        rotateLabelBounds(state: any, bounds: any): void;
        /**
         * Redraws the overlays for the given cell state.
         *
         * Parameters:
         *
         * state - <mxCellState> whose overlays should be redrawn.
         */
        redrawCellOverlays(state: any, forced: any): void;
        /**
         * Redraws the control for the given cell state.
         *
         * Parameters:
         *
         * state - <mxCellState> whose control should be redrawn.
         */
        redrawControl(state: any, forced: any): void;
        /**
         * Returns the bounds to be used to draw the control (folding icon) of the
         * given state.
         */
        getControlBounds(state: any, w: any, h: any): mxRectangle;
        /**
         * Inserts the given array of <mxShapes> after the given nodes in the DOM.
         *
         * Parameters:
         *
         * shapes - Array of <mxShapes> to be inserted.
         * node - Node in <drawPane> after which the shapes should be inserted.
         * htmlNode - Node in the graph container after which the shapes should be inserted that
         * will not go into the <drawPane> (eg. HTML labels without foreignObjects).
         */
        insertStateAfter(state: any, node: any, htmlNode: any): any[];
        /**
         * Returns the <mxShapes> for the given cell state in the order in which they should
         * appear in the DOM.
         *
         * Parameters:
         *
         * state - <mxCellState> whose shapes should be returned.
         */
        getShapesForState(state: any): any[];
        /**
         * Updates the bounds or points and scale of the shapes for the given cell
         * state. This is called in mxGraphView.validatePoints as the last step of
         * updating all cells.
         *
         * Parameters:
         *
         * state - <mxCellState> for which the shapes should be updated.
         * force - Optional boolean that specifies if the cell should be reconfiured
         * and redrawn without any additional checks.
         * rendering - Optional boolean that specifies if the cell should actually
         * be drawn into the DOM. If this is false then redraw and/or reconfigure
         * will not be called on the shape.
         */
        redraw(state: mxCellState, force?: any, rendering?: any): void;
        /**
         * Redraws the shape for the given cell state.
         *
         * Parameters:
         *
         * state - <mxCellState> whose label should be redrawn.
         */
        redrawShape(state: any, force: any, rendering: any): boolean;
        /**
         * Invokes redraw on the shape of the given state.
         */
        doRedrawShape(state: any): void;
        /**
         * Returns true if the given shape must be repainted.
         */
        isShapeInvalid(state: any, shape: any): boolean;
        /**
         * Destroys the shapes associated with the given cell state.
         *
         * Parameters:
         *
         * state - <mxCellState> for which the shapes should be destroyed.
         */
        destroy(state: any): void;
    }
    var mxEdgeStyle: {
        EntityRelation(state: any, source: any, target: any, points: any, result: any): void;
        Loop(state: any, source: any, target: any, points: any, result: any): void;
        ElbowConnector(state: any, source: any, target: any, points: any, result: any): void;
        SideToSide(state: any, source: any, target: any, points: any, result: any): void;
        TopToBottom(state: any, source: any, target: any, points: any, result: any): void;
        SegmentConnector(state: any, source: any, target: any, hints: any, result: any): void;
        orthBuffer: number;
        orthPointsFallback: boolean;
        dirVectors: number[][];
        wayPoints1: number[][];
        routePatterns: number[][][];
        inlineRoutePatterns: number[][][];
        vertexSeperations: any[];
        limits: number[][];
        LEFT_MASK: number;
        TOP_MASK: number;
        RIGHT_MASK: number;
        BOTTOM_MASK: number;
        LEFT: number;
        TOP: number;
        RIGHT: number;
        BOTTOM: number;
        SIDE_MASK: number;
        CENTER_MASK: number;
        SOURCE_MASK: number;
        TARGET_MASK: number;
        VERTEX_MASK: number;
        getJettySize(state: any, source: any, target: any, points: any, isSource: any): any;
        OrthConnector(state: any, source: any, target: any, points: any, result: any): void;
        getRoutePattern(dir: any, quad: any, dx: any, dy: any): any;
    };
    var mxStyleRegistry: {
        values: any[];
        dynamicLoading?: any;
        putValue(name: any, obj: any): void;
        getValue(name: any): any;
        getName(value: any): string;
    };
    /**
     * Extends <mxEventSource> to implement a view for a graph. This class is in
     * charge of computing the absolute coordinates for the relative child
     * geometries, the points for perimeters and edge styles and keeping them
     * cached in <mxCellStates> for faster retrieval. The states are updated
     * whenever the model or the view state (translate, scale) changes. The scale
     * and translate are honoured in the bounds.
     *
     * Event: mxEvent.UNDO
     *
     * Fires after the root was changed in <setCurrentRoot>. The <code>edit</code>
     * property contains the <mxUndoableEdit> which contains the
     * <mxCurrentRootChange>.
     *
     * Event: mxEvent.SCALE_AND_TRANSLATE
     *
     * Fires after the scale and translate have been changed in <scaleAndTranslate>.
     * The <code>scale</code>, <code>previousScale</code>, <code>translate</code>
     * and <code>previousTranslate</code> properties contain the new and previous
     * scale and translate, respectively.
     *
     * Event: mxEvent.SCALE
     *
     * Fires after the scale was changed in <setScale>. The <code>scale</code> and
     * <code>previousScale</code> properties contain the new and previous scale.
     *
     * Event: mxEvent.TRANSLATE
     *
     * Fires after the translate was changed in <setTranslate>. The
     * <code>translate</code> and <code>previousTranslate</code> properties contain
     * the new and previous value for translate.
     *
     * Event: mxEvent.DOWN and mxEvent.UP
     *
     * Fire if the current root is changed by executing an <mxCurrentRootChange>.
     * The event name depends on the location of the root in the cell hierarchy
     * with respect to the current root. The <code>root</code> and
     * <code>previous</code> properties contain the new and previous root,
     * respectively.
     */
    class mxGraphView extends mxEventSource {
        backgroundPageShape: mxRectangleShape;
        /**
         *
         */
        EMPTY_POINT: mxPoint;
        /**
         * Specifies the resource key for the status message after a long operation.
         * If the resource for this key does not exist then the value is used as
         * the status message. Default is 'done'.
         */
        doneResource: string;
        /**
         * Specifies the resource key for the status message while the document is
         * being updated. If the resource for this key does not exist then the
         * value is used as the status message. Default is 'updatingDocument'.
         */
        updatingDocumentResource: string;
        /**
         * Specifies if string values in cell styles should be evaluated using
         * <mxUtils.eval>. This will only be used if the string values can't be mapped
         * to objects using <mxStyleRegistry>. Default is false. NOTE: Enabling this
         * switch carries a possible security risk.
         */
        allowEval: boolean;
        /**
         * Specifies if a gesture should be captured when it goes outside of the
         * graph container. Default is true.
         */
        captureDocumentGesture: boolean;
        /**
         * Specifies if the <canvas> should be hidden while rendering in IE8 standards
         * mode and quirks mode. This will significantly improve rendering performance.
         * Default is true.
         */
        optimizeVmlReflows: boolean;
        /**
         * Specifies if shapes should be created, updated and destroyed using the
         * methods of <mxCellRenderer> in <graph>. Default is true.
         */
        rendering: boolean;
        /**
         * Reference to the enclosing <mxGraph>.
         */
        graph: mxGraph;
        /**
         * <mxCell> that acts as the root of the displayed cell hierarchy.
         */
        currentRoot: mxCell;
        /**
         * <mxRectangle> that caches the scales, translated bounds of the current view.
         */
        graphBounds: mxRectangle;
        /**
         * Specifies the scale. Default is 1 (100%).
         */
        scale: number;
        /**
         * <mxPoint> that specifies the current translation. Default is a new
         * empty <mxPoint>.
         */
        translate: mxPoint;
        /**
         * <mxDictionary> that maps from cell IDs to <mxCellStates>.
         */
        states: mxDictionary;
        /**
         * Specifies if the style should be updated in each validation step. If this
         * is false then the style is only updated if the state is created or if the
         * style of the cell was changed. Default is false.
         */
        updateStyle: boolean;
        /**
         * During validation, this contains the last DOM node that was processed.
         */
        lastNode: HTMLElement;
        /**
         * During validation, this contains the last HTML DOM node that was processed.
         */
        lastHtmlNode: HTMLElement;
        /**
         * During validation, this contains the last edge's DOM node that was processed.
         */
        lastForegroundNode: HTMLElement;
        /**
         * During validation, this contains the last edge HTML DOM node that was processed.
         */
        lastForegroundHtmlNode: HTMLElement;
        /**
         * Implicit variable definitions
         */
        canvas: SVGGElement;
        placeholder: HTMLElement;
        textDiv: HTMLElement;
        backgroundPane: HTMLElement;
        drawPane: SVGElement;
        overlayPane: HTMLElement;
        decoratorPane: HTMLElement;
        /**
         * Constructs a new view for the given <mxGraph>.
         *
         * @param graph - Reference to the enclosing <mxGraph>.
         */
        constructor(graph: mxGraph);
        /**
         * Returns <graphBounds>.
         */
        getGraphBounds(): mxRectangle;
        /**
         * Sets <graphBounds>.
         */
        setGraphBounds(value: mxRectangle): void;
        /**
         * Returns the union of all <mxCellStates> for the given array of <mxCells>.
         *
         * @param cells - Array of <mxCells> whose bounds should be returned.
         */
        getBounds(cells: mxCell[]): mxRectangle;
        /**
         * Sets and returns the current root and fires an <undo> event before
         * calling <mxGraph.sizeDidChange>.
         *
         * @param root - <mxCell> that specifies the root of the displayed cell hierarchy.
         */
        setCurrentRoot(root: any): any;
        /**
         * Sets the scale and translation and fires a <scale> and <translate> event
         * before calling <revalidate> followed by <mxGraph.sizeDidChange>.
         *
         * @param scale - Decimal value that specifies the new scale (1 is 100%).
         * @param dx - X-coordinate of the translation.
         * @param dy - Y-coordinate of the translation.
         */
        scaleAndTranslate(scale: any, dx: any, dy: any): void;
        /**
         * Returns the <scale>.
         */
        getScale(): number;
        /**
         * Sets the scale and fires a <scale> event before calling <revalidate> followed
         * by <mxGraph.sizeDidChange>.
         *
         * @param value - Decimal value that specifies the new scale (1 is 100%).
         */
        setScale(value: any): void;
        /**
         * Returns the <translate>.
         */
        getTranslate(): mxPoint;
        /**
         * Sets the translation and fires a <translate> event before calling
         * <revalidate> followed by <mxGraph.sizeDidChange>. The translation is the
         * negative of the origin.
         *
         * @param dx - X-coordinate of the translation.
         * @param dy - Y-coordinate of the translation.
         */
        setTranslate(dx: number, dy: number): void;
        /**
         * Clears the view if <currentRoot> is not null and revalidates.
         */
        refresh(): void;
        /**
         * Revalidates the complete view with all cell states.
         */
        revalidate(): void;
        /**
         * Removes the state of the given cell and all descendants if the given
         * cell is not the current root.
         *
         * @param cell - Optional <mxCell> for which the state should be removed. Default
         * is the root of the model.
         * @param force - Boolean indicating if the current root should be ignored for
         * recursion.
         */
        clear(cell?: mxCell, force?: boolean, recurse?: boolean): void;
        /**
         * Invalidates the state of the given cell, all its descendants and
         * connected edges.
         *
         * @param cell - Optional <mxCell> to be invalidated. Default is the root of the
         * model.
         */
        invalidate(cell?: mxCell, recurse?: boolean, includeEdges?: boolean): void;
        /**
         * Calls <validateCell> and <validateCellState> and updates the <graphBounds>
         * using <getBoundingBox>. Finally the background is validated using
         * <validateBackground>.
         *
         * @param cell - Optional <mxCell> to be used as the root of the validation.
         * Default is <currentRoot> or the root of the model.
         */
        validate(cell?: mxCell): void;
        /**
         * Returns the bounds for an empty graph. This returns a rectangle at
         * <translate> with the size of 0 x 0.
         */
        getEmptyBounds(): mxRectangle;
        /**
         * Returns the bounding box of the shape and the label for the given
         * <mxCellState> and its children if recurse is true.
         *
         * @param state - <mxCellState> whose bounding box should be returned.
         * @param recurse - Optional boolean indicating if the children should be included.
         * Default is true.
         */
        getBoundingBox(state: mxCellState, recurse?: boolean): mxRectangle;
        /**
         * Creates and returns the shape used as the background page.
         *
         * bounds - <mxRectangle> that represents the bounds of the shape.
         */
        createBackgroundPageShape(bounds: any): mxRectangleShape;
        /**
         * Calls <validateBackgroundImage> and <validateBackgroundPage>.
         */
        validateBackground(): void;
        /**
         * Validates the background image.
         */
        validateBackgroundImage(): void;
        /**
         * Validates the background page.
         */
        validateBackgroundPage(): void;
        /**
         * Returns the bounds for the background page.
         */
        getBackgroundPageBounds(): mxRectangle;
        /**
         * Updates the bounds and redraws the background image.
         *
         * Example:
         *
         * If the background image should not be scaled, this can be replaced with
         * the following.
         *
         * (code)
         * mxGraphView.prototype.redrawBackground = function(backgroundImage, bg)
         * {
         *   backgroundImage.bounds.x = this.translate.x;
         *   backgroundImage.bounds.y = this.translate.y;
         *   backgroundImage.bounds.width = bg.width;
         *   backgroundImage.bounds.height = bg.height;
         *
         *   backgroundImage.redraw();
         * };
         * (end)
         *
         * @param backgroundImage - <mxImageShape> that represents the background image.
         * @param bg - <mxImage> that specifies the image and its dimensions.
         */
        redrawBackgroundImage(backgroundImage: any, bg: any): void;
        /**
         * Recursively creates the cell state for the given cell if visible is true and
         * the given cell is visible. If the cell is not visible but the state exists
         * then it is removed using <removeState>.
         *
         * @param cell - <mxCell> whose <mxCellState> should be created.
         * @param visible - Optional boolean indicating if the cell should be visible. Default
         * is true.
         */
        validateCell(cell: mxCell, visible?: boolean): mxCell;
        /**
         * Validates and repaints the <mxCellState> for the given <mxCell>.
         *
         * @param cell - <mxCell> whose <mxCellState> should be validated.
         * @param recurse - Optional boolean indicating if the children of the cell should be
         * validated. Default is true.
         */
        validateCellState(cell: mxCell, recurse?: boolean): mxCellState;
        /**
         * Updates the given <mxCellState>.
         *
         * @param state - <mxCellState> to be updated.
         */
        updateCellState(state: mxCellState): void;
        /**
         * Returns true if the children of the given cell should not be visible in the
         * view. This implementation uses <mxGraph.isCellVisible> but it can be
         * overidden to use a separate condition.
         *
         * @param cell
         */
        isCellCollapsed(cell: any): boolean;
        /**
         * Validates the given cell state.
         *
         * @param state
         * @param geo
         */
        updateVertexState(state: any, geo: any): void;
        /**
         * Validates the given cell state.
         *
         * @param state
         * @param geo
         */
        updateEdgeState(state: any, geo: any): void;
        /**
         * Updates the absoluteOffset of the given vertex cell state. This takes
         * into account the label position styles.
         *
         * @param state - <mxCellState> whose absolute offset should be updated.
         */
        updateVertexLabelOffset(state: any): void;
        /**
         * Resets the current validation state.
         */
        resetValidationState(): void;
        /**
         * Invoked when a state has been processed in <validatePoints>. This is used
         * to update the order of the DOM nodes of the shape.
         *
         * @param state - <mxCellState> that represents the cell state.
         */
        stateValidated(state: any): void;
        /**
         * Sets the initial absolute terminal points in the given state before the edge
         * style is computed.
         *
         * @param edge - <mxCellState> whose initial terminal points should be updated.
         * @param source - <mxCellState> which represents the source terminal.
         * @param target - <mxCellState> which represents the target terminal.
         */
        updateFixedTerminalPoints(edge: any, source: any, target: any): void;
        /**
         * Sets the fixed source or target terminal point on the given edge.
         *
         * @param edge - <mxCellState> whose terminal point should be updated.
         * @param terminal - <mxCellState> which represents the actual terminal.
         * @param source - Boolean that specifies if the terminal is the source.
         * @param constraint - <mxConnectionConstraint> that specifies the connection.
         */
        updateFixedTerminalPoint(edge: any, terminal: any, source: any, constraint: any): void;
        /**
         * Returns the fixed source or target terminal point for the given edge.
         *
         * @param edge - <mxCellState> whose terminal point should be returned.
         * @param terminal - <mxCellState> which represents the actual terminal.
         * @param source - Boolean that specifies if the terminal is the source.
         * @param constraint - <mxConnectionConstraint> that specifies the connection.
         */
        getFixedTerminalPoint(edge: any, terminal: any, source: any, constraint: any): any;
        /**
         * Updates the bounds of the given cell state to reflect the bounds of the stencil
         * if it has a fixed aspect and returns the previous bounds as an <mxRectangle> if
         * the bounds have been modified or null otherwise.
         *
         * @param edge - <mxCellState> whose bounds should be updated.
         */
        updateBoundsFromStencil(state: any): any;
        /**
         * Updates the absolute points in the given state using the specified array
         * of <mxPoints> as the relative points.
         *
         * @param edge - <mxCellState> whose absolute points should be updated.
         * @param points - Array of <mxPoints> that constitute the relative points.
         * @param source - <mxCellState> that represents the source terminal.
         * @param target - <mxCellState> that represents the target terminal.
         */
        updatePoints(edge: any, points: any, source: any, target: any): void;
        /**
         * Transforms the given control point to an absolute point.
         *
         * @param state
         * @param pt
         */
        transformControlPoint(state: any, pt: any): mxPoint;
        /**
         * Returns true if the given edge should be routed with <mxGraph.defaultLoopStyle>
         * or the <mxConstants.STYLE_LOOP> defined for the given edge. This implementation
         * returns true if the given edge is a loop and does not
         *
         * @param edge
         * @param points
         * @param source
         * @param target
         */
        isLoopStyleEnabled(edge: mxCellState, points: any, source: any, target: any): boolean;
        /**
         * Returns the edge style function to be used to render the given edge state.
         *
         * @param edge
         * @param points
         * @param source
         * @param target
         */
        getEdgeStyle(edge: any, points?: any, source?: any, target?: any): any;
        /**
         * Updates the terminal points in the given state after the edge style was
         * computed for the edge.
         *
         * @param state - <mxCellState> whose terminal points should be updated.
         * @param source - <mxCellState> that represents the source terminal.
         * @param target - <mxCellState> that represents the target terminal.
         */
        updateFloatingTerminalPoints(state: any, source: any, target: any): void;
        /**
         * Updates the absolute terminal point in the given state for the given
         * start and end state, where start is the source if source is true.
         *
         * @param edge - <mxCellState> whose terminal point should be updated.
         * @param start - <mxCellState> for the terminal on "this" side of the edge.
         * @param end - <mxCellState> for the terminal on the other side of the edge.
         * @param source - Boolean indicating if start is the source terminal state.
         */
        updateFloatingTerminalPoint(edge: any, start: any, end: any, source: any): void;
        /**
         * Returns the floating terminal point for the given edge, start and end
         * state, where start is the source if source is true.
         *
         * @param edge - <mxCellState> whose terminal point should be returned.
         * @param start - <mxCellState> for the terminal on "this" side of the edge.
         * @param end - <mxCellState> for the terminal on the other side of the edge.
         * @param source - Boolean indicating if start is the source terminal state.
         */
        getFloatingTerminalPoint(edge: any, start: any, end: any, source: any): mxPoint;
        /**
         * Returns an <mxCellState> that represents the source or target terminal or
         * port for the given edge.
         *
         * @param state - <mxCellState> that represents the state of the edge.
         * @param terminal - <mxCellState> that represents the terminal.
         * @param source - Boolean indicating if the given terminal is the source terminal.
         */
        getTerminalPort(state: any, terminal: any, source: any): any;
        /**
         * Returns an <mxPoint> that defines the location of the intersection point between
         * the perimeter and the line between the center of the shape and the given point.
         *
         * @param terminal - <mxCellState> for the source or target terminal.
         * @param next - <mxPoint> that lies outside of the given terminal.
         * @param orthogonal - Boolean that specifies if the orthogonal projection onto
         * the perimeter should be returned. If this is false then the intersection
         * of the perimeter and the line between the next and the center point is
         * returned.
         * @param border - Optional border between the perimeter and the shape.
         */
        getPerimeterPoint(terminal: mxCellState, next: mxPoint, orthogonal: boolean, border?: number): mxPoint;
        /**
         * Returns the x-coordinate of the center point for automatic routing.
         */
        getRoutingCenterX(state: any): any;
        /**
         * Returns the y-coordinate of the center point for automatic routing.
         */
        getRoutingCenterY(state: any): any;
        /**
         * Returns the perimeter bounds for the given terminal, edge pair as an
         * <mxRectangle>.
         *
         * If you have a model where each terminal has a relative child that should
         * act as the graphical endpoint for a connection from/to the terminal, then
         * this method can be replaced as follows:
         *
         * (code)
         * var oldGetPerimeterBounds = mxGraphView.prototype.getPerimeterBounds;
         * mxGraphView.prototype.getPerimeterBounds = function(terminal, edge, isSource)
         * {
         *   var model = this.graph.getModel();
         *   var childCount = model.getChildCount(terminal.cell);
         *
         *   if (childCount > 0)
         *   {
         *     var child = model.getChildAt(terminal.cell, 0);
         *     var geo = model.getGeometry(child);
         *
         *     if (geo != null &&
         *         geo.relative)
         *     {
         *       var state = this.getState(child);
         *
         *       if (state != null)
         *       {
         *         terminal = state;
         *       }
         *     }
         *   }
         *
         *   return oldGetPerimeterBounds.apply(this, arguments);
         * };
         * (end)
         *
         * @param terminal - <mxCellState> that represents the terminal.
         * @param border - Number that adds a border between the shape and the perimeter.
         */
        getPerimeterBounds(terminal: mxCellState, border?: number): mxRectangle;
        /**
         * Returns the perimeter function for the given state.
         *
         * @param state
         */
        getPerimeterFunction(state: mxCellState): any;
        /**
         * Returns the nearest point in the list of absolute points or the center
         * of the opposite terminal.
         *
         * @param edge - <mxCellState> that represents the edge.
         * @param opposite - <mxCellState> that represents the opposite terminal.
         * @param source - Boolean indicating if the next point for the source or target
         * @param should be returned.
         */
        getNextPoint(edge: any, opposite: any, source: any): any;
        /**
         * Returns the nearest ancestor terminal that is visible. The edge appears
         * to be connected to this terminal on the display. The result of this method
         * is cached in <mxCellState.getVisibleTerminalState>.
         *
         * @param edge - <mxCell> whose visible terminal should be returned.
         * @param source - Boolean that specifies if the source or target terminal
         * should be returned.
         */
        getVisibleTerminal(edge: any, source: any): mxCell;
        /**
         * Updates the given state using the bounding box of t
         * he absolute points.
         * Also updates <mxCellState.terminalDistance>, <mxCellState.length> and
         * <mxCellState.segments>.
         *
         * @param state - <mxCellState> whose bounds should be updated.
         */
        updateEdgeBounds(state: any): void;
        /**
         * Returns the absolute point on the edge for the given relative
         * <mxGeometry> as an <mxPoint>. The edge is represented by the given
         * <mxCellState>.
         *
         * @param state - <mxCellState> that represents the state of the parent edge.
         * @param geometry - <mxGeometry> that represents the relative location.
         */
        getPoint(state: any, geometry?: any): mxPoint;
        /**
         * Gets the relative point that describes the given, absolute label
         * position for the given edge state.
         *
         * @param state - <mxCellState> that represents the state of the parent edge.
         * @param x - Specifies the x-coordinate of the absolute label location.
         * @param y - Specifies the y-coordinate of the absolute label location.
         */
        getRelativePoint(edgeState: any, x: any, y: any): mxPoint;
        /**
         * Updates <mxCellState.absoluteOffset> for the given state. The absolute
         * offset is normally used for the position of the edge label. Is is
         * calculated from the geometry as an absolute offset from the center
         * between the two endpoints if the geometry is absolute, or as the
         * relative distance between the center along the line and the absolute
         * orthogonal distance if the geometry is relative.
         *
         * @param state - <mxCellState> whose absolute offset should be updated.
         */
        updateEdgeLabelOffset(state: any): void;
        /**
         * Returns the <mxCellState> for the given cell. If create is true, then
         * the state is created if it does not yet exist.
         *
         * @param cell - <mxCell> for which the <mxCellState> should be returned.
         * @param create - Optional boolean indicating if a new state should be created
         * @param if it does not yet exist. Default is false.
         */
        getState(cell: mxCell, create?: boolean): mxCellState;
        /**
         * Returns <rendering>.
         */
        isRendering(): boolean;
        /**
         * Sets <rendering>.
         *
         * @param value
         */
        setRendering(value: boolean): void;
        /**
         * Returns <allowEval>.
         */
        isAllowEval(): boolean;
        /**
         * Sets <allowEval>.
         *
         * @param value
         */
        setAllowEval(value: boolean): void;
        /**
         * Returns <mxCellState>.
         */
        getState(cell: mxCell): mxCellState;
        /**
         * Returns <states>.
         */
        getStates(): mxDictionary;
        /**
         * Sets <states>.
         *
         * @param value
         */
        setStates(value: mxDictionary): void;
        /**
         * Returns the <mxCellStates> for the given array of <mxCells>. The array
         * contains all states that are not null, that is, the returned array may
         * have less elements than the given array. If no argument is given, then
         * this returns <states>.
         *
         * @param cells
         */
        getCellStates(cells: mxCell[]): any[] | mxDictionary;
        /**
         * Removes and returns the <mxCellState> for the given cell.
         *
         * @param cell - <mxCell> for which the <mxCellState> should be removed.
         */
        removeState(cell: any): any;
        /**
         * Creates and returns an <mxCellState> for the given cell and initializes
         * it using <mxCellRenderer.initialize>.
         *
         * @param cell - <mxCell> for which a new <mxCellState> should be created.
         */
        createState(cell: any): mxCellState;
        /**
         * Returns the DOM node that contains the background-, draw- and
         * overlay- and decoratorpanes.
         */
        getCanvas(): Element;
        /**
         * Returns the DOM node that represents the background layer.
         */
        getBackgroundPane(): HTMLElement;
        /**
         * Returns the DOM node that represents the main drawing layer.
         */
        getDrawPane(): SVGElement;
        /**
         * Returns the DOM node that represents the layer above the drawing layer.
         */
        getOverlayPane(): HTMLElement;
        /**
         * Returns the DOM node that represents the topmost drawing layer.
         */
        getDecoratorPane(): HTMLElement;
        /**
         * Returns true if the event origin is one of the drawing panes or
         * containers of the view.
         */
        isContainerEvent(evt: any): boolean;
        /**
         * Returns true if the event origin is one of the scrollbars of the
         * container in IE. Such events are ignored.
         */
        isScrollEvent(evt: any): boolean;
        /**
         * Initializes the graph event dispatch loop for the specified container
         * and invokes <create> to create the required DOM nodes for the display.
         */
        init(): void;
        /**
         * Installs the required listeners in the container.
         */
        installListeners(): void;
        /**
         * Creates the DOM nodes for the HTML display.
         */
        createHtml(): void;
        /**
         * Updates the size of the HTML canvas.
         */
        updateHtmlCanvasSize(width: any, height: any): void;
        /**
         * Creates and returns a drawing pane in HTML (DIV).
         */
        createHtmlPane(width: any, height: any): HTMLElement;
        /**
         * Creates the DOM nodes for the VML display.
         */
        createVml(): void;
        /**
         * Creates a drawing pane in VML (group).
         */
        createVmlPane(width: any, height: any): HTMLElement;
        /**
         * Creates and returns the DOM nodes for the SVG display.
         */
        createSvg(): void;
        /**
         * Updates the style of the container after installing the SVG DOM elements.
         */
        updateContainerStyle(container: any): void;
        /**
         * Destroys the view and all its resources.
         */
        destroy(): void;
    }
    /**
     * Action to change the current root in a view.
     *
     * Constructor: mxCurrentRootChange
     *
     * Constructs a change of the current root in the given view.
     */
    class mxCurrentRootChange {
        constructor(view: any, root: any);
        /**
         * Changes the current root of the view.
         */
        execute(): void;
    }
    /**
     * A string to affect the display performance and rendering in IE, but not in SVG-based browsers. The parameter is mapped to <dialect>, which may be one of <mxConstants.DIALECT_SVG> for SVG-based browsers,
     * <mxConstants.DIALECT_STRICTHTML> for fastest display mode,
     * <mxConstants.DIALECT_PREFERHTML> for faster display mode,
     * <mxConstants.DIALECT_MIXEDHTML> for fast
     * and <mxConstants.DIALECT_VML> for exact display mode (slowest). The dialects are defined in mxConstants.
     * The default values are DIALECT_SVG for SVG-based browsers and DIALECT_MIXED for IE.
     */
    enum renderingHint {
        /**
        * The display performance is
        * highly improved in IE if the VML is not contained within a VML group
        * element. The lack of a group element only slightly affects the display while
        * panning, but improves the performance by almost a factor of 2, while keeping
        * the display sufficiently accurate. This also allows to render certain shapes as HTML
        * if the display accuracy is not affected, which is implemented by
        * <mxShape.isMixedModeHtml>. This is the default setting and is mapped to
        * DIALECT_MIXEDHTML.
        */
        fast = "fast",
        /**
        * Same as fast, but more expensive shapes are avoided. This is
        * controlled by <mxShape.preferModeHtml>. The default implementation will
        * avoid gradients and rounded rectangles, but more significant shapes, such
        * as rhombus, ellipse, actor and cylinder will be rendered accurately. This
        * setting is mapped to DIALECT_PREFERHTML.
        */
        faster = "faster",
        /**
        * Almost anything will be rendered in Html.This allows for
        * rectangles, labels and images.This setting is mapped to
        * DIALECT_STRICTHTML.
        */
        fastest = "fastest",
        /**
        * exact - If accurate panning is required and if the diagram is small(up
        * to 100 cells), then this value should be used.In this mode, a group is
        * created that contains the VML.This allows for accurate panning and is
        * mapped to DIALECT_VML.
        */
        exact = "exact"
    }
    /**
     * Class: mxGraph
     *
     * Extends <mxEventSource> to implement a graph component for
     * the browser. This is the main class of the package. To activate
     * panning and connections use <setPanning> and <setConnectable>.
     * For rubberband selection you must create a new instance of
     * <mxRubberband>. The following listeners are added to
     * <mouseListeners> by default:
     *
     * - <tooltipHandler>: <mxTooltipHandler> that displays tooltips
     * - <panningHandler>: <mxPanningHandler> for panning and popup menus
     * - <connectionHandler>: <mxConnectionHandler> for creating connections
     * - <graphHandler>: <mxGraphHandler> for moving and cloning cells
     *
     * These listeners will be called in the above order if they are enabled.
     *
     * Background Images:
     *
     * To display a background image, set the image, image width and
     * image height using <setBackgroundImage>. If one of the
     * above values has changed then the <view>'s <mxGraphView.validate>
     * should be invoked.
     *
     * Cell Images:
     *
     * To use images in cells, a shape must be specified in the default
     * vertex style (or any named style). Possible shapes are
     * <mxConstants.SHAPE_IMAGE> and <mxConstants.SHAPE_LABEL>.
     * The code to change the shape used in the default vertex style,
     * the following code is used:
     *
     * (code)
     * var style = graph.getStylesheet().getDefaultVertexStyle();
     * style[mxConstants.STYLE_SHAPE] = mxConstants.SHAPE_IMAGE;
     * (end)
     *
     * For the default vertex style, the image to be displayed can be
     * specified in a cell's style using the <mxConstants.STYLE_IMAGE>
     * key and the image URL as a value, for example:
     *
     * (code)
     * image=http://www.example.com/image.gif
     * (end)
     *
     * For a named style, the the stylename must be the first element
     * of the cell style:
     *
     * (code)
     * stylename;image=http://www.example.com/image.gif
     * (end)
     *
     * A cell style can have any number of key=value pairs added, divided
     * by a semicolon as follows:
     *
     * (code)
     * [stylename;|key=value;]
     * (end)
     *
     * Labels:
     *
     * The cell labels are defined by <getLabel> which uses <convertValueToString>
     * if <labelsVisible> is true. If a label must be rendered as HTML markup, then
     * <isHtmlLabel> should return true for the respective cell. If all labels
     * contain HTML markup, <htmlLabels> can be set to true. NOTE: Enabling HTML
     * labels carries a possible security risk (see the section on security in
     * the manual).
     *
     * If wrapping is needed for a label, then <isHtmlLabel> and <isWrapping> must
     * return true for the cell whose label should be wrapped. See <isWrapping> for
     * an example.
     *
     * If clipping is needed to keep the rendering of a HTML label inside the
     * bounds of its vertex, then <isClipping> should return true for the
     * respective cell.
     *
     * By default, edge labels are movable and vertex labels are fixed. This can be
     * changed by setting <edgeLabelsMovable> and <vertexLabelsMovable>, or by
     * overriding <isLabelMovable>.
     *
     * In-place Editing:
     *
     * In-place editing is started with a doubleclick or by typing F2.
     * Programmatically, <edit> is used to check if the cell is editable
     * (<isCellEditable>) and call <startEditingAtCell>, which invokes
     * <mxCellEditor.startEditing>. The editor uses the value returned
     * by <getEditingValue> as the editing value.
     *
     * After in-place editing, <labelChanged> is called, which invokes
     * <mxGraphModel.setValue>, which in turn calls
     * <mxGraphModel.valueForCellChanged> via <mxValueChange>.
     *
     * The event that triggers in-place editing is passed through to the
     * <cellEditor>, which may take special actions depending on the type of the
     * event or mouse location, and is also passed to <getEditingValue>. The event
     * is then passed back to the event processing functions which can perform
     * specific actions based on the trigger event.
     *
     * Tooltips:
     *
     * Tooltips are implemented by <getTooltip>, which calls <getTooltipForCell>
     * if a cell is under the mousepointer. The default implementation checks if
     * the cell has a getTooltip function and calls it if it exists. Hence, in order
     * to provide custom tooltips, the cell must provide a getTooltip function, or
     * one of the two above functions must be overridden.
     *
     * Typically, for custom cell tooltips, the latter function is overridden as
     * follows:
     *
     * (code)
     * graph.getTooltipForCell = function(cell)
     * {
     *   var label = this.convertValueToString(cell);
     *   return 'Tooltip for '+label;
     * }
     * (end)
     *
     * When using a config file, the function is overridden in the mxGraph section
     * using the following entry:
     *
     * (code)
     * <add as="getTooltipForCell"><![CDATA[
     *   function(cell)
     *   {
     *     var label = this.convertValueToString(cell);
     *     return 'Tooltip for '+label;
     *   }
     * ]]></add>
     * (end)
     *
     * "this" refers to the graph in the implementation, so for example to check if
     * a cell is an edge, you use this.getModel().isEdge(cell)
     *
     * For replacing the default implementation of <getTooltipForCell> (rather than
     * replacing the function on a specific instance), the following code should be
     * used after loading the JavaScript files, but before creating a new mxGraph
     * instance using <mxGraph>:
     *
     * (code)
     * mxGraph.prototype.getTooltipForCell = function(cell)
     * {
     *   var label = this.convertValueToString(cell);
     *   return 'Tooltip for '+label;
     * }
     * (end)
     *
     * Shapes & Styles:
     *
     * The implementation of new shapes is demonstrated in the examples. We'll assume
     * that we have implemented a custom shape with the name BoxShape which we want
     * to use for drawing vertices. To use this shape, it must first be registered in
     * the cell renderer as follows:
     *
     * (code)
     * mxCellRenderer.registerShape('box', BoxShape);
     * (end)
     *
     * The code registers the BoxShape constructor under the name box in the cell
     * renderer of the graph. The shape can now be referenced using the shape-key in
     * a style definition. (The cell renderer contains a set of additional shapes,
     * namely one for each constant with a SHAPE-prefix in <mxConstants>.)
     *
     * Styles are a collection of key, value pairs and a stylesheet is a collection
     * of named styles. The names are referenced by the cellstyle, which is stored
     * in <mxCell.style> with the following format: [stylename;|key=value;]. The
     * string is resolved to a collection of key, value pairs, where the keys are
     * overridden with the values in the string.
     *
     * When introducing a new shape, the name under which the shape is registered
     * must be used in the stylesheet. There are three ways of doing this:
     *
     *   - By changing the default style, so that all vertices will use the new
     * 		shape
     *   - By defining a new style, so that only vertices with the respective
     * 		cellstyle will use the new shape
     *   - By using shape=box in the cellstyle's optional list of key, value pairs
     * 		to be overridden
     *
     * In the first case, the code to fetch and modify the default style for
     * vertices is as follows:
     *
     * (code)
     * var style = graph.getStylesheet().getDefaultVertexStyle();
     * style[mxConstants.STYLE_SHAPE] = 'box';
     * (end)
     *
     * The code takes the default vertex style, which is used for all vertices that
     * do not have a specific cellstyle, and modifies the value for the shape-key
     * in-place to use the new BoxShape for drawing vertices. This is done by
     * assigning the box value in the second line, which refers to the name of the
     * BoxShape in the cell renderer.
     *
     * In the second case, a collection of key, value pairs is created and then
     * added to the stylesheet under a new name. In order to distinguish the
     * shapename and the stylename we'll use boxstyle for the stylename:
     *
     * (code)
     * var style = new Object();
     * style[mxConstants.STYLE_SHAPE] = 'box';
     * style[mxConstants.STYLE_STROKECOLOR] = '#000000';
     * style[mxConstants.STYLE_FONTCOLOR] = '#000000';
     * graph.getStylesheet().putCellStyle('boxstyle', style);
     * (end)
     *
     * The code adds a new style with the name boxstyle to the stylesheet. To use
     * this style with a cell, it must be referenced from the cellstyle as follows:
     *
     * (code)
     * var vertex = graph.insertVertex(parent, null, 'Hello, World!', 20, 20, 80, 20,
     * 				'boxstyle');
     * (end)
     *
     * To summarize, each new shape must be registered in the <mxCellRenderer> with
     * a unique name. That name is then used as the value of the shape-key in a
     * default or custom style. If there are multiple custom shapes, then there
     * should be a separate style for each shape.
     *
     * Inheriting Styles:
     *
     * For fill-, stroke-, gradient-, font- and indicatorColors special keywords
     * can be used. The inherit keyword for one of these colors will inherit the
     * color for the same key from the parent cell. The swimlane keyword does the
     * same, but inherits from the nearest swimlane in the ancestor hierarchy.
     * Finally, the indicated keyword will use the color of the indicator as the
     * color for the given key.
     *
     * Scrollbars:
     *
     * The <containers> overflow CSS property defines if scrollbars are used to
     * display the graph. For values of 'auto' or 'scroll', the scrollbars will
     * be shown. Note that the <resizeContainer> flag is normally not used
     * together with scrollbars, as it will resize the container to match the
     * size of the graph after each change.
     *
     * Multiplicities and Validation:
     *
     * To control the possible connections in mxGraph, <getEdgeValidationError> is
     * used. The default implementation of the function uses <multiplicities>,
     * which is an array of <mxMultiplicity>. Using this class allows to establish
     * simple multiplicities, which are enforced by the graph.
     *
     * The <mxMultiplicity> uses <mxCell.is> to determine for which terminals it
     * applies. The default implementation of <mxCell.is> works with DOM nodes (XML
     * nodes) and checks if the given type parameter matches the nodeName of the
     * node (case insensitive). Optionally, an attributename and value can be
     * specified which are also checked.
     *
     * <getEdgeValidationError> is called whenever the connectivity of an edge
     * changes. It returns an empty string or an error message if the edge is
     * invalid or null if the edge is valid. If the returned string is not empty
     * then it is displayed as an error message.
     *
     * <mxMultiplicity> allows to specify the multiplicity between a terminal and
     * its possible neighbors. For example, if any rectangle may only be connected
     * to, say, a maximum of two circles you can add the following rule to
     * <multiplicities>:
     *
     * (code)
     * graph.multiplicities.push(new mxMultiplicity(
     *   true, 'rectangle', null, null, 0, 2, ['circle'],
     *   'Only 2 targets allowed',
     *   'Only shape targets allowed'));
     * (end)
     *
     * This will display the first error message whenever a rectangle is connected
     * to more than two circles and the second error message if a rectangle is
     * connected to anything but a circle.
     *
     * For certain multiplicities, such as a minimum of 1 connection, which cannot
     * be enforced at cell creation time (unless the cell is created together with
     * the connection), mxGraph offers <validate> which checks all multiplicities
     * for all cells and displays the respective error messages in an overlay icon
     * on the cells.
     *
     * If a cell is collapsed and contains validation errors, a respective warning
     * icon is attached to the collapsed cell.
     *
     * Auto-Layout:
     *
     * For automatic layout, the <getLayout> hook is provided in <mxLayoutManager>.
     * It can be overridden to return a layout algorithm for the children of a
     * given cell.
     *
     * Unconnected edges:
     *
     * The default values for all switches are designed to meet the requirements of
     * general diagram drawing applications. A very typical set of settings to
     * avoid edges that are not connected is the following:
     *
     * (code)
     * graph.setAllowDanglingEdges(false);
     * graph.setDisconnectOnMove(false);
     * (end)
     *
     * Setting the <cloneInvalidEdges> switch to true is optional. This switch
     * controls if edges are inserted after a copy, paste or clone-drag if they are
     * invalid. For example, edges are invalid if copied or control-dragged without
     * having selected the corresponding terminals and allowDanglingEdges is
     * false, in which case the edges will not be cloned if the switch is false.
     *
     * Output:
     *
     * To produce an XML representation for a diagram, the following code can be
     * used.
     *
     * (code)
     * var enc = new mxCodec(mxUtils.createXmlDocument());
     * var node = enc.encode(graph.getModel());
     * (end)
     *
     * This will produce an XML node than can be handled using the DOM API or
     * turned into a string representation using the following code:
     *
     * (code)
     * var xml = mxUtils.getXml(node);
     * (end)
     *
     * To obtain a formatted string, mxUtils.getPrettyXml can be used instead.
     *
     * This string can now be stored in a local persistent storage (for example
     * using Google Gears) or it can be passed to a backend using mxUtils.post as
     * follows. The url variable is the URL of the Java servlet, PHP page or HTTP
     * handler, depending on the server.
     *
     * (code)
     * var xmlString = encodeURIComponent(mxUtils.getXml(node));
     * mxUtils.post(url, 'xml='+xmlString, function(req)
     * {
     *   // Process server response using req of type mxXmlRequest
     * });
     * (end)
     *
     * Input:
     *
     * To load an XML representation of a diagram into an existing graph object
     * mxUtils.load can be used as follows. The url variable is the URL of the Java
     * servlet, PHP page or HTTP handler that produces the XML string.
     *
     * (code)
     * var xmlDoc = mxUtils.load(url).getXml();
     * var node = xmlDoc.documentElement;
     * var dec = new mxCodec(node.ownerDocument);
     * dec.decode(node, graph.getModel());
     * (end)
     *
     * For creating a page that loads the client and a diagram using a single
     * request please refer to the deployment examples in the backends.
     *
     * Functional dependencies:
     *
     * (see images/callgraph.png)
     *
     * Resources:
     *
     * resources/graph - Language resources for mxGraph
     *
     * Group: Events
     *
     * Event: mxEvent.ROOT
     *
     * Fires if the root in the model has changed. This event has no properties.
     *
     * Event: mxEvent.ALIGN_CELLS
     *
     * Fires between begin- and endUpdate in <alignCells>. The <code>cells</code>
     * and <code>align</code> properties contain the respective arguments that were
     * passed to <alignCells>.
     *
     * Event: mxEvent.FLIP_EDGE
     *
     * Fires between begin- and endUpdate in <flipEdge>. The <code>edge</code>
     * property contains the edge passed to <flipEdge>.
     *
     * Event: mxEvent.ORDER_CELLS
     *
     * Fires between begin- and endUpdate in <orderCells>. The <code>cells</code>
     * and <code>back</code> properties contain the respective arguments that were
     * passed to <orderCells>.
     *
     * Event: mxEvent.CELLS_ORDERED
     *
     * Fires between begin- and endUpdate in <cellsOrdered>. The <code>cells</code>
     * and <code>back</code> arguments contain the respective arguments that were
     * passed to <cellsOrdered>.
     *
     * Event: mxEvent.GROUP_CELLS
     *
     * Fires between begin- and endUpdate in <groupCells>. The <code>group</code>,
     * <code>cells</code> and <code>border</code> arguments contain the respective
     * arguments that were passed to <groupCells>.
     *
     * Event: mxEvent.UNGROUP_CELLS
     *
     * Fires between begin- and endUpdate in <ungroupCells>. The <code>cells</code>
     * property contains the array of cells that was passed to <ungroupCells>.
     *
     * Event: mxEvent.REMOVE_CELLS_FROM_PARENT
     *
     * Fires between begin- and endUpdate in <removeCellsFromParent>. The
     * <code>cells</code> property contains the array of cells that was passed to
     * <removeCellsFromParent>.
     *
     * Event: mxEvent.ADD_CELLS
     *
     * Fires between begin- and endUpdate in <addCells>. The <code>cells</code>,
     * <code>parent</code>, <code>index</code>, <code>source</code> and
     * <code>target</code> properties contain the respective arguments that were
     * passed to <addCells>.
     *
     * Event: mxEvent.CELLS_ADDED
     *
     * Fires between begin- and endUpdate in <cellsAdded>. The <code>cells</code>,
     * <code>parent</code>, <code>index</code>, <code>source</code>,
     * <code>target</code> and <code>absolute</code> properties contain the
     * respective arguments that were passed to <cellsAdded>.
     *
     * Event: mxEvent.REMOVE_CELLS
     *
     * Fires between begin- and endUpdate in <removeCells>. The <code>cells</code>
     * and <code>includeEdges</code> arguments contain the respective arguments
     * that were passed to <removeCells>.
     *
     * Event: mxEvent.CELLS_REMOVED
     *
     * Fires between begin- and endUpdate in <cellsRemoved>. The <code>cells</code>
     * argument contains the array of cells that was removed.
     *
     * Event: mxEvent.SPLIT_EDGE
     *
     * Fires between begin- and endUpdate in <splitEdge>. The <code>edge</code>
     * property contains the edge to be splitted, the <code>cells</code>,
     * <code>newEdge</code>, <code>dx</code> and <code>dy</code> properties contain
     * the respective arguments that were passed to <splitEdge>.
     *
     * Event: mxEvent.TOGGLE_CELLS
     *
     * Fires between begin- and endUpdate in <toggleCells>. The <code>show</code>,
     * <code>cells</code> and <code>includeEdges</code> properties contain the
     * respective arguments that were passed to <toggleCells>.
     *
     * Event: mxEvent.FOLD_CELLS
     *
     * Fires between begin- and endUpdate in <foldCells>. The
     * <code>collapse</code>, <code>cells</code> and <code>recurse</code>
     * properties contain the respective arguments that were passed to <foldCells>.
     *
     * Event: mxEvent.CELLS_FOLDED
     *
     * Fires between begin- and endUpdate in cellsFolded. The
     * <code>collapse</code>, <code>cells</code> and <code>recurse</code>
     * properties contain the respective arguments that were passed to
     * <cellsFolded>.
     *
     * Event: mxEvent.UPDATE_CELL_SIZE
     *
     * Fires between begin- and endUpdate in <updateCellSize>. The
     * <code>cell</code> and <code>ignoreChildren</code> properties contain the
     * respective arguments that were passed to <updateCellSize>.
     *
     * Event: mxEvent.RESIZE_CELLS
     *
     * Fires between begin- and endUpdate in <resizeCells>. The <code>cells</code>
     * and <code>bounds</code> properties contain the respective arguments that
     * were passed to <resizeCells>.
     *
     * Event: mxEvent.CELLS_RESIZED
     *
     * Fires between begin- and endUpdate in <cellsResized>. The <code>cells</code>
     * and <code>bounds</code> properties contain the respective arguments that
     * were passed to <cellsResized>.
     *
     * Event: mxEvent.MOVE_CELLS
     *
     * Fires between begin- and endUpdate in <moveCells>. The <code>cells</code>,
     * <code>dx</code>, <code>dy</code>, <code>clone</code>, <code>target</code>
     * and <code>event</code> properties contain the respective arguments that
     * were passed to <moveCells>.
     *
     * Event: mxEvent.CELLS_MOVED
     *
     * Fires between begin- and endUpdate in <cellsMoved>. The <code>cells</code>,
     * <code>dx</code>, <code>dy</code> and <code>disconnect</code> properties
     * contain the respective arguments that were passed to <cellsMoved>.
     *
     * Event: mxEvent.CONNECT_CELL
     *
     * Fires between begin- and endUpdate in <connectCell>. The <code>edge</code>,
     * <code>terminal</code> and <code>source</code> properties contain the
     * respective arguments that were passed to <connectCell>.
     *
     * Event: mxEvent.CELL_CONNECTED
     *
     * Fires between begin- and endUpdate in <cellConnected>. The
     * <code>edge</code>, <code>terminal</code> and <code>source</code> properties
     * contain the respective arguments that were passed to <cellConnected>.
     *
     * Event: mxEvent.REFRESH
     *
     * Fires after <refresh> was executed. This event has no properties.
     *
     * Event: mxEvent.CLICK
     *
     * Fires in <click> after a click event. The <code>event</code> property
     * contains the original mouse event and <code>cell</code> property contains
     * the cell under the mouse or null if the background was clicked.
     *
     * Event: mxEvent.DOUBLE_CLICK
     *
     * Fires in <dblClick> after a double click. The <code>event</code> property
     * contains the original mouse event and the <code>cell</code> property
     * contains the cell under the mouse or null if the background was clicked.
     *
     * Event: mxEvent.GESTURE
     *
     * Fires in <fireGestureEvent> after a touch gesture. The <code>event</code>
     * property contains the original gesture end event and the <code>cell</code>
     * property contains the optional cell associated with the gesture.
     *
     * Event: mxEvent.TAP_AND_HOLD
     *
     * Fires in <tapAndHold> if a tap and hold event was detected. The <code>event</code>
     * property contains the initial touch event and the <code>cell</code> property
     * contains the cell under the mouse or null if the background was clicked.
     *
     * Event: mxEvent.FIRE_MOUSE_EVENT
     *
     * Fires in <fireMouseEvent> before the mouse listeners are invoked. The
     * <code>eventName</code> property contains the event name and the
     * <code>event</code> property contains the <mxMouseEvent>.
     *
     * Event: mxEvent.SIZE
     *
     * Fires after <sizeDidChange> was executed. The <code>bounds</code> property
     * contains the new graph bounds.
     *
     * Event: mxEvent.START_EDITING
     *
     * Fires before the in-place editor starts in <startEditingAtCell>. The
     * <code>cell</code> property contains the cell that is being edited and the
     * <code>event</code> property contains the optional event argument that was
     * passed to <startEditingAtCell>.
     *
     * Event: mxEvent.EDITING_STARTED
     *
     * Fires after the in-place editor starts in <startEditingAtCell>. The
     * <code>cell</code> property contains the cell that is being edited and the
     * <code>event</code> property contains the optional event argument that was
     * passed to <startEditingAtCell>.
     *
     * Event: mxEvent.EDITING_STOPPED
     *
     * Fires after the in-place editor stops in <stopEditing>.
     *
     * Event: mxEvent.LABEL_CHANGED
     *
     * Fires between begin- and endUpdate in <cellLabelChanged>. The
     * <code>cell</code> property contains the cell, the <code>value</code>
     * property contains the new value for the cell, the <code>old</code> property
     * contains the old value and the optional <code>event</code> property contains
     * the mouse event that started the edit.
     *
     * Event: mxEvent.ADD_OVERLAY
     *
     * Fires after an overlay is added in <addCellOverlay>. The <code>cell</code>
     * property contains the cell and the <code>overlay</code> property contains
     * the <mxCellOverlay> that was added.
     *
     * Event: mxEvent.REMOVE_OVERLAY
     *
     * Fires after an overlay is removed in <removeCellOverlay> and
     * <removeCellOverlays>. The <code>cell</code> property contains the cell and
     * the <code>overlay</code> property contains the <mxCellOverlay> that was
     * removed.
     *
     * Constructor: mxGraph
     *
     * Constructs a new mxGraph in the specified container. Model is an optional
     * mxGraphModel. If no model is provided, a new mxGraphModel instance is
     * used as the model. The container must have a valid owner document prior
     * to calling this function in Internet Explorer. RenderHint is a string to
     * affect the display performance and rendering in IE, but not in SVG-based
     * browsers. The parameter is mapped to <dialect>, which may
     * be one of <mxConstants.DIALECT_SVG> for SVG-based browsers,
     * <mxConstants.DIALECT_STRICTHTML> for fastest display mode,
     * <mxConstants.DIALECT_PREFERHTML> for faster display mode,
     * <mxConstants.DIALECT_MIXEDHTML> for fast and <mxConstants.DIALECT_VML>
     * for exact display mode (slowest). The dialects are defined in mxConstants.
     * The default values are DIALECT_SVG for SVG-based browsers and
     * DIALECT_MIXED for IE.
     *
     * The possible values for the renderingHint parameter are explained below:
     *
     * fast - The parameter is based on the fact that the display performance is
     * highly improved in IE if the VML is not contained within a VML group
     * element. The lack of a group element only slightly affects the display while
     * panning, but improves the performance by almost a factor of 2, while keeping
     * the display sufficiently accurate. This also allows to render certain shapes as HTML
     * if the display accuracy is not affected, which is implemented by
     * <mxShape.isMixedModeHtml>. This is the default setting and is mapped to
     * DIALECT_MIXEDHTML.
     * faster - Same as fast, but more expensive shapes are avoided. This is
     * controlled by <mxShape.preferModeHtml>. The default implementation will
     * avoid gradients and rounded rectangles, but more significant shapes, such
     * as rhombus, ellipse, actor and cylinder will be rendered accurately. This
     * setting is mapped to DIALECT_PREFERHTML.
     * fastest - Almost anything will be rendered in Html. This allows for
     * rectangles, labels and images. This setting is mapped to
     * DIALECT_STRICTHTML.
     * exact - If accurate panning is required and if the diagram is small (up
     * to 100 cells), then this value should be used. In this mode, a group is
     * created that contains the VML. This allows for accurate panning and is
     * mapped to DIALECT_VML.
     *
     * Example:
     *
     * To create a graph inside a DOM node with an id of graph:
     * (code)
     * var container = document.getElementById('graph');
     * var graph = new mxGraph(container);
     * (end)
     *
     * Parameters:
     *
     * container - Optional DOM node that acts as a container for the graph.
     * If this is null then the container can be initialized later using
     * <init>.
     * model - Optional <mxGraphModel> that constitutes the graph data.
     * renderHint - Optional string that specifies the display accuracy and
     * performance. Default is mxConstants.DIALECT_MIXEDHTML (for IE).
     * stylesheet - Optional <mxStylesheet> to be used in the graph.
     */
    class mxGraph extends mxEventSource {
        constructor(container?: Element, model?: mxGraphModel, renderHint?: renderingHint, stylesheet?: mxStylesheet);
        /**
         * Variable: mouseListeners
         *
         * Holds the mouse event listeners. See <fireMouseEvent>.
         */
        mouseListeners: any;
        /**
         * Variable: isMouseDown
         *
         * Holds the state of the mouse button.
         */
        isMouseDown: boolean;
        /**
         * Variable: model
         *
         * Holds the <mxGraphModel> that contains the cells to be displayed.
         */
        model: mxGraphModel;
        /**
         * Variable: view
         *
         * Holds the <mxGraphView> that caches the <mxCellStates> for the cells.
         */
        view: mxGraphView;
        /**
         * Variable: stylesheet
         *
         * Holds the <mxStylesheet> that defines the appearance of the cells.
         *
         *
         * Example:
         *
         * Use the following code to read a stylesheet into an existing graph.
         *
         * (code)
         * var req = mxUtils.load('stylesheet.xml');
         * var root = req.getDocumentElement();
         * var dec = new mxCodec(root.ownerDocument);
         * dec.decode(root, graph.stylesheet);
         * (end)
         */
        stylesheet: mxStylesheet;
        /**
         * Variable: selectionModel
         *
         * Holds the <mxGraphSelectionModel> that models the current selection.
         */
        selectionModel: mxGraphSelectionModel;
        /**
         * Variable: cellEditor
         *
         * Holds the <mxCellEditor> that is used as the in-place editing.
         */
        cellEditor: mxCellEditor;
        /**
         * Variable: cellRenderer
         *
         * Holds the <mxCellRenderer> for rendering the cells in the graph.
         */
        cellRenderer: mxCellRenderer;
        /**
         * Variable: multiplicities
         *
         * An array of <mxMultiplicities> describing the allowed
         * connections in a graph.
         */
        multiplicities: mxMultiplicity[];
        /**
         * Variable: renderHint
         *
         * RenderHint as it was passed to the constructor.
         */
        renderHint: any;
        /**
         * Variable: dialect
         *
         * Dialect to be used for drawing the graph. Possible values are all
         * constants in <mxConstants> with a DIALECT-prefix.
         */
        dialect: any;
        /**
         * Variable: gridSize
         *
         * Specifies the grid size. Default is 10.
         */
        gridSize: number;
        /**
         * Variable: gridEnabled
         *
         * Specifies if the grid is enabled. This is used in <snap>. Default is
         * true.
         */
        gridEnabled: boolean;
        /**
         * Variable: portsEnabled
         *
         * Specifies if ports are enabled. This is used in <cellConnected> to update
         * the respective style. Default is true.
         */
        portsEnabled: boolean;
        /**
         * Variable: nativeDoubleClickEnabled
         *
         * Specifies if native double click events should be detected. Default is true.
         */
        nativeDblClickEnabled: boolean;
        /**
         * Variable: doubleTapEnabled
         *
         * Specifies if double taps on touch-based devices should be handled as a
         * double click. Default is true.
         */
        doubleTapEnabled: boolean;
        /**
         * Variable: doubleTapTimeout
         *
         * Specifies the timeout for double taps and non-native double clicks. Default
         * is 500 ms.
         */
        doubleTapTimeout: number;
        /**
         * Variable: doubleTapTolerance
         *
         * Specifies the tolerance for double taps and double clicks in quirks mode.
         * Default is 25 pixels.
         */
        doubleTapTolerance: number;
        /**
         * Variable: lastTouchX
         *
         * Holds the x-coordinate of the last touch event for double tap detection.
         */
        lastTouchX: number;
        /**
         * Variable: lastTouchX
         *
         * Holds the y-coordinate of the last touch event for double tap detection.
         */
        lastTouchY: number;
        /**
         * Variable: lastTouchTime
         *
         * Holds the time of the last touch event for double click detection.
         */
        lastTouchTime: number;
        /**
         * Variable: tapAndHoldEnabled
         *
         * Specifies if tap and hold should be used for starting connections on touch-based
         * devices. Default is true.
         */
        tapAndHoldEnabled: boolean;
        /**
         * Variable: tapAndHoldDelay
         *
         * Specifies the time for a tap and hold. Default is 500 ms.
         */
        tapAndHoldDelay: number;
        /**
         * Variable: tapAndHoldInProgress
         *
         * True if the timer for tap and hold events is running.
         */
        tapAndHoldInProgress: boolean;
        /**
         * Variable: tapAndHoldValid
         *
         * True as long as the timer is running and the touch events
         * stay within the given <tapAndHoldTolerance>.
         */
        tapAndHoldValid: boolean;
        /**
         * Variable: initialTouchX
         *
         * Holds the x-coordinate of the intial touch event for tap and hold.
         */
        initialTouchX: number;
        /**
         * Variable: initialTouchY
         *
         * Holds the y-coordinate of the intial touch event for tap and hold.
         */
        initialTouchY: number;
        /**
         * Variable: tolerance
         *
         * Tolerance for a move to be handled as a single click.
         * Default is 4 pixels.
         */
        tolerance: number;
        /**
         * Variable: defaultOverlap
         *
         * Value returned by <getOverlap> if <isAllowOverlapParent> returns
         * true for the given cell. <getOverlap> is used in <constrainChild> if
         * <isConstrainChild> returns true. The value specifies the
         * portion of the child which is allowed to overlap the parent.
         */
        defaultOverlap: number;
        /**
         * Variable: defaultParent
         *
         * Specifies the default parent to be used to insert new cells.
         * This is used in <getDefaultParent>. Default is null.
         */
        defaultParent: mxCell;
        /**
         * Variable: alternateEdgeStyle
         *
         * Specifies the alternate edge style to be used if the main control point
         * on an edge is being doubleclicked. Default is null.
         */
        alternateEdgeStyle: any;
        /**
         * Variable: backgroundImage
         *
         * Specifies the <mxImage> to be returned by <getBackgroundImage>. Default
         * is null.
         *
         * Example:
         *
         * (code)
         * var img = new mxImage('http://www.example.com/maps/examplemap.jpg', 1024, 768);
         * graph.setBackgroundImage(img);
         * graph.view.validate();
         * (end)
         */
        backgroundImage: mxImage;
        /**
         * Variable: pageVisible
         *
         * Specifies if the background page should be visible. Default is false.
         * Not yet implemented.
         */
        pageVisible: boolean;
        /**
         * Variable: pageBreaksVisible
         *
         * Specifies if a dashed line should be drawn between multiple pages. Default
         * is false. If you change this value while a graph is being displayed then you
         * should call <sizeDidChange> to force an update of the display.
         */
        pageBreaksVisible: boolean;
        /**
         * Variable: pageBreakColor
         *
         * Specifies the color for page breaks. Default is 'gray'.
         */
        pageBreakColor: string;
        /**
         * Variable: pageBreakDashed
         *
         * Specifies the page breaks should be dashed. Default is true.
         */
        pageBreakDashed: boolean;
        /**
         * Variable: minPageBreakDist
         *
         * Specifies the minimum distance for page breaks to be visible. Default is
         * 20 (in pixels).
         */
        minPageBreakDist: number;
        /**
         * Variable: preferPageSize
         *
         * Specifies if the graph size should be rounded to the next page number in
         * <sizeDidChange>. This is only used if the graph container has scrollbars.
         * Default is false.
         */
        preferPageSize: boolean;
        /**
         * Variable: pageFormat
         *
         * Specifies the page format for the background page. Default is
         * <mxConstants.PAGE_FORMAT_A4_PORTRAIT>. This is used as the default in
         * <mxPrintPreview> and for painting the background page if <pageVisible> is
         * true and the pagebreaks if <pageBreaksVisible> is true.
         */
        pageFormat: mxRectangle;
        /**
         * Variable: pageScale
         *
         * Specifies the scale of the background page. Default is 1.5.
         * Not yet implemented.
         */
        pageScale: number;
        /**
         * Variable: enabled
         *
         * Specifies the return value for <isEnabled>. Default is true.
         */
        enabled: boolean;
        /**
         * Variable: escapeEnabled
         *
         * Specifies if <mxKeyHandler> should invoke <escape> when the escape key
         * is pressed. Default is true.
         */
        escapeEnabled: boolean;
        /**
         * Variable: invokesStopCellEditing
         *
         * If true, when editing is to be stopped by way of selection changing,
         * data in diagram changing or other means stopCellEditing is invoked, and
         * changes are saved. This is implemented in a focus handler in
         * <mxCellEditor>. Default is true.
         */
        invokesStopCellEditing: boolean;
        /**
         * Variable: enterStopsCellEditing
         *
         * If true, pressing the enter key without pressing control or shift will stop
         * editing and accept the new value. This is used in <mxCellEditor> to stop
         * cell editing. Note: You can always use F2 and escape to stop editing.
         * Default is false.
         */
        enterStopsCellEditing: boolean;
        /**
         * Variable: useScrollbarsForPanning
         *
         * Specifies if scrollbars should be used for panning in <panGraph> if
         * any scrollbars are available. If scrollbars are enabled in CSS, but no
         * scrollbars appear because the graph is smaller than the container size,
         * then no panning occurs if this is true. Default is true.
         */
        useScrollbarsForPanning: boolean;
        /**
         * Variable: exportEnabled
         *
         * Specifies the return value for <canExportCell>. Default is true.
         */
        exportEnabled: boolean;
        /**
         * Variable: importEnabled
         *
         * Specifies the return value for <canImportCell>. Default is true.
         */
        importEnabled: boolean;
        /**
         * Variable: cellsLocked
         *
         * Specifies the return value for <isCellLocked>. Default is false.
         */
        cellsLocked: boolean;
        /**
         * Variable: cellsCloneable
         *
         * Specifies the return value for <isCellCloneable>. Default is true.
         */
        cellsCloneable: boolean;
        /**
         * Variable: foldingEnabled
         *
         * Specifies if folding (collapse and expand via an image icon in the graph
         * should be enabled). Default is true.
         */
        foldingEnabled: boolean;
        /**
         * Variable: cellsEditable
         *
         * Specifies the return value for <isCellEditable>. Default is true.
         */
        cellsEditable: boolean;
        /**
         * Variable: cellsDeletable
         *
         * Specifies the return value for <isCellDeletable>. Default is true.
         */
        cellsDeletable: boolean;
        /**
         * Variable: cellsMovable
         *
         * Specifies the return value for <isCellMovable>. Default is true.
         */
        cellsMovable: boolean;
        /**
         * Variable: edgeLabelsMovable
         *
         * Specifies the return value for edges in <isLabelMovable>. Default is true.
         */
        edgeLabelsMovable: boolean;
        /**
         * Variable: vertexLabelsMovable
         *
         * Specifies the return value for vertices in <isLabelMovable>. Default is false.
         */
        vertexLabelsMovable: boolean;
        /**
         * Variable: dropEnabled
         *
         * Specifies the return value for <isDropEnabled>. Default is false.
         */
        dropEnabled: boolean;
        /**
         * Variable: splitEnabled
         *
         * Specifies if dropping onto edges should be enabled. This is ignored if
         * <dropEnabled> is false. If enabled, it will call <splitEdge> to carry
         * out the drop operation. Default is true.
         */
        splitEnabled: boolean;
        /**
         * Variable: cellsResizable
         *
         * Specifies the return value for <isCellResizable>. Default is true.
         */
        cellsResizable: boolean;
        /**
         * Variable: cellsBendable
         *
         * Specifies the return value for <isCellsBendable>. Default is true.
         */
        cellsBendable: boolean;
        /**
         * Variable: cellsSelectable
         *
         * Specifies the return value for <isCellSelectable>. Default is true.
         */
        cellsSelectable: boolean;
        /**
         * Variable: cellsDisconnectable
         *
         * Specifies the return value for <isCellDisconntable>. Default is true.
         */
        cellsDisconnectable: boolean;
        /**
         * Variable: autoSizeCells
         *
         * Specifies if the graph should automatically update the cell size after an
         * edit. This is used in <isAutoSizeCell>. Default is false.
         */
        autoSizeCells: boolean;
        /**
         * Variable: autoSizeCellsOnAdd
         *
         * Specifies if autoSize style should be applied when cells are added. Default is false.
         */
        autoSizeCellsOnAdd: boolean;
        /**
         * Variable: autoScroll
         *
         * Specifies if the graph should automatically scroll if the mouse goes near
         * the container edge while dragging. This is only taken into account if the
         * container has scrollbars. Default is true.
         *
         * If you need this to work without scrollbars then set <ignoreScrollbars> to
         * true. Please consult the <ignoreScrollbars> for details. In general, with
         * no scrollbars, the use of <allowAutoPanning> is recommended.
         */
        autoScroll: boolean;
        /**
         * Variable: ignoreScrollbars
         *
         * Specifies if the graph should automatically scroll regardless of the
         * scrollbars. This will scroll the container using positive values for
         * scroll positions (ie usually only rightwards and downwards). To avoid
         * possible conflicts with panning, set <translateToScrollPosition> to true.
         */
        ignoreScrollbars: boolean;
        /**
         * Variable: translateToScrollPosition
         *
         * Specifies if the graph should automatically convert the current scroll
         * position to a translate in the graph view when a mouseUp event is received.
         * This can be used to avoid conflicts when using <autoScroll> and
         * <ignoreScrollbars> with no scrollbars in the container.
         */
        translateToScrollPosition: boolean;
        /**
         * Variable: timerAutoScroll
         *
         * Specifies if autoscrolling should be carried out via mxPanningManager even
         * if the container has scrollbars. This disables <scrollPointToVisible> and
         * uses <mxPanningManager> instead. If this is true then <autoExtend> is
         * disabled. It should only be used with a scroll buffer or when scollbars
         * are visible and scrollable in all directions. Default is false.
         */
        timerAutoScroll: boolean;
        /**
         * Variable: allowAutoPanning
         *
         * Specifies if panning via <panGraph> should be allowed to implement autoscroll
         * if no scrollbars are available in <scrollPointToVisible>. To enable panning
         * inside the container, near the edge, set <mxPanningManager.border> to a
         * positive value. Default is false.
         */
        allowAutoPanning: boolean;
        /**
         * Variable: autoExtend
         *
         * Specifies if the size of the graph should be automatically extended if the
         * mouse goes near the container edge while dragging. This is only taken into
         * account if the container has scrollbars. Default is true. See <autoScroll>.
         */
        autoExtend: boolean;
        /**
         * Variable: maximumGraphBounds
         *
         * <mxRectangle> that specifies the area in which all cells in the diagram
         * should be placed. Uses in <getMaximumGraphBounds>. Use a width or height of
         * 0 if you only want to give a upper, left corner.
         */
        maximumGraphBounds: mxRectangle;
        /**
         * Variable: minimumGraphSize
         *
         * <mxRectangle> that specifies the minimum size of the graph. This is ignored
         * if the graph container has no scrollbars. Default is null.
         */
        minimumGraphSize: mxRectangle;
        /**
         * Variable: minimumContainerSize
         *
         * <mxRectangle> that specifies the minimum size of the <container> if
         * <resizeContainer> is true.
         */
        minimumContainerSize: mxRectangle;
        /**
         * Variable: maximumContainerSize
         *
         * <mxRectangle> that specifies the maximum size of the container if
         * <resizeContainer> is true.
         */
        maximumContainerSize: mxRectangle;
        /**
         * Variable: resizeContainer
         *
         * Specifies if the container should be resized to the graph size when
         * the graph size has changed. Default is false.
         */
        resizeContainer: boolean;
        /**
         * Variable: border
         *
         * Border to be added to the bottom and right side when the container is
         * being resized after the graph has been changed. Default is 0.
         */
        border: number;
        /**
         * Variable: keepEdgesInForeground
         *
         * Specifies if edges should appear in the foreground regardless of their order
         * in the model. If <keepEdgesInForeground> and <keepEdgesInBackground> are
         * both true then the normal order is applied. Default is false.
         */
        keepEdgesInForeground: boolean;
        /**
         * Variable: keepEdgesInBackground
         *
         * Specifies if edges should appear in the background regardless of their order
         * in the model. If <keepEdgesInForeground> and <keepEdgesInBackground> are
         * both true then the normal order is applied. Default is false.
         */
        keepEdgesInBackground: boolean;
        /**
         * Variable: allowNegativeCoordinates
         *
         * Specifies if negative coordinates for vertices are allowed. Default is true.
         */
        allowNegativeCoordinates: boolean;
        /**
         * Variable: constrainChildren
         *
         * Specifies if a child should be constrained inside the parent bounds after a
         * move or resize of the child. Default is true.
         */
        constrainChildren: boolean;
        /**
         * Variable: constrainRelativeChildren
         *
         * Specifies if child cells with relative geometries should be constrained
         * inside the parent bounds, if <constrainChildren> is true, and/or the
         * <maximumGraphBounds>. Default is false.
         */
        constrainRelativeChildren: boolean;
        /**
         * Variable: extendParents
         *
         * Specifies if a parent should contain the child bounds after a resize of
         * the child. Default is true. This has precedence over <constrainChildren>.
         */
        extendParents: boolean;
        /**
         * Variable: extendParentsOnAdd
         *
         * Specifies if parents should be extended according to the <extendParents>
         * switch if cells are added. Default is true.
         */
        extendParentsOnAdd: boolean;
        /**
         * Variable: extendParentsOnAdd
         *
         * Specifies if parents should be extended according to the <extendParents>
         * switch if cells are added. Default is false for backwards compatiblity.
         */
        extendParentsOnMove: boolean;
        /**
         * Variable: recursiveResize
         *
         * Specifies the return value for <isRecursiveResize>. Default is
         * false for backwards compatiblity.
         */
        recursiveResize: boolean;
        /**
         * Variable: collapseToPreferredSize
         *
         * Specifies if the cell size should be changed to the preferred size when
         * a cell is first collapsed. Default is true.
         */
        collapseToPreferredSize: boolean;
        /**
         * Variable: zoomFactor
         *
         * Specifies the factor used for <zoomIn> and <zoomOut>. Default is 1.2
         * (120%).
         */
        zoomFactor: number;
        /**
         * Variable: keepSelectionVisibleOnZoom
         *
         * Specifies if the viewport should automatically contain the selection cells
         * after a zoom operation. Default is false.
         */
        keepSelectionVisibleOnZoom: boolean;
        /**
         * Variable: centerZoom
         *
         * Specifies if the zoom operations should go into the center of the actual
         * diagram rather than going from top, left. Default is true.
         */
        centerZoom: boolean;
        /**
         * Variable: resetViewOnRootChange
         *
         * Specifies if the scale and translate should be reset if the root changes in
         * the model. Default is true.
         */
        resetViewOnRootChange: boolean;
        /**
         * Variable: resetEdgesOnResize
         *
         * Specifies if edge control points should be reset after the resize of a
         * connected cell. Default is false.
         */
        resetEdgesOnResize: boolean;
        /**
         * Variable: resetEdgesOnMove
         *
         * Specifies if edge control points should be reset after the move of a
         * connected cell. Default is false.
         */
        resetEdgesOnMove: boolean;
        /**
         * Variable: resetEdgesOnConnect
         *
         * Specifies if edge control points should be reset after the the edge has been
         * reconnected. Default is true.
         */
        resetEdgesOnConnect: boolean;
        /**
         * Variable: allowLoops
         *
         * Specifies if loops (aka self-references) are allowed. Default is false.
         */
        allowLoops: boolean;
        /**
         * Variable: defaultLoopStyle
         *
         * <mxEdgeStyle> to be used for loops. This is a fallback for loops if the
         * <mxConstants.STYLE_LOOP> is undefined. Default is <mxEdgeStyle.Loop>.
         */
        defaultLoopStyle: any;
        /**
         * Variable: multigraph
         *
         * Specifies if multiple edges in the same direction between the same pair of
         * vertices are allowed. Default is true.
         */
        multigraph: boolean;
        /**
         * Variable: connectableEdges
         *
         * Specifies if edges are connectable. Default is false. This overrides the
         * connectable field in edges.
         */
        connectableEdges: boolean;
        /**
         * Variable: allowDanglingEdges
         *
         * Specifies if edges with disconnected terminals are allowed in the graph.
         * Default is true.
         */
        allowDanglingEdges: boolean;
        /**
         * Variable: cloneInvalidEdges
         *
         * Specifies if edges that are cloned should be validated and only inserted
         * if they are valid. Default is true.
         */
        cloneInvalidEdges: boolean;
        /**
         * Variable: disconnectOnMove
         *
         * Specifies if edges should be disconnected from their terminals when they
         * are moved. Default is true.
         */
        disconnectOnMove: boolean;
        /**
         * Variable: labelsVisible
         *
         * Specifies if labels should be visible. This is used in <getLabel>. Default
         * is true.
         */
        labelsVisible: boolean;
        /**
         * Variable: htmlLabels
         *
         * Specifies the return value for <isHtmlLabel>. Default is false.
         */
        htmlLabels: boolean;
        /**
         * Variable: swimlaneSelectionEnabled
         *
         * Specifies if swimlanes should be selectable via the content if the
         * mouse is released. Default is true.
         */
        swimlaneSelectionEnabled: boolean;
        /**
         * Variable: swimlaneNesting
         *
         * Specifies if nesting of swimlanes is allowed. Default is true.
         */
        swimlaneNesting: boolean;
        /**
         * Variable: swimlaneIndicatorColorAttribute
         *
         * The attribute used to find the color for the indicator if the indicator
         * color is set to 'swimlane'. Default is <mxConstants.STYLE_FILLCOLOR>.
         */
        swimlaneIndicatorColorAttribute: string;
        /**
         * Variable: imageBundles
         *
         * Holds the list of image bundles.
         */
        imageBundles: any;
        /**
         * Variable: minFitScale
         *
         * Specifies the minimum scale to be applied in <fit>. Default is 0.1. Set this
         * to null to allow any value.
         */
        minFitScale: number;
        /**
         * Variable: maxFitScale
         *
         * Specifies the maximum scale to be applied in <fit>. Default is 8. Set this
         * to null to allow any value.
         */
        maxFitScale: number;
        /**
         * Variable: panDx
         *
         * Current horizontal panning value. Default is 0.
         */
        panDx: number;
        /**
         * Variable: panDy
         *
         * Current vertical panning value. Default is 0.
         */
        panDy: number;
        /**
         * Variable: collapsedImage
         *
         * Specifies the <mxImage> to indicate a collapsed state.
         * Default value is mxClient.imageBasePath + '/collapsed.gif'
         */
        collapsedImage: mxImage;
        /**
         * Variable: expandedImage
         *
         * Specifies the <mxImage> to indicate a expanded state.
         * Default value is mxClient.imageBasePath + '/expanded.gif'
         */
        expandedImage: mxImage;
        /**
         * Variable: warningImage
         *
         * Specifies the <mxImage> for the image to be used to display a warning
         * overlay. See <setCellWarning>. Default value is mxClient.imageBasePath +
         * '/warning'.  The extension for the image depends on the platform. It is
         * '.png' on the Mac and '.gif' on all other platforms.
         */
        warningImage: mxImage;
        /**
         * Variable: alreadyConnectedResource
         *
         * Specifies the resource key for the error message to be displayed in
         * non-multigraphs when two vertices are already connected. If the resource
         * for this key does not exist then the value is used as the error message.
         * Default is 'alreadyConnected'.
         */
        alreadyConnectedResource: string;
        /**
         * Variable: containsValidationErrorsResource
         *
         * Specifies the resource key for the warning message to be displayed when
         * a collapsed cell contains validation errors. If the resource for this
         * key does not exist then the value is used as the warning message.
         * Default is 'containsValidationErrors'.
         */
        containsValidationErrorsResource: string;
        /**
         * Variable: collapseExpandResource
         *
         * Specifies the resource key for the tooltip on the collapse/expand icon.
         * If the resource for this key does not exist then the value is used as
         * the tooltip. Default is 'collapse-expand'.
         */
        collapseExpandResource: string;
        container: HTMLElement;
        tooltipHandler: mxTooltipHandler;
        selectionCellsHandler: mxSelectionCellsHandler;
        connectionHandler: mxConnectionHandler;
        graphHandler: mxGraphHandler;
        panningHandler: mxPanningHandler;
        popupMenuHandler: mxPopupMenuHandler;
        panningManager: typeof mxPanningManager;
        horizontalPageBreaks: any[];
        verticalPageBreaks: any[];
        graphModelChangeListener: any;
        shiftPreview1: HTMLDivElement;
        shiftPreview2: HTMLDivElement;
        lastEvent: any;
        mouseMoveRedirect: any;
        mouseUpRedirect: any;
        isMouseTrigger: boolean;
        lastMouseX: number;
        lastMouseY: number;
        ignoreMouseEvents: boolean;
        fireDoubleClick: any;
        lastTouchEvent: any;
        doubleClickCounter: number;
        lastTouchCell: any;
        tapAndHoldThread: any;
        destroyed: boolean;
        /**
         * Function: init
         *
         * Initializes the <container> and creates the respective datastructures.
         *
         * Parameters:
         *
         * container - DOM node that will contain the graph display.
         */
        init(container: HTMLElement): void;
        /**
         * Function: createHandlers
         *
         * Creates the tooltip-, panning-, connection- and graph-handler (in this
         * order). This is called in the constructor before <init> is called.
         */
        createHandlers(): void;
        /**
         * Function: createTooltipHandler
         *
         * Creates and returns a new <mxTooltipHandler> to be used in this graph.
         */
        createTooltipHandler(): mxTooltipHandler;
        /**
         * Function: createSelectionCellsHandler
         *
         * Creates and returns a new <mxSelectionCellsHandler> to be used in this graph.
         */
        createSelectionCellsHandler(): mxSelectionCellsHandler;
        /**
         * Function: createConnectionHandler
         *
         * Creates and returns a new <mxConnectionHandler> to be used in this graph.
         */
        createConnectionHandler(): mxConnectionHandler;
        /**
         * Function: createGraphHandler
         *
         * Creates and returns a new <mxGraphHandler> to be used in this graph.
         */
        createGraphHandler(): mxGraphHandler;
        /**
         * Function: createPanningHandler
         *
         * Creates and returns a new <mxPanningHandler> to be used in this graph.
         */
        createPanningHandler(): mxPanningHandler;
        /**
         * Function: createPopupMenuHandler
         *
         * Creates and returns a new <mxPopupMenuHandler> to be used in this graph.
         */
        createPopupMenuHandler(): mxPopupMenuHandler;
        /**
         * Function: createSelectionModel
         *
         * Creates a new <mxGraphSelectionModel> to be used in this graph.
         */
        createSelectionModel(): mxGraphSelectionModel;
        /**
         * Function: createStylesheet
         *
         * Creates a new <mxStylesheet> to be used in this graph.
         */
        createStylesheet(): mxStylesheet;
        /**
         * Function: createGraphView
         *
         * Creates a new <mxGraphView> to be used in this graph.
         */
        createGraphView(): mxGraphView;
        /**
         * Function: createCellRenderer
         *
         * Creates a new <mxCellRenderer> to be used in this graph.
         */
        createCellRenderer(): mxCellRenderer;
        /**
         * Function: createCellEditor
         *
         * Creates a new <mxCellEditor> to be used in this graph.
         */
        createCellEditor(): mxCellEditor;
        /**
         * Function: getModel
         *
         * Returns the <mxGraphModel> that contains the cells.
         */
        getModel(): mxGraphModel;
        /**
         * Function: getView
         *
         * Returns the <mxGraphView> that contains the <mxCellStates>.
         */
        getView(): mxGraphView;
        /**
         * Function: getStylesheet
         *
         * Returns the <mxStylesheet> that defines the style.
         */
        getStylesheet(): mxStylesheet;
        /**
         * Function: setStylesheet
         *
         * Sets the <mxStylesheet> that defines the style.
         */
        setStylesheet(stylesheet: mxStylesheet): void;
        /**
         * Function: getSelectionModel
         *
         * Returns the <mxGraphSelectionModel> that contains the selection.
         */
        getSelectionModel(): mxGraphSelectionModel;
        /**
         * Function: setSelectionModel
         *
         * Sets the <mxSelectionModel> that contains the selection.
         */
        setSelectionModel(selectionModel: mxGraphSelectionModel): void;
        /**
         * Function: getSelectionCellsForChanges
         *
         * Returns the cells to be selected for the given array of changes.
         *
         * Parameters:
         *
         * ignoreFn - Optional function that takes a change and returns true if the
         * change should be ignored.
         *
         */
        getSelectionCellsForChanges(changes: any, ignoreFn?: any): mxCell[];
        /**
         * Function: graphModelChanged
         *
         * Called when the graph model changes. Invokes <processChange> on each
         * item of the given array to update the view accordingly.
         *
         * Parameters:
         *
         * changes - Array that contains the individual changes.
         */
        graphModelChanged(changes: any[]): void;
        /**
         * Function: updateSelection
         *
         * Removes selection cells that are not in the model from the selection.
         */
        updateSelection(): void;
        /**
         * Function: processChange
         *
         * Processes the given change and invalidates the respective cached data
         * in <view>. This fires a <root> event if the root has changed in the
         * model.
         *
         * Parameters:
         *
         * change - Object that represents the change on the model.
         */
        processChange(change: any): void;
        /**
         * Function: removeStateForCell
         *
         * Removes all cached information for the given cell and its descendants.
         * This is called when a cell was removed from the model.
         *
         * Paramters:
         *
         * cell - <mxCell> that was removed from the model.
         */
        removeStateForCell(cell: mxCell): void;
        /**
         * Group: Overlays
         */
        /**
         * Function: addCellOverlay
         *
         * Adds an <mxCellOverlay> for the specified cell. This method fires an
         * <addoverlay> event and returns the new <mxCellOverlay>.
         *
         * Parameters:
         *
         * cell - <mxCell> to add the overlay for.
         * overlay - <mxCellOverlay> to be added for the cell.
         */
        addCellOverlay(cell: mxCell, overlay: mxCellOverlay): mxCellOverlay;
        /**
         * Function: getCellOverlays
         *
         * Returns the array of <mxCellOverlays> for the given cell or null, if
         * no overlays are defined.
         *
         * Parameters:
         *
         * cell - <mxCell> whose overlays should be returned.
         */
        getCellOverlays(cell: mxCell): mxCellOverlay[];
        /**
         * Function: removeCellOverlay
         *
         * Removes and returns the given <mxCellOverlay> from the given cell. This
         * method fires a <removeoverlay> event. If no overlay is given, then all
         * overlays are removed using <removeOverlays>.
         *
         * Parameters:
         *
         * cell - <mxCell> whose overlay should be removed.
         * overlay - Optional <mxCellOverlay> to be removed.
         */
        removeCellOverlay(cell: mxCell, overlay: mxCellOverlay): mxCellOverlay;
        /**
         * Function: removeCellOverlays
         *
         * Removes all <mxCellOverlays> from the given cell. This method
         * fires a <removeoverlay> event for each <mxCellOverlay> and returns
         * the array of <mxCellOverlays> that was removed from the cell.
         *
         * Parameters:
         *
         * cell - <mxCell> whose overlays should be removed
         */
        removeCellOverlays(cell: mxCell): mxCellOverlay[];
        /**
         * Function: clearCellOverlays
         *
         * Removes all <mxCellOverlays> in the graph for the given cell and all its
         * descendants. If no cell is specified then all overlays are removed from
         * the graph. This implementation uses <removeCellOverlays> to remove the
         * overlays from the individual cells.
         *
         * Parameters:
         *
         * cell - Optional <mxCell> that represents the root of the subtree to
         * remove the overlays from. Default is the root in the model.
         */
        clearCellOverlays(cell?: mxCell): void;
        /**
         * Function: setCellWarning
         *
         * Creates an overlay for the given cell using the warning and image or
         * <warningImage> and returns the new <mxCellOverlay>. The warning is
         * displayed as a tooltip in a red font and may contain HTML markup. If
         * the warning is null or a zero length string, then all overlays are
         * removed from the cell.
         *
         * Example:
         *
         * (code)
         * graph.setCellWarning(cell, '<b>Warning:</b>: Hello, World!');
         * (end)
         *
         * Parameters:
         *
         * cell - <mxCell> whose warning should be set.
         * warning - String that represents the warning to be displayed.
         * img - Optional <mxImage> to be used for the overlay. Default is
         * <warningImage>.
         * isSelect - Optional boolean indicating if a click on the overlay
         * should select the corresponding cell. Default is false.
         */
        setCellWarning(cell: mxCell, warning: string, img?: mxImage, isSelect?: boolean): mxCellOverlay;
        /**
         * Group: In-place editing
         */
        /**
         * Function: startEditing
         *
         * Calls <startEditingAtCell> using the given cell or the first selection
         * cell.
         *
         * Parameters:
         *
         * evt - Optional mouse event that triggered the editing.
         */
        startEditing(evt?: any): void;
        /**
         * Function: startEditingAtCell
         *
         * Fires a <startEditing> event and invokes <mxCellEditor.startEditing>
         * on <editor>. After editing was started, a <editingStarted> event is
         * fired.
         *
         * Parameters:
         *
         * cell - <mxCell> to start the in-place editor for.
         * evt - Optional mouse event that triggered the editing.
         */
        startEditingAtCell(cell: mxCell, evt?: any): void;
        /**
         * Function: getEditingValue
         *
         * Returns the initial value for in-place editing. This implementation
         * returns <convertValueToString> for the given cell. If this function is
         * overridden, then <mxGraphModel.valueForCellChanged> should take care
         * of correctly storing the actual new value inside the user object.
         *
         * Parameters:
         *
         * cell - <mxCell> for which the initial editing value should be returned.
         * evt - Optional mouse event that triggered the editor.
         */
        getEditingValue(cell: mxCell, evt?: any): any;
        /**
         * Function: stopEditing
         *
         * Stops the current editing  and fires a <editingStopped> event.
         *
         * Parameters:
         *
         * cancel - Boolean that specifies if the current editing value
         * should be stored.
         */
        stopEditing(cancel?: boolean): void;
        /**
         * Function: labelChanged
         *
         * Sets the label of the specified cell to the given value using
         * <cellLabelChanged> and fires <mxEvent.LABEL_CHANGED> while the
         * transaction is in progress. Returns the cell whose label was changed.
         *
         * Parameters:
         *
         * cell - <mxCell> whose label should be changed.
         * value - New label to be assigned.
         * evt - Optional event that triggered the change.
         */
        labelChanged(cell: mxCell, value: any, evt?: any): mxCell;
        /**
         * Function: cellLabelChanged
         *
         * Sets the new label for a cell. If autoSize is true then
         * <cellSizeUpdated> will be called.
         *
         * In the following example, the function is extended to map changes to
         * attributes in an XML node, as shown in <convertValueToString>.
         * Alternatively, the handling of this can be implemented as shown in
         * <mxGraphModel.valueForCellChanged> without the need to clone the
         * user object.
         *
         * (code)
         * var graphCellLabelChanged = graph.cellLabelChanged;
         * graph.cellLabelChanged = function(cell, newValue, autoSize)
         * {
         * 	// Cloned for correct undo/redo
         * 	var elt = cell.value.cloneNode(true);
         *  elt.setAttribute('label', newValue);
         *
         *  newValue = elt;
         *  graphCellLabelChanged.apply(this, arguments);
         * };
         * (end)
         *
         * Parameters:
         *
         * cell - <mxCell> whose label should be changed.
         * value - New label to be assigned.
         * autoSize - Boolean that specifies if <cellSizeUpdated> should be called.
         */
        cellLabelChanged(cell: mxCell, value: any, autoSize: boolean): void;
        /**
         * Group: Event processing
         */
        /**
         * Function: escape
         *
         * Processes an escape keystroke.
         *
         * Parameters:
         *
         * evt - Mouseevent that represents the keystroke.
         */
        escape(evt?: any): void;
        /**
         * Function: click
         *
         * Processes a singleclick on an optional cell and fires a <click> event.
         * The click event is fired initially. If the graph is enabled and the
         * event has not been consumed, then the cell is selected using
         * <selectCellForEvent> or the selection is cleared using
         * <clearSelection>. The events consumed state is set to true if the
         * corresponding <mxMouseEvent> has been consumed.
         *
         * To handle a click event, use the following code.
         *
         * (code)
         * graph.addListener(mxEvent.CLICK, function(sender, evt)
         * {
         *   var e = evt.getProperty('event'); // mouse event
         *   var cell = evt.getProperty('cell'); // cell may be null
         *
         *   if (cell != null)
         *   {
         *     // Do something useful with cell and consume the event
         *     evt.consume();
         *   }
         * });
         * (end)
         *
         * Parameters:
         *
         * me - <mxMouseEvent> that represents the single click.
         */
        click(me: mxMouseEvent): void;
        /**
         * Function: isSiblingSelected
         *
         * Returns true if any sibling of the given cell is selected.
         */
        isSiblingSelected(cell: mxCell): boolean;
        /**
         * Function: dblClick
         *
         * Processes a doubleclick on an optional cell and fires a <dblclick>
         * event. The event is fired initially. If the graph is enabled and the
         * event has not been consumed, then <edit> is called with the given
         * cell. The event is ignored if no cell was specified.
         *
         * Example for overriding this method.
         *
         * (code)
         * graph.dblClick = function(evt, cell)
         * {
         *   var mxe = new mxEventObject(mxEvent.DOUBLE_CLICK, 'event', evt, 'cell', cell);
         *   this.fireEvent(mxe);
         *
         *   if (this.isEnabled() && !mxEvent.isConsumed(evt) && !mxe.isConsumed())
         *   {
         * 	   mxUtils.alert('Hello, World!');
         *     mxe.consume();
         *   }
         * }
         * (end)
         *
         * Example listener for this event.
         *
         * (code)
         * graph.addListener(mxEvent.DOUBLE_CLICK, function(sender, evt)
         * {
         *   var cell = evt.getProperty('cell');
         *   // do something with the cell and consume the
         *   // event to prevent in-place editing from start
         * });
         * (end)
         *
         * Parameters:
         *
         * evt - Mouseevent that represents the doubleclick.
         * cell - Optional <mxCell> under the mousepointer.
         */
        dblClick(evt: any, cell?: mxCell): void;
        /**
         * Function: tapAndHold
         *
         * Handles the <mxMouseEvent> by highlighting the <mxCellState>.
         *
         * Parameters:
         *
         * me - <mxMouseEvent> that represents the touch event.
         * state - Optional <mxCellState> that is associated with the event.
         */
        tapAndHold(me: mxMouseEvent): void;
        /**
         * Function: scrollPointToVisible
         *
         * Scrolls the graph to the given point, extending the graph container if
         * specified.
         */
        scrollPointToVisible(x: number, y: number, extend: boolean, border?: number): void;
        /**
         * Function: createPanningManager
         *
         * Creates and returns an <mxPanningManager>.
         */
        createPanningManager(): typeof mxPanningManager;
        /**
         * Function: getBorderSizes
         *
         * Returns the size of the border and padding on all four sides of the
         * container. The left, top, right and bottom borders are stored in the x, y,
         * width and height of the returned <mxRectangle>, respectively.
         */
        getBorderSizes(): mxRectangle;
        /**
         * Function: getPreferredPageSize
         *
         * Returns the preferred size of the background page if <preferPageSize> is true.
         */
        getPreferredPageSize(bounds: mxRectangle, width: number, height: number): mxRectangle;
        /**
         * Function: fit
         *
         * Scales the graph such that the complete diagram fits into <container> and
         * returns the current scale in the view. To fit an initial graph prior to
         * rendering, set <mxGraphView.rendering> to false prior to changing the model
         * and execute the following after changing the model.
         *
         * (code)
         * graph.fit();
         * graph.view.rendering = true;
         * graph.refresh();
         * (end)
         *
         * To fit and center the graph, the following code can be used.
         *
         * (code)
         * var margin = 2;
         * var max = 3;
         *
         * var bounds = graph.getGraphBounds();
         * var cw = graph.container.clientWidth - margin;
         * var ch = graph.container.clientHeight - margin;
         * var w = bounds.width / graph.view.scale;
         * var h = bounds.height / graph.view.scale;
         * var s = Math.min(max, Math.min(cw / w, ch / h));
         *
         * graph.view.scaleAndTranslate(s,
         *   (margin + cw - w * s) / (2 * s) - bounds.x / graph.view.scale,
         *   (margin + ch - h * s) / (2 * s) - bounds.y / graph.view.scale);
         * (end)
         *
         * Parameters:
         *
         * border - Optional number that specifies the border. Default is <border>.
         * keepOrigin - Optional boolean that specifies if the translate should be
         * changed. Default is false.
         * margin - Optional margin in pixels. Default is 0.
         * enabled - Optional boolean that specifies if the scale should be set or
         * just returned. Default is true.
         * ignoreWidth - Optional boolean that specifies if the width should be
         * ignored. Default is false.
         * ignoreHeight - Optional boolean that specifies if the height should be
         * ignored. Default is false.
         * maxHeight - Optional maximum height.
         */
        fit(border?: number, keepOrigin?: boolean, margin?: number, enabled?: boolean, ignoreWidth?: number, ignoreHeight?: number, maxHeight?: number): number;
        /**
         * Function: sizeDidChange
         *
         * Called when the size of the graph has changed. This implementation fires
         * a <size> event after updating the clipping region of the SVG element in
         * SVG-bases browsers.
         */
        sizeDidChange(): void;
        /**
         * Function: doResizeContainer
         *
         * Resizes the container for the given graph width and height.
         */
        doResizeContainer(width: number, height: number): void;
        /**
         * Function: updatePageBreaks
         *
         * Invokes from <sizeDidChange> to redraw the page breaks.
         *
         * Parameters:
         *
         * visible - Boolean that specifies if page breaks should be shown.
         * width - Specifies the width of the container in pixels.
         * height - Specifies the height of the container in pixels.
         */
        updatePageBreaks(visible: boolean, width: number, height: number): void;
        /**
         * Group: Cell styles
         */
        /**
         * Function: getCurrentCellStyle
         *
         * Returns the style for the given cell from the cell state, if one exists,
         * or using <getCellStyle>.
         *
         * Parameters:
         *
         * cell - <mxCell> whose style should be returned as an array.
         * ignoreState - Optional boolean that specifies if the cell state should be ignored.
         */
        getCurrentCellStyle(cell: mxCell, ignoreState?: boolean): any;
        /**
         * Function: getCellStyle
         *
         * Returns an array of key, value pairs representing the cell style for the
         * given cell. If no string is defined in the model that specifies the
         * style, then the default style for the cell is returned or an empty object,
         * if no style can be found. Note: You should try and get the cell state
         * for the given cell and use the cached style in the state before using
         * this method.
         *
         * Parameters:
         *
         * cell - <mxCell> whose style should be returned as an array.
         */
        getCellStyle(cell: mxCell): any;
        /**
         * Function: postProcessCellStyle
         *
         * Tries to resolve the value for the image style in the image bundles and
         * turns short data URIs as defined in mxImageBundle to data URIs as
         * defined in RFC 2397 of the IETF.
         */
        postProcessCellStyle(style: any): any;
        /**
         * Function: setCellStyle
         *
         * Sets the style of the specified cells. If no cells are given, then the
         * selection cells are changed.
         *
         * Parameters:
         *
         * style - String representing the new style of the cells.
         * cells - Optional array of <mxCells> to set the style for. Default is the
         * selection cells.
         */
        setCellStyle(style: any, cells?: mxCell[]): void;
        /**
         * Function: toggleCellStyle
         *
         * Toggles the boolean value for the given key in the style of the given cell
         * and returns the new value as 0 or 1. If no cell is specified then the
         * selection cell is used.
         *
         * Parameter:
         *
         * key - String representing the key for the boolean value to be toggled.
         * defaultValue - Optional boolean default value if no value is defined.
         * Default is false.
         * cell - Optional <mxCell> whose style should be modified. Default is
         * the selection cell.
         */
        toggleCellStyle(key: string, defaultValue?: any, cell?: mxCell): any;
        /**
         * Function: toggleCellStyles
         *
         * Toggles the boolean value for the given key in the style of the given cells
         * and returns the new value as 0 or 1. If no cells are specified, then the
         * selection cells are used. For example, this can be used to toggle
         * <mxConstants.STYLE_ROUNDED> or any other style with a boolean value.
         *
         * Parameter:
         *
         * key - String representing the key for the boolean value to be toggled.
         * defaultValue - Optional boolean default value if no value is defined.
         * Default is false.
         * cells - Optional array of <mxCells> whose styles should be modified.
         * Default is the selection cells.
         */
        toggleCellStyles(key: string, defaultValue?: any, cells?: mxCell[]): any;
        /**
         * Function: setCellStyles
         *
         * Sets the key to value in the styles of the given cells. This will modify
         * the existing cell styles in-place and override any existing assignment
         * for the given key. If no cells are specified, then the selection cells
         * are changed. If no value is specified, then the respective key is
         * removed from the styles.
         *
         * Parameters:
         *
         * key - String representing the key to be assigned.
         * value - String representing the new value for the key.
         * cells - Optional array of <mxCells> to change the style for. Default is
         * the selection cells.
         */
        setCellStyles(key: string, value: any, cells?: mxCell[]): void;
        /**
         * Function: toggleCellStyleFlags
         *
         * Toggles the given bit for the given key in the styles of the specified
         * cells.
         *
         * Parameters:
         *
         * key - String representing the key to toggle the flag in.
         * flag - Integer that represents the bit to be toggled.
         * cells - Optional array of <mxCells> to change the style for. Default is
         * the selection cells.
         */
        toggleCellStyleFlags(key: string, flag: any, cells?: mxCell[]): void;
        /**
         * Function: setCellStyleFlags
         *
         * Sets or toggles the given bit for the given key in the styles of the
         * specified cells.
         *
         * Parameters:
         *
         * key - String representing the key to toggle the flag in.
         * flag - Integer that represents the bit to be toggled.
         * value - Boolean value to be used or null if the value should be toggled.
         * cells - Optional array of <mxCells> to change the style for. Default is
         * the selection cells.
         */
        setCellStyleFlags(key: string, flag: any, value: any, cells?: mxCell[]): void;
        /**
         * Group: Cell alignment and orientation
         */
        /**
         * Function: alignCells
         *
         * Aligns the given cells vertically or horizontally according to the given
         * alignment using the optional parameter as the coordinate.
         *
         * Parameters:
         *
         * align - Specifies the alignment. Possible values are all constants in
         * mxConstants with an ALIGN prefix.
         * cells - Array of <mxCells> to be aligned.
         * param - Optional coordinate for the alignment.
         */
        alignCells(align: any, cells?: mxCell[], param?: any): mxCell[];
        /**
         * Function: flipEdge
         *
         * Toggles the style of the given edge between null (or empty) and
         * <alternateEdgeStyle>. This method fires <mxEvent.FLIP_EDGE> while the
         * transaction is in progress. Returns the edge that was flipped.
         *
         * Here is an example that overrides this implementation to invert the
         * value of <mxConstants.STYLE_ELBOW> without removing any existing styles.
         *
         * (code)
         * graph.flipEdge = function(edge)
         * {
         *   if (edge != null)
         *   {
         *     var style = this.getCurrentCellStyle(edge);
         *     var elbow = mxUtils.getValue(style, mxConstants.STYLE_ELBOW,
         *         mxConstants.ELBOW_HORIZONTAL);
         *     var value = (elbow == mxConstants.ELBOW_HORIZONTAL) ?
         *         mxConstants.ELBOW_VERTICAL : mxConstants.ELBOW_HORIZONTAL;
         *     this.setCellStyles(mxConstants.STYLE_ELBOW, value, [edge]);
         *   }
         * };
         * (end)
         *
         * Parameters:
         *
         * edge - <mxCell> whose style should be changed.
         */
        flipEdge(edge: mxCell): mxCell;
        /**
         * Function: addImageBundle
         *
         * Adds the specified <mxImageBundle>.
         */
        addImageBundle(bundle: any): void;
        /**
         * Function: removeImageBundle
         *
         * Removes the specified <mxImageBundle>.
         */
        removeImageBundle(bundle: any): void;
        /**
         * Function: getImageFromBundles
         *
         * Searches all <imageBundles> for the specified key and returns the value
         * for the first match or null if the key is not found.
         */
        getImageFromBundles(key: any): any;
        /**
         * Group: Order
         */
        /**
         * Function: orderCells
         *
         * Moves the given cells to the front or back. The change is carried out
         * using <cellsOrdered>. This method fires <mxEvent.ORDER_CELLS> while the
         * transaction is in progress.
         *
         * Parameters:
         *
         * back - Boolean that specifies if the cells should be moved to back.
         * cells - Array of <mxCells> to move to the background. If null is
         * specified then the selection cells are used.
         */
        orderCells(back?: boolean, cells?: mxCell[]): mxCell[];
        /**
         * Function: cellsOrdered
         *
         * Moves the given cells to the front or back. This method fires
         * <mxEvent.CELLS_ORDERED> while the transaction is in progress.
         *
         * Parameters:
         *
         * cells - Array of <mxCells> whose order should be changed.
         * back - Boolean that specifies if the cells should be moved to back.
         */
        cellsOrdered(cells?: mxCell[], back?: boolean): void;
        /**
         * Group: Grouping
         */
        /**
         * Function: groupCells
         *
         * Adds the cells into the given group. The change is carried out using
         * <cellsAdded>, <cellsMoved> and <cellsResized>. This method fires
         * <mxEvent.GROUP_CELLS> while the transaction is in progress. Returns the
         * new group. A group is only created if there is at least one entry in the
         * given array of cells.
         *
         * Parameters:
         *
         * group - <mxCell> that represents the target group. If null is specified
         * then a new group is created using <createGroupCell>.
         * border - Optional integer that specifies the border between the child
         * area and the group bounds. Default is 0.
         * cells - Optional array of <mxCells> to be grouped. If null is specified
         * then the selection cells are used.
         */
        groupCells(group: mxCell, border?: number, cells?: mxCell[]): mxCell;
        /**
         * Function: getCellsForGroup
         *
         * Returns the cells with the same parent as the first cell
         * in the given array.
         */
        getCellsForGroup(cells: mxCell[]): mxCell[];
        /**
         * Function: getBoundsForGroup
         *
         * Returns the bounds to be used for the given group and children.
         */
        getBoundsForGroup(group: mxCell, children: mxCell[], border?: number): mxRectangle;
        /**
         * Function: createGroupCell
         *
         * Hook for creating the group cell to hold the given array of <mxCells> if
         * no group cell was given to the <group> function.
         *
         * The following code can be used to set the style of new group cells.
         *
         * (code)
         * var graphCreateGroupCell = graph.createGroupCell;
         * graph.createGroupCell = function(cells)
         * {
         *   var group = graphCreateGroupCell.apply(this, arguments);
         *   group.setStyle('group');
         *
         *   return group;
         * };
         */
        createGroupCell(cells?: mxCell[]): mxCell;
        /**
         * Function: ungroupCells
         *
         * Ungroups the given cells by moving the children the children to their
         * parents parent and removing the empty groups. Returns the children that
         * have been removed from the groups.
         *
         * Parameters:
         *
         * cells - Array of cells to be ungrouped. If null is specified then the
         * selection cells are used.
         */
        ungroupCells(cells?: mxCell[]): mxCell[];
        /**
         * Function: getCellsForUngroup
         *
         * Returns the selection cells that can be ungrouped.
         */
        getCellsForUngroup(): mxCell[];
        /**
         * Function: removeCellsAfterUngroup
         *
         * Hook to remove the groups after <ungroupCells>.
         *
         * Parameters:
         *
         * cells - Array of <mxCells> that were ungrouped.
         */
        removeCellsAfterUngroup(cells: mxCell[]): void;
        /**
         * Function: removeCellsFromParent
         *
         * Removes the specified cells from their parents and adds them to the
         * default parent. Returns the cells that were removed from their parents.
         *
         * Parameters:
         *
         * cells - Array of <mxCells> to be removed from their parents.
         */
        removeCellsFromParent(cells?: mxCell[]): mxCell[];
        /**
         * Function: updateGroupBounds
         *
         * Updates the bounds of the given groups to include all children and returns
         * the passed-in cells. Call this with the groups in parent to child order,
         * top-most group first, the cells are processed in reverse order and cells
         * with no children are ignored.
         *
         * Parameters:
         *
         * cells - The groups whose bounds should be updated. If this is null, then
         * the selection cells are used.
         * border - Optional border to be added in the group. Default is 0.
         * moveGroup - Optional boolean that allows the group to be moved. Default
         * is false.
         * topBorder - Optional top border to be added in the group. Default is 0.
         * rightBorder - Optional top border to be added in the group. Default is 0.
         * bottomBorder - Optional top border to be added in the group. Default is 0.
         * leftBorder - Optional top border to be added in the group. Default is 0.
         */
        updateGroupBounds(cells?: mxCell[], border?: number, moveGroup?: boolean, topBorder?: number, rightBorder?: number, bottomBorder?: number, leftBorder?: number): mxCell[];
        /**
         * Function: getBoundingBox
         *
         * Returns the bounding box for the given array of <mxCells>. The bounding box for
         * each cell and its descendants is computed using <mxGraphView.getBoundingBox>.
         *
         * Parameters:
         *
         * cells - Array of <mxCells> whose bounding box should be returned.
         */
        getBoundingBox(cells: mxCell[]): mxRectangle;
        /**
         * Group: Cell cloning, insertion and removal
         */
        /**
         * Function: cloneCell
         *
         * Returns the clone for the given cell. Uses <cloneCells>.
         *
         * Parameters:
         *
         * cell - <mxCell> to be cloned.
         * allowInvalidEdges - Optional boolean that specifies if invalid edges
         * should be cloned. Default is true.
         * mapping - Optional mapping for existing clones.
         * keepPosition - Optional boolean indicating if the position of the cells should
         * be updated to reflect the lost parent cell. Default is false.
         */
        cloneCell(cell: mxCell, allowInvalidEdges?: boolean, mapping?: any, keepPosition?: boolean): mxCell;
        /**
         * Function: cloneCells
         *
         * Returns the clones for the given cells. The clones are created recursively
         * using <mxGraphModel.cloneCells>. If the terminal of an edge is not in the
         * given array, then the respective end is assigned a terminal point and the
         * terminal is removed.
         *
         * Parameters:
         *
         * cells - Array of <mxCells> to be cloned.
         * allowInvalidEdges - Optional boolean that specifies if invalid edges
         * should be cloned. Default is true.
         * mapping - Optional mapping for existing clones.
         * keepPosition - Optional boolean indicating if the position of the cells should
         * be updated to reflect the lost parent cell. Default is false.
         */
        cloneCells(cells: mxCell[], allowInvalidEdges?: boolean, mapping?: any, keepPosition?: boolean): mxCell[];
        /**
         * Function: insertVertex
         *
         * Adds a new vertex into the given parent <mxCell> using value as the user
         * object and the given coordinates as the <mxGeometry> of the new vertex.
         * The id and style are used for the respective properties of the new
         * <mxCell>, which is returned.
         *
         * When adding new vertices from a mouse event, one should take into
         * account the offset of the graph container and the scale and translation
         * of the view in order to find the correct unscaled, untranslated
         * coordinates using <mxGraph.getPointForEvent> as follows:
         *
         * (code)
         * var pt = graph.getPointForEvent(evt);
         * var parent = graph.getDefaultParent();
         * graph.insertVertex(parent, null,
         * 			'Hello, World!', x, y, 220, 30);
         * (end)
         *
         * For adding image cells, the style parameter can be assigned as
         *
         * (code)
         * stylename;image=imageUrl
         * (end)
         *
         * See <mxGraph> for more information on using images.
         *
         * Parameters:
         *
         * parent - <mxCell> that specifies the parent of the new vertex.
         * id - Optional string that defines the Id of the new vertex.
         * value - Object to be used as the user object.
         * x - Integer that defines the x coordinate of the vertex.
         * y - Integer that defines the y coordinate of the vertex.
         * width - Integer that defines the width of the vertex.
         * height - Integer that defines the height of the vertex.
         * style - Optional string that defines the cell style.
         * relative - Optional boolean that specifies if the geometry is relative.
         * Default is false.
         */
        insertVertex(parent?: mxCell, id?: any, value?: any, x?: number, y?: number, width?: number, height?: number, style?: string, relative?: boolean): mxCell;
        /**
         * Function: createVertex
         *
         * Hook method that creates the new vertex for <insertVertex>.
         */
        createVertex(parent?: mxCell, id?: any, value?: any, x?: number, y?: number, width?: number, height?: number, style?: string, relative?: boolean): mxCell;
        /**
         * Function: insertEdge
         *
         * Adds a new edge into the given parent <mxCell> using value as the user
         * object and the given source and target as the terminals of the new edge.
         * The id and style are used for the respective properties of the new
         * <mxCell>, which is returned.
         *
         * Parameters:
         *
         * parent - <mxCell> that specifies the parent of the new edge.
         * id - Optional string that defines the Id of the new edge.
         * value - JavaScript object to be used as the user object.
         * source - <mxCell> that defines the source of the edge.
         * target - <mxCell> that defines the target of the edge.
         * style - Optional string that defines the cell style.
         */
        insertEdge(parent?: mxCell, id?: any, value?: any, source?: mxCell, target?: mxCell, style?: string): mxCell;
        /**
         * Function: createEdge
         *
         * Hook method that creates the new edge for <insertEdge>. This
         * implementation does not set the source and target of the edge, these
         * are set when the edge is added to the model.
         *
         */
        createEdge(parent?: mxCell, id?: any, value?: any, source?: mxCell, target?: mxCell, style?: string): mxCell;
        /**
         * Function: addEdge
         *
         * Adds the edge to the parent and connects it to the given source and
         * target terminals. This is a shortcut method. Returns the edge that was
         * added.
         *
         * Parameters:
         *
         * edge - <mxCell> to be inserted into the given parent.
         * parent - <mxCell> that represents the new parent. If no parent is
         * given then the default parent is used.
         * source - Optional <mxCell> that represents the source terminal.
         * target - Optional <mxCell> that represents the target terminal.
         * index - Optional index to insert the cells at. Default is to append.
         */
        addEdge(edge: mxCell, parent?: mxCell, source?: mxCell, target?: mxCell, index?: any): mxCell;
        /**
         * Function: addCell
         *
         * Adds the cell to the parent and connects it to the given source and
         * target terminals. This is a shortcut method. Returns the cell that was
         * added.
         *
         * Parameters:
         *
         * cell - <mxCell> to be inserted into the given parent.
         * parent - <mxCell> that represents the new parent. If no parent is
         * given then the default parent is used.
         * index - Optional index to insert the cells at. Default is to append.
         * source - Optional <mxCell> that represents the source terminal.
         * target - Optional <mxCell> that represents the target terminal.
         */
        addCell(cell: mxCell, parent?: mxCell, index?: any, source?: mxCell, target?: mxCell): mxCell;
        /**
         * Function: addCells
         *
         * Adds the cells to the parent at the given index, connecting each cell to
         * the optional source and target terminal. The change is carried out using
         * <cellsAdded>. This method fires <mxEvent.ADD_CELLS> while the
         * transaction is in progress. Returns the cells that were added.
         *
         * Parameters:
         *
         * cells - Array of <mxCells> to be inserted.
         * parent - <mxCell> that represents the new parent. If no parent is
         * given then the default parent is used.
         * index - Optional index to insert the cells at. Default is to append.
         * source - Optional source <mxCell> for all inserted cells.
         * target - Optional target <mxCell> for all inserted cells.
         * absolute - Optional boolean indicating of cells should be kept at
         * their absolute position. Default is false.
         */
        addCells(cells?: mxCell[], parent?: mxCell, index?: any, source?: mxCell, target?: mxCell, absolute?: boolean): mxCell[];
        /**
         * Function: cellsAdded
         *
         * Adds the specified cells to the given parent. This method fires
         * <mxEvent.CELLS_ADDED> while the transaction is in progress.
         */
        cellsAdded(cells?: mxCell[], parent?: mxCell, index?: any, source?: mxCell, target?: mxCell, absolute?: boolean, constrain?: boolean, extend?: boolean): void;
        /**
         * Function: autoSizeCell
         *
         * Resizes the specified cell to just fit around the its label and/or children
         *
         * Parameters:
         *
         * cell - <mxCells> to be resized.
         * recurse - Optional boolean which specifies if all descendants should be
         * autosized. Default is true.
         */
        autoSizeCell(cell: mxCell, recurse?: boolean): void;
        /**
         * Function: removeCells
         *
         * Removes the given cells from the graph including all connected edges if
         * includeEdges is true. The change is carried out using <cellsRemoved>.
         * This method fires <mxEvent.REMOVE_CELLS> while the transaction is in
         * progress. The removed cells are returned as an array.
         *
         * Parameters:
         *
         * cells - Array of <mxCells> to remove. If null is specified then the
         * selection cells which are deletable are used.
         * includeEdges - Optional boolean which specifies if all connected edges
         * should be removed as well. Default is true.
         */
        removeCells(cells?: mxCell[], includeEdges?: boolean): mxCell[];
        /**
         * Function: cellsRemoved
         *
         * Removes the given cells from the model. This method fires
         * <mxEvent.CELLS_REMOVED> while the transaction is in progress.
         *
         * Parameters:
         *
         * cells - Array of <mxCells> to remove.
         */
        cellsRemoved(cells?: mxCell[]): void;
        /**
         * Function: splitEdge
         *
         * Splits the given edge by adding the newEdge between the previous source
         * and the given cell and reconnecting the source of the given edge to the
         * given cell. This method fires <mxEvent.SPLIT_EDGE> while the transaction
         * is in progress. Returns the new edge that was inserted.
         *
         * Parameters:
         *
         * edge - <mxCell> that represents the edge to be splitted.
         * cells - <mxCells> that represents the cells to insert into the edge.
         * newEdge - <mxCell> that represents the edge to be inserted.
         * dx - Optional integer that specifies the vector to move the cells.
         * dy - Optional integer that specifies the vector to move the cells.
         * x - Integer that specifies the x-coordinate of the drop location.
         * y - Integer that specifies the y-coordinate of the drop location.
         * parent - Optional parent to insert the cell. If null the parent of
         * the edge is used.
         */
        splitEdge(edge: mxCell, cells: mxCell[], newEdge?: mxCell, dx?: number, dy?: number, x?: number, y?: number, parent?: mxCell): mxCell;
        /**
         * Group: Cell visibility
         */
        /**
         * Function: toggleCells
         *
         * Sets the visible state of the specified cells and all connected edges
         * if includeEdges is true. The change is carried out using <cellsToggled>.
         * This method fires <mxEvent.TOGGLE_CELLS> while the transaction is in
         * progress. Returns the cells whose visible state was changed.
         *
         * Parameters:
         *
         * show - Boolean that specifies the visible state to be assigned.
         * cells - Array of <mxCells> whose visible state should be changed. If
         * null is specified then the selection cells are used.
         * includeEdges - Optional boolean indicating if the visible state of all
         * connected edges should be changed as well. Default is true.
         */
        toggleCells(show: boolean, cells: mxCell[], includeEdges?: boolean): mxCell[];
        /**
         * Function: cellsToggled
         *
         * Sets the visible state of the specified cells.
         *
         * Parameters:
         *
         * cells - Array of <mxCells> whose visible state should be changed.
         * show - Boolean that specifies the visible state to be assigned.
         */
        cellsToggled(cells: mxCell[], show: boolean): void;
        /**
         * Group: Folding
         */
        /**
         * Function: foldCells
         *
         * Sets the collapsed state of the specified cells and all descendants
         * if recurse is true. The change is carried out using <cellsFolded>.
         * This method fires <mxEvent.FOLD_CELLS> while the transaction is in
         * progress. Returns the cells whose collapsed state was changed.
         *
         * Parameters:
         *
         * collapsed - Boolean indicating the collapsed state to be assigned.
         * recurse - Optional boolean indicating if the collapsed state of all
         * descendants should be set. Default is false.
         * cells - Array of <mxCells> whose collapsed state should be set. If
         * null is specified then the foldable selection cells are used.
         * checkFoldable - Optional boolean indicating of isCellFoldable should be
         * checked. Default is false.
         * evt - Optional native event that triggered the invocation.
         */
        foldCells(collapse: boolean, recurse?: boolean, cells?: mxCell[], checkFoldable?: boolean, evt?: any): mxCell[];
        /**
         * Function: cellsFolded
         *
         * Sets the collapsed state of the specified cells. This method fires
         * <mxEvent.CELLS_FOLDED> while the transaction is in progress. Returns the
         * cells whose collapsed state was changed.
         *
         * Parameters:
         *
         * cells - Array of <mxCells> whose collapsed state should be set.
         * collapsed - Boolean indicating the collapsed state to be assigned.
         * recurse - Boolean indicating if the collapsed state of all descendants
         * should be set.
         * checkFoldable - Optional boolean indicating of isCellFoldable should be
         * checked. Default is false.
         */
        cellsFolded(cells: mxCell[], collapse: boolean, recurse?: boolean, checkFoldable?: boolean): void;
        /**
         * Function: swapBounds
         *
         * Swaps the alternate and the actual bounds in the geometry of the given
         * cell invoking <updateAlternateBounds> before carrying out the swap.
         *
         * Parameters:
         *
         * cell - <mxCell> for which the bounds should be swapped.
         * willCollapse - Boolean indicating if the cell is going to be collapsed.
         */
        swapBounds(cell: mxCell, willCollapse: boolean): void;
        /**
         * Function: updateAlternateBounds
         *
         * Updates or sets the alternate bounds in the given geometry for the given
         * cell depending on whether the cell is going to be collapsed. If no
         * alternate bounds are defined in the geometry and
         * <collapseToPreferredSize> is true, then the preferred size is used for
         * the alternate bounds. The top, left corner is always kept at the same
         * location.
         *
         * Parameters:
         *
         * cell - <mxCell> for which the geometry is being udpated.
         * g - <mxGeometry> for which the alternate bounds should be updated.
         * willCollapse - Boolean indicating if the cell is going to be collapsed.
         */
        updateAlternateBounds(cell: mxCell, geo: mxGeometry, willCollapse: boolean): void;
        /**
         * Function: addAllEdges
         *
         * Returns an array with the given cells and all edges that are connected
         * to a cell or one of its descendants.
         */
        addAllEdges(cells: mxCell[]): any;
        /**
         * Function: getAllEdges
         *
         * Returns all edges connected to the given cells or its descendants.
         */
        getAllEdges(cells: mxCell[]): mxCell[];
        /**
         * Group: Cell sizing
         */
        /**
         * Function: updateCellSize
         *
         * Updates the size of the given cell in the model using <cellSizeUpdated>.
         * This method fires <mxEvent.UPDATE_CELL_SIZE> while the transaction is in
         * progress. Returns the cell whose size was updated.
         *
         * Parameters:
         *
         * cell - <mxCell> whose size should be updated.
         */
        updateCellSize(cell: mxCell, ignoreChildren?: boolean): mxCell;
        /**
         * Function: cellSizeUpdated
         *
         * Updates the size of the given cell in the model using
         * <getPreferredSizeForCell> to get the new size.
         *
         * Parameters:
         *
         * cell - <mxCell> for which the size should be changed.
         */
        cellSizeUpdated(cell: mxCell, ignoreChildren?: boolean): void;
        /**
         * Function: getPreferredSizeForCell
         *
         * Returns the preferred width and height of the given <mxCell> as an
         * <mxRectangle>. To implement a minimum width, add a new style eg.
         * minWidth in the vertex and override this method as follows.
         *
         * (code)
         * var graphGetPreferredSizeForCell = graph.getPreferredSizeForCell;
         * graph.getPreferredSizeForCell = function(cell)
         * {
         *   var result = graphGetPreferredSizeForCell.apply(this, arguments);
         *   var style = this.getCellStyle(cell);
         *
         *   if (style['minWidth'] > 0)
         *   {
         *     result.width = Math.max(style['minWidth'], result.width);
         *   }
         *
         *   return result;
         * };
         * (end)
         *
         * Parameters:
         *
         * cell - <mxCell> for which the preferred size should be returned.
         * textWidth - Optional maximum text width for word wrapping.
         */
        getPreferredSizeForCell(cell: mxCell, textWidth?: any): mxRectangle;
        /**
         * Function: resizeCell
         *
         * Sets the bounds of the given cell using <resizeCells>. Returns the
         * cell which was passed to the function.
         *
         * Parameters:
         *
         * cell - <mxCell> whose bounds should be changed.
         * bounds - <mxRectangle> that represents the new bounds.
         */
        resizeCell(cell: mxCell, bounds: mxRectangle, recurse?: boolean): mxCell;
        /**
         * Function: resizeCells
         *
         * Sets the bounds of the given cells and fires a <mxEvent.RESIZE_CELLS>
         * event while the transaction is in progress. Returns the cells which
         * have been passed to the function.
         *
         * Parameters:
         *
         * cells - Array of <mxCells> whose bounds should be changed.
         * bounds - Array of <mxRectangles> that represent the new bounds.
         */
        resizeCells(cells: mxCell[], bounds: mxRectangle[], recurse?: boolean): mxCell[];
        /**
         * Function: cellsResized
         *
         * Sets the bounds of the given cells and fires a <mxEvent.CELLS_RESIZED>
         * event. If <extendParents> is true, then the parent is extended if a
         * child size is changed so that it overlaps with the parent.
         *
         * The following example shows how to control group resizes to make sure
         * that all child cells stay within the group.
         *
         * (code)
         * graph.addListener(mxEvent.CELLS_RESIZED, function(sender, evt)
         * {
         *   var cells = evt.getProperty('cells');
         *
         *   if (cells != null)
         *   {
         *     for (var i = 0; i < cells.length; i++)
         *     {
         *       if (graph.getModel().getChildCount(cells[i]) > 0)
         *       {
         *         var geo = graph.getCellGeometry(cells[i]);
         *
         *         if (geo != null)
         *         {
         *           var children = graph.getChildCells(cells[i], true, true);
         *           var bounds = graph.getBoundingBoxFromGeometry(children, true);
         *
         *           geo = geo.clone();
         *           geo.width = Math.max(geo.width, bounds.width);
         *           geo.height = Math.max(geo.height, bounds.height);
         *
         *           graph.getModel().setGeometry(cells[i], geo);
         *         }
         *       }
         *     }
         *   }
         * });
         * (end)
         *
         * Parameters:
         *
         * cells - Array of <mxCells> whose bounds should be changed.
         * bounds - Array of <mxRectangles> that represent the new bounds.
         * recurse - Optional boolean that specifies if the children should be resized.
         */
        cellsResized(cells: mxCell[], bounds: mxRectangle[], recurse?: boolean): mxRectangle[];
        /**
         * Function: cellResized
         *
         * Resizes the parents recursively so that they contain the complete area
         * of the resized child cell.
         *
         * Parameters:
         *
         * cell - <mxCell> whose bounds should be changed.
         * bounds - <mxRectangles> that represent the new bounds.
         * ignoreRelative - Boolean that indicates if relative cells should be ignored.
         * recurse - Optional boolean that specifies if the children should be resized.
         */
        cellResized(cell: mxCell, bounds: mxRectangle, ignoreRelative?: boolean, recurse?: boolean): mxRectangle;
        /**
         * Function: resizeChildCells
         *
         * Resizes the child cells of the given cell for the given new geometry with
         * respect to the current geometry of the cell.
         *
         * Parameters:
         *
         * cell - <mxCell> that has been resized.
         * newGeo - <mxGeometry> that represents the new bounds.
         */
        resizeChildCells(cell: mxCell, newGeo: mxGeometry): void;
        /**
         * Function: constrainChildCells
         *
         * Constrains the children of the given cell using <constrainChild>.
         *
         * Parameters:
         *
         * cell - <mxCell> that has been resized.
         */
        constrainChildCells(cell: mxCell): void;
        /**
         * Function: scaleCell
         *
         * Scales the points, position and size of the given cell according to the
         * given vertical and horizontal scaling factors.
         *
         * Parameters:
         *
         * cell - <mxCell> whose geometry should be scaled.
         * dx - Horizontal scaling factor.
         * dy - Vertical scaling factor.
         * recurse - Boolean indicating if the child cells should be scaled.
         */
        scaleCell(cell: mxCell, dx: number, dy: number, recurse?: boolean): void;
        /**
         * Function: extendParent
         *
         * Resizes the parents recursively so that they contain the complete area
         * of the resized child cell.
         *
         * Parameters:
         *
         * cell - <mxCell> that has been resized.
         */
        extendParent(cell: mxCell): void;
        /**
         * Group: Cell moving
         */
        /**
         * Function: importCells
         *
         * Clones and inserts the given cells into the graph using the move
         * method and returns the inserted cells. This shortcut is used if
         * cells are inserted via datatransfer.
         *
         * Parameters:
         *
         * cells - Array of <mxCells> to be imported.
         * dx - Integer that specifies the x-coordinate of the vector. Default is 0.
         * dy - Integer that specifies the y-coordinate of the vector. Default is 0.
         * target - <mxCell> that represents the new parent of the cells.
         * evt - Mouseevent that triggered the invocation.
         * mapping - Optional mapping for existing clones.
         */
        importCells(cells: mxCell[], dx?: number, dy?: number, target?: mxCell, evt?: any, mapping?: any): mxCell[];
        /**
         * Function: moveCells
         *
         * Moves or clones the specified cells and moves the cells or clones by the
         * given amount, adding them to the optional target cell. The evt is the
         * mouse event as the mouse was released. The change is carried out using
         * <cellsMoved>. This method fires <mxEvent.MOVE_CELLS> while the
         * transaction is in progress. Returns the cells that were moved.
         *
         * Use the following code to move all cells in the graph.
         *
         * (code)
         * graph.moveCells(graph.getChildCells(null, true, true), 10, 10);
         * (end)
         *
         * Parameters:
         *
         * cells - Array of <mxCells> to be moved, cloned or added to the target.
         * dx - Integer that specifies the x-coordinate of the vector. Default is 0.
         * dy - Integer that specifies the y-coordinate of the vector. Default is 0.
         * clone - Boolean indicating if the cells should be cloned. Default is false.
         * target - <mxCell> that represents the new parent of the cells.
         * evt - Mouseevent that triggered the invocation.
         * mapping - Optional mapping for existing clones.
         */
        moveCells(cells: mxCell[], dx?: number, dy?: number, clone?: boolean, target?: mxCell, evt?: any, mapping?: any): mxCell[];
        /**
         * Function: cellsMoved
         *
         * Moves the specified cells by the given vector, disconnecting the cells
         * using disconnectGraph is disconnect is true. This method fires
         * <mxEvent.CELLS_MOVED> while the transaction is in progress.
         */
        cellsMoved(cells: mxCell[], dx?: number, dy?: number, disconnect?: boolean, constrain?: boolean, extend?: boolean): void;
        /**
         * Function: translateCell
         *
         * Translates the geometry of the given cell and stores the new,
         * translated geometry in the model as an atomic change.
         */
        translateCell(cell: mxCell, dx: any, dy: any): void;
        /**
         * Function: getCellContainmentArea
         *
         * Returns the <mxRectangle> inside which a cell is to be kept.
         *
         * Parameters:
         *
         * cell - <mxCell> for which the area should be returned.
         */
        getCellContainmentArea(cell: mxCell): mxRectangle;
        /**
         * Function: getMaximumGraphBounds
         *
         * Returns the bounds inside which the diagram should be kept as an
         * <mxRectangle>.
         */
        getMaximumGraphBounds(): mxRectangle;
        /**
         * Function: constrainChild
         *
         * Keeps the given cell inside the bounds returned by
         * <getCellContainmentArea> for its parent, according to the rules defined by
         * <getOverlap> and <isConstrainChild>. This modifies the cell's geometry
         * in-place and does not clone it.
         *
         * Parameters:
         *
         * cells - <mxCell> which should be constrained.
         * sizeFirst - Specifies if the size should be changed first. Default is true.
         */
        constrainChild(cell: mxCell, sizeFirst?: boolean): void;
        /**
         * Function: resetEdges
         *
         * Resets the control points of the edges that are connected to the given
         * cells if not both ends of the edge are in the given cells array.
         *
         * Parameters:
         *
         * cells - Array of <mxCells> for which the connected edges should be
         * reset.
         */
        resetEdges(cells: mxCell[]): void;
        /**
         * Function: resetEdge
         *
         * Resets the control points of the given edge.
         *
         * Parameters:
         *
         * edge - <mxCell> whose points should be reset.
         */
        resetEdge(edge: mxCell): mxCell;
        /**
         * Group: Cell connecting and connection constraints
         */
        /**
         * Function: getOutlineConstraint
         *
         * Returns the constraint used to connect to the outline of the given state.
         */
        getOutlineConstraint(point: mxPoint, terminalState: mxCellState, me?: any): mxConnectionConstraint;
        /**
         * Function: getAllConnectionConstraints
         *
         * Returns an array of all <mxConnectionConstraints> for the given terminal. If
         * the shape of the given terminal is a <mxStencilShape> then the constraints
         * of the corresponding <mxStencil> are returned.
         *
         * Parameters:
         *
         * terminal - <mxCellState> that represents the terminal.
         * source - Boolean that specifies if the terminal is the source or target.
         */
        getAllConnectionConstraints(terminal: mxCellState, source?: boolean): any[];
        /**
         * Function: getConnectionConstraint
         *
         * Returns an <mxConnectionConstraint> that describes the given connection
         * point. This result can then be passed to <getConnectionPoint>.
         *
         * Parameters:
         *
         * edge - <mxCellState> that represents the edge.
         * terminal - <mxCellState> that represents the terminal.
         * source - Boolean indicating if the terminal is the source or target.
         */
        getConnectionConstraint(edge: mxCellState, terminal?: mxCellState, source?: boolean): mxConnectionConstraint;
        /**
         * Function: setConnectionConstraint
         *
         * Sets the <mxConnectionConstraint> that describes the given connection point.
         * If no constraint is given then nothing is changed. To remove an existing
         * constraint from the given edge, use an empty constraint instead.
         *
         * Parameters:
         *
         * edge - <mxCell> that represents the edge.
         * terminal - <mxCell> that represents the terminal.
         * source - Boolean indicating if the terminal is the source or target.
         * constraint - Optional <mxConnectionConstraint> to be used for this
         * connection.
         */
        setConnectionConstraint(edge: mxCell, terminal?: mxCell, source?: boolean, constraint?: mxConnectionConstraint): void;
        /**
         * Function: getConnectionPoint
         *
         * Returns the nearest point in the list of absolute points or the center
         * of the opposite terminal.
         *
         * Parameters:
         *
         * vertex - <mxCellState> that represents the vertex.
         * constraint - <mxConnectionConstraint> that represents the connection point
         * constraint as returned by <getConnectionConstraint>.
         * round - Optional boolean that specifies if the nearest point should be
         * rounded to the nearest grid intersection. Default is true.
         */
        getConnectionPoint(vertex: mxCellState, constraint: mxConnectionConstraint, round?: boolean): mxPoint;
        /**
         * Function: connectCell
         *
         * Connects the specified end of the given edge to the given terminal
         * using <cellConnected> and fires <mxEvent.CONNECT_CELL> while the
         * transaction is in progress. Returns the updated edge.
         *
         * Parameters:
         *
         * edge - <mxCell> whose terminal should be updated.
         * terminal - <mxCell> that represents the new terminal to be used.
         * source - Boolean indicating if the new terminal is the source or target.
         * constraint - Optional <mxConnectionConstraint> to be used for this
         * connection.
         */
        connectCell(edge: mxCell, terminal?: mxCell, source?: boolean, constraint?: mxConnectionConstraint): mxCell;
        /**
         * Function: cellConnected
         *
         * Sets the new terminal for the given edge and resets the edge points if
         * <resetEdgesOnConnect> is true. This method fires
         * <mxEvent.CELL_CONNECTED> while the transaction is in progress.
         *
         * Parameters:
         *
         * edge - <mxCell> whose terminal should be updated.
         * terminal - <mxCell> that represents the new terminal to be used.
         * source - Boolean indicating if the new terminal is the source or target.
         * constraint - <mxConnectionConstraint> to be used for this connection.
         */
        cellConnected(edge: mxCell, terminal?: mxCell, source?: boolean, constraint?: mxConnectionConstraint): void;
        /**
         * Function: disconnectGraph
         *
         * Disconnects the given edges from the terminals which are not in the
         * given array.
         *
         * Parameters:
         *
         * cells - Array of <mxCells> to be disconnected.
         */
        disconnectGraph(cells: mxCell[]): void;
        /**
         * Group: Drilldown
         */
        /**
         * Function: getCurrentRoot
         *
         * Returns the current root of the displayed cell hierarchy. This is a
         * shortcut to <mxGraphView.currentRoot> in <view>.
         */
        getCurrentRoot(): mxCell;
        /**
         * Function: getTranslateForRoot
         *
         * Returns the translation to be used if the given cell is the root cell as
         * an <mxPoint>. This implementation returns null.
         *
         * Example:
         *
         * To keep the children at their absolute position while stepping into groups,
         * this function can be overridden as follows.
         *
         * (code)
         * var offset = new mxPoint(0, 0);
         *
         * while (cell != null)
         * {
         *   var geo = this.model.getGeometry(cell);
         *
         *   if (geo != null)
         *   {
         *     offset.x -= geo.x;
         *     offset.y -= geo.y;
         *   }
         *
         *   cell = this.model.getParent(cell);
         * }
         *
         * return offset;
         * (end)
         *
         * Parameters:
         *
         * cell - <mxCell> that represents the root.
         */
        getTranslateForRoot(cell: mxCell): mxPoint;
        /**
         * Function: isPort
         *
         * Returns true if the given cell is a "port", that is, when connecting to
         * it, the cell returned by getTerminalForPort should be used as the
         * terminal and the port should be referenced by the ID in either the
         * mxConstants.STYLE_SOURCE_PORT or the or the
         * mxConstants.STYLE_TARGET_PORT. Note that a port should not be movable.
         * This implementation always returns false.
         *
         * A typical implementation is the following:
         *
         * (code)
         * graph.isPort = function(cell)
         * {
         *   var geo = this.getCellGeometry(cell);
         *
         *   return (geo != null) ? geo.relative : false;
         * };
         * (end)
         *
         * Parameters:
         *
         * cell - <mxCell> that represents the port.
         */
        isPort(cell: mxCell): boolean;
        /**
         * Function: getTerminalForPort
         *
         * Returns the terminal to be used for a given port. This implementation
         * always returns the parent cell.
         *
         * Parameters:
         *
         * cell - <mxCell> that represents the port.
         * source - If the cell is the source or target port.
         */
        getTerminalForPort(cell: mxCell, source?: boolean): any;
        /**
         * Function: getChildOffsetForCell
         *
         * Returns the offset to be used for the cells inside the given cell. The
         * root and layer cells may be identified using <mxGraphModel.isRoot> and
         * <mxGraphModel.isLayer>. For all other current roots, the
         * <mxGraphView.currentRoot> field points to the respective cell, so that
         * the following holds: cell == this.view.currentRoot. This implementation
         * returns null.
         *
         * Parameters:
         *
         * cell - <mxCell> whose offset should be returned.
         */
        getChildOffsetForCell(cell: mxCell): any;
        /**
         * Function: enterGroup
         *
         * Uses the given cell as the root of the displayed cell hierarchy. If no
         * cell is specified then the selection cell is used. The cell is only used
         * if <isValidRoot> returns true.
         *
         * Parameters:
         *
         * cell - Optional <mxCell> to be used as the new root. Default is the
         * selection cell.
         */
        enterGroup(cell?: mxCell): void;
        /**
         * Function: exitGroup
         *
         * Changes the current root to the next valid root in the displayed cell
         * hierarchy.
         */
        exitGroup(): void;
        /**
         * Function: home
         *
         * Uses the root of the model as the root of the displayed cell hierarchy
         * and selects the previous root.
         */
        home(): void;
        /**
         * Function: isValidRoot
         *
         * Returns true if the given cell is a valid root for the cell display
         * hierarchy. This implementation returns true for all non-null values.
         *
         * Parameters:
         *
         * cell - <mxCell> which should be checked as a possible root.
         */
        isValidRoot(cell: mxCell): boolean;
        /**
         * Group: Graph display
         */
        /**
         * Function: getGraphBounds
         *
         * Returns the bounds of the visible graph. Shortcut to
         * <mxGraphView.getGraphBounds>. See also: <getBoundingBoxFromGeometry>.
         */
        getGraphBounds(): mxRectangle;
        /**
         * Function: getCellBounds
         *
         * Returns the scaled, translated bounds for the given cell. See
         * <mxGraphView.getBounds> for arrays.
         *
         * Parameters:
         *
         * cell - <mxCell> whose bounds should be returned.
         * includeEdge - Optional boolean that specifies if the bounds of
         * the connected edges should be included. Default is false.
         * includeDescendants - Optional boolean that specifies if the bounds
         * of all descendants should be included. Default is false.
         */
        getCellBounds(cell: mxCell, includeEdges?: boolean, includeDescendants?: boolean): mxRectangle;
        /**
         * Function: getBoundingBoxFromGeometry
         *
         * Returns the bounding box for the geometries of the vertices in the
         * given array of cells. This can be used to find the graph bounds during
         * a layout operation (ie. before the last endUpdate) as follows:
         *
         * (code)
         * var cells = graph.getChildCells(graph.getDefaultParent(), true, true);
         * var bounds = graph.getBoundingBoxFromGeometry(cells, true);
         * (end)
         *
         * This can then be used to move cells to the origin:
         *
         * (code)
         * if (bounds.x < 0 || bounds.y < 0)
         * {
         *   graph.moveCells(cells, -Math.min(bounds.x, 0), -Math.min(bounds.y, 0))
         * }
         * (end)
         *
         * Or to translate the graph view:
         *
         * (code)
         * if (bounds.x < 0 || bounds.y < 0)
         * {
         *   graph.view.setTranslate(-Math.min(bounds.x, 0), -Math.min(bounds.y, 0));
         * }
         * (end)
         *
         * Parameters:
         *
         * cells - Array of <mxCells> whose bounds should be returned.
         * includeEdges - Specifies if edge bounds should be included by computing
         * the bounding box for all points in geometry. Default is false.
         */
        getBoundingBoxFromGeometry(cells: mxCell[], includeEdges?: boolean): mxRectangle;
        /**
         * Function: refresh
         *
         * Clears all cell states or the states for the hierarchy starting at the
         * given cell and validates the graph. This fires a refresh event as the
         * last step.
         *
         * Parameters:
         *
         * cell - Optional <mxCell> for which the cell states should be cleared.
         */
        refresh(cell?: mxCell): void;
        /**
         * Function: snap
         *
         * Snaps the given numeric value to the grid if <gridEnabled> is true.
         *
         * Parameters:
         *
         * value - Numeric value to be snapped to the grid.
         */
        snap(value: any): any;
        /**
         * Function: snapDelta
         *
         * Snaps the given delta with the given scaled bounds.
         */
        snapDelta(delta: any, bounds: any, ignoreGrid?: boolean, ignoreHorizontal?: boolean, ignoreVertical?: boolean): any;
        /**
         * Function: panGraph
         *
         * Shifts the graph display by the given amount. This is used to preview
         * panning operations, use <mxGraphView.setTranslate> to set a persistent
         * translation of the view. Fires <mxEvent.PAN>.
         *
         * Parameters:
         *
         * dx - Amount to shift the graph along the x-axis.
         * dy - Amount to shift the graph along the y-axis.
         */
        panGraph(dx: number, dy: number): void;
        /**
         * Function: zoomIn
         *
         * Zooms into the graph by <zoomFactor>.
         */
        zoomIn(): void;
        /**
         * Function: zoomOut
         *
         * Zooms out of the graph by <zoomFactor>.
         */
        zoomOut(): void;
        /**
         * Function: zoomActual
         *
         * Resets the zoom and panning in the view.
         */
        zoomActual(): void;
        /**
         * Function: zoomTo
         *
         * Zooms the graph to the given scale with an optional boolean center
         * argument, which is passd to <zoom>.
         */
        zoomTo(scale: number, center?: boolean): void;
        /**
         * Function: center
         *
         * Centers the graph in the container.
         *
         * Parameters:
         *
         * horizontal - Optional boolean that specifies if the graph should be centered
         * horizontally. Default is true.
         * vertical - Optional boolean that specifies if the graph should be centered
         * vertically. Default is true.
         * cx - Optional float that specifies the horizontal center. Default is 0.5.
         * cy - Optional float that specifies the vertical center. Default is 0.5.
         */
        center(horizontal?: boolean, vertical?: boolean, cx?: number, cy?: number): void;
        /**
         * Function: zoom
         *
         * Zooms the graph using the given factor. Center is an optional boolean
         * argument that keeps the graph scrolled to the center. If the center argument
         * is omitted, then <centerZoom> will be used as its value.
         */
        zoom(factor: number, center?: boolean): void;
        /**
         * Function: zoomToRect
         *
         * Zooms the graph to the specified rectangle. If the rectangle does not have same aspect
         * ratio as the display container, it is increased in the smaller relative dimension only
         * until the aspect match. The original rectangle is centralised within this expanded one.
         *
         * Note that the input rectangular must be un-scaled and un-translated.
         *
         * Parameters:
         *
         * rect - The un-scaled and un-translated rectangluar region that should be just visible
         * after the operation
         */
        zoomToRect(rect: mxRectangle): void;
        /**
         * Function: scrollCellToVisible
         *
         * Pans the graph so that it shows the given cell. Optionally the cell may
         * be centered in the container.
         *
         * To center a given graph if the <container> has no scrollbars, use the following code.
         *
         * [code]
         * var bounds = graph.getGraphBounds();
         * graph.view.setTranslate(-bounds.x - (bounds.width - container.clientWidth) / 2,
         * 						   -bounds.y - (bounds.height - container.clientHeight) / 2);
         * [/code]
         *
         * Parameters:
         *
         * cell - <mxCell> to be made visible.
         * center - Optional boolean flag. Default is false.
         */
        scrollCellToVisible(cell: mxCell, center?: boolean): void;
        /**
         * Function: scrollRectToVisible
         *
         * Pans the graph so that it shows the given rectangle.
         *
         * Parameters:
         *
         * rect - <mxRectangle> to be made visible.
         */
        scrollRectToVisible(rect: mxRectangle): boolean;
        /**
         * Function: getCellGeometry
         *
         * Returns the <mxGeometry> for the given cell. This implementation uses
         * <mxGraphModel.getGeometry>. Subclasses can override this to implement
         * specific geometries for cells in only one graph, that is, it can return
         * geometries that depend on the current state of the view.
         *
         * Parameters:
         *
         * cell - <mxCell> whose geometry should be returned.
         */
        getCellGeometry(cell: mxCell): mxGeometry;
        /**
         * Function: isCellVisible
         *
         * Returns true if the given cell is visible in this graph. This
         * implementation uses <mxGraphModel.isVisible>. Subclassers can override
         * this to implement specific visibility for cells in only one graph, that
         * is, without affecting the visible state of the cell.
         *
         * When using dynamic filter expressions for cell visibility, then the
         * graph should be revalidated after the filter expression has changed.
         *
         * Parameters:
         *
         * cell - <mxCell> whose visible state should be returned.
         */
        isCellVisible(cell: mxCell): boolean;
        /**
         * Function: isCellCollapsed
         *
         * Returns true if the given cell is collapsed in this graph. This
         * implementation uses <mxGraphModel.isCollapsed>. Subclassers can override
         * this to implement specific collapsed states for cells in only one graph,
         * that is, without affecting the collapsed state of the cell.
         *
         * When using dynamic filter expressions for the collapsed state, then the
         * graph should be revalidated after the filter expression has changed.
         *
         * Parameters:
         *
         * cell - <mxCell> whose collapsed state should be returned.
         */
        isCellCollapsed(cell: mxCell): boolean;
        /**
         * Function: isCellConnectable
         *
         * Returns true if the given cell is connectable in this graph. This
         * implementation uses <mxGraphModel.isConnectable>. Subclassers can override
         * this to implement specific connectable states for cells in only one graph,
         * that is, without affecting the connectable state of the cell in the model.
         *
         * Parameters:
         *
         * cell - <mxCell> whose connectable state should be returned.
         */
        isCellConnectable(cell: mxCell): boolean;
        /**
         * Function: isOrthogonal
         *
         * Returns true if perimeter points should be computed such that the
         * resulting edge has only horizontal or vertical segments.
         *
         * Parameters:
         *
         * edge - <mxCellState> that represents the edge.
         */
        isOrthogonal(edge: mxCellState): boolean;
        /**
         * Function: isLoop
         *
         * Returns true if the given cell state is a loop.
         *
         * Parameters:
         *
         * state - <mxCellState> that represents a potential loop.
         */
        isLoop(state: mxCellState): boolean;
        /**
         * Function: isCloneEvent
         *
         * Returns true if the given event is a clone event. This implementation
         * returns true if control is pressed.
         */
        isCloneEvent(evt: any): boolean;
        /**
         * Function: isTransparentClickEvent
         *
         * Hook for implementing click-through behaviour on selected cells. If this
         * returns true the cell behind the selected cell will be selected. This
         * implementation returns false;
         */
        isTransparentClickEvent(evt: any): boolean;
        /**
         * Function: isToggleEvent
         *
         * Returns true if the given event is a toggle event. This implementation
         * returns true if the meta key (Cmd) is pressed on Macs or if control is
         * pressed on any other platform.
         */
        isToggleEvent(evt: any): boolean;
        /**
         * Function: isGridEnabledEvent
         *
         * Returns true if the given mouse event should be aligned to the grid.
         */
        isGridEnabledEvent(evt: any): boolean;
        /**
         * Function: isConstrainedEvent
         *
         * Returns true if the given mouse event should be aligned to the grid.
         */
        isConstrainedEvent(evt: any): boolean;
        /**
         * Function: isIgnoreTerminalEvent
         *
         * Returns true if the given mouse event should not allow any connections to be
         * made. This implementation returns false.
         */
        isIgnoreTerminalEvent(evt: any): boolean;
        /**
         * Group: Validation
         */
        /**
         * Function: validationAlert
         *
         * Displays the given validation error in a dialog. This implementation uses
         * mxUtils.alert.
         */
        validationAlert(message: any): void;
        /**
         * Function: isEdgeValid
         *
         * Checks if the return value of <getEdgeValidationError> for the given
         * arguments is null.
         *
         * Parameters:
         *
         * edge - <mxCell> that represents the edge to validate.
         * source - <mxCell> that represents the source terminal.
         * target - <mxCell> that represents the target terminal.
         */
        isEdgeValid(edge: mxCell, source: mxCell, target: mxCell): any;
        /**
         * Function: getEdgeValidationError
         *
         * Returns the validation error message to be displayed when inserting or
         * changing an edges' connectivity. A return value of null means the edge
         * is valid, a return value of '' means it's not valid, but do not display
         * an error message. Any other (non-empty) string returned from this method
         * is displayed as an error message when trying to connect an edge to a
         * source and target. This implementation uses the <multiplicities>, and
         * checks <multigraph>, <allowDanglingEdges> and <allowLoops> to generate
         * validation errors.
         *
         * For extending this method with specific checks for source/target cells,
         * the method can be extended as follows. Returning an empty string means
         * the edge is invalid with no error message, a non-null string specifies
         * the error message, and null means the edge is valid.
         *
         * (code)
         * graph.getEdgeValidationError = function(edge, source, target)
         * {
         *   if (source != null && target != null &&
         *     this.model.getValue(source) != null &&
         *     this.model.getValue(target) != null)
         *   {
         *     if (target is not valid for source)
         *     {
         *       return 'Invalid Target';
         *     }
         *   }
         *
         *   // "Supercall"
         *   return mxGraph.prototype.getEdgeValidationError.apply(this, arguments);
         * }
         * (end)
         *
         * Parameters:
         *
         * edge - <mxCell> that represents the edge to validate.
         * source - <mxCell> that represents the source terminal.
         * target - <mxCell> that represents the target terminal.
         */
        getEdgeValidationError(edge: mxCell, source: mxCell, target: mxCell): any;
        /**
         * Function: validateEdge
         *
         * Hook method for subclassers to return an error message for the given
         * edge and terminals. This implementation returns null.
         *
         * Parameters:
         *
         * edge - <mxCell> that represents the edge to validate.
         * source - <mxCell> that represents the source terminal.
         * target - <mxCell> that represents the target terminal.
         */
        validateEdge(edge: mxCell, source: mxCell, target: mxCell): any;
        /**
         * Function: validateGraph
         *
         * Validates the graph by validating each descendant of the given cell or
         * the root of the model. Context is an object that contains the validation
         * state for the complete validation run. The validation errors are
         * attached to their cells using <setCellWarning>. Returns null in the case of
         * successful validation or an array of strings (warnings) in the case of
         * failed validations.
         *
         * Paramters:
         *
         * cell - Optional <mxCell> to start the validation recursion. Default is
         * the graph root.
         * context - Object that represents the global validation state.
         */
        validateGraph(cell?: mxCell, context?: any): any;
        /**
         * Function: getCellValidationError
         *
         * Checks all <multiplicities> that cannot be enforced while the graph is
         * being modified, namely, all multiplicities that require a minimum of
         * 1 edge.
         *
         * Parameters:
         *
         * cell - <mxCell> for which the multiplicities should be checked.
         */
        getCellValidationError(cell: mxCell): any;
        /**
         * Function: validateCell
         *
         * Hook method for subclassers to return an error message for the given
         * cell and validation context. This implementation returns null. Any HTML
         * breaks will be converted to linefeeds in the calling method.
         *
         * Parameters:
         *
         * cell - <mxCell> that represents the cell to validate.
         * context - Object that represents the global validation state.
         */
        validateCell(cell: mxCell, context?: any): any;
        /**
         * Group: Graph appearance
         */
        /**
         * Function: getBackgroundImage
         *
         * Returns the <backgroundImage> as an <mxImage>.
         */
        getBackgroundImage(): mxImage;
        /**
         * Function: setBackgroundImage
         *
         * Sets the new <backgroundImage>.
         *
         * Parameters:
         *
         * image - New <mxImage> to be used for the background.
         */
        setBackgroundImage(image: mxImage): void;
        /**
         * Function: getFoldingImage
         *
         * Returns the <mxImage> used to display the collapsed state of
         * the specified cell state. This returns null for all edges.
         */
        getFoldingImage(state: mxCellState): mxImage;
        /**
         * Function: convertValueToString
         *
         * Returns the textual representation for the given cell. This
         * implementation returns the nodename or string-representation of the user
         * object.
         *
         * Example:
         *
         * The following returns the label attribute from the cells user
         * object if it is an XML node.
         *
         * (code)
         * graph.convertValueToString = function(cell)
         * {
         * 	return cell.getAttribute('label');
         * }
         * (end)
         *
         * See also: <cellLabelChanged>.
         *
         * Parameters:
         *
         * cell - <mxCell> whose textual representation should be returned.
         */
        convertValueToString(cell: mxCell): any;
        /**
         * Function: getLabel
         *
         * Returns a string or DOM node that represents the label for the given
         * cell. This implementation uses <convertValueToString> if <labelsVisible>
         * is true. Otherwise it returns an empty string.
         *
         * To truncate a label to match the size of the cell, the following code
         * can be used.
         *
         * (code)
         * graph.getLabel = function(cell)
         * {
         *   var label = mxGraph.prototype.getLabel.apply(this, arguments);
         *
         *   if (label != null && this.model.isVertex(cell))
         *   {
         *     var geo = this.getCellGeometry(cell);
         *
         *     if (geo != null)
         *     {
         *       var max = parseInt(geo.width / 8);
         *
         *       if (label.length > max)
         *       {
         *         label = label.substring(0, max)+'...';
         *       }
         *     }
         *   }
         *   return mxUtils.htmlEntities(label);
         * }
         * (end)
         *
         * A resize listener is needed in the graph to force a repaint of the label
         * after a resize.
         *
         * (code)
         * graph.addListener(mxEvent.RESIZE_CELLS, function(sender, evt)
         * {
         *   var cells = evt.getProperty('cells');
         *
         *   for (var i = 0; i < cells.length; i++)
         *   {
         *     this.view.removeState(cells[i]);
         *   }
         * });
         * (end)
         *
         * Parameters:
         *
         * cell - <mxCell> whose label should be returned.
         */
        getLabel(cell: mxCell): any;
        /**
         * Function: isHtmlLabel
         *
         * Returns true if the label must be rendered as HTML markup. The default
         * implementation returns <htmlLabels>.
         *
         * Parameters:
         *
         * cell - <mxCell> whose label should be displayed as HTML markup.
         */
        isHtmlLabel(cell: mxCell): boolean;
        /**
         * Function: isHtmlLabels
         *
         * Returns <htmlLabels>.
         */
        isHtmlLabels(): boolean;
        /**
         * Function: setHtmlLabels
         *
         * Sets <htmlLabels>.
         */
        setHtmlLabels(value: boolean): void;
        /**
         * Function: isWrapping
         *
         * This enables wrapping for HTML labels.
         *
         * Returns true if no white-space CSS style directive should be used for
         * displaying the given cells label. This implementation returns true if
         * <mxConstants.STYLE_WHITE_SPACE> in the style of the given cell is 'wrap'.
         *
         * This is used as a workaround for IE ignoring the white-space directive
         * of child elements if the directive appears in a parent element. It
         * should be overridden to return true if a white-space directive is used
         * in the HTML markup that represents the given cells label. In order for
         * HTML markup to work in labels, <isHtmlLabel> must also return true
         * for the given cell.
         *
         * Example:
         *
         * (code)
         * graph.getLabel = function(cell)
         * {
         *   var tmp = mxGraph.prototype.getLabel.apply(this, arguments); // "supercall"
         *
         *   if (this.model.isEdge(cell))
         *   {
         *     tmp = '<div style="width: 150px; white-space:normal;">'+tmp+'</div>';
         *   }
         *
         *   return tmp;
         * }
         *
         * graph.isWrapping = function(state)
         * {
         * 	 return this.model.isEdge(state.cell);
         * }
         * (end)
         *
         * Makes sure no edge label is wider than 150 pixels, otherwise the content
         * is wrapped. Note: No width must be specified for wrapped vertex labels as
         * the vertex defines the width in its geometry.
         *
         * Parameters:
         *
         * state - <mxCell> whose label should be wrapped.
         */
        isWrapping(cell: mxCell): boolean;
        /**
         * Function: isLabelClipped
         *
         * Returns true if the overflow portion of labels should be hidden. If this
         * returns true then vertex labels will be clipped to the size of the vertices.
         * This implementation returns true if <mxConstants.STYLE_OVERFLOW> in the
         * style of the given cell is 'hidden'.
         *
         * Parameters:
         *
         * state - <mxCell> whose label should be clipped.
         */
        isLabelClipped(cell: mxCell): boolean;
        /**
         * Function: getTooltip
         *
         * Returns the string or DOM node that represents the tooltip for the given
         * state, node and coordinate pair. This implementation checks if the given
         * node is a folding icon or overlay and returns the respective tooltip. If
         * this does not result in a tooltip, the handler for the cell is retrieved
         * from <selectionCellsHandler> and the optional getTooltipForNode method is
         * called. If no special tooltip exists here then <getTooltipForCell> is used
         * with the cell in the given state as the argument to return a tooltip for the
         * given state.
         *
         * Parameters:
         *
         * state - <mxCellState> whose tooltip should be returned.
         * node - DOM node that is currently under the mouse.
         * x - X-coordinate of the mouse.
         * y - Y-coordinate of the mouse.
         */
        getTooltip(state: mxCellState, node: any, x: number, y: number): string;
        /**
         * Function: getTooltipForCell
         *
         * Returns the string or DOM node to be used as the tooltip for the given
         * cell. This implementation uses the cells getTooltip function if it
         * exists, or else it returns <convertValueToString> for the cell.
         *
         * Example:
         *
         * (code)
         * graph.getTooltipForCell = function(cell)
         * {
         *   return 'Hello, World!';
         * }
         * (end)
         *
         * Replaces all tooltips with the string Hello, World!
         *
         * Parameters:
         *
         * cell - <mxCell> whose tooltip should be returned.
         */
        getTooltipForCell(cell: mxCell): string;
        /**
         * Function: getLinkForCell
         *
         * Returns the string to be used as the link for the given cell. This
         * implementation returns null.
         *
         * Parameters:
         *
         * cell - <mxCell> whose tooltip should be returned.
         */
        getLinkForCell(cell: mxCell): string;
        /**
         * Function: getCursorForMouseEvent
         *
         * Returns the cursor value to be used for the CSS of the shape for the
         * given event. This implementation calls <getCursorForCell>.
         *
         * Parameters:
         *
         * me - <mxMouseEvent> whose cursor should be returned.
         */
        getCursorForMouseEvent(me: mxMouseEvent): any;
        /**
         * Function: getCursorForCell
         *
         * Returns the cursor value to be used for the CSS of the shape for the
         * given cell. This implementation returns null.
         *
         * Parameters:
         *
         * cell - <mxCell> whose cursor should be returned.
         */
        getCursorForCell(cell: mxCell): any;
        /**
         * Function: getStartSize
         *
         * Returns the start size of the given swimlane, that is, the width or
         * height of the part that contains the title, depending on the
         * horizontal style. The return value is an <mxRectangle> with either
         * width or height set as appropriate.
         *
         * Parameters:
         *
         * swimlane - <mxCell> whose start size should be returned.
         * ignoreState - Optional boolean that specifies if cell state should be ignored.
         */
        getStartSize(swimlane: mxCell, ignoreState?: boolean): mxRectangle;
        /**
         * Function: getSwimlaneDirection
         *
         * Returns the direction for the given swimlane style.
         */
        getSwimlaneDirection(style: any): any;
        /**
         * Function: getActualStartSize
         *
         * Returns the actual start size of the given swimlane taking into account
         * direction and horizontal and vertial flip styles. The start size is
         * returned as an <mxRectangle> where top, left, bottom, right start sizes
         * are returned as x, y, height and width, respectively.
         *
         * Parameters:
         *
         * swimlane - <mxCell> whose start size should be returned.
         * ignoreState - Optional boolean that specifies if cell state should be ignored.
         */
        getActualStartSize(swimlane: mxCell, ignoreState?: boolean): mxRectangle;
        /**
         * Function: getImage
         *
         * Returns the image URL for the given cell state. This implementation
         * returns the value stored under <mxConstants.STYLE_IMAGE> in the cell
         * style.
         *
         * Parameters:
         *
         * state - <mxCellState> whose image URL should be returned.
         */
        getImage(state: mxCellState): any;
        /**
         * Function: isTransparentState
         *
         * Returns true if the given state has no stroke- or fillcolor and no image.
         *
         * Parameters:
         *
         * state - <mxCellState> to check.
         */
        isTransparentState(state: mxCellState): boolean;
        /**
         * Function: getVerticalAlign
         *
         * Returns the vertical alignment for the given cell state. This
         * implementation returns the value stored under
         * <mxConstants.STYLE_VERTICAL_ALIGN> in the cell style.
         *
         * Parameters:
         *
         * state - <mxCellState> whose vertical alignment should be
         * returned.
         */
        getVerticalAlign(state: mxCellState): any;
        /**
         * Function: getIndicatorColor
         *
         * Returns the indicator color for the given cell state. This
         * implementation returns the value stored under
         * <mxConstants.STYLE_INDICATOR_COLOR> in the cell style.
         *
         * Parameters:
         *
         * state - <mxCellState> whose indicator color should be
         * returned.
         */
        getIndicatorColor(state: mxCellState): any;
        /**
         * Function: getIndicatorGradientColor
         *
         * Returns the indicator gradient color for the given cell state. This
         * implementation returns the value stored under
         * <mxConstants.STYLE_INDICATOR_GRADIENTCOLOR> in the cell style.
         *
         * Parameters:
         *
         * state - <mxCellState> whose indicator gradient color should be
         * returned.
         */
        getIndicatorGradientColor(state: mxCellState): any;
        /**
         * Function: getIndicatorShape
         *
         * Returns the indicator shape for the given cell state. This
         * implementation returns the value stored under
         * <mxConstants.STYLE_INDICATOR_SHAPE> in the cell style.
         *
         * Parameters:
         *
         * state - <mxCellState> whose indicator shape should be returned.
         */
        getIndicatorShape(state: mxCellState): any;
        /**
         * Function: getIndicatorImage
         *
         * Returns the indicator image for the given cell state. This
         * implementation returns the value stored under
         * <mxConstants.STYLE_INDICATOR_IMAGE> in the cell style.
         *
         * Parameters:
         *
         * state - <mxCellState> whose indicator image should be returned.
         */
        getIndicatorImage(state: mxCellState): any;
        /**
         * Function: getBorder
         *
         * Returns the value of <border>.
         */
        getBorder(): number;
        /**
         * Function: setBorder
         *
         * Sets the value of <border>.
         *
         * Parameters:
         *
         * value - Positive integer that represents the border to be used.
         */
        setBorder(value: number): void;
        /**
         * Function: isSwimlane
         *
         * Returns true if the given cell is a swimlane in the graph. A swimlane is
         * a container cell with some specific behaviour. This implementation
         * checks if the shape associated with the given cell is a <mxSwimlane>.
         *
         * Parameters:
         *
         * cell - <mxCell> to be checked.
         * ignoreState - Optional boolean that specifies if the cell state should be ignored.
         */
        isSwimlane(cell: mxCell, ignoreState?: boolean): boolean;
        /**
         * Group: Graph behaviour
         */
        /**
         * Function: isResizeContainer
         *
         * Returns <resizeContainer>.
         */
        isResizeContainer(): boolean;
        /**
         * Function: setResizeContainer
         *
         * Sets <resizeContainer>.
         *
         * Parameters:
         *
         * value - Boolean indicating if the container should be resized.
         */
        setResizeContainer(value: boolean): void;
        /**
         * Function: isEnabled
         *
         * Returns true if the graph is <enabled>.
         */
        isEnabled(): boolean;
        /**
         * Function: setEnabled
         *
         * Specifies if the graph should allow any interactions. This
         * implementation updates <enabled>.
         *
         * Parameters:
         *
         * value - Boolean indicating if the graph should be enabled.
         */
        setEnabled(value: boolean): void;
        /**
         * Function: isEscapeEnabled
         *
         * Returns <escapeEnabled>.
         */
        isEscapeEnabled(): boolean;
        /**
         * Function: setEscapeEnabled
         *
         * Sets <escapeEnabled>.
         *
         * Parameters:
         *
         * enabled - Boolean indicating if escape should be enabled.
         */
        setEscapeEnabled(value: boolean): void;
        /**
         * Function: isInvokesStopCellEditing
         *
         * Returns <invokesStopCellEditing>.
         */
        isInvokesStopCellEditing(): boolean;
        /**
         * Function: setInvokesStopCellEditing
         *
         * Sets <invokesStopCellEditing>.
         */
        setInvokesStopCellEditing(value: boolean): void;
        /**
         * Function: isEnterStopsCellEditing
         *
         * Returns <enterStopsCellEditing>.
         */
        isEnterStopsCellEditing(): boolean;
        /**
         * Function: setEnterStopsCellEditing
         *
         * Sets <enterStopsCellEditing>.
         */
        setEnterStopsCellEditing(value: boolean): void;
        /**
         * Function: isCellLocked
         *
         * Returns true if the given cell may not be moved, sized, bended,
         * disconnected, edited or selected. This implementation returns true for
         * all vertices with a relative geometry if <locked> is false.
         *
         * Parameters:
         *
         * cell - <mxCell> whose locked state should be returned.
         */
        isCellLocked(cell: mxCell): boolean;
        /**
         * Function: isCellsLocked
         *
         * Returns true if the given cell may not be moved, sized, bended,
         * disconnected, edited or selected. This implementation returns true for
         * all vertices with a relative geometry if <locked> is false.
         *
         * Parameters:
         *
         * cell - <mxCell> whose locked state should be returned.
         */
        isCellsLocked(): boolean;
        /**
         * Function: setCellsLocked
         *
         * Sets if any cell may be moved, sized, bended, disconnected, edited or
         * selected.
         *
         * Parameters:
         *
         * value - Boolean that defines the new value for <cellsLocked>.
         */
        setCellsLocked(value: boolean): void;
        /**
         * Function: getCloneableCells
         *
         * Returns the cells which may be exported in the given array of cells.
         */
        getCloneableCells(cells: mxCell[]): mxCell[];
        /**
         * Function: isCellCloneable
         *
         * Returns true if the given cell is cloneable. This implementation returns
         * <isCellsCloneable> for all cells unless a cell style specifies
         * <mxConstants.STYLE_CLONEABLE> to be 0.
         *
         * Parameters:
         *
         * cell - Optional <mxCell> whose cloneable state should be returned.
         */
        isCellCloneable(cell?: mxCell): boolean;
        /**
         * Function: isCellsCloneable
         *
         * Returns <cellsCloneable>, that is, if the graph allows cloning of cells
         * by using control-drag.
         */
        isCellsCloneable(): boolean;
        /**
         * Function: setCellsCloneable
         *
         * Specifies if the graph should allow cloning of cells by holding down the
         * control key while cells are being moved. This implementation updates
         * <cellsCloneable>.
         *
         * Parameters:
         *
         * value - Boolean indicating if the graph should be cloneable.
         */
        setCellsCloneable(value: boolean): void;
        /**
         * Function: getExportableCells
         *
         * Returns the cells which may be exported in the given array of cells.
         */
        getExportableCells(cells: mxCell[]): mxCell[];
        /**
         * Function: canExportCell
         *
         * Returns true if the given cell may be exported to the clipboard. This
         * implementation returns <exportEnabled> for all cells.
         *
         * Parameters:
         *
         * cell - <mxCell> that represents the cell to be exported.
         */
        canExportCell(cell: mxCell): boolean;
        /**
         * Function: getImportableCells
         *
         * Returns the cells which may be imported in the given array of cells.
         */
        getImportableCells(cells: mxCell[]): mxCell[];
        /**
         * Function: canImportCell
         *
         * Returns true if the given cell may be imported from the clipboard.
         * This implementation returns <importEnabled> for all cells.
         *
         * Parameters:
         *
         * cell - <mxCell> that represents the cell to be imported.
         */
        canImportCell(cell: mxCell): boolean;
        /**
         * Function: isCellSelectable
         *
         * Returns true if the given cell is selectable. This implementation
         * returns <cellsSelectable>.
         *
         * To add a new style for making cells (un)selectable, use the following code.
         *
         * (code)
         * mxGraph.prototype.isCellSelectable = function(cell)
         * {
         *   var style = this.getCurrentCellStyle(cell);
         *
         *   return this.isCellsSelectable() && !this.isCellLocked(cell) && style['selectable'] != 0;
         * };
         * (end)
         *
         * You can then use the new style as shown in this example.
         *
         * (code)
         * graph.insertVertex(parent, null, 'Hello,', 20, 20, 80, 30, 'selectable=0');
         * (end)
         *
         * Parameters:
         *
         * cell - <mxCell> whose selectable state should be returned.
         */
        isCellSelectable(cell: mxCell): boolean;
        /**
         * Function: isCellsSelectable
         *
         * Returns <cellsSelectable>.
         */
        isCellsSelectable(): boolean;
        /**
         * Function: setCellsSelectable
         *
         * Sets <cellsSelectable>.
         */
        setCellsSelectable(value: boolean): void;
        /**
         * Function: getDeletableCells
         *
         * Returns the cells which may be exported in the given array of cells.
         */
        getDeletableCells(cells: mxCell[]): mxCell[];
        /**
         * Function: isCellDeletable
         *
         * Returns true if the given cell is moveable. This returns
         * <cellsDeletable> for all given cells if a cells style does not specify
         * <mxConstants.STYLE_DELETABLE> to be 0.
         *
         * Parameters:
         *
         * cell - <mxCell> whose deletable state should be returned.
         */
        isCellDeletable(cell: mxCell): boolean;
        /**
         * Function: isCellsDeletable
         *
         * Returns <cellsDeletable>.
         */
        isCellsDeletable(): boolean;
        /**
         * Function: setCellsDeletable
         *
         * Sets <cellsDeletable>.
         *
         * Parameters:
         *
         * value - Boolean indicating if the graph should allow deletion of cells.
         */
        setCellsDeletable(value: boolean): void;
        /**
         * Function: isLabelMovable
         *
         * Returns true if the given edges's label is moveable. This returns
         * <movable> for all given cells if <isLocked> does not return true
         * for the given cell.
         *
         * Parameters:
         *
         * cell - <mxCell> whose label should be moved.
         */
        isLabelMovable(cell: mxCell): boolean;
        /**
         * Function: isCellRotatable
         *
         * Returns true if the given cell is rotatable. This returns true for the given
         * cell if its style does not specify <mxConstants.STYLE_ROTATABLE> to be 0.
         *
         * Parameters:
         *
         * cell - <mxCell> whose rotatable state should be returned.
         */
        isCellRotatable(cell: mxCell): boolean;
        /**
         * Function: getMovableCells
         *
         * Returns the cells which are movable in the given array of cells.
         */
        getMovableCells(cells: mxCell[]): mxCell[];
        /**
         * Function: isCellMovable
         *
         * Returns true if the given cell is moveable. This returns <cellsMovable>
         * for all given cells if <isCellLocked> does not return true for the given
         * cell and its style does not specify <mxConstants.STYLE_MOVABLE> to be 0.
         *
         * Parameters:
         *
         * cell - <mxCell> whose movable state should be returned.
         */
        isCellMovable(cell: mxCell): boolean;
        /**
         * Function: isCellsMovable
         *
         * Returns <cellsMovable>.
         */
        isCellsMovable(): boolean;
        /**
         * Function: setCellsMovable
         *
         * Specifies if the graph should allow moving of cells. This implementation
         * updates <cellsMsovable>.
         *
         * Parameters:
         *
         * value - Boolean indicating if the graph should allow moving of cells.
         */
        setCellsMovable(value: boolean): void;
        /**
         * Function: isGridEnabled
         *
         * Returns <gridEnabled> as a boolean.
         */
        isGridEnabled(): boolean;
        /**
         * Function: setGridEnabled
         *
         * Specifies if the grid should be enabled.
         *
         * Parameters:
         *
         * value - Boolean indicating if the grid should be enabled.
         */
        setGridEnabled(value: boolean): void;
        /**
         * Function: isPortsEnabled
         *
         * Returns <portsEnabled> as a boolean.
         */
        isPortsEnabled(): boolean;
        /**
         * Function: setPortsEnabled
         *
         * Specifies if the ports should be enabled.
         *
         * Parameters:
         *
         * value - Boolean indicating if the ports should be enabled.
         */
        setPortsEnabled(value: boolean): void;
        /**
         * Function: getGridSize
         *
         * Returns <gridSize>.
         */
        getGridSize(): any;
        /**
         * Function: setGridSize
         *
         * Sets <gridSize>.
         */
        setGridSize(value: any): void;
        /**
         * Function: getTolerance
         *
         * Returns <tolerance>.
         */
        getTolerance(): any;
        /**
         * Function: setTolerance
         *
         * Sets <tolerance>.
         */
        setTolerance(value: any): void;
        /**
         * Function: isVertexLabelsMovable
         *
         * Returns <vertexLabelsMovable>.
         */
        isVertexLabelsMovable(): boolean;
        /**
         * Function: setVertexLabelsMovable
         *
         * Sets <vertexLabelsMovable>.
         */
        setVertexLabelsMovable(value: boolean): void;
        /**
         * Function: isEdgeLabelsMovable
         *
         * Returns <edgeLabelsMovable>.
         */
        isEdgeLabelsMovable(): boolean;
        /**
         * Function: isEdgeLabelsMovable
         *
         * Sets <edgeLabelsMovable>.
         */
        setEdgeLabelsMovable(value: boolean): void;
        /**
         * Function: isSwimlaneNesting
         *
         * Returns <swimlaneNesting> as a boolean.
         */
        isSwimlaneNesting(): boolean;
        /**
         * Function: setSwimlaneNesting
         *
         * Specifies if swimlanes can be nested by drag and drop. This is only
         * taken into account if dropEnabled is true.
         *
         * Parameters:
         *
         * value - Boolean indicating if swimlanes can be nested.
         */
        setSwimlaneNesting(value: boolean): void;
        /**
         * Function: isSwimlaneSelectionEnabled
         *
         * Returns <swimlaneSelectionEnabled> as a boolean.
         */
        isSwimlaneSelectionEnabled(): boolean;
        /**
         * Function: setSwimlaneSelectionEnabled
         *
         * Specifies if swimlanes should be selected if the mouse is released
         * over their content area.
         *
         * Parameters:
         *
         * value - Boolean indicating if swimlanes content areas
         * should be selected when the mouse is released over them.
         */
        setSwimlaneSelectionEnabled(value: boolean): void;
        /**
         * Function: isMultigraph
         *
         * Returns <multigraph> as a boolean.
         */
        isMultigraph(): boolean;
        /**
         * Function: setMultigraph
         *
         * Specifies if the graph should allow multiple connections between the
         * same pair of vertices.
         *
         * Parameters:
         *
         * value - Boolean indicating if the graph allows multiple connections
         * between the same pair of vertices.
         */
        setMultigraph(value: boolean): void;
        /**
         * Function: isAllowLoops
         *
         * Returns <allowLoops> as a boolean.
         */
        isAllowLoops(): boolean;
        /**
         * Function: setAllowDanglingEdges
         *
         * Specifies if dangling edges are allowed, that is, if edges are allowed
         * that do not have a source and/or target terminal defined.
         *
         * Parameters:
         *
         * value - Boolean indicating if dangling edges are allowed.
         */
        setAllowDanglingEdges(value: boolean): void;
        /**
         * Function: isAllowDanglingEdges
         *
         * Returns <allowDanglingEdges> as a boolean.
         */
        isAllowDanglingEdges(): boolean;
        /**
         * Function: setConnectableEdges
         *
         * Specifies if edges should be connectable.
         *
         * Parameters:
         *
         * value - Boolean indicating if edges should be connectable.
         */
        setConnectableEdges(value: boolean): void;
        /**
         * Function: isConnectableEdges
         *
         * Returns <connectableEdges> as a boolean.
         */
        isConnectableEdges(): boolean;
        /**
         * Function: setCloneInvalidEdges
         *
         * Specifies if edges should be inserted when cloned but not valid wrt.
         * <getEdgeValidationError>. If false such edges will be silently ignored.
         *
         * Parameters:
         *
         * value - Boolean indicating if cloned invalid edges should be
         * inserted into the graph or ignored.
         */
        setCloneInvalidEdges(value: boolean): void;
        /**
         * Function: isCloneInvalidEdges
         *
         * Returns <cloneInvalidEdges> as a boolean.
         */
        isCloneInvalidEdges(): boolean;
        /**
         * Function: setAllowLoops
         *
         * Specifies if loops are allowed.
         *
         * Parameters:
         *
         * value - Boolean indicating if loops are allowed.
         */
        setAllowLoops(value: boolean): void;
        /**
         * Function: isDisconnectOnMove
         *
         * Returns <disconnectOnMove> as a boolean.
         */
        isDisconnectOnMove(): boolean;
        /**
         * Function: setDisconnectOnMove
         *
         * Specifies if edges should be disconnected when moved. (Note: Cloned
         * edges are always disconnected.)
         *
         * Parameters:
         *
         * value - Boolean indicating if edges should be disconnected
         * when moved.
         */
        setDisconnectOnMove(value: boolean): void;
        /**
         * Function: isDropEnabled
         *
         * Returns <dropEnabled> as a boolean.
         */
        isDropEnabled(): boolean;
        /**
         * Function: setDropEnabled
         *
         * Specifies if the graph should allow dropping of cells onto or into other
         * cells.
         *
         * Parameters:
         *
         * dropEnabled - Boolean indicating if the graph should allow dropping
         * of cells into other cells.
         */
        setDropEnabled(value: boolean): void;
        /**
         * Function: isSplitEnabled
         *
         * Returns <splitEnabled> as a boolean.
         */
        isSplitEnabled(): boolean;
        /**
         * Function: setSplitEnabled
         *
         * Specifies if the graph should allow dropping of cells onto or into other
         * cells.
         *
         * Parameters:
         *
         * dropEnabled - Boolean indicating if the graph should allow dropping
         * of cells into other cells.
         */
        setSplitEnabled(value: boolean): void;
        /**
         * Function: isCellResizable
         *
         * Returns true if the given cell is resizable. This returns
         * <cellsResizable> for all given cells if <isCellLocked> does not return
         * true for the given cell and its style does not specify
         * <mxConstants.STYLE_RESIZABLE> to be 0.
         *
         * Parameters:
         *
         * cell - <mxCell> whose resizable state should be returned.
         */
        isCellResizable(cell: mxCell): boolean;
        /**
         * Function: isCellsResizable
         *
         * Returns <cellsResizable>.
         */
        isCellsResizable(): boolean;
        /**
         * Function: setCellsResizable
         *
         * Specifies if the graph should allow resizing of cells. This
         * implementation updates <cellsResizable>.
         *
         * Parameters:
         *
         * value - Boolean indicating if the graph should allow resizing of
         * cells.
         */
        setCellsResizable(value: boolean): void;
        /**
         * Function: isTerminalPointMovable
         *
         * Returns true if the given terminal point is movable. This is independent
         * from <isCellConnectable> and <isCellDisconnectable> and controls if terminal
         * points can be moved in the graph if the edge is not connected. Note that it
         * is required for this to return true to connect unconnected edges. This
         * implementation returns true.
         *
         * Parameters:
         *
         * cell - <mxCell> whose terminal point should be moved.
         * source - Boolean indicating if the source or target terminal should be moved.
         */
        isTerminalPointMovable(cell: mxCell, source: boolean): boolean;
        /**
         * Function: isCellBendable
         *
         * Returns true if the given cell is bendable. This returns <cellsBendable>
         * for all given cells if <isLocked> does not return true for the given
         * cell and its style does not specify <mxConstants.STYLE_BENDABLE> to be 0.
         *
         * Parameters:
         *
         * cell - <mxCell> whose bendable state should be returned.
         */
        isCellBendable(cell: mxCell): boolean;
        /**
         * Function: isCellsBendable
         *
         * Returns <cellsBenadable>.
         */
        isCellsBendable(): boolean;
        /**
         * Function: setCellsBendable
         *
         * Specifies if the graph should allow bending of edges. This
         * implementation updates <bendable>.
         *
         * Parameters:
         *
         * value - Boolean indicating if the graph should allow bending of
         * edges.
         */
        setCellsBendable(value: boolean): void;
        /**
         * Function: isCellEditable
         *
         * Returns true if the given cell is editable. This returns <cellsEditable> for
         * all given cells if <isCellLocked> does not return true for the given cell
         * and its style does not specify <mxConstants.STYLE_EDITABLE> to be 0.
         *
         * Parameters:
         *
         * cell - <mxCell> whose editable state should be returned.
         */
        isCellEditable(cell: mxCell): boolean;
        /**
         * Function: isCellsEditable
         *
         * Returns <cellsEditable>.
         */
        isCellsEditable(): boolean;
        /**
         * Function: setCellsEditable
         *
         * Specifies if the graph should allow in-place editing for cell labels.
         * This implementation updates <cellsEditable>.
         *
         * Parameters:
         *
         * value - Boolean indicating if the graph should allow in-place
         * editing.
         */
        setCellsEditable(value: boolean): void;
        /**
         * Function: isCellDisconnectable
         *
         * Returns true if the given cell is disconnectable from the source or
         * target terminal. This returns <isCellsDisconnectable> for all given
         * cells if <isCellLocked> does not return true for the given cell.
         *
         * Parameters:
         *
         * cell - <mxCell> whose disconnectable state should be returned.
         * terminal - <mxCell> that represents the source or target terminal.
         * source - Boolean indicating if the source or target terminal is to be
         * disconnected.
         */
        isCellDisconnectable(cell: mxCell, terminal: mxCell, source: boolean): boolean;
        /**
         * Function: isCellsDisconnectable
         *
         * Returns <cellsDisconnectable>.
         */
        isCellsDisconnectable(): boolean;
        /**
         * Function: setCellsDisconnectable
         *
         * Sets <cellsDisconnectable>.
         */
        setCellsDisconnectable(value: boolean): void;
        /**
         * Function: isValidSource
         *
         * Returns true if the given cell is a valid source for new connections.
         * This implementation returns true for all non-null values and is
         * called by is called by <isValidConnection>.
         *
         * Parameters:
         *
         * cell - <mxCell> that represents a possible source or null.
         */
        isValidSource(cell: mxCell): boolean;
        /**
         * Function: isValidTarget
         *
         * Returns <isValidSource> for the given cell. This is called by
         * <isValidConnection>.
         *
         * Parameters:
         *
         * cell - <mxCell> that represents a possible target or null.
         */
        isValidTarget(cell: mxCell): boolean;
        /**
         * Function: isValidConnection
         *
         * Returns true if the given target cell is a valid target for source.
         * This is a boolean implementation for not allowing connections between
         * certain pairs of vertices and is called by <getEdgeValidationError>.
         * This implementation returns true if <isValidSource> returns true for
         * the source and <isValidTarget> returns true for the target.
         *
         * Parameters:
         *
         * source - <mxCell> that represents the source cell.
         * target - <mxCell> that represents the target cell.
         */
        isValidConnection(source: mxCell, target: mxCell): boolean;
        /**
         * Function: setConnectable
         *
         * Specifies if the graph should allow new connections. This implementation
         * updates <mxConnectionHandler.enabled> in <connectionHandler>.
         *
         * Parameters:
         *
         * connectable - Boolean indicating if new connections should be allowed.
         */
        setConnectable(connectable: boolean): void;
        /**
         * Function: isConnectable
         *
         * Returns true if the <connectionHandler> is enabled.
         */
        isConnectable(): boolean;
        /**
         * Function: setTooltips
         *
         * Specifies if tooltips should be enabled. This implementation updates
         * <mxTooltipHandler.enabled> in <tooltipHandler>.
         *
         * Parameters:
         *
         * enabled - Boolean indicating if tooltips should be enabled.
         */
        setTooltips(enabled: boolean): void;
        /**
         * Function: setPanning
         *
         * Specifies if panning should be enabled. This implementation updates
         * <mxPanningHandler.panningEnabled> in <panningHandler>.
         *
         * Parameters:
         *
         * enabled - Boolean indicating if panning should be enabled.
         */
        setPanning(enabled: boolean): void;
        /**
         * Function: isEditing
         *
         * Returns true if the given cell is currently being edited.
         * If no cell is specified then this returns true if any
         * cell is currently being edited.
         *
         * Parameters:
         *
         * cell - <mxCell> that should be checked.
         */
        isEditing(cell?: mxCell): boolean;
        /**
         * Function: isAutoSizeCell
         *
         * Returns true if the size of the given cell should automatically be
         * updated after a change of the label. This implementation returns
         * <autoSizeCells> or checks if the cell style does specify
         * <mxConstants.STYLE_AUTOSIZE> to be 1.
         *
         * Parameters:
         *
         * cell - <mxCell> that should be resized.
         */
        isAutoSizeCell(cell: mxCell): boolean;
        /**
         * Function: isAutoSizeCells
         *
         * Returns <autoSizeCells>.
         */
        isAutoSizeCells(): boolean;
        /**
         * Function: setAutoSizeCells
         *
         * Specifies if cell sizes should be automatically updated after a label
         * change. This implementation sets <autoSizeCells> to the given parameter.
         * To update the size of cells when the cells are added, set
         * <autoSizeCellsOnAdd> to true.
         *
         * Parameters:
         *
         * value - Boolean indicating if cells should be resized
         * automatically.
         */
        setAutoSizeCells(value: boolean): void;
        /**
         * Function: isExtendParent
         *
         * Returns true if the parent of the given cell should be extended if the
         * child has been resized so that it overlaps the parent. This
         * implementation returns <isExtendParents> if the cell is not an edge.
         *
         * Parameters:
         *
         * cell - <mxCell> that has been resized.
         */
        isExtendParent(cell: mxCell): boolean;
        /**
         * Function: isExtendParents
         *
         * Returns <extendParents>.
         */
        isExtendParents(): boolean;
        /**
         * Function: setExtendParents
         *
         * Sets <extendParents>.
         *
         * Parameters:
         *
         * value - New boolean value for <extendParents>.
         */
        setExtendParents(value: boolean): void;
        /**
         * Function: isExtendParentsOnAdd
         *
         * Returns <extendParentsOnAdd>.
         */
        isExtendParentsOnAdd(cell: mxCell): boolean;
        /**
         * Function: setExtendParentsOnAdd
         *
         * Sets <extendParentsOnAdd>.
         *
         * Parameters:
         *
         * value - New boolean value for <extendParentsOnAdd>.
         */
        setExtendParentsOnAdd(value: boolean): void;
        /**
         * Function: isExtendParentsOnMove
         *
         * Returns <extendParentsOnMove>.
         */
        isExtendParentsOnMove(): boolean;
        /**
         * Function: setExtendParentsOnMove
         *
         * Sets <extendParentsOnMove>.
         *
         * Parameters:
         *
         * value - New boolean value for <extendParentsOnAdd>.
         */
        setExtendParentsOnMove(value: boolean): void;
        /**
         * Function: isRecursiveResize
         *
         * Returns <recursiveResize>.
         *
         * Parameters:
         *
         * state - <mxCellState> that is being resized.
         */
        isRecursiveResize(state: mxCellState): boolean;
        /**
         * Function: setRecursiveResize
         *
         * Sets <recursiveResize>.
         *
         * Parameters:
         *
         * value - New boolean value for <recursiveResize>.
         */
        setRecursiveResize(value: boolean): void;
        /**
         * Function: isConstrainChild
         *
         * Returns true if the given cell should be kept inside the bounds of its
         * parent according to the rules defined by <getOverlap> and
         * <isAllowOverlapParent>. This implementation returns false for all children
         * of edges and <isConstrainChildren> otherwise.
         *
         * Parameters:
         *
         * cell - <mxCell> that should be constrained.
         */
        isConstrainChild(cell: mxCell): boolean;
        /**
         * Function: isConstrainChildren
         *
         * Returns <constrainChildren>.
         */
        isConstrainChildren(): boolean;
        /**
         * Function: setConstrainChildren
         *
         * Sets <constrainChildren>.
         */
        setConstrainChildren(value: boolean): void;
        /**
         * Function: isConstrainRelativeChildren
         *
         * Returns <constrainRelativeChildren>.
         */
        isConstrainRelativeChildren(): boolean;
        /**
         * Function: setConstrainRelativeChildren
         *
         * Sets <constrainRelativeChildren>.
         */
        setConstrainRelativeChildren(value: boolean): void;
        /**
         * Function: isConstrainChildren
         *
         * Returns <allowNegativeCoordinates>.
         */
        isAllowNegativeCoordinates(): boolean;
        /**
         * Function: setConstrainChildren
         *
         * Sets <allowNegativeCoordinates>.
         */
        setAllowNegativeCoordinates(value: boolean): void;
        /**
         * Function: getOverlap
         *
         * Returns a decimal number representing the amount of the width and height
         * of the given cell that is allowed to overlap its parent. A value of 0
         * means all children must stay inside the parent, 1 means the child is
         * allowed to be placed outside of the parent such that it touches one of
         * the parents sides. If <isAllowOverlapParent> returns false for the given
         * cell, then this method returns 0.
         *
         * Parameters:
         *
         * cell - <mxCell> for which the overlap ratio should be returned.
         */
        getOverlap(cell: mxCell): number;
        /**
         * Function: isAllowOverlapParent
         *
         * Returns true if the given cell is allowed to be placed outside of the
         * parents area.
         *
         * Parameters:
         *
         * cell - <mxCell> that represents the child to be checked.
         */
        isAllowOverlapParent(cell: mxCell): boolean;
        /**
         * Function: getFoldableCells
         *
         * Returns the cells which are movable in the given array of cells.
         */
        getFoldableCells(cells: mxCell[], collapse: boolean): mxCell[];
        /**
         * Function: isCellFoldable
         *
         * Returns true if the given cell is foldable. This implementation
         * returns true if the cell has at least one child and its style
         * does not specify <mxConstants.STYLE_FOLDABLE> to be 0.
         *
         * Parameters:
         *
         * cell - <mxCell> whose foldable state should be returned.
         */
        isCellFoldable(cell: mxCell, collapse?: boolean): boolean;
        /**
         * Function: isValidDropTarget
         *
         * Returns true if the given cell is a valid drop target for the specified
         * cells. If <splitEnabled> is true then this returns <isSplitTarget> for
         * the given arguments else it returns true if the cell is not collapsed
         * and its child count is greater than 0.
         *
         * Parameters:
         *
         * cell - <mxCell> that represents the possible drop target.
         * cells - <mxCells> that should be dropped into the target.
         * evt - Mouseevent that triggered the invocation.
         */
        isValidDropTarget(cell: mxCell, cells?: mxCell[], evt?: any): boolean;
        /**
         * Function: isSplitTarget
         *
         * Returns true if the given edge may be splitted into two edges with the
         * given cell as a new terminal between the two.
         *
         * Parameters:
         *
         * target - <mxCell> that represents the edge to be splitted.
         * cells - <mxCells> that should split the edge.
         * evt - Mouseevent that triggered the invocation.
         */
        isSplitTarget(target: mxCell, cells?: mxCell[], evt?: any): boolean;
        /**
         * Function: getDropTarget
         *
         * Returns the given cell if it is a drop target for the given cells or the
         * nearest ancestor that may be used as a drop target for the given cells.
         * If the given array contains a swimlane and <swimlaneNesting> is false
         * then this always returns null. If no cell is given, then the bottommost
         * swimlane at the location of the given event is returned.
         *
         * This function should only be used if <isDropEnabled> returns true.
         *
         * Parameters:
         *
         * cells - Array of <mxCells> which are to be dropped onto the target.
         * evt - Mouseevent for the drag and drop.
         * cell - <mxCell> that is under the mousepointer.
         * clone - Optional boolean to indicate of cells will be cloned.
         */
        getDropTarget(cells: mxCell[], evt: any, cell?: mxCell, clone?: boolean): mxCell;
        /**
         * Group: Cell retrieval
         */
        /**
         * Function: getDefaultParent
         *
         * Returns <defaultParent> or <mxGraphView.currentRoot> or the first child
         * child of <mxGraphModel.root> if both are null. The value returned by
         * this function should be used as the parent for new cells (aka default
         * layer).
         */
        getDefaultParent(): mxCell;
        /**
         * Function: setDefaultParent
         *
         * Sets the <defaultParent> to the given cell. Set this to null to return
         * the first child of the root in getDefaultParent.
         */
        setDefaultParent(cell: mxCell): void;
        /**
         * Function: getSwimlane
         *
         * Returns the nearest ancestor of the given cell which is a swimlane, or
         * the given cell, if it is itself a swimlane.
         *
         * Parameters:
         *
         * cell - <mxCell> for which the ancestor swimlane should be returned.
         */
        getSwimlane(cell: mxCell): mxCell;
        /**
         * Function: getSwimlaneAt
         *
         * Returns the bottom-most swimlane that intersects the given point (x, y)
         * in the cell hierarchy that starts at the given parent.
         *
         * Parameters:
         *
         * x - X-coordinate of the location to be checked.
         * y - Y-coordinate of the location to be checked.
         * parent - <mxCell> that should be used as the root of the recursion.
         * Default is <defaultParent>.
         */
        getSwimlaneAt(x: number, y: number, parent?: mxCell): mxCell;
        /**
         * Function: getCellAt
         *
         * Returns the bottom-most cell that intersects the given point (x, y) in
         * the cell hierarchy starting at the given parent. This will also return
         * swimlanes if the given location intersects the content area of the
         * swimlane. If this is not desired, then the <hitsSwimlaneContent> may be
         * used if the returned cell is a swimlane to determine if the location
         * is inside the content area or on the actual title of the swimlane.
         *
         * Parameters:
         *
         * x - X-coordinate of the location to be checked.
         * y - Y-coordinate of the location to be checked.
         * parent - <mxCell> that should be used as the root of the recursion.
         * Default is current root of the view or the root of the model.
         * vertices - Optional boolean indicating if vertices should be returned.
         * Default is true.
         * edges - Optional boolean indicating if edges should be returned. Default
         * is true.
         * ignoreFn - Optional function that returns true if cell should be ignored.
         * The function is passed the cell state and the x and y parameter.
         */
        getCellAt(x: number, y: number, parent?: mxCell, vertices?: boolean, edges?: boolean, ignoreFn?: any): mxCell;
        /**
         * Function: intersects
         *
         * Returns the bottom-most cell that intersects the given point (x, y) in
         * the cell hierarchy that starts at the given parent.
         *
         * Parameters:
         *
         * state - <mxCellState> that represents the cell state.
         * x - X-coordinate of the location to be checked.
         * y - Y-coordinate of the location to be checked.
         */
        intersects(state: mxCellState, x: number, y: number): boolean;
        /**
         * Function: hitsSwimlaneContent
         *
         * Returns true if the given coordinate pair is inside the content
         * are of the given swimlane.
         *
         * Parameters:
         *
         * swimlane - <mxCell> that specifies the swimlane.
         * x - X-coordinate of the mouse event.
         * y - Y-coordinate of the mouse event.
         */
        hitsSwimlaneContent(swimlane: mxCell, x: number, y: number): boolean;
        /**
         * Function: getChildVertices
         *
         * Returns the visible child vertices of the given parent.
         *
         * Parameters:
         *
         * parent - <mxCell> whose children should be returned.
         */
        getChildVertices(parent: mxCell): mxCell[];
        /**
         * Function: getChildEdges
         *
         * Returns the visible child edges of the given parent.
         *
         * Parameters:
         *
         * parent - <mxCell> whose child vertices should be returned.
         */
        getChildEdges(parent: mxCell): mxCell[];
        /**
         * Function: getChildCells
         *
         * Returns the visible child vertices or edges in the given parent. If
         * vertices and edges is false, then all children are returned.
         *
         * Parameters:
         *
         * parent - <mxCell> whose children should be returned.
         * vertices - Optional boolean that specifies if child vertices should
         * be returned. Default is false.
         * edges - Optional boolean that specifies if child edges should
         * be returned. Default is false.
         */
        getChildCells(parent: mxCell, vertices?: boolean, edges?: boolean): mxCell[];
        /**
         * Function: getConnections
         *
         * Returns all visible edges connected to the given cell without loops.
         *
         * Parameters:
         *
         * cell - <mxCell> whose connections should be returned.
         * parent - Optional parent of the opposite end for a connection to be
         * returned.
         */
        getConnections(cell: mxCell, parent?: mxCell): mxCell[];
        /**
         * Function: getIncomingEdges
         *
         * Returns the visible incoming edges for the given cell. If the optional
         * parent argument is specified, then only child edges of the given parent
         * are returned.
         *
         * Parameters:
         *
         * cell - <mxCell> whose incoming edges should be returned.
         * parent - Optional parent of the opposite end for an edge to be
         * returned.
         */
        getIncomingEdges(cell: mxCell, parent?: mxCell): mxCell[];
        /**
         * Function: getOutgoingEdges
         *
         * Returns the visible outgoing edges for the given cell. If the optional
         * parent argument is specified, then only child edges of the given parent
         * are returned.
         *
         * Parameters:
         *
         * cell - <mxCell> whose outgoing edges should be returned.
         * parent - Optional parent of the opposite end for an edge to be
         * returned.
         */
        getOutgoingEdges(cell: mxCell, parent?: mxCell): mxCell[];
        /**
         * Function: getEdges
         *
         * Returns the incoming and/or outgoing edges for the given cell.
         * If the optional parent argument is specified, then only edges are returned
         * where the opposite is in the given parent cell. If at least one of incoming
         * or outgoing is true, then loops are ignored, if both are false, then all
         * edges connected to the given cell are returned including loops.
         *
         * Parameters:
         *
         * cell - <mxCell> whose edges should be returned.
         * parent - Optional parent of the opposite end for an edge to be
         * returned.
         * incoming - Optional boolean that specifies if incoming edges should
         * be included in the result. Default is true.
         * outgoing - Optional boolean that specifies if outgoing edges should
         * be included in the result. Default is true.
         * includeLoops - Optional boolean that specifies if loops should be
         * included in the result. Default is true.
         * recurse - Optional boolean the specifies if the parent specified only
         * need be an ancestral parent, true, or the direct parent, false.
         * Default is false
         */
        getEdges(cell: mxCell, parent?: mxCell, incoming?: boolean, outgoing?: boolean, includeLoops?: boolean, recurse?: boolean): mxCell[];
        /**
         * Function: isValidAncestor
         *
         * Returns whether or not the specified parent is a valid
         * ancestor of the specified cell, either direct or indirectly
         * based on whether ancestor recursion is enabled.
         *
         * Parameters:
         *
         * cell - <mxCell> the possible child cell
         * parent - <mxCell> the possible parent cell
         * recurse - boolean whether or not to recurse the child ancestors
         */
        isValidAncestor(cell: mxCell, parent: mxCell, recurse?: boolean): boolean;
        /**
         * Function: getOpposites
         *
         * Returns all distinct visible opposite cells for the specified terminal
         * on the given edges.
         *
         * Parameters:
         *
         * edges - Array of <mxCells> that contains the edges whose opposite
         * terminals should be returned.
         * terminal - Terminal that specifies the end whose opposite should be
         * returned.
         * sources - Optional boolean that specifies if source terminals should be
         * included in the result. Default is true.
         * targets - Optional boolean that specifies if targer terminals should be
         * included in the result. Default is true.
         */
        getOpposites(edges: mxCell[], terminal: mxCell, sources?: boolean, targets?: boolean): mxCell[];
        /**
         * Function: getEdgesBetween
         *
         * Returns the edges between the given source and target. This takes into
         * account collapsed and invisible cells and returns the connected edges
         * as displayed on the screen.
         *
         * Parameters:
         *
         * source -
         * target -
         * directed -
         */
        getEdgesBetween(source: mxCell, target: mxCell, directed?: boolean): mxCell[];
        /**
         * Function: getPointForEvent
         *
         * Returns an <mxPoint> representing the given event in the unscaled,
         * non-translated coordinate space of <container> and applies the grid.
         *
         * Parameters:
         *
         * evt - Mousevent that contains the mouse pointer location.
         * addOffset - Optional boolean that specifies if the position should be
         * offset by half of the <gridSize>. Default is true.
         */
        getPointForEvent(evt: any, addOffset?: boolean): mxPoint;
        /**
         * Function: getCells
         *
         * Returns the child vertices and edges of the given parent that are contained
         * in the given rectangle. The result is added to the optional result array,
         * which is returned. If no result array is specified then a new array is
         * created and returned.
         *
         * Parameters:
         *
         * x - X-coordinate of the rectangle.
         * y - Y-coordinate of the rectangle.
         * width - Width of the rectangle.
         * height - Height of the rectangle.
         * parent - <mxCell> that should be used as the root of the recursion.
         * Default is current root of the view or the root of the model.
         * result - Optional array to store the result in.
         * intersection - Optional <mxRectangle> to check vertices for intersection.
         * ignoreFn - Optional function to check if a cell state is ignored.
         * includeDescendants - Optional boolean flag to add descendants to the result.
         * Default is false.
         */
        getCells(x: number, y: number, width: number, height: number, parent: mxCell, result?: mxCell[], intersection?: mxRectangle, ignoreFn?: any, includeDescendants?: boolean): mxCell[];
        /**
         * Function: getCellsBeyond
         *
         * Returns the children of the given parent that are contained in the
         * halfpane from the given point (x0, y0) rightwards or downwards
         * depending on rightHalfpane and bottomHalfpane.
         *
         * Parameters:
         *
         * x0 - X-coordinate of the origin.
         * y0 - Y-coordinate of the origin.
         * parent - Optional <mxCell> whose children should be checked. Default is
         * <defaultParent>.
         * rightHalfpane - Boolean indicating if the cells in the right halfpane
         * from the origin should be returned.
         * bottomHalfpane - Boolean indicating if the cells in the bottom halfpane
         * from the origin should be returned.
         */
        getCellsBeyond(x0: number, y0: number, parent?: mxCell, rightHalfpane?: boolean, bottomHalfpane?: boolean): mxCell[];
        /**
         * Function: findTreeRoots
         *
         * Returns all children in the given parent which do not have incoming
         * edges. If the result is empty then the with the greatest difference
         * between incoming and outgoing edges is returned.
         *
         * Parameters:
         *
         * parent - <mxCell> whose children should be checked.
         * isolate - Optional boolean that specifies if edges should be ignored if
         * the opposite end is not a child of the given parent cell. Default is
         * false.
         * invert - Optional boolean that specifies if outgoing or incoming edges
         * should be counted for a tree root. If false then outgoing edges will be
         * counted. Default is false.
         */
        findTreeRoots(parent: mxCell, isolate?: boolean, invert?: boolean): mxCell[];
        /**
         * Function: traverse
         *
         * Traverses the (directed) graph invoking the given function for each
         * visited vertex and edge. The function is invoked with the current vertex
         * and the incoming edge as a parameter. This implementation makes sure
         * each vertex is only visited once. The function may return false if the
         * traversal should stop at the given vertex.
         *
         * Example:
         *
         * (code)
         * mxLog.show();
         * var cell = graph.getSelectionCell();
         * graph.traverse(cell, false, function(vertex, edge)
         * {
         *   mxLog.debug(graph.getLabel(vertex));
         * });
         * (end)
         *
         * Parameters:
         *
         * vertex - <mxCell> that represents the vertex where the traversal starts.
         * directed - Optional boolean indicating if edges should only be traversed
         * from source to target. Default is true.
         * func - Visitor function that takes the current vertex and the incoming
         * edge as arguments. The traversal stops if the function returns false.
         * edge - Optional <mxCell> that represents the incoming edge. This is
         * null for the first step of the traversal.
         * visited - Optional <mxDictionary> from cells to true for the visited cells.
         * inverse - Optional boolean to traverse in inverse direction. Default is false.
         * This is ignored if directed is false.
         */
        traverse(vertex: mxCell, directed?: boolean, func?: any, edge?: mxCell, visited?: boolean, inverse?: boolean): void;
        /**
         * Group: Selection
         */
        /**
         * Function: isCellSelected
         *
         * Returns true if the given cell is selected.
         *
         * Parameters:
         *
         * cell - <mxCell> for which the selection state should be returned.
         */
        isCellSelected(cell: mxCell): boolean;
        /**
         * Function: isSelectionEmpty
         *
         * Returns true if the selection is empty.
         */
        isSelectionEmpty(): boolean;
        /**
         * Function: clearSelection
         *
         * Clears the selection using <mxGraphSelectionModel.clear>.
         */
        clearSelection(): any;
        /**
         * Function: getSelectionCount
         *
         * Returns the number of selected cells.
         */
        getSelectionCount(): number;
        /**
         * Function: getSelectionCell
         *
         * Returns the first cell from the array of selected <mxCells>.
         */
        getSelectionCell(): mxCell;
        /**
         * Function: getSelectionCells
         *
         * Returns the array of selected <mxCells>.
         */
        getSelectionCells(): mxCell[];
        /**
         * Function: setSelectionCell
         *
         * Sets the selection cell.
         *
         * Parameters:
         *
         * cell - <mxCell> to be selected.
         */
        setSelectionCell(cell: mxCell): void;
        /**
         * Function: setSelectionCells
         *
         * Sets the selection cell.
         *
         * Parameters:
         *
         * cells - Array of <mxCells> to be selected.
         */
        setSelectionCells(cells: mxCell[]): void;
        /**
         * Function: addSelectionCell
         *
         * Adds the given cell to the selection.
         *
         * Parameters:
         *
         * cell - <mxCell> to be add to the selection.
         */
        addSelectionCell(cell: mxCell): void;
        /**
         * Function: addSelectionCells
         *
         * Adds the given cells to the selection.
         *
         * Parameters:
         *
         * cells - Array of <mxCells> to be added to the selection.
         */
        addSelectionCells(cells: mxCell[]): void;
        /**
         * Function: removeSelectionCell
         *
         * Removes the given cell from the selection.
         *
         * Parameters:
         *
         * cell - <mxCell> to be removed from the selection.
         */
        removeSelectionCell(cell: mxCell): void;
        /**
         * Function: removeSelectionCells
         *
         * Removes the given cells from the selection.
         *
         * Parameters:
         *
         * cells - Array of <mxCells> to be removed from the selection.
         */
        removeSelectionCells(cells: mxCell[]): void;
        /**
         * Function: selectRegion
         *
         * Selects and returns the cells inside the given rectangle for the
         * specified event.
         *
         * Parameters:
         *
         * rect - <mxRectangle> that represents the region to be selected.
         * evt - Mouseevent that triggered the selection.
         */
        selectRegion(rect: mxRectangle, evt: any): mxCell[];
        /**
         * Function: selectNextCell
         *
         * Selects the next cell.
         */
        selectNextCell(): void;
        /**
         * Function: selectPreviousCell
         *
         * Selects the previous cell.
         */
        selectPreviousCell(): void;
        /**
         * Function: selectParentCell
         *
         * Selects the parent cell.
         */
        selectParentCell(): void;
        /**
         * Function: selectChildCell
         *
         * Selects the first child cell.
         */
        selectChildCell(): void;
        /**
         * Function: selectCell
         *
         * Selects the next, parent, first child or previous cell, if all arguments
         * are false.
         *
         * Parameters:
         *
         * isNext - Boolean indicating if the next cell should be selected.
         * isParent - Boolean indicating if the parent cell should be selected.
         * isChild - Boolean indicating if the first child cell should be selected.
         */
        selectCell(isNext?: boolean, isParent?: boolean, isChild?: boolean): void;
        /**
         * Function: selectAll
         *
         * Selects all children of the given parent cell or the children of the
         * default parent if no parent is specified. To select leaf vertices and/or
         * edges use <selectCells>.
         *
         * Parameters:
         *
         * parent - Optional <mxCell> whose children should be selected.
         * Default is <defaultParent>.
         * descendants - Optional boolean specifying whether all descendants should be
         * selected. Default is false.
         */
        selectAll(parent?: mxCell, descendants?: boolean): void;
        /**
         * Function: selectVertices
         *
         * Select all vertices inside the given parent or the default parent.
         */
        selectVertices(parent?: mxCell, selectGroups?: boolean): void;
        /**
         * Function: selectVertices
         *
         * Select all vertices inside the given parent or the default parent.
         */
        selectEdges(parent?: mxCell): void;
        /**
         * Function: selectCells
         *
         * Selects all vertices and/or edges depending on the given boolean
         * arguments recursively, starting at the given parent or the default
         * parent if no parent is specified. Use <selectAll> to select all cells.
         * For vertices, only cells with no children are selected.
         *
         * Parameters:
         *
         * vertices - Boolean indicating if vertices should be selected.
         * edges - Boolean indicating if edges should be selected.
         * parent - Optional <mxCell> that acts as the root of the recursion.
         * Default is <defaultParent>.
         * selectGroups - Optional boolean that specifies if groups should be
         * selected. Default is false.
         */
        selectCells(vertices: boolean, edges: boolean, parent?: mxCell, selectGroups?: boolean): void;
        /**
         * Function: selectCellForEvent
         *
         * Selects the given cell by either adding it to the selection or
         * replacing the selection depending on whether the given mouse event is a
         * toggle event.
         *
         * Parameters:
         *
         * cell - <mxCell> to be selected.
         * evt - Optional mouseevent that triggered the selection.
         */
        selectCellForEvent(cell: mxCell, evt?: any): void;
        /**
         * Function: selectCellsForEvent
         *
         * Selects the given cells by either adding them to the selection or
         * replacing the selection depending on whether the given mouse event is a
         * toggle event.
         *
         * Parameters:
         *
         * cells - Array of <mxCells> to be selected.
         * evt - Optional mouseevent that triggered the selection.
         */
        selectCellsForEvent(cells: mxCell[], evt?: any): void;
        /**
         * Group: Selection state
         */
        /**
         * Function: createHandler
         *
         * Creates a new handler for the given cell state. This implementation
         * returns a new <mxEdgeHandler> of the corresponding cell is an edge,
         * otherwise it returns an <mxVertexHandler>.
         *
         * Parameters:
         *
         * state - <mxCellState> whose handler should be created.
         */
        createHandler(state: mxCellState): any;
        /**
         * Function: createVertexHandler
         *
         * Hooks to create a new <mxVertexHandler> for the given <mxCellState>.
         *
         * Parameters:
         *
         * state - <mxCellState> to create the handler for.
         */
        createVertexHandler(state: mxCellState): mxVertexHandler;
        /**
         * Function: createEdgeHandler
         *
         * Hooks to create a new <mxEdgeHandler> for the given <mxCellState>.
         *
         * Parameters:
         *
         * state - <mxCellState> to create the handler for.
         */
        createEdgeHandler(state: mxCellState, edgeStyle?: any): mxEdgeHandler;
        /**
         * Function: createEdgeSegmentHandler
         *
         * Hooks to create a new <mxEdgeSegmentHandler> for the given <mxCellState>.
         *
         * Parameters:
         *
         * state - <mxCellState> to create the handler for.
         */
        createEdgeSegmentHandler(state: mxCellState): mxEdgeSegmentHandler;
        /**
         * Function: createElbowEdgeHandler
         *
         * Hooks to create a new <mxElbowEdgeHandler> for the given <mxCellState>.
         *
         * Parameters:
         *
         * state - <mxCellState> to create the handler for.
         */
        createElbowEdgeHandler(state: mxCellState): mxElbowEdgeHandler;
        /**
         * Group: Graph events
         */
        /**
         * Function: addMouseListener
         *
         * Adds a listener to the graph event dispatch loop. The listener
         * must implement the mouseDown, mouseMove and mouseUp methods
         * as shown in the <mxMouseEvent> class.
         *
         * Parameters:
         *
         * listener - Listener to be added to the graph event listeners.
         */
        addMouseListener(listener: any): void;
        /**
         * Function: removeMouseListener
         *
         * Removes the specified graph listener.
         *
         * Parameters:
         *
         * listener - Listener to be removed from the graph event listeners.
         */
        removeMouseListener(listener: any): void;
        /**
         * Function: updateMouseEvent
         *
         * Sets the graphX and graphY properties if the given <mxMouseEvent> if
         * required and returned the event.
         *
         * Parameters:
         *
         * me - <mxMouseEvent> to be updated.
         * evtName - Name of the mouse event.
         */
        updateMouseEvent(me: mxMouseEvent, evtName: any): any;
        /**
         * Function: getStateForEvent
         *
         * Returns the state for the given touch event.
         */
        getStateForTouchEvent(evt: any): mxCellState;
        /**
         * Function: isEventIgnored
         *
         * Returns true if the event should be ignored in <fireMouseEvent>.
         */
        isEventIgnored(evtName: any, me: mxMouseEvent, sender: any): boolean;
        /**
         * Function: isSyntheticEventIgnored
         *
         * Hook for ignoring synthetic mouse events after touchend in Firefox.
         */
        isSyntheticEventIgnored(evtName: any, me: mxMouseEvent, sender?: any): boolean;
        /**
         * Function: isEventSourceIgnored
         *
         * Returns true if the event should be ignored in <fireMouseEvent>. This
         * implementation returns true for select, option and input (if not of type
         * checkbox, radio, button, submit or file) event sources if the event is not
         * a mouse event or a left mouse button press event.
         *
         * Parameters:
         *
         * evtName - The name of the event.
         * me - <mxMouseEvent> that should be ignored.
         */
        isEventSourceIgnored(evtName: any, me: mxMouseEvent): boolean;
        /**
         * Function: getEventState
         *
         * Returns the <mxCellState> to be used when firing the mouse event for the
         * given state. This implementation returns the given state.
         *
         * Parameters:
         *
         * <mxCellState> - State whose event source should be returned.
         */
        getEventState(state: mxCellState): mxCellState;
        /**
         * Function: fireMouseEvent
         *
         * Dispatches the given event in the graph event dispatch loop. Possible
         * event names are <mxEvent.MOUSE_DOWN>, <mxEvent.MOUSE_MOVE> and
         * <mxEvent.MOUSE_UP>. All listeners are invoked for all events regardless
         * of the consumed state of the event.
         *
         * Parameters:
         *
         * evtName - String that specifies the type of event to be dispatched.
         * me - <mxMouseEvent> to be fired.
         * sender - Optional sender argument. Default is this.
         */
        fireMouseEvent(evtName: any, me: mxMouseEvent, sender?: any): void;
        /**
         * Function: consumeMouseEvent
         *
         * Consumes the given <mxMouseEvent> if it's a touchStart event.
         */
        consumeMouseEvent(evtName: any, me: mxMouseEvent, sender?: any): void;
        /**
         * Function: fireGestureEvent
         *
         * Dispatches a <mxEvent.GESTURE> event. The following example will resize the
         * cell under the mouse based on the scale property of the native touch event.
         *
         * (code)
         * graph.addListener(mxEvent.GESTURE, function(sender, eo)
         * {
         *   var evt = eo.getProperty('event');
         *   var state = graph.view.getState(eo.getProperty('cell'));
         *
         *   if (graph.isEnabled() && graph.isCellResizable(state.cell) && Math.abs(1 - evt.scale) > 0.2)
         *   {
         *     var scale = graph.view.scale;
         *     var tr = graph.view.translate;
         *
         *     var w = state.width * evt.scale;
         *     var h = state.height * evt.scale;
         *     var x = state.x - (w - state.width) / 2;
         *     var y = state.y - (h - state.height) / 2;
         *
         *     var bounds = new mxRectangle(graph.snap(x / scale) - tr.x,
         *     		graph.snap(y / scale) - tr.y, graph.snap(w / scale), graph.snap(h / scale));
         *     graph.resizeCell(state.cell, bounds);
         *     eo.consume();
         *   }
         * });
         * (end)
         *
         * Parameters:
         *
         * evt - Gestureend event that represents the gesture.
         * cell - Optional <mxCell> associated with the gesture.
         */
        fireGestureEvent(evt?: any, cell?: mxCell): void;
        /**
         * Function: destroy
         *
         * Destroys the graph and all its resources.
         */
        destroy(): void;
    }
    /**
     * Extends <mxEventSource> to implement a graph overlay, represented by an icon
     * and a tooltip. Overlays can handle and fire <click> events and are added to
     * the graph using <mxGraph.addCellOverlay>, and removed using
     * <mxGraph.removeCellOverlay>, or <mxGraph.removeCellOverlays> to remove all overlays.
     * The <mxGraph.getCellOverlays> function returns the array of overlays for a given
     * cell in a graph. If multiple overlays exist for the same cell, then
     * <getBounds> should be overridden in at least one of the overlays.
     *
     * Overlays appear on top of all cells in a special layer. If this is not
     * desirable, then the image must be rendered as part of the shape or label of
     * the cell instead.
     *
     * Example:
     *
     * The following adds a new overlays for a given vertex and selects the cell
     * if the overlay is clicked.
     *
     * (code)
     * var overlay = new mxCellOverlay(img, html);
     * graph.addCellOverlay(vertex, overlay);
     * overlay.addListener(mxEvent.CLICK, function(sender, evt)
     * {
     *   var cell = evt.getProperty('cell');
     *   graph.setSelectionCell(cell);
     * });
     * (end)
     *
     * For cell overlays to be printed use <mxPrintPreview.printOverlays>.
     *
     * Event: mxEvent.CLICK
     *
     * Fires when the user clicks on the overlay. The <code>event</code> property
     * contains the corresponding mouse event and the <code>cell</code> property
     * contains the cell. For touch devices this is fired if the element receives
     * a touchend event.
     */
    class mxCellOverlay extends mxEventSource {
        /**
         * Holds the <mxImage> to be used as the icon.
         */
        image: any;
        /**
         * Holds the optional string to be used as the tooltip.
         */
        tooltip: any;
        /**
         * Holds the horizontal alignment for the overlay. Default is
         * <mxConstants.ALIGN_RIGHT>. For edges, the overlay always appears in the
         * center of the edge.
         */
        align: string;
        /**
         * Holds the vertical alignment for the overlay. Default is
         * <mxConstants.ALIGN_BOTTOM>. For edges, the overlay always appears in the
         * center of the edge.
         */
        verticalAlign: string;
        /**
         * Holds the offset as an <mxPoint>. The offset will be scaled according to the
         * current scale.
         */
        offset: any;
        /**
         * Holds the cursor for the overlay. Default is 'help'.
         */
        cursor: any;
        /**
         * Defines the overlapping for the overlay, that is, the proportional distance
         * from the origin to the point defined by the alignment. Default is 0.5.
         */
        defaultOverlap: number;
        /**
         * Constructs a new overlay using the given image and tooltip.
         *
         * @param image - <mxImage> that represents the icon to be displayed.
         * @param tooltip - Optional string that specifies the tooltip.
         * @param align - Optional horizontal alignment for the overlay. Possible
         * values are <ALIGN_LEFT>, <ALIGN_CENTER> and <ALIGN_RIGHT>
         * (default).
         * @param verticalAlign - Vertical alignment for the overlay. Possible
         * values are <ALIGN_TOP>, <ALIGN_MIDDLE> and <ALIGN_BOTTOM>
         * (default).
         * @param offset ?
         * @param cursor ?
         */
        constructor(image: mxImage, tooltip?: string, align?: any, verticalAlign?: any, offset?: mxPoint, cursor?: string);
        /**
         * Returns the bounds of the overlay for the given <mxCellState> as an
         * <mxRectangle>. This should be overridden when using multiple overlays
         * per cell so that the overlays do not overlap.
         *
         * The following example will place the overlay along an edge (where
         * x=[-1..1] from the start to the end of the edge and y is the
         * orthogonal offset in px).
         *
         * (code)
         * overlay.getBounds = function(state)
         * {
         *   var bounds = mxCellOverlay.prototype.getBounds.apply(this, arguments);
         *
         *   if (state.view.graph.getModel().isEdge(state.cell))
         *   {
         *     var pt = state.view.getPoint(state, {x: 0, y: 0, relative: true});
         *
         *     bounds.x = pt.x - bounds.width / 2;
         *     bounds.y = pt.y - bounds.height / 2;
         *   }
         *
         *   return bounds;
         * };
         * (end)
         *
         * Parameters:
         *
         * state - <mxCellState> that represents the current state of the
         * associated cell.
         */
        getBounds(state: any): mxRectangle;
        /**
         * Returns the textual representation of the overlay to be used as the
         * tooltip. This implementation returns <tooltip>.
         */
        toString(): any;
    }
    /**
     * Implements an outline (aka overview) for a graph. Set <updateOnPan> to true
     * to enable updates while the source graph is panning.
     *
     * Example:
     *
     * (code)
     * var outline = new mxOutline(graph, div);
     * (end)
     *
     * If an outline is used in an <mxWindow> in IE8 standards mode, the following
     * code makes sure that the shadow filter is not inherited and that any
     * transparent elements in the graph do not show the page background, but the
     * background of the graph container.
     *
     * (code)
     * if (document.documentMode == 8)
     * {
     *   container.style.filter = 'progid:DXImageTransform.Microsoft.alpha(opacity=100)';
     * }
     * (end)
     *
     * To move the graph to the top, left corner the following code can be used.
     *
     * (code)
     * var scale = graph.view.scale;
     * var bounds = graph.getGraphBounds();
     * graph.view.setTranslate(-bounds.x / scale, -bounds.y / scale);
     * (end)
     *
     * To toggle the suspended mode, the following can be used.
     *
     * (code)
     * outline.suspended = !outln.suspended;
     * if (!outline.suspended)
     * {
     *   outline.update(true);
     * }
     * (end)
     *
     * Constructor: mxOutline
     *
     * Constructs a new outline for the specified graph inside the given
     * container.
     *
     * Parameters:
     *
     * source - <mxGraph> to create the outline for.
     * container - DOM node that will contain the outline.
     */
    class mxOutline {
        /**
         * Variable: sizerImage
         *
         * Optional <mxImage> to be used for the sizer. Default is null.
         */
        sizerImage: mxImage;
        /**
         * Variable: labelsVisible
         *
         * Specifies if labels should be visible in the outline. Default is false.
         */
        labelsVisible: boolean;
        graphRenderHint: MxGraphNS.renderingHint;
        source: mxGraph;
        suspended: boolean;
        outline: mxGraph;
        border: number;
        /**
         * Variable: minScale
         *
         * Minimum scale to be used. Default is 0.0001.
         */
        minScale: number;
        constructor(source: any, container?: any);
        /**
         * Creates the <mxGraph> used in the outline.
         */
        createGraph(container: any): mxGraph;
        /**
         * Initializes the outline inside the given container.
         */
        init(container: any): void;
        /**
         * Returns true if events are handled. This implementation
         * returns <enabled>.
         */
        isEnabled(): any;
        /**
         * Enables or disables event handling. This implementation
         * updates <enabled>.
         *
         * Parameters:
         *
         * value - Boolean that specifies the new enabled state.
         */
        setEnabled(value: any): void;
        /**
         * Enables or disables the zoom handling by showing or hiding the respective
         * handle.
         *
         * Parameters:
         *
         * value - Boolean that specifies the new enabled state.
         */
        setZoomEnabled(value: any): void;
        /**
         * Invokes <update> and revalidate the outline. This method is deprecated.
         */
        refresh(): void;
        /**
         * Creates the shape used as the sizer.
         */
        createSizer(): any;
        /**
         * Returns the size of the source container.
         */
        getSourceContainerSize(): mxRectangle;
        /**
         * Returns the offset for drawing the outline graph.
         */
        getOutlineOffset(scale: any): any;
        /**
         * Returns the offset for drawing the outline graph.
         */
        getSourceGraphBounds(): any;
        /**
         * Updates the outline.
         */
        update(revalidate?: any): void;
        /**
         * Handles the event by starting a translation or zoom.
         */
        mouseDown(sender: any, me: any): void;
        /**
         * Handles the event by previewing the viewrect in <graph> and updating the
         * rectangle that represents the viewrect in the outline.
         */
        mouseMove(sender: any, me: any): void;
        /**
         * Gets the translate for the given mouse event. Here is an example to limit
         * the outline to stay within positive coordinates:
         *
         * (code)
         * outline.getTranslateForEvent = function(me)
         * {
         *   var pt = new mxPoint(me.getX() - this.startX, me.getY() - this.startY);
         *
         *   if (!this.zoom)
         *   {
         *     var tr = this.source.view.translate;
         *     pt.x = Math.max(tr.x * this.outline.view.scale, pt.x);
         *     pt.y = Math.max(tr.y * this.outline.view.scale, pt.y);
         *   }
         *
         *   return pt;
         * };
         * (end)
         */
        getTranslateForEvent(me: any): mxPoint;
        /**
         * Handles the event by applying the translation or zoom to <graph>.
         */
        mouseUp(sender: any, me: any): void;
        /**
         * Destroy this outline and removes all listeners from <source>.
         */
        destroy(): void;
    }
    /**
     * Defines invalid connections along with the error messages that they produce.
     * To add or remove rules on a graph, you must add/remove instances of this
     * class to <mxGraph.multiplicities>.
     *
     * Example:
     *
     * (code)
     * graph.multiplicities.push(new mxMultiplicity(
     *   true, 'rectangle', null, null, 0, 2, ['circle'],
     *   'Only 2 targets allowed',
     *   'Only circle targets allowed'));
     * (end)
     *
     * Defines a rule where each rectangle must be connected to no more than 2
     * circles and no other types of targets are allowed.
     */
    class mxMultiplicity {
        /**
         * Defines the type of the source or target terminal. The type is a string
         * passed to <mxUtils.isNode> together with the source or target vertex
         * value as the first argument.
         */
        type: any;
        /**
         * Optional string that specifies the attributename to be passed to
         * <mxUtils.isNode> to check if the rule applies to a cell.
         */
        attr: any;
        /**
         * Optional string that specifies the value of the attribute to be passed
         * to <mxUtils.isNode> to check if the rule applies to a cell.
         */
        value: any;
        /**
         * Boolean that specifies if the rule is applied to the source or target
         * terminal of an edge.
         */
        source: any;
        /**
         * Defines the minimum number of connections for which this rule applies.
         * Default is 0.
         */
        min: any;
        /**
         * Defines the maximum number of connections for which this rule applies.
         * A value of 'n' means unlimited times. Default is 'n'.
         */
        max: any;
        /**
         * Holds an array of strings that specify the type of neighbor for which
         * this rule applies. The strings are used in <mxCell.is> on the opposite
         * terminal to check if the rule applies to the connection.
         */
        validNeighbors: any;
        /**
         * Boolean indicating if the list of validNeighbors are those that are allowed
         * for this rule or those that are not allowed for this rule.
         */
        validNeighborsAllowed: boolean;
        /**
         * Holds the localized error message to be displayed if the number of
         * connections for which the rule applies is smaller than <min> or greater
         * than <max>.
         */
        countError: any;
        /**
         * Holds the localized error message to be displayed if the type of the
         * neighbor for a connection does not match the rule.
         */
        typeError: any;
        /**
         * Instantiate class mxMultiplicity in order to describe allowed
         * connections in a graph. Not all constraints can be enforced while
         * editing, some must be checked at validation time. The <countError> and
         * <typeError> are treated as resource keys in <mxResources>.
         *
         * @param source - Boolean indicating if this rule applies to the source or target
         * terminal.
         * @param type - Type of the source or target terminal that this rule applies to.
         * See <type> for more information.
         * @param attr - Optional attribute name to match the source or target terminal.
         * @param value - Optional attribute value to match the source or target terminal.
         * @param min - Minimum number of edges for this rule. Default is 1.
         * @param max - Maximum number of edges for this rule. n means infinite. Default
         * is n.
         * @param validNeighbors - Array of types of the opposite terminal for which this
         * rule applies.
         * @param countError - Error to be displayed for invalid number of edges.
         * @param typeError - Error to be displayed for invalid opposite terminals.
         * @param validNeighborsAllowed - Optional boolean indicating if the array of
         * opposite types should be valid or invalid.
         */
        constructor(source: boolean, type: any, attr: any, value: any, min: number, max: number | 'n', validNeighbors: any, countError: string, typeError: string, validNeighborsAllowed?: boolean);
        /**
         * Checks the multiplicity for the given arguments and returns the error
         * for the given connection or null if the multiplicity does not apply.
         *
         * graph - Reference to the enclosing <mxGraph> instance.
         * edge - <mxCell> that represents the edge to validate.
         * source - <mxCell> that represents the source terminal.
         * target - <mxCell> that represents the target terminal.
         * sourceOut - Number of outgoing edges from the source terminal.
         * targetIn - Number of incoming edges for the target terminal.
         */
        check(graph: any, edge: any, source: any, target: any, sourceOut: any, targetIn: any): string;
        /**
         * Checks if there are any valid neighbours in <validNeighbors>. This is only
         * called if <validNeighbors> is a non-empty array.
         */
        checkNeighbors(graph: any, edge: any, source: any, target: any): boolean;
        /**
         * Checks the given terminal cell and returns true if this rule applies. The
         * given cell is the source or target of the given edge, depending on
         * <source>. This implementation uses <checkType> on the terminal's value.
         */
        checkTerminal(graph: any, terminal: any, edge: any): any;
        /**
         * Checks the type of the given value.
         */
        checkType(graph: any, value: any, type: any, attr: any, attrValue: any): any;
    }
    /**
     * Implements a layout manager that runs a given layout after any changes to the graph:
     *
     * Example:
     *
     * (code)
     * var layoutMgr = new mxLayoutManager(graph);
     * layoutMgr.getLayout = function(cell)
     * {
     *   return layout;
     * };
     * (end)
     *
     * Event: mxEvent.LAYOUT_CELLS
     *
     * Fires between begin- and endUpdate after all cells have been layouted in
     * <layoutCells>. The <code>cells</code> property contains all cells that have
     * been passed to <layoutCells>.
     *
     * Constructor: mxLayoutManager
     *
     * Constructs a new automatic layout for the given graph.
     *
     * Arguments:
     *
     * graph - Reference to the enclosing graph.
     */
    class mxLayoutManager extends mxEventSource {
        graph: mxGraph;
        constructor(graph: any);
        /**
         * Function: hasLayout
         *
         * Returns true if the given cell has a layout. This implementation invokes
         * <getLayout> with <mxEvent.LAYOUT_CELLS> as the eventName. Override this
         * if creating layouts in <getLayout> is expensive and return true if
         * <getLayout> will return a layout for the given cell for
         * <mxEvent.BEGIN_UPDATE> or <mxEvent.END_UPDATE>.
         */
        hasLayout(cell: any): any;
        /**
         * Returns true if events are handled. This implementation
         * returns <enabled>.
         */
        isEnabled(): any;
        /**
         * Enables or disables event handling. This implementation
         * updates <enabled>.
         *
         * Parameters:
         *
         * enabled - Boolean that specifies the new enabled state.
         */
        setEnabled(enabled: any): void;
        /**
         * Returns true if a layout should bubble, that is, if the parent layout
         * should be executed whenever a cell layout (layout of the children of
         * a cell) has been executed. This implementation returns <bubbling>.
         */
        isBubbling(): any;
        /**
         * Sets <bubbling>.
         */
        setBubbling(value: any): void;
        /**
         * Returns the graph that this layout operates on.
         */
        getGraph(): any;
        /**
         * Sets the graph that the layouts operate on.
         */
        setGraph(graph: any): void;
        /**
         * Returns the layout to be executed for the given graph and parent.
         */
        getLayout(cell: any, eventName?: any): any;
        /**
         * Called from the undoHandler.
         *
         * Parameters:
         *
         * cell - Array of <mxCells> that have been moved.
         * evt - Mouse event that represents the mousedown.
         */
        beforeUndo(undoableEdit: any): void;
        /**
         * Executes the given layout on the given parent.
         */
        executeLayoutForCells(cells: any): void;
        /**
         * Called from the moveHandler.
         *
         * Parameters:
         *
         * cell - Array of <mxCells> that have been moved.
         * evt - Mouse event that represents the mousedown.
         */
        cellsMoved(cells: any, evt: any): void;
        /**
         * Returns the cells to be layouted for the given sequence of changes.
         */
        getCellsForChanges(changes: any): any[];
        /**
         * Executes all layouts which have been scheduled during the
         * changes.
         */
        getCellsForChange(change: any): any[];
        /**
         * Executes all layouts which have been scheduled during the
         * changes.
         */
        layoutCells(cells: any): void;
        /**
         * Executes the given layout on the given parent.
         */
        executeLayout(layout: any, parent: any): boolean;
        /**
         * Removes all handlers from the <graph> and deletes the reference to it.
         */
        destroy(): void;
    }
    /**
     * Manager for swimlanes and nested swimlanes that sets the size of newly added
     * swimlanes to that of their siblings, and propagates changes to the size of a
     * swimlane to its siblings, if <siblings> is true, and its ancestors, if
     * <bubbling> is true.
     *
     * Constructor: mxSwimlaneManager
     *
     * Constructs a new swimlane manager for the given graph.
     *
     * Arguments:
     *
     * graph - Reference to the enclosing graph.
     */
    class mxSwimlaneManager extends mxEventSource {
        constructor(graph: any, horizontal: any, addEnabled: any, resizeEnabled: any);
        /**
         * Returns true if events are handled. This implementation
         * returns <enabled>.
         */
        isEnabled(): any;
        /**
         * Enables or disables event handling. This implementation
         * updates <enabled>.
         *
         * Parameters:
         *
         * enabled - Boolean that specifies the new enabled state.
         */
        setEnabled(value: any): void;
        /**
         * Returns <horizontal>.
         */
        isHorizontal(): any;
        /**
         * Sets <horizontal>.
         */
        setHorizontal(value: any): void;
        /**
         * Returns <addEnabled>.
         */
        isAddEnabled(): any;
        /**
         * Sets <addEnabled>.
         */
        setAddEnabled(value: any): void;
        /**
         * Returns <resizeEnabled>.
         */
        isResizeEnabled(): any;
        /**
         * Sets <resizeEnabled>.
         */
        setResizeEnabled(value: any): void;
        /**
         * Returns the graph that this manager operates on.
         */
        getGraph(): any;
        /**
         * Sets the graph that the manager operates on.
         */
        setGraph(graph: any): void;
        /**
         * Returns true if the given swimlane should be ignored.
         */
        isSwimlaneIgnored(swimlane: any): boolean;
        /**
         * Returns true if the given cell is horizontal. If the given cell is not a
         * swimlane, then the global orientation is returned.
         */
        isCellHorizontal(cell: any): boolean;
        /**
         * Called if any cells have been added.
         *
         * Parameters:
         *
         * cell - Array of <mxCells> that have been added.
         */
        cellsAdded(cells: any): void;
        /**
         * Updates the size of the given swimlane to match that of any existing
         * siblings swimlanes.
         *
         * Parameters:
         *
         * swimlane - <mxCell> that represents the new swimlane.
         */
        swimlaneAdded(swimlane: any): void;
        /**
         * Called if any cells have been resizes. Calls <swimlaneResized> for all
         * swimlanes where <isSwimlaneIgnored> returns false.
         *
         * Parameters:
         *
         * cells - Array of <mxCells> whose size was changed.
         */
        cellsResized(cells: any): void;
        /**
         * Called from <cellsResized> for all swimlanes that are not ignored to update
         * the size of the siblings and the size of the parent swimlanes, recursively,
         * if <bubbling> is true.
         *
         * Parameters:
         *
         * swimlane - <mxCell> whose size has changed.
         */
        resizeSwimlane(swimlane: any, w: any, h: any, parentHorizontal: any): void;
        /**
         * Removes all handlers from the <graph> and deletes the reference to it.
         */
        destroy(): void;
    }
    /**
     * Creates a temporary set of cell states.
     */
    class mxTemporaryCellStates {
        constructor(view: any, scale: any, cells: any, isCellVisibleFn: any, getLinkForCellState: any);
        /**
         * Returns the top, left corner as a new <mxPoint>.
         */
        destroy(): void;
    }
    /**
     *
     * Implements a live preview for moving cells.
     *
     * Constructor: mxCellStatePreview
     *
     * Constructs a move preview for the given graph.
     *
     * Parameters:
     *
     * graph - Reference to the enclosing <mxGraph>.
     */
    class mxCellStatePreview {
        constructor(graph: any);
        /**
         * Returns true if this contains no entries.
         */
        isEmpty(): boolean;
        /**
         * Function: moveState
         */
        moveState(state: any, dx: any, dy: any, add: any, includeEdges: any): any;
        /**
         * Function: show
         */
        show(visitor: any): void;
        /**
         * Function: translateState
         */
        translateState(state: any, dx: any, dy: any): void;
        /**
         * Function: revalidateState
         */
        revalidateState(state: any, dx: any, dy: any, visitor: any): void;
        /**
         * Function: addEdges
         */
        addEdges(state: any): void;
    }
    /**
     * Defines an object that contains the constraints about how to connect one
     * side of an edge to its terminal.
     */
    class mxConnectionConstraint {
        id: any;
        /**
         * <mxPoint> that specifies the fixed location of the connection point.
         */
        point: mxPoint;
        /**
         * Boolean that specifies if the point should be projected onto the perimeter
         * of the terminal.
         */
        perimeter: any;
        /**
         * Optional string that specifies the name of the constraint.
         */
        name: any;
        /**
         * Optional float that specifies the horizontal offset of the constraint.
         */
        dx: number;
        /**
         * Optional float that specifies the vertical offset of the constraint.
         */
        dy: number;
        /**
         * Constructs a new connection constraint for the given point and boolean
         * arguments.
         *
         * @param point - Optional <mxPoint> that specifies the fixed location of the point
         * in relative coordinates. Default is null.
         * @param perimeter - Optional boolean that specifies if the fixed point should be
         * projected onto the perimeter of the terminal. Default is true.
         */
        constructor(point?: mxPoint, perimeter?: boolean, name?: string, dx?: number, dy?: number);
    }
    /**
     * Graph event handler that handles selection. Individual cells are handled
     * separately using <mxVertexHandler> or one of the edge handlers. These
     * handlers are created using <mxGraph.createHandler> in
     * <mxGraphSelectionModel.cellAdded>.
     *
     * To avoid the container to scroll a moved cell into view, set
     * <scrollAfterMove> to false.
     *
     * Constructor: mxGraphHandler
     *
     * Constructs an event handler that creates handles for the
     * selection cells.
     *
     * Parameters:
     *
     * graph - Reference to the enclosing <mxGraph>.
     */
    class mxGraphHandler {
        cellWasClicked: boolean;
        /**
         * Variable: graph
         *
         * Reference to the enclosing <mxGraph>.
         */
        graph: mxGraph;
        /**
         * Variable: maxCells
         *
         * Defines the maximum number of cells to paint subhandles
         * for. Default is 50 for Firefox and 20 for IE. Set this
         * to 0 if you want an unlimited number of handles to be
         * displayed. This is only recommended if the number of
         * cells in the graph is limited to a small number, eg.
         * 500.
         */
        maxCells: number;
        /**
         * Variable: enabled
         *
         * Specifies if events are handled. Default is true.
         */
        enabled: boolean;
        /**
         * Variable: highlightEnabled
         *
         * Specifies if drop targets under the mouse should be enabled. Default is
         * true.
         */
        highlightEnabled: boolean;
        /**
         * Variable: cloneEnabled
         *
         * Specifies if cloning by control-drag is enabled. Default is true.
         */
        cloneEnabled: boolean;
        /**
         * Variable: moveEnabled
         *
         * Specifies if moving is enabled. Default is true.
         */
        moveEnabled: boolean;
        /**
         * Variable: guidesEnabled
         *
         * Specifies if other cells should be used for snapping the right, center or
         * left side of the current selection. Default is false.
         */
        guidesEnabled: boolean;
        /**
         * Variable: handlesVisible
         *
         * Whether the handles of the selection are currently visible.
         */
        handlesVisible: boolean;
        /**
         * Variable: guide
         *
         * Holds the <mxGuide> instance that is used for alignment.
         */
        guide: any;
        /**
         * Repaints the handler after autoscroll
         */
        panHandler: any;
        /**
         * Handles escape keystrokes
         */
        escapeHandler: any;
        /**
         * Updates the preview box for remote changes
         */
        refreshHandler: any;
        /**
         * Waits for the states and handlers to be updated
         */
        refreshThread: any;
        /**
         * Variable: currentDx
         *
         * Stores the x-coordinate of the current mouse move.
         */
        currentDx: any;
        /**
         * Variable: currentDy
         *
         * Stores the y-coordinate of the current mouse move.
         */
        currentDy: any;
        /**
         * Variable: updateCursor
         *
         * Specifies if a move cursor should be shown if the mouse is over a movable
         * cell. Default is true.
         */
        updateCursor: boolean;
        /**
         * Variable: selectEnabled
         *
         * Specifies if selecting is enabled. Default is true.
         */
        selectEnabled: boolean;
        /**
         * Variable: removeCellsFromParent
         *
         * Specifies if cells may be moved out of their parents. Default is true.
         */
        removeCellsFromParent: boolean;
        /**
         * Variable: removeEmptyParents
         *
         * If empty parents should be removed from the model after all child cells
         * have been moved out. Default is true.
         */
        removeEmptyParents: boolean;
        /**
         * Variable: scrollOnMove
         *
         * Specifies if the view should be scrolled so that a moved cell is
         * visible. Default is true.
         */
        connectOnDrop: boolean;
        /**
         * Variable: minimumSize
         *
         * Specifies the minimum number of pixels for the width and height of a
         * selection border. Default is 6.
         */
        minimumSize: number;
        /**
         * Variable: previewColor
         *
         * Specifies the color of the preview shape. Default is black.
         */
        previewColor: string;
        /**
         * Variable: htmlPreview
         *
         * Specifies if the graph container should be used for preview. If this is used
         * then drop target detection relies entirely on <mxGraph.getCellAt> because
         * the HTML preview does not "let events through". Default is false.
         */
        htmlPreview: boolean;
        /**
         * Variable: shape
         *
         * Reference to the <mxShape> that represents the preview.
         */
        shape: mxShape;
        /**
         * Variable: scaleGrid
         *
         * Specifies if the grid should be scaled. Default is false.
         */
        scaleGrid: boolean;
        /**
         * Variable: rotationEnabled
         *
         * Specifies if the bounding box should allow for rotation. Default is true.
         */
        rotationEnabled: boolean;
        /**
         * Variable: maxLivePreview
         *
         * Maximum number of cells for which live preview should be used. Default is 0
         * which means no live preview.
         */
        maxLivePreview: number;
        /**
         * Variable: allowLivePreview
         *
         * If live preview is allowed on this system. Default is true for systems with
         * SVG support.
         */
        allowLivePreview: boolean;
        livePreviewUsed: any;
        keyHandler: any;
        first: any;
        cloning: any;
        checkPreview(): void;
        updatePreview(): void;
        /**
         * Function: selectCellForEvent
         *
         * Selects the given cell for the given <mxMouseEvent>.
         */
        selectCellForEvent(cell: mxCell, me: mxMouseEvent): mxCell;
        /**
         * Specifies if the view should be scrolled so that a moved cell is visible.  Default is true.
         */
        scrollOnMove: boolean;
        constructor(graph: any);
        /**
         * Returns <enabled>.
         */
        isEnabled(): any;
        /**
         * Sets <enabled>.
         */
        setEnabled(value: any): void;
        /**
         * Returns <cloneEnabled>.
         */
        isCloneEnabled(): any;
        /**
         * Sets <cloneEnabled>.
         *
         * Parameters:
         *
         * value - Boolean that specifies the new clone enabled state.
         */
        setCloneEnabled(value: any): void;
        /**
         * Returns <moveEnabled>.
         */
        isMoveEnabled(): any;
        /**
         * Sets <moveEnabled>.
         */
        setMoveEnabled(value: any): void;
        /**
         * Returns <selectEnabled>.
         */
        isSelectEnabled(): any;
        /**
         * Sets <selectEnabled>.
         */
        setSelectEnabled(value: any): void;
        /**
         * Returns <removeCellsFromParent>.
         */
        isRemoveCellsFromParent(): any;
        /**
         * Sets <removeCellsFromParent>.
         */
        setRemoveCellsFromParent(value: any): void;
        /**
         * Function: isPropagateSelectionCell
         *
         * Returns true if the given cell and parent should propagate
         * selection state to the parent.
         */
        isPropagateSelectionCell(cell: mxCell, immediate: any, me: any): boolean;
        /**
         * Function: getInitialCellForEvent
         *
         * Hook to return initial cell for the given event. This returns
         * the topmost cell that is not a swimlane or is selected.
         */
        getInitialCellForEvent(me: any): any;
        /**
         * Function: isDelayedSelection
         *
         * Returns true if the cell or one of its ancestors is selected.
         */
        isDelayedSelection(cell: any, me: any): any;
        /**
         * Function: selectDelayed
         *
         * Implements the delayed selection for the given mouse event.
         */
        selectDelayed(me: any): void;
        /**
         * Function: selectCellForEvent
         *
         * Selects the given cell for the given <mxMouseEvent>.
         */
        selectCellForEvent(cell: mxCell, me: mxMouseEvent): mxCell;
        /**
         * Function: consumeMouseEvent
         *
         * Consumes the given mouse event. NOTE: This may be used to enable click
         * events for links in labels on iOS as follows as consuming the initial
         * touchStart disables firing the subsequent click event on the link.
         *
         * <code>
         * mxGraphHandler.prototype.consumeMouseEvent = function(evtName, me)
         * {
         *   var source = mxEvent.getSource(me.getEvent());
         *
         *   if (!mxEvent.isTouchEvent(me.getEvent()) || source.nodeName != 'A')
         *   {
         *     me.consume();
         *   }
         * }
         * </code>
         */
        consumeMouseEvent(evtName: any, me: any): void;
        /**
         * Function: mouseDown
         *
         * Handles the event by selecing the given cell and creating a handle for
         * it. By consuming the event all subsequent events of the gesture are
         * redirected to this handler.
         */
        mouseDown(sender: any, me: any): void;
        /**
         * Function: getGuideStates
         *
         * Creates an array of cell states which should be used as guides.
         */
        getGuideStates(): any;
        /**
         * Function: getCells
         *
         * Returns the cells to be modified by this handler. This implementation
         * returns all selection cells that are movable, or the given initial cell if
         * the given cell is not selected and movable. This handles the case of moving
         * unselectable or unselected cells.
         *
         * Parameters:
         *
         * initialCell - <mxCell> that triggered this handler.
         */
        getCells(initialCell: any): any;
        /**
         * Function: getPreviewBounds
         *
         * Returns the <mxRectangle> used as the preview bounds for
         * moving the given cells.
         */
        getPreviewBounds(cells: any): any;
        /**
         * Function: getBoundingBox
         *
         * Returns the union of the <mxCellStates> for the given array of <mxCells>.
         * For vertices, this method uses the bounding box of the corresponding shape
         * if one exists. The bounding box of the corresponding text label and all
         * controls and overlays are ignored. See also: <mxGraphView.getBounds> and
         * <mxGraph.getBoundingBox>.
         *
         * Parameters:
         *
         * cells - Array of <mxCells> whose bounding box should be returned.
         */
        getBoundingBox(cells: any): any;
        /**
         * Function: createPreviewShape
         *
         * Creates the shape used to draw the preview for the given bounds.
         */
        createPreviewShape(bounds: any): mxRectangleShape;
        /**
         * Function: start
         *
         * Starts the handling of the mouse gesture.
         */
        start(cell: any, x: any, y: any, cells?: any): void;
        /**
         * Function: addStates
         *
         * Adds the states for the given cell recursively to the given dictionary.
         */
        addStates(cell: mxCell, dict: any): number;
        /**
         * Function: isCellMoving
         *
         * Returns true if the given cell is currently being moved.
         */
        isCellMoving(cell: mxCell): boolean;
        /**
         * Function: useGuidesForEvent
         *
         * Returns true if the guides should be used for the given <mxMouseEvent>.
         * This implementation returns <mxGuide.isEnabledForEvent>.
         */
        useGuidesForEvent(me: any): any;
        /**
         * Function: snap
         *
         * Snaps the given vector to the grid and returns the given mxPoint instance.
         */
        snap(vector: any): any;
        /**
         * Function: getDelta
         *
         * Returns an <mxPoint> that represents the vector for moving the cells
         * for the given <mxMouseEvent>.
         */
        getDelta(me: any): mxPoint;
        /**
         * Function: updateHint
         *
         * Hook for subclassers do show details while the handler is active.
         */
        updateHint(me: any): void;
        /**
         * Function: removeHint
         *
         * Hooks for subclassers to hide details when the handler gets inactive.
         */
        removeHint(): void;
        /**
         * Function: roundLength
         *
         * Hook for rounding the unscaled vector. Allows for half steps in the raster so
         * numbers coming in should be rounded if no half steps are allowed (ie for non
         * aligned standard moving where pixel steps should be preferred).
         */
        roundLength(length: any): number;
        /**
         * Function: isValidDropTarget
         *
         * Returns true if the given cell is a valid drop target.
         */
        isValidDropTarget(target: mxCell, me: any): boolean;
        /**
         * Function: checkPreview
         *
         * Updates the preview if cloning state has changed.
         */
        checkPreview(): void;
        /**
         * Function: mouseMove
         *
         * Handles the event by highlighting possible drop targets and updating the
         * preview.
         */
        mouseMove(sender: any, me: any): void;
        /**
         * Function: updatePreview
         *
         * Updates the bounds of the preview shape.
         */
        updatePreview(remote: any): void;
        /**
         * Function: updatePreviewShape
         *
         * Updates the bounds of the preview shape.
         */
        updatePreviewShape(): void;
        /**
         * Function: updateLivePreview
         *
         * Updates the bounds of the preview shape.
         */
        updateLivePreview(dx: number, dy: number): void;
        /**
         * Function: redrawHandles
         *
         * Redraws the preview shape for the given states array.
         */
        redrawHandles(states: mxCellState[]): void;
        /**
         * Function: resetPreviewStates
         *
         * Resets the given preview states array.
         */
        resetPreviewStates(states: mxCellState[]): void;
        /**
         * Function: suspend
         *
         * Suspends the livew preview.
         */
        suspend(): void;
        /**
         * Function: resume
         *
         * Suspends the livew preview.
         */
        resume(): void;
        /**
         * Function: resetLivePreview
         *
         * Resets the livew preview.
         */
        resetLivePreview(): void;
        /**
         * Function: setHandlesVisibleForCells
         *
         * Sets wether the handles attached to the given cells are visible.
         *
         * Parameters:
         *
         * cells - Array of <mxCells>.
         * visible - Boolean that specifies if the handles should be visible.
         * force - Forces an update of the handler regardless of the last used value.
         */
        setHandlesVisibleForCells(cells: mxCell[], visible: boolean, force: boolean): void;
        /**
         * Function: setHighlightColor
         *
         * Sets the color of the rectangle used to highlight drop targets.
         *
         * Parameters:
         *
         * color - String that represents the new highlight color.
         */
        setHighlightColor(color: any): void;
        /**
         * Function: mouseUp
         *
         * Handles the event by applying the changes to the selection cells.
         */
        mouseUp(sender: any, me: any): void;
        /**
         * Function: reset
         *
         * Resets the state of this handler.
         */
        reset(): void;
        /**
         * Function: shouldRemoveCellsFromParent
         *
         * Returns true if the given cells should be removed from the parent for the specified
         * mousereleased event.
         */
        shouldRemoveCellsFromParent(parent: any, cells: any, evt: any): boolean;
        /**
         * Function: moveCells
         *
         * Moves the given cells by the specified amount.
         */
        moveCells(cells: any, dx: any, dy: any, clone: any, target: any, evt: any): void;
        /**
         * Function: shouldRemoveParent
         *
         * Returns true if the given parent should be removed after removal of child cells.
         */
        shouldRemoveParent(parent: any): boolean;
        /**
         * Function: destroyShapes
         *
         * Destroy the preview and highlight shapes.
         */
        destroyShapes(): void;
        /**
         * Function: destroy
         *
         * Destroys the handler and all its resources and DOM nodes.
         */
        destroy(): void;
    }
    /**
     * Event handler that pans and creates popupmenus. To use the left
     * mousebutton for panning without interfering with cell moving and
     * resizing, use <isUseLeftButton> and <isIgnoreCell>. For grid size
     * steps while panning, use <useGrid>. This handler is built-into
     * <mxGraph.panningHandler> and enabled using <mxGraph.setPanning>.
     *
     * Event: mxEvent.PAN_START
     *
     * Fires when the panning handler changes its <active> state to true. The
     * <code>event</code> property contains the corresponding <mxMouseEvent>.
     *
     * Event: mxEvent.PAN
     *
     * Fires while handle is processing events. The <code>event</code> property contains
     * the corresponding <mxMouseEvent>.
     *
     * Event: mxEvent.PAN_END
     *
     * Fires when the panning handler changes its <active> state to false. The
     * <code>event</code> property contains the corresponding <mxMouseEvent>.
     */
    class mxPanningHandler extends mxEventSource {
        /**
         * Reference to the enclosing <mxGraph>.
         */
        graph: mxGraph;
        /**
         * Specifies if panning should be active for the left mouse button.
         * Setting this to true may conflict with <mxRubberband>. Default is false.
         */
        useLeftButtonForPanning: boolean;
        /**
         * Specifies if <mxEvent.isPopupTrigger> should also be used for panning.
         */
        usePopupTrigger: boolean;
        /**
         * Specifies if panning should be active even if there is a cell under the
         * mousepointer. Default is false.
         */
        ignoreCell: boolean;
        /**
         * Specifies if the panning should be previewed. Default is true.
         */
        previewEnabled: boolean;
        /**
         * Specifies if the panning steps should be aligned to the grid size.
         * Default is false.
         */
        useGrid: boolean;
        /**
         * Specifies if panning should be enabled. Default is true.
         */
        panningEnabled: boolean;
        /**
         * Specifies if pinch gestures should be handled as zoom. Default is true.
         */
        pinchEnabled: boolean;
        /**
         * Specifies the maximum scale. Default is 8.
         */
        maxScale: number;
        /**
         * Specifies the minimum scale. Default is 0.01.
         */
        minScale: number;
        /**
         * Holds the current horizontal offset.
         */
        dx: number;
        /**
         * Holds the current vertical offset.
         */
        dy: number;
        /**
         * Holds the x-coordinate of the start point.
         */
        startX: number;
        /**
         * Holds the y-coordinate of the start point.
         */
        startY: number;
        /**
         * Implicit variable declarations
         */
        forcePanningHandler: any;
        panningTrigger: any;
        gestureHandler: any;
        /** True if the handler is currently active. */
        active: boolean;
        initialScale: any;
        mouseDownEvent: any;
        dx0: number;
        dy0: number;
        /**
         * Constructs an event handler that creates a <mxPopupMenu>
         * and pans the graph.
         * @param graph
         */
        constructor(graph: mxGraph);
        /**
         * Returns true if the handler is currently active.
         */
        isActive(): boolean;
        /**
         * Returns <panningEnabled>.
         */
        isPanningEnabled(): boolean;
        /**
         * Sets <panningEnabled>.
         */
        setPanningEnabled(value: boolean): void;
        /**
         * Returns <pinchEnabled>.
         */
        isPinchEnabled(): boolean;
        /**
         * Sets <pinchEnabled>.
         */
        setPinchEnabled(value: boolean): void;
        /**
         * Returns true if the given event is a panning trigger for the optional
         * given cell. This returns true if control-shift is pressed or if
         * <usePopupTrigger> is true and the event is a popup trigger.
         */
        isPanningTrigger(me: any): boolean;
        /**
         * Returns true if the given <mxMouseEvent> should start panning. This
         * implementation always returns true if <ignoreCell> is true or for
         * multi touch events.
         */
        isForcePanningEvent(me: any): boolean;
        /**
         * Handles the event by initiating the panning. By consuming the event all
         * subsequent events of the gesture are redirected to this handler.
         */
        mouseDown(sender: any, me: any): void;
        /**
         * Starts panning at the given event.
         */
        start(me: any): void;
        /**
         * Consumes the given <mxMouseEvent> if it was a panning trigger in
         * <mouseDown>. The default is to invoke <mxMouseEvent.consume>. Note that this
         * will block any further event processing. If you haven't disabled built-in
         * context menus and require immediate selection of the cell on mouseDown in
         * Safari and/or on the Mac, then use the following code:
         *
         * (code)
         * mxPanningHandler.prototype.consumePanningTrigger = function(me)
         * {
         *   if (me.evt.preventDefault)
         *   {
         *     me.evt.preventDefault();
         *   }
         *
         *   // Stops event processing in IE
         *   me.evt.returnValue = false;
         *
         *   // Sets local consumed state
         *   if (!mxClient.IS_SF && !mxClient.IS_MAC)
         *   {
         *     me.consumed = true;
         *   }
         * };
         * (end)
         */
        consumePanningTrigger(me: any): void;
        /**
         * Handles the event by updating the panning on the graph.
         */
        mouseMove(sender: any, me: any): void;
        /**
         * Handles the event by setting the translation on the view or showing the
         * popupmenu.
         */
        mouseUp(sender: any, me: any): void;
        /**
         * Pans <graph> by the given amount.
         */
        panGraph(dx: number, dy: number): void;
        /**
         * Destroys the handler and all its resources and DOM nodes.
         */
        destroy(): void;
    }
    /**
     * Event handler that creates popupmenus.
     *
     * Constructor: mxPopupMenuHandler
     *
     * Constructs an event handler that creates a <mxPopupMenu>.
     */
    class mxPopupMenuHandler extends mxPopupMenu {
        triggerY: number;
        triggerX: number;
        factoryMethod: any;
        constructor(graph?: any, factoryMethod?: any);
        /**
         * Initializes the shapes required for this vertex handler.
         */
        init(): void;
        /**
         * Hook for returning if a cell should be selected for a given <mxMouseEvent>.
         * This implementation returns <selectOnPopup>.
         */
        isSelectOnPopup(me: any): any;
        /**
         * Handles the event by initiating the panning. By consuming the event all
         * subsequent events of the gesture are redirected to this handler.
         */
        mouseDown(sender: any, me: any): void;
        /**
         * Handles the event by updating the panning on the graph.
         */
        mouseMove(sender: any, me: any): void;
        /**
         * Handles the event by setting the translation on the view or showing the
         * popupmenu.
         */
        mouseUp(sender: any, me: any): void;
        /**
         * Hook to return the cell for the mouse up popup trigger handling.
         */
        getCellForPopupEvent(me: any): any;
        /**
         * Destroys the handler and all its resources and DOM nodes.
         */
        destroy(): void;
    }
    /**
     * A helper class to process mouse locations and highlight cells.
     *
     * Helper class to highlight cells. To add a cell marker to an existing graph
     * for highlighting all cells, the following code is used:
     *
     * (code)
     * var marker = new mxCellMarker(graph);
     * graph.addMouseListener({
     *   mouseDown: function() {},
     *   mouseMove: function(sender: any, me: any): void;
     *   {
     *     marker.process(me);
     *   },
     *   mouseUp: function() {}
     * });
     * (end)
     *
     * Event: mxEvent.MARK
     *
     * Fires after a cell has been marked or unmarked. The <code>state</code>
     * property contains the marked <mxCellState> or null if no state is marked.
     *
     * Constructor: mxCellMarker
     *
     * Constructs a new cell marker.
     *
     * Parameters:
     *
     * graph - Reference to the enclosing <mxGraph>.
     * validColor - Optional marker color for valid states. Default is
     * <mxConstants.DEFAULT_VALID_COLOR>.
     * invalidColor - Optional marker color for invalid states. Default is
     * <mxConstants.DEFAULT_INVALID_COLOR>.
     * hotspot - Portion of the width and hight where a state intersects a
     * given coordinate pair. A value of 0 means always highlight. Default is
     * <mxConstants.DEFAULT_HOTSPOT>.
     */
    class mxCellMarker extends mxEventSource {
        constructor(graph: any, validColor: any, invalidColor: any, hotspot: any);
        /**
         * Enables or disables event handling. This implementation
         * updates <enabled>.
         *
         * Parameters:
         *
         * enabled - Boolean that specifies the new enabled state.
         */
        setEnabled(enabled: any): void;
        /**
         * Returns true if events are handled. This implementation
         * returns <enabled>.
         */
        isEnabled(): any;
        /**
         * Sets the <hotspot>.
         */
        setHotspot(hotspot: any): void;
        /**
         * Returns the <hotspot>.
         */
        getHotspot(): any;
        /**
         * Specifies whether the hotspot should be used in <intersects>.
         */
        setHotspotEnabled(enabled: any): void;
        /**
         * Returns true if hotspot is used in <intersects>.
         */
        isHotspotEnabled(): any;
        /**
         * Returns true if <validState> is not null.
         */
        hasValidState(): boolean;
        /**
         * Returns the <validState>.
         */
        getValidState(): any;
        /**
         * Returns the <markedState>.
         */
        getMarkedState(): any;
        /**
         * Resets the state of the cell marker.
         */
        reset(): void;
        /**
         * Processes the given event and cell and marks the state returned by
         * <getState> with the color returned by <getMarkerColor>. If the
         * markerColor is not null, then the state is stored in <markedState>. If
         * <isValidState> returns true, then the state is stored in <validState>
         * regardless of the marker color. The state is returned regardless of the
         * marker color and valid state.
         */
        process(me: any): any;
        /**
         * Sets and marks the current valid state.
         */
        setCurrentState(state: any, me: any, color: any): void;
        /**
         * Marks the given cell using the given color, or <validColor> if no color is specified.
         */
        markCell(cell: any, color: any): void;
        /**
         * Marks the <markedState> and fires a <mark> event.
         */
        mark(): void;
        /**
         * Hides the marker and fires a <mark> event.
         */
        unmark(): void;
        /**
         * Returns true if the given <mxCellState> is a valid state. If this
         * returns true, then the state is stored in <validState>. The return value
         * of this method is used as the argument for <getMarkerColor>.
         */
        isValidState(state: any): boolean;
        /**
         * Returns the valid- or invalidColor depending on the value of isValid.
         * The given <mxCellState> is ignored by this implementation.
         */
        getMarkerColor(evt: any, state: any, isValid: any): any;
        /**
         * Uses <getCell>, <getStateToMark> and <intersects> to return the
         * <mxCellState> for the given <mxMouseEvent>.
         */
        getState(me: any): any;
        /**
         * Returns the <mxCell> for the given event and cell. This returns the
         * given cell.
         */
        getCell(me: any): any;
        /**
         * Returns the <mxCellState> to be marked for the given <mxCellState> under
         * the mouse. This returns the given state.
         */
        getStateToMark(state: any): any;
        /**
         * Returns true if the given coordinate pair intersects the given state.
         * This returns true if the <hotspot> is 0 or the coordinates are inside
         * the hotspot for the given cell state.
         */
        intersects(state: any, me: any): any;
        /**
         * Destroys the handler and all its resources and DOM nodes.
         */
        destroy(): void;
    }
    /**
     * An event handler that manages cell handlers and invokes their mouse event
     * processing functions.
     *
     * Group: Events
     *
     * Event: mxEvent.ADD
     *
     * Fires if a cell has been added to the selection. The <code>state</code>
     * property contains the <mxCellState> that has been added.
     *
     * Event: mxEvent.REMOVE
     *
     * Fires if a cell has been remove from the selection. The <code>state</code>
     * property contains the <mxCellState> that has been removed.
     *
     * Parameters:
     *
     * graph - Reference to the enclosing <mxGraph>.
     */
    class mxSelectionCellsHandler extends mxEventSource {
        getHandledSelectionCells(): mxCell[];
        handlers: mxDictionary;
        /**
         * Function: isHandled
         *
         * Returns true if the given cell has a handler.
         */
        isHandled(cell: mxCell): boolean;
        constructor(graph: any);
        /**
         * Returns <enabled>.
         */
        isEnabled(): any;
        /**
         * Sets <enabled>.
         */
        setEnabled(value: any): void;
        /**
         * Returns the handler for the given cell.
         */
        getHandler(cell: any): any;
        /**
         * Resets all handlers.
         */
        reset(): void;
        /**
         * Reloads or updates all handlers.
         */
        refresh(): void;
        /**
         * Returns true if the given handler is active and should not be redrawn.
         */
        isHandlerActive(handler: any): boolean;
        /**
         * Updates the handler for the given shape if one exists.
         */
        updateHandler(state: any): void;
        /**
         * Redirects the given event to the handlers.
         */
        mouseDown(sender: any, me: any): void;
        /**
         * Redirects the given event to the handlers.
         */
        mouseMove(sender: any, me: any): void;
        /**
         * Redirects the given event to the handlers.
         */
        mouseUp(sender: any, me: any): void;
        /**
         * Destroys the handler and all its resources and DOM nodes.
         */
        destroy(): void;
    }
    /**
     * Class: mxConnectionHandler
     *
     * Graph event handler that creates new connections. Uses <mxTerminalMarker>
     * for finding and highlighting the source and target vertices and
     * <factoryMethod> to create the edge instance. This handler is built-into
     * <mxGraph.connectionHandler> and enabled using <mxGraph.setConnectable>.
     *
     * Example:
     *
     * (code)
     * new mxConnectionHandler(graph, function(source, target, style)
     * {
     *   edge = new mxCell('', new mxGeometry());
     *   edge.setEdge(true);
     *   edge.setStyle(style);
     *   edge.geometry.relative = true;
     *   return edge;
     * });
     * (end)
     *
     * Here is an alternative solution that just sets a specific user object for
     * new edges by overriding <insertEdge>.
     *
     * (code)
     * mxConnectionHandlerInsertEdge = mxConnectionHandler.prototype.insertEdge;
     * mxConnectionHandler.prototype.insertEdge = function(parent, id, value, source, target, style)
     * {
     *   value = 'Test';
     *
     *   return mxConnectionHandlerInsertEdge.apply(this, arguments);
     * };
     * (end)
     *
     * Using images to trigger connections:
     *
     * This handler uses mxTerminalMarker to find the source and target cell for
     * the new connection and creates a new edge using <connect>. The new edge is
     * created using <createEdge> which in turn uses <factoryMethod> or creates a
     * new default edge.
     *
     * The handler uses a "highlight-paradigm" for indicating if a cell is being
     * used as a source or target terminal, as seen in other diagramming products.
     * In order to allow both, moving and connecting cells at the same time,
     * <mxConstants.DEFAULT_HOTSPOT> is used in the handler to determine the hotspot
     * of a cell, that is, the region of the cell which is used to trigger a new
     * connection. The constant is a value between 0 and 1 that specifies the
     * amount of the width and height around the center to be used for the hotspot
     * of a cell and its default value is 0.5. In addition,
     * <mxConstants.MIN_HOTSPOT_SIZE> defines the minimum number of pixels for the
     * width and height of the hotspot.
     *
     * This solution, while standards compliant, may be somewhat confusing because
     * there is no visual indicator for the hotspot and the highlight is seen to
     * switch on and off while the mouse is being moved in and out. Furthermore,
     * this paradigm does not allow to create different connections depending on
     * the highlighted hotspot as there is only one hotspot per cell and it
     * normally does not allow cells to be moved and connected at the same time as
     * there is no clear indication of the connectable area of the cell.
     *
     * To come across these issues, the handle has an additional <createIcons> hook
     * with a default implementation that allows to create one icon to be used to
     * trigger new connections. If this icon is specified, then new connections can
     * only be created if the image is clicked while the cell is being highlighted.
     * The <createIcons> hook may be overridden to create more than one
     * <mxImageShape> for creating new connections, but the default implementation
     * supports one image and is used as follows:
     *
     * In order to display the "connect image" whenever the mouse is over the cell,
     * an DEFAULT_HOTSPOT of 1 should be used:
     *
     * (code)
     * mxConstants.DEFAULT_HOTSPOT = 1;
     * (end)
     *
     * In order to avoid confusion with the highlighting, the highlight color
     * should not be used with a connect image:
     *
     * (code)
     * mxConstants.HIGHLIGHT_COLOR = null;
     * (end)
     *
     * To install the image, the connectImage field of the mxConnectionHandler must
     * be assigned a new <mxImage> instance:
     *
     * (code)
     * mxConnectionHandler.prototype.connectImage = new mxImage('images/green-dot.gif', 14, 14);
     * (end)
     *
     * This will use the green-dot.gif with a width and height of 14 pixels as the
     * image to trigger new connections. In createIcons the icon field of the
     * handler will be set in order to remember the icon that has been clicked for
     * creating the new connection. This field will be available under selectedIcon
     * in the connect method, which may be overridden to take the icon that
     * triggered the new connection into account. This is useful if more than one
     * icon may be used to create a connection.
     *
     * Group: Events
     *
     * Event: mxEvent.START
     *
     * Fires when a new connection is being created by the user. The <code>state</code>
     * property contains the state of the source cell.
     *
     * Event: mxEvent.CONNECT
     *
     * Fires between begin- and endUpdate in <connect>. The <code>cell</code>
     * property contains the inserted edge, the <code>event</code> and <code>target</code>
     * properties contain the respective arguments that were passed to <connect> (where
     * target corresponds to the dropTarget argument). Finally, the <code>terminal</code>
     * property corresponds to the target argument in <connect> or the clone of the source
     * terminal if <createTarget> is enabled.
     *
     * Note that the target is the cell under the mouse where the mouse button was released.
     * Depending on the logic in the handler, this doesn't necessarily have to be the target
     * of the inserted edge. To print the source, target or any optional ports IDs that the
     * edge is connected to, the following code can be used. To get more details about the
     * actual connection point, <mxGraph.getConnectionConstraint> can be used. To resolve
     * the port IDs, use <mxGraphModel.getCell>.
     *
     * (code)
     * graph.connectionHandler.addListener(mxEvent.CONNECT, function(sender, evt)
     * {
     *   var edge = evt.getProperty('cell');
     *   var source = graph.getModel().getTerminal(edge, true);
     *   var target = graph.getModel().getTerminal(edge, false);
     *
     *   var style = graph.getCellStyle(edge);
     *   var sourcePortId = style[mxConstants.STYLE_SOURCE_PORT];
     *   var targetPortId = style[mxConstants.STYLE_TARGET_PORT];
     *
     *   mxLog.show();
     *   mxLog.debug('connect', edge, source.id, target.id, sourcePortId, targetPortId);
     * });
     * (end)
     *
     * Event: mxEvent.RESET
     *
     * Fires when the <reset> method is invoked.
     *
     * Constructor: mxConnectionHandler
     *
     * Constructs an event handler that connects vertices using the specified
     * factory method to create the new edges. Modify
     * <mxConstants.ACTIVE_REGION> to setup the region on a cell which triggers
     * the creation of a new connection or use connect icons as explained
     * above.
     *
     * Parameters:
     *
     * graph - Reference to the enclosing <mxGraph>.
     * factoryMethod - Optional function to create the edge. The function takes
     * the source and target <mxCell> as the first and second argument and an
     * optional cell style from the preview as the third argument. It returns
     * the <mxCell> that represents the new edge.
     */
    class mxConnectionHandler extends mxEventSource {
        constructor(graph: mxGraph, factoryMethod?: any);
        /**
         * Variable: graph
         *
         * Reference to the enclosing <mxGraph>.
         */
        graph: mxGraph;
        /**
         * Variable: factoryMethod
         *
         * Function that is used for creating new edges. The function takes the
         * source and target <mxCell> as the first and second argument and returns
         * a new <mxCell> that represents the edge. This is used in <createEdge>.
         */
        factoryMethod: any;
        /**
         * Variable: moveIconFront
         *
         * Specifies if icons should be displayed inside the graph container instead
         * of the overlay pane. This is used for HTML labels on vertices which hide
         * the connect icon. This has precendence over <moveIconBack> when set
         * to true. Default is false.
         */
        moveIconFront: boolean;
        /**
         * Variable: moveIconBack
         *
         * Specifies if icons should be moved to the back of the overlay pane. This can
         * be set to true if the icons of the connection handler conflict with other
         * handles, such as the vertex label move handle. Default is false.
         */
        moveIconBack: boolean;
        /**
         * Variable: connectImage
         *
         * <mxImage> that is used to trigger the creation of a new connection. This
         * is used in <createIcons>. Default is null.
         */
        connectImage: mxImage;
        /**
         * Variable: targetConnectImage
         *
         * Specifies if the connect icon should be centered on the target state
         * while connections are being previewed. Default is false.
         */
        targetConnectImage: boolean;
        /**
         * Variable: enabled
         *
         * Specifies if events are handled. Default is true.
         */
        enabled: boolean;
        /**
         * Variable: select
         *
         * Specifies if new edges should be selected. Default is true.
         */
        select: boolean;
        /**
         * Variable: createTarget
         *
         * Specifies if <createTargetVertex> should be called if no target was under the
         * mouse for the new connection. Setting this to true means the connection
         * will be drawn as valid if no target is under the mouse, and
         * <createTargetVertex> will be called before the connection is created between
         * the source cell and the newly created vertex in <createTargetVertex>, which
         * can be overridden to create a new target. Default is false.
         */
        createTarget: boolean;
        /**
         * Variable: marker
         *
         * Holds the <mxTerminalMarker> used for finding source and target cells.
         */
        marker: any;
        /**
         * Variable: constraintHandler
         *
         * Holds the <mxConstraintHandler> used for drawing and highlighting
         * constraints.
         */
        constraintHandler: mxConstraintHandler;
        /**
         * Variable: error
         *
         * Holds the current validation error while connections are being created.
         */
        error: any;
        /**
         * Variable: waypointsEnabled
         *
         * Specifies if single clicks should add waypoints on the new edge. Default is
         * false.
         */
        waypointsEnabled: boolean;
        /**
         * Variable: ignoreMouseDown
         *
         * Specifies if the connection handler should ignore the state of the mouse
         * button when highlighting the source. Default is false, that is, the
         * handler only highlights the source if no button is being pressed.
         */
        ignoreMouseDown: boolean;
        /**
         * Variable: first
         *
         * Holds the <mxPoint> where the mouseDown took place while the handler is
         * active.
         */
        first: mxPoint;
        /**
         * Variable: connectIconOffset
         *
         * Holds the offset for connect icons during connection preview.
         * Default is mxPoint(0, <mxConstants.TOOLTIP_VERTICAL_OFFSET>).
         * Note that placing the icon under the mouse pointer with an
         * offset of (0,0) will affect hit detection.
         */
        connectIconOffset: mxPoint;
        /**
         * Variable: edgeState
         *
         * Optional <mxCellState> that represents the preview edge while the
         * handler is active. This is created in <createEdgeState>.
         */
        edgeState: mxCellState;
        /**
         * Variable: changeHandler
         *
         * Holds the change event listener for later removal.
         */
        changeHandler: any;
        /**
         * Variable: drillHandler
         *
         * Holds the drill event listener for later removal.
         */
        drillHandler: any;
        /**
         * Variable: mouseDownCounter
         *
         * Counts the number of mouseDown events since the start. The initial mouse
         * down event counts as 1.
         */
        mouseDownCounter: number;
        /**
         * Variable: movePreviewAway
         *
         * Switch to enable moving the preview away from the mousepointer. This is required in browsers
         * where the preview cannot be made transparent to events and if the built-in hit detection on
         * the HTML elements in the page should be used. Default is the value of <mxClient.IS_VML>.
         */
        movePreviewAway: boolean;
        /**
         * Variable: outlineConnect
         *
         * Specifies if connections to the outline of a highlighted target should be
         * enabled. This will allow to place the connection point along the outline of
         * the highlighted target. Default is false.
         */
        outlineConnect: boolean;
        /**
         * Variable: livePreview
         *
         * Specifies if the actual shape of the edge state should be used for the preview.
         * Default is false. (Ignored if no edge state is created in <createEdgeState>.)
         */
        livePreview: boolean;
        /**
         * Variable: cursor
         *
         * Specifies the cursor to be used while the handler is active. Default is null.
         */
        cursor: any;
        /**
         * Variable: insertBeforeSource
         *
         * Specifies if new edges should be inserted before the source vertex in the
         * cell hierarchy. Default is false for backwards compatibility.
         */
        insertBeforeSource: boolean;
        escapeHandler: any;
        iconState: any;
        icons: any;
        icon: any;
        selectedIcon: any;
        previous: any;
        currentPoint: any;
        currentState: any;
        sourceConstraint: any;
        waypoints: mxPoint[];
        shape: any;
        originalPoint: any;
        /**
         * Function: isEnabled
         *
         * Returns true if events are handled. This implementation
         * returns <enabled>.
         */
        isEnabled(): boolean;
        /**
         * Function: setEnabled
         *
         * Enables or disables event handling. This implementation
         * updates <enabled>.
         *
         * Parameters:
         *
         * enabled - Boolean that specifies the new enabled state.
         */
        setEnabled(enabled: boolean): void;
        /**
         * Function: isInsertBefore
         *
         * Returns <insertBeforeSource> for non-loops and false for loops.
         *
         * Parameters:
         *
         * edge - <mxCell> that represents the edge to be inserted.
         * source - <mxCell> that represents the source terminal.
         * target - <mxCell> that represents the target terminal.
         * evt - Mousedown event of the connect gesture.
         * dropTarget - <mxCell> that represents the cell under the mouse when it was
         * released.
         */
        isInsertBefore(edge: mxCell, source: mxCell, target: mxCell, evt: any, dropTarget: any): boolean;
        /**
         * Function: isCreateTarget
         *
         * Returns <createTarget>.
         *
         * Parameters:
         *
         * evt - Current active native pointer event.
         */
        isCreateTarget(evt: any): boolean;
        /**
         * Function: setCreateTarget
         *
         * Sets <createTarget>.
         */
        setCreateTarget(value: boolean): void;
        /**
         * Function: createShape
         *
         * Creates the preview shape for new connections.
         */
        createShape(): mxShape;
        /**
         * Function: init
         *
         * Initializes the shapes required for this connection handler. This should
         * be invoked if <mxGraph.container> is assigned after the connection
         * handler has been created.
         */
        init(): void;
        /**
         * Function: isConnectableCell
         *
         * Returns true if the given cell is connectable. This is a hook to
         * disable floating connections. This implementation returns true.
         */
        isConnectableCell(cell: mxCell): boolean;
        /**
         * Function: createMarker
         *
         * Creates and returns the <mxCellMarker> used in <marker>.
         */
        createMarker(): mxCellMarker;
        /**
         * Function: start
         *
         * Starts a new connection for the given state and coordinates.
         */
        start(state: any, x: number, y: number, edgeState?: number): void;
        /**
         * Function: isConnecting
         *
         * Returns true if the source terminal has been clicked and a new
         * connection is currently being previewed.
         */
        isConnecting(): boolean;
        /**
         * Function: isValidSource
         *
         * Returns <mxGraph.isValidSource> for the given source terminal.
         *
         * Parameters:
         *
         * cell - <mxCell> that represents the source terminal.
         * me - <mxMouseEvent> that is associated with this call.
         */
        isValidSource(cell: mxCell, me: mxMouseEvent): boolean;
        /**
         * Function: isValidTarget
         *
         * Returns true. The call to <mxGraph.isValidTarget> is implicit by calling
         * <mxGraph.getEdgeValidationError> in <validateConnection>. This is an
         * additional hook for disabling certain targets in this specific handler.
         *
         * Parameters:
         *
         * cell - <mxCell> that represents the target terminal.
         */
        isValidTarget(cell: mxCell): boolean;
        /**
         * Function: validateConnection
         *
         * Returns the error message or an empty string if the connection for the
         * given source target pair is not valid. Otherwise it returns null. This
         * implementation uses <mxGraph.getEdgeValidationError>.
         *
         * Parameters:
         *
         * source - <mxCell> that represents the source terminal.
         * target - <mxCell> that represents the target terminal.
         */
        validateConnection(source: mxCell, target: mxCell): any;
        /**
         * Function: getConnectImage
         *
         * Hook to return the <mxImage> used for the connection icon of the given
         * <mxCellState>. This implementation returns <connectImage>.
         *
         * Parameters:
         *
         * state - <mxCellState> whose connect image should be returned.
         */
        getConnectImage(state: mxCellState): mxImage;
        /**
         * Function: isMoveIconToFrontForState
         *
         * Returns true if the state has a HTML label in the graph's container, otherwise
         * it returns <moveIconFront>.
         *
         * Parameters:
         *
         * state - <mxCellState> whose connect icons should be returned.
         */
        isMoveIconToFrontForState(state: mxCellState): boolean;
        /**
         * Function: createIcons
         *
         * Creates the array <mxImageShapes> that represent the connect icons for
         * the given <mxCellState>.
         *
         * Parameters:
         *
         * state - <mxCellState> whose connect icons should be returned.
         */
        createIcons(state: mxCellState): any;
        /**
         * Function: redrawIcons
         *
         * Redraws the given array of <mxImageShapes>.
         *
         * Parameters:
         *
         * icons - Optional array of <mxImageShapes> to be redrawn.
         */
        redrawIcons(icons: any, state: any): void;
        /**
         * Function: getIconPosition
         *
         * Returns the center position of the given icon.
         *
         * Parameters:
         *
         * icon - The connect icon of <mxImageShape> with the mouse.
         * state - <mxCellState> under the mouse.
         */
        getIconPosition(icon: any, state: mxCellState): mxPoint;
        /**
         * Function: destroyIcons
         *
         * Destroys the connect icons and resets the respective state.
         */
        destroyIcons(): void;
        /**
         * Function: isStartEvent
         *
         * Returns true if the given mouse down event should start this handler. The
         * This implementation returns true if the event does not force marquee
         * selection, and the currentConstraint and currentFocus of the
         * <constraintHandler> are not null, or <previous> and <error> are not null and
         * <icons> is null or <icons> and <icon> are not null.
         */
        isStartEvent(me: any): boolean;
        /**
         * Function: mouseDown
         *
         * Handles the event by initiating a new connection.
         */
        mouseDown(sender: any, me: any): void;
        /**
         * Function: isImmediateConnectSource
         *
         * Returns true if a tap on the given source state should immediately start
         * connecting. This implementation returns true if the state is not movable
         * in the graph.
         */
        isImmediateConnectSource(state: mxCellState): boolean;
        /**
         * Function: createEdgeState
         *
         * Hook to return an <mxCellState> which may be used during the preview.
         * This implementation returns null.
         *
         * Use the following code to create a preview for an existing edge style:
         *
         * (code)
         * graph.connectionHandler.createEdgeState = function(me)
         * {
         *   var edge = graph.createEdge(null, null, null, null, null, 'edgeStyle=elbowEdgeStyle');
         *
         *   return new mxCellState(this.graph.view, edge, this.graph.getCellStyle(edge));
         * };
         * (end)
         */
        createEdgeState(me: any): mxCellState;
        /**
         * Function: isOutlineConnectEvent
         *
         * Returns true if <outlineConnect> is true and the source of the event is the outline shape
         * or shift is pressed.
         */
        isOutlineConnectEvent(me: any): boolean;
        /**
         * Function: updateCurrentState
         *
         * Updates the current state for a given mouse move event by using
         * the <marker>.
         */
        updateCurrentState(me: any, point: any): void;
        /**
         * Function: isCellEnabled
         *
         * Returns true if the given cell allows new connections to be created. This implementation
         * always returns true.
         */
        isCellEnabled(cell: mxCell): boolean;
        /**
         * Function: convertWaypoint
         *
         * Converts the given point from screen coordinates to model coordinates.
         */
        convertWaypoint(point: mxPoint): void;
        /**
         * Function: snapToPreview
         *
         * Called to snap the given point to the current preview. This snaps to the
         * first point of the preview if alt is not pressed.
         */
        snapToPreview(me: any, point: mxPoint): void;
        /**
         * Function: mouseMove
         *
         * Handles the event by updating the preview edge or by highlighting
         * a possible source or target terminal.
         */
        mouseMove(sender: any, me: any): void;
        /**
         * Function: updateEdgeState
         *
         * Updates <edgeState>.
         */
        updateEdgeState(current: any, constraint: any): void;
        /**
         * Function: getTargetPerimeterPoint
         *
         * Returns the perimeter point for the given target state.
         *
         * Parameters:
         *
         * state - <mxCellState> that represents the target cell state.
         * me - <mxMouseEvent> that represents the mouse move.
         */
        getTargetPerimeterPoint(state: mxCellState, me: mxMouseEvent): mxPoint;
        /**
         * Function: getSourcePerimeterPoint
         *
         * Hook to update the icon position(s) based on a mouseOver event. This is
         * an empty implementation.
         *
         * Parameters:
         *
         * state - <mxCellState> that represents the target cell state.
         * next - <mxPoint> that represents the next point along the previewed edge.
         * me - <mxMouseEvent> that represents the mouse move.
         */
        getSourcePerimeterPoint(state: mxCellState, next: mxPoint, me: mxMouseEvent): mxPoint;
        /**
         * Function: updateIcons
         *
         * Hook to update the icon position(s) based on a mouseOver event. This is
         * an empty implementation.
         *
         * Parameters:
         *
         * state - <mxCellState> under the mouse.
         * icons - Array of currently displayed icons.
         * me - <mxMouseEvent> that contains the mouse event.
         */
        updateIcons(state: mxCellState, icons: any, me: mxMouseEvent): void;
        /**
         * Function: isStopEvent
         *
         * Returns true if the given mouse up event should stop this handler. The
         * connection will be created if <error> is null. Note that this is only
         * called if <waypointsEnabled> is true. This implemtation returns true
         * if there is a cell state in the given event.
         */
        isStopEvent(me: any): boolean;
        /**
         * Function: addWaypoint
         *
         * Adds the waypoint for the given event to <waypoints>.
         */
        addWaypointForEvent(me: any): void;
        /**
         * Function: checkConstraints
         *
         * Returns true if the connection for the given constraints is valid. This
         * implementation returns true if the constraints are not pointing to the
         * same fixed connection point.
         */
        checkConstraints(c1: any, c2: any): boolean;
        /**
         * Function: mouseUp
         *
         * Handles the event by inserting the new connection.
         */
        mouseUp(sender: any, me: any): void;
        /**
         * Function: reset
         *
         * Resets the state of this handler.
         */
        reset(): void;
        /**
         * Function: drawPreview
         *
         * Redraws the preview edge using the color and width returned by
         * <getEdgeColor> and <getEdgeWidth>.
         */
        drawPreview(): void;
        /**
         * Function: updatePreview
         *
         * Returns the color used to draw the preview edge. This returns green if
         * there is no edge validation error and red otherwise.
         *
         * Parameters:
         *
         * valid - Boolean indicating if the color for a valid edge should be
         * returned.
         */
        updatePreview(valid: boolean): void;
        /**
         * Function: getEdgeColor
         *
         * Returns the color used to draw the preview edge. This returns green if
         * there is no edge validation error and red otherwise.
         *
         * Parameters:
         *
         * valid - Boolean indicating if the color for a valid edge should be
         * returned.
         */
        getEdgeColor(valid: boolean): any;
        /**
         * Function: getEdgeWidth
         *
         * Returns the width used to draw the preview edge. This returns 3 if
         * there is no edge validation error and 1 otherwise.
         *
         * Parameters:
         *
         * valid - Boolean indicating if the width for a valid edge should be
         * returned.
         */
        getEdgeWidth(valid: boolean): any;
        /**
         * Function: connect
         *
         * Connects the given source and target using a new edge. This
         * implementation uses <createEdge> to create the edge.
         *
         * Parameters:
         *
         * source - <mxCell> that represents the source terminal.
         * target - <mxCell> that represents the target terminal.
         * evt - Mousedown event of the connect gesture.
         * dropTarget - <mxCell> that represents the cell under the mouse when it was
         * released.
         */
        connect(source: mxCell, target: mxCell, evt: any, dropTarget: mxCell): void;
        /**
         * Function: selectCells
         *
         * Selects the given edge after adding a new connection. The target argument
         * contains the target vertex if one has been inserted.
         */
        selectCells(edge: any, target: any): void;
        /**
         * Function: insertEdge
         *
         * Creates, inserts and returns the new edge for the given parameters. This
         * implementation does only use <createEdge> if <factoryMethod> is defined,
         * otherwise <mxGraph.insertEdge> will be used.
         */
        insertEdge(parent: mxCell, id: any, value: any, source: mxCell, target: mxCell, style?: any): mxCell;
        /**
         * Function: createTargetVertex
         *
         * Hook method for creating new vertices on the fly if no target was
         * under the mouse. This is only called if <createTarget> is true and
         * returns null.
         *
         * Parameters:
         *
         * evt - Mousedown event of the connect gesture.
         * source - <mxCell> that represents the source terminal.
         */
        createTargetVertex(evt: any, source: mxCell): any;
        /**
         * Function: getAlignmentTolerance
         *
         * Returns the tolerance for aligning new targets to sources. This returns the grid size / 2.
         */
        getAlignmentTolerance(evt: any): any;
        /**
         * Function: createEdge
         *
         * Creates and returns a new edge using <factoryMethod> if one exists. If
         * no factory method is defined, then a new default edge is returned. The
         * source and target arguments are informal, the actual connection is
         * setup later by the caller of this function.
         *
         * Parameters:
         *
         * value - Value to be used for creating the edge.
         * source - <mxCell> that represents the source terminal.
         * target - <mxCell> that represents the target terminal.
         * style - Optional style from the preview edge.
         */
        createEdge(value: any, source: mxCell, target: mxCell, style?: string): mxCell;
        /**
         * Function: destroy
         *
         * Destroys the handler and all its resources and DOM nodes. This should be
         * called on all instances. It is called automatically for the built-in
         * instance created for each <mxGraph>.
         */
        destroy(): void;
    }
    /**
     * Handles constraints on connection targets. This class is in charge of
     * showing fixed points when the mouse is over a vertex and handles constraints
     * to establish new connections.
     *
     * Constructor: mxConstraintHandler
     *
     * Constructs an new constraint handler.
     *
     * Parameters:
     *
     * graph - Reference to the enclosing <mxGraph>.
     * factoryMethod - Optional function to create the edge. The function takes
     * the source and target <mxCell> as the first and second argument and
     * returns the <mxCell> that represents the new edge.
     */
    class mxConstraintHandler {
        /**
         * mxImage to be used as the image for fixed connection points.
         */
        pointImage: mxImage;
        currentConstraint?: any;
        currentFocus?: any;
        constructor(graph: any);
        /**
         * Returns true if events are handled. This implementation
         * returns <enabled>.
         */
        isEnabled(): any;
        /**
         * Enables or disables event handling. This implementation
         * updates <enabled>.
         *
         * Parameters:
         *
         * enabled - Boolean that specifies the new enabled state.
         */
        setEnabled(enabled: any): void;
        /**
         * Resets the state of this handler.
         */
        reset(): void;
        /**
         * Returns the tolerance to be used for intersecting connection points. This
         * implementation returns <mxGraph.tolerance>.
         *
         * Parameters:
         *
         * me - <mxMouseEvent> whose tolerance should be returned.
         */
        getTolerance(me: any): any;
        /**
         * Returns the tolerance to be used for intersecting connection points.
         */
        getImageForConstraint(state: any, constraint: any, point: any): any;
        /**
         * Returns true if the given <mxMouseEvent> should be ignored in <update>. This
         * implementation always returns false.
         */
        isEventIgnored(me: any, source: any): boolean;
        /**
         * Returns true if the given state should be ignored. This always returns false.
         */
        isStateIgnored(state: any, source: any): boolean;
        /**
         * Destroys the <focusIcons> if they exist.
         */
        destroyIcons(): void;
        /**
         * Destroys the <focusHighlight> if one exists.
         */
        destroyFocusHighlight(): void;
        /**
         * Returns true if the current focused state should not be changed for the given event.
         * This returns true if shift and alt are pressed.
         */
        isKeepFocusEvent(me: any): boolean;
        /**
         * Returns the cell for the given event.
         */
        getCellForEvent(me: any, point: any): any;
        /**
         * Updates the state of this handler based on the given <mxMouseEvent>.
         * Source is a boolean indicating if the cell is a source or target.
         */
        update(me: any, source: any, existingEdge: any, point: any): void;
        /**
         * Transfers the focus to the given state as a source or target terminal. If
         * the handler is not enabled then the outline is painted, but the constraints
         * are ignored.
         */
        redraw(): void;
        /**
         * Transfers the focus to the given state as a source or target terminal. If
         * the handler is not enabled then the outline is painted, but the constraints
         * are ignored.
         */
        setFocus(me: any, state: any, source: any): void;
        /**
         * Create the shape used to paint the highlight.
         *
         * Returns true if the given icon intersects the given point.
         */
        createHighlightShape(): mxRectangleShape;
        /**
         * Returns true if the given icon intersects the given rectangle.
         */
        intersects(icon: any, mouse: any, source: any, existingEdge: any): any;
        /**
         * Destroy this handler.
         */
        destroy(): void;
    }
    /**
     * Event handler that selects rectangular regions. This is not built-into
     * <mxGraph>. To enable rubberband selection in a graph, use the following code.
     *
     * Example:
     *
     * (code)
     * var rubberband = new mxRubberband(graph);
     * (end)
     *
     * Constructor: mxRubberband
     *
     * Constructs an event handler that selects rectangular regions in the graph
     * using rubberband selection.
     */
    class mxRubberband {
        /**
         * Variable: defaultOpacity
         *
         * Specifies the default opacity to be used for the rubberband div. Default
         * is 20.
         */
        defaultOpacity: number;
        /**
         * Variable: fadeOut
         *
         * Optional fade out effect. Default is false.
         */
        fadeOut: boolean;
        constructor(graph: any);
        /**
         * Returns true if events are handled. This implementation returns
         * <enabled>.
         */
        isEnabled(): any;
        /**
         * Enables or disables event handling. This implementation updates
         * <enabled>.
         */
        setEnabled(enabled: any): void;
        /**
         * Returns true if the given <mxMouseEvent> should start rubberband selection.
         * This implementation returns true if the alt key is pressed.
         */
        isForceRubberbandEvent(me: any): boolean;
        /**
         * Handles the event by initiating a rubberband selection. By consuming the
         * event all subsequent events of the gesture are redirected to this
         * handler.
         */
        mouseDown(sender: any, me: any): void;
        /**
         * Sets the start point for the rubberband selection.
         */
        start(x: any, y: any): void;
        /**
         * Handles the event by updating therubberband selection.
         */
        mouseMove(sender: any, me: any): void;
        /**
         * Creates the rubberband selection shape.
         */
        createShape(): any;
        /**
         * Returns true if this handler is active.
         */
        isActive(sender: any, me: any): boolean;
        /**
         * Handles the event by selecting the region of the rubberband using
         * <mxGraph.selectRegion>.
         */
        mouseUp(sender: any, me: any): void;
        /**
         * Resets the state of this handler and selects the current region
         * for the given event.
         */
        execute(evt: any): void;
        /**
         * Resets the state of the rubberband selection.
         */
        reset(): void;
        /**
         * Sets <currentX> and <currentY> and calls <repaint>.
         */
        update(x: any, y: any): void;
        /**
         * Computes the bounding box and updates the style of the <div>.
         */
        repaint(): void;
        /**
         * Destroys the handler and all its resources and DOM nodes. This does
         * normally not need to be called, it is called automatically when the
         * window unloads.
         */
        destroy(): void;
    }
    /**
     * Class: mxHandle
     *
     * Implements a single custom handle for vertices.
     *
     * Constructor: mxHandle
     *
     * Constructs a new handle for the given state.
     *
     * Parameters:
     *
     * state - <mxCellState> of the cell to be handled.
     */
    class mxHandle {
        constructor(state: any, cursor: any, image: any, shape: any);
        /**
         * Variable: cursor
         *
         * Specifies the cursor to be used for this handle. Default is 'default'.
         */
        cursor: any;
        /**
         * Variable: image
         *
         * Specifies the <mxImage> to be used to render the handle. Default is null.
         */
        image: mxImage;
        /**
         * Variable: ignoreGrid
         *
         * Default is false.
         */
        ignoreGrid: boolean;
        graph: mxGraph;
        state: mxCellState;
        shape: any;
        /**
         * Function: getPosition
         *
         * Hook for subclassers to return the current position of the handle.
         */
        getPosition(bounds: any): any;
        /**
         * Function: setPosition
         *
         * Hooks for subclassers to update the style in the <state>.
         */
        setPosition(bounds: any, pt: any, me: any): any;
        /**
         * Function: execute
         *
         * Hook for subclassers to execute the handle.
         */
        execute(me: any): any;
        /**
         * Function: copyStyle
         *
         * Sets the cell style with the given name to the corresponding value in <state>.
         */
        copyStyle(key: any): void;
        /**
         * Function: processEvent
         *
         * Processes the given <mxMouseEvent> and invokes <setPosition>.
         */
        processEvent(me: mxMouseEvent): void;
        /**
         * Function: positionChanged
         *
         * Should be called after <setPosition> in <processEvent>.
         * This repaints the state using <mxCellRenderer>.
         */
        positionChanged(): void;
        /**
         * Function: getRotation
         *
         * Returns the rotation defined in the style of the cell.
         */
        getRotation(): number;
        /**
         * Function: getTotalRotation
         *
         * Returns the rotation from the style and the rotation from the direction of
         * the cell.
         */
        getTotalRotation(): number;
        /**
         * Function: init
         *
         * Creates and initializes the shapes required for this handle.
         */
        init(): void;
        /**
         * Function: createShape
         *
         * Creates and returns the shape for this handle.
         */
        createShape(html: any): mxRectangleShape;
        /**
         * Function: initShape
         *
         * Initializes <shape> and sets its cursor.
         */
        initShape(html: any): void;
        /**
         * Function: redraw
         *
         * Renders the shape for this handle.
         */
        redraw(): void;
        /**
         * Function: isHtmlRequired
         *
         * Returns true if this handle should be rendered in HTML. This returns true if
         * the text node is in the graph container.
         */
        isHtmlRequired(): boolean;
        /**
         * Function: rotatePoint
         *
         * Rotates the point by the given angle.
         */
        rotatePoint(pt: mxPoint, alpha: number): mxPoint;
        /**
         * Function: flipPoint
         *
         * Flips the given point vertically and/or horizontally.
         */
        flipPoint(pt: mxPoint): mxPoint;
        /**
         * Function: snapPoint
         *
         * Snaps the given point to the grid if ignore is false. This modifies
         * the given point in-place and also returns it.
         */
        snapPoint(pt: mxPoint, ignore: boolean): mxPoint;
        /**
         * Function: setVisible
         *
         * Shows or hides this handle.
         */
        setVisible(visible: boolean): void;
        /**
         * Function: reset
         *
         * Resets the state of this handle by setting its visibility to true.
         */
        reset(): void;
        /**
         * Function: destroy
         *
         * Destroys this handle.
         */
        destroy(): void;
    }
    /**
     * Class: mxVertexHandler
     *
     * Event handler for resizing cells. This handler is automatically created in
     * <mxGraph.createHandler>.
     *
     * Constructor: mxVertexHandler
     *
     * Constructs an event handler that allows to resize vertices
     * and groups.
     *
     * Parameters:
     *
     * state - <mxCellState> of the cell to be resized.
     */
    class mxVertexHandler {
        /**
         * Class: mxVertexHandler
         *
         * Event handler for resizing cells. This handler is automatically created in
         * <mxGraph.createHandler>.
         *
         * Constructor: mxVertexHandler
         *
         * Constructs an event handler that allows to resize vertices
         * and groups.
         *
         * Parameters:
         *
         * state - <mxCellState> of the cell to be resized.
         */
        constructor(state: any);
        /**
         * Variable: graph
         *
         * Reference to the enclosing <mxGraph>.
         */
        graph: mxGraph;
        /**
         * Variable: state
         *
         * Reference to the <mxCellState> being modified.
         */
        state: mxCellState;
        /**
         * Variable: singleSizer
         *
         * Specifies if only one sizer handle at the bottom, right corner should be
         * used. Default is false.
         */
        singleSizer: boolean;
        /**
         * Variable: index
         *
         * Holds the index of the current handle.
         */
        index: any;
        /**
         * Variable: allowHandleBoundsCheck
         *
         * Specifies if the bounds of handles should be used for hit-detection in IE or
         * if <tolerance> > 0. Default is true.
         */
        allowHandleBoundsCheck: boolean;
        /**
         * Variable: handleImage
         *
         * Optional <mxImage> to be used as handles. Default is null.
         */
        handleImage: mxImage;
        /**
         * Variable: handlesVisible
         *
         * If handles are currently visible.
         */
        handlesVisible: boolean;
        /**
         * Variable: tolerance
         *
         * Optional tolerance for hit-detection in <getHandleForEvent>. Default is 0.
         */
        tolerance: number;
        /**
         * Variable: rotationEnabled
         *
         * Specifies if a rotation handle should be visible. Default is false.
         */
        rotationEnabled: boolean;
        /**
         * Variable: parentHighlightEnabled
         *
         * Specifies if the parent should be highlighted if a child cell is selected.
         * Default is false.
         */
        parentHighlightEnabled: boolean;
        /**
         * Variable: rotationRaster
         *
         * Specifies if rotation steps should be "rasterized" depening on the distance
         * to the handle. Default is true.
         */
        rotationRaster: boolean;
        /**
         * Variable: rotationCursor
         *
         * Specifies the cursor for the rotation handle. Default is 'crosshair'.
         */
        rotationCursor: any;
        /**
         * Variable: livePreview
         *
         * Specifies if resize should change the cell in-place. This is an experimental
         * feature for non-touch devices. Default is false.
         */
        livePreview: boolean;
        /**
         * Variable: movePreviewToFront
         *
         * Specifies if the live preview should be moved to the front.
         */
        movePreviewToFront: boolean;
        /**
         * Variable: manageSizers
         *
         * Specifies if sizers should be hidden and spaced if the vertex is small.
         * Default is false.
         */
        manageSizers: boolean;
        /**
         * Variable: constrainGroupByChildren
         *
         * Specifies if the size of groups should be constrained by the children.
         * Default is false.
         */
        constrainGroupByChildren: boolean;
        /**
         * Variable: rotationHandleVSpacing
         *
         * Vertical spacing for rotation icon. Default is -16.
         */
        rotationHandleVSpacing: number;
        /**
         * Variable: horizontalOffset
         *
         * The horizontal offset for the handles. This is updated in <redrawHandles>
         * if <manageSizers> is true and the sizers are offset horizontally.
         */
        horizontalOffset: number;
        /**
         * Variable: verticalOffset
         *
         * The horizontal offset for the handles. This is updated in <redrawHandles>
         * if <manageSizers> is true and the sizers are offset vertically.
         */
        verticalOffset: number;
        livePreviewActive: boolean;
        preview: any;
        inTolerance: boolean;
        childOffsetX: number;
        childOffsetY: number;
        startX: any;
        startY: any;
        startAngle: any;
        startDist: any;
        selectionBorder: mxRectangleShape;
        rotationShape: any;
        bounds: mxRectangle;
        customHandles: any[];
        edgeHandlers: any[];
        sizers: any[];
        unscaledBounds: mxRectangle;
        /**
        * Function: init
        *
        * Initializes the shapes required for this vertex handler.
        */
        init(): void;
        /**
         * Function: isRotationHandleVisible
         *
         * Returns true if the rotation handle should be showing.
         */
        isRotationHandleVisible(): boolean;
        /**
         * Function: isConstrainedEvent
         *
         * Returns true if the aspect ratio if the cell should be maintained.
         */
        isConstrainedEvent(me: any): boolean;
        /**
         * Function: isCenteredEvent
         *
         * Returns true if the center of the vertex should be maintained during the resize.
         */
        isCenteredEvent(state: mxCellState, me: any): boolean;
        /**
         * Function: createCustomHandles
         *
         * Returns an array of custom handles. This implementation returns null.
         */
        createCustomHandles(): any[];
        /**
         * Function: updateMinBounds
         *
         * Initializes the shapes required for this vertex handler.
         */
        updateMinBounds(): void;
        /**
         * Function: getSelectionBounds
         *
         * Returns the mxRectangle that defines the bounds of the selection
         * border.
         */
        getSelectionBounds(state: mxCellState): mxRectangle;
        /**
         * Function: createParentHighlightShape
         *
         * Creates the shape used to draw the selection border.
         */
        createParentHighlightShape(bounds: mxRectangle): mxShape;
        /**
         * Function: createSelectionShape
         *
         * Creates the shape used to draw the selection border.
         */
        createSelectionShape(bounds: mxRectangle): mxRectangleShape;
        /**
         * Function: getSelectionColor
         *
         * Returns <mxConstants.VERTEX_SELECTION_COLOR>.
         */
        getSelectionColor(): any;
        /**
         * Function: getSelectionStrokeWidth
         *
         * Returns <mxConstants.VERTEX_SELECTION_STROKEWIDTH>.
         */
        getSelectionStrokeWidth(): any;
        /**
         * Function: isSelectionDashed
         *
         * Returns <mxConstants.VERTEX_SELECTION_DASHED>.
         */
        isSelectionDashed(): any;
        /**
         * Function: createSizer
         *
         * Creates a sizer handle for the specified cursor and index and returns
         * the new <mxRectangleShape> that represents the handle.
         */
        createSizer(cursor: any, index: number, size: number, fillColor: any): mxShape;
        /**
         * Function: isSizerVisible
         *
         * Returns true if the sizer for the given index is visible.
         * This returns true for all given indices.
         */
        isSizerVisible(index: number): boolean;
        /**
         * Function: createSizerShape
         *
         * Creates the shape used for the sizer handle for the specified bounds an
         * index. Only images and rectangles should be returned if support for HTML
         * labels with not foreign objects is required.
         */
        createSizerShape(bounds: mxRectangle, index: number, fillColor: any): mxShape;
        /**
         * Function: createBounds
         *
         * Helper method to create an <mxRectangle> around the given centerpoint
         * with a width and height of 2*s or 6, if no s is given.
         */
        moveSizerTo(shape: mxShape, x: number, y: number): void;
        /**
         * Function: getHandleForEvent
         *
         * Returns the index of the handle for the given event. This returns the index
         * of the sizer from where the event originated or <mxEvent.LABEL_INDEX>.
         */
        getHandleForEvent(me: any): any;
        /**
         * Function: isCustomHandleEvent
         *
         * Returns true if the given event allows custom handles to be changed. This
         * implementation returns true.
         */
        isCustomHandleEvent(me: any): boolean;
        /**
         * Function: mouseDown
         *
         * Handles the event if a handle has been clicked. By consuming the
         * event all subsequent events of the gesture are redirected to this
         * handler.
         */
        mouseDown(sender: any, me: any): void;
        /**
         * Function: isLivePreviewBorder
         *
         * Called if <livePreview> is enabled to check if a border should be painted.
         * This implementation returns true if the shape is transparent.
         */
        isLivePreviewBorder(): boolean;
        /**
         * Function: start
         *
         * Starts the handling of the mouse gesture.
         */
        start(x: number, y: number, index: any): void;
        /**
         * Function: createGhostPreview
         *
         * Starts the handling of the mouse gesture.
         */
        createGhostPreview(): mxShape;
        /**
         * Function: hideHandles
         *
         * Shortcut to <hideSizers>.
         */
        setHandlesVisible(visible: boolean): void;
        /**
         * Function: hideSizers
         *
         * Hides all sizers except.
         *
         * Starts the handling of the mouse gesture.
         */
        hideSizers(): void;
        /**
         * Function: checkTolerance
         *
         * Checks if the coordinates for the given event are within the
         * <mxGraph.tolerance>. If the event is a mouse event then the tolerance is
         * ignored.
         */
        checkTolerance(me: any): void;
        /**
         * Function: updateHint
         *
         * Hook for subclassers do show details while the handler is active.
         */
        updateHint(me: any): void;
        /**
         * Function: removeHint
         *
         * Hooks for subclassers to hide details when the handler gets inactive.
         */
        removeHint(): void;
        /**
         * Function: roundAngle
         *
         * Hook for rounding the angle. This uses Math.round.
         */
        roundAngle(angle: number): number;
        /**
         * Function: roundLength
         *
         * Hook for rounding the unscaled width or height. This uses Math.round.
         */
        roundLength(length: number): number;
        /**
         * Function: mouseMove
         *
         * Handles the event by updating the preview.
         */
        mouseMove(sender: any, me: any): void;
        /**
         * Function: isGhostPreview
         *
         * Returns true if a ghost preview should be used for custom handles.
         */
        isGhostPreview(): boolean;
        /**
         * Function: moveLabel
         *
         * Moves the label.
         */
        moveLabel(me: any): void;
        /**
         * Function: rotateVertex
         *
         * Rotates the vertex.
         */
        rotateVertex(me: any): void;
        /**
         * Function: resizeVertex
         *
         * Risizes the vertex.
         */
        resizeVertex(me: any): void;
        /**
         * Function: updateLivePreview
         *
         * Repaints the live preview.
         */
        updateLivePreview(me: any): void;
        /**
         * Function: moveToFront
         *
         * Handles the event by applying the changes to the geometry.
         */
        moveToFront(): void;
        /**
         * Function: mouseUp
         *
         * Handles the event by applying the changes to the geometry.
         */
        mouseUp(sender: any, me: any): void;
        /**
         * Function: isRecursiveResize
         *
         * Returns the recursiveResize of the give state.
         *
         * Parameters:
         *
         * state - the given <mxCellState>. This implementation takes
         * the value of this state.
         * me - the mouse event.
         */
        isRecursiveResize(state: mxCellState, me: any): boolean;
        /**
         * Function: rotateClick
         *
         * Hook for subclassers to implement a single click on the rotation handle.
         * This code is executed as part of the model transaction. This implementation
         * is empty.
         */
        rotateClick(): void;
        /**
         * Function: rotateCell
         *
         * Rotates the given cell and its children by the given angle in degrees.
         *
         * Parameters:
         *
         * cell - <mxCell> to be rotated.
         * angle - Angle in degrees.
         */
        rotateCell(cell: mxCell, angle: number, parent: any): void;
        /**
         * Function: reset
         *
         * Resets the state of this handler.
         */
        reset(): void;
        /**
         * Function: resizeCell
         *
         * Uses the given vector to change the bounds of the given cell
         * in the graph using <mxGraph.resizeCell>.
         */
        resizeCell(cell: mxCell, dx: number, dy: number, index: any, gridEnabled: boolean, constrained: boolean, recurse: boolean): void;
        /**
         * Function: moveChildren
         *
         * Moves the children of the given cell by the given vector.
         */
        moveChildren(cell: mxCell, dx: number, dy: number): void;
        /**
         * Function: union
         *
         * Returns the union of the given bounds and location for the specified
         * handle index.
         *
         * To override this to limit the size of vertex via a minWidth/-Height style,
         * the following code can be used.
         *
         * (code)
         * var vertexHandlerUnion = union;
         * union = function(bounds, dx, dy, index, gridEnabled, scale, tr, constrained)
         * {
         *   var result = vertexHandlerUnion.apply(this, arguments);
         *
         *   result.width = Math.max(result.width, mxUtils.getNumber(this.state.style, 'minWidth', 0));
         *   result.height = Math.max(result.height, mxUtils.getNumber(this.state.style, 'minHeight', 0));
         *
         *   return result;
         * };
         * (end)
         *
         * The minWidth/-Height style can then be used as follows:
         *
         * (code)
         * graph.insertVertex(parent, null, 'Hello,', 20, 20, 80, 30, 'minWidth=100;minHeight=100;');
         * (end)
         *
         * To override this to update the height for a wrapped text if the width of a vertex is
         * changed, the following can be used.
         *
         * (code)
         * var mxVertexHandlerUnion = union;
         * union = function(bounds, dx, dy, index, gridEnabled, scale, tr, constrained)
         * {
         *   var result = mxVertexHandlerUnion.apply(this, arguments);
         *   var s = this.state;
         *
         *   if (this.graph.isHtmlLabel(s.cell) && (index == 3 || index == 4) &&
         *       s.text != null && s.style[mxConstants.STYLE_WHITE_SPACE] == 'wrap')
         *   {
         *     var label = this.graph.getLabel(s.cell);
         *     var fontSize = mxUtils.getNumber(s.style, mxConstants.STYLE_FONTSIZE, mxConstants.DEFAULT_FONTSIZE);
         *     var ww = result.width / s.view.scale - s.text.spacingRight - s.text.spacingLeft
         *
         *     result.height = mxUtils.getSizeForString(label, fontSize, s.style[mxConstants.STYLE_FONTFAMILY], ww).height;
         *   }
         *
         *   return result;
         * };
         * (end)
         */
        union(bounds: mxRectangle, dx: number, dy: number, index: any, gridEnabled: boolean, scale: number, tr: any, constrained: boolean, centered: boolean): mxRectangle;
        /**
         * Function: redraw
         *
         * Redraws the handles and the preview.
         */
        redraw(ignoreHandles: boolean): void;
        /**
         * Returns the padding to be used for drawing handles for the current <bounds>.
         */
        getHandlePadding(): mxPoint;
        /**
         * Function: getSizerBounds
         *
         * Returns the bounds used to paint the resize handles.
         */
        getSizerBounds(): mxRectangle;
        /**
         * Function: redrawHandles
         *
         * Redraws the handles. To hide certain handles the following code can be used.
         *
         * (code)
         * redrawHandles = function()
         * {
         *   mxVertexHandlerRedrawHandles.apply(this, arguments);
         *
         *   if (this.sizers != null && this.sizers.length > 7)
         *   {
         *     this.sizers[1].node.style.display = 'none';
         *     this.sizers[6].node.style.display = 'none';
         *   }
         * };
         * (end)
         */
        redrawHandles(): void;
        /**
         * Function: isCustomHandleVisible
         *
         * Returns true if the given custom handle is visible.
         */
        isCustomHandleVisible(handle: any): boolean;
        /**
         * Function: getRotationHandlePosition
         *
         * Returns an <mxPoint> that defines the rotation handle position.
         */
        getRotationHandlePosition(): mxPoint;
        /**
         * Function: isParentHighlightVisible
         *
         * Returns true if the parent highlight should be visible. This implementation
         * always returns true.
         */
        isParentHighlightVisible(): boolean;
        /**
         * Function: updateParentHighlight
         *
         * Updates the highlight of the parent if <parentHighlightEnabled> is true.
         */
        updateParentHighlight(): void;
        /**
         * Function: drawPreview
         *
         * Redraws the preview.
         */
        drawPreview(): void;
        /**
         * Function: getSelectionBorderBounds
         *
         * Returns the bounds for the selection border.
         */
        getSelectionBorderBounds(): mxRectangle;
        /**
         * Function: isDestroyed
         *
         * Returns true if this handler was destroyed or not initialized.
         */
        isDestroyed(): boolean;
        /**
         * Function: destroy
         *
         * Destroys the handler and all its resources and DOM nodes.
         */
        destroy(): void;
    }
    /**
     * Class: mxEdgeHandler
     *
     * Graph event handler that reconnects edges and modifies control points and
     * the edge label location. Uses <mxTerminalMarker> for finding and
     * highlighting new source and target vertices. This handler is automatically
     * created in <mxGraph.createHandler> for each selected edge.
     *
     * To enable adding/removing control points, the following code can be used:
     *
     * (code)
     * mxEdgeHandler.prototype.addEnabled = true;
     * mxEdgeHandler.prototype.removeEnabled = true;
     * (end)
     *
     * Note: This experimental feature is not recommended for production use.
     *
     * Constructor: mxEdgeHandler
     *
     * Constructs an edge handler for the specified <mxCellState>.
     *
     * Parameters:
     *
     * state - <mxCellState> of the cell to be handled.
     */
    class mxEdgeHandler {
        constructor(state: mxCellState);
        /**
         * Variable: graph
         *
         * Reference to the enclosing <mxGraph>.
         */
        graph: mxGraph;
        /**
         * Variable: state
         *
         * Reference to the <mxCellState> being modified.
         */
        state: mxCellState;
        /**
         * Variable: marker
         *
         * Holds the <mxTerminalMarker> which is used for highlighting terminals.
         */
        marker: any;
        /**
         * Variable: constraintHandler
         *
         * Holds the <mxConstraintHandler> used for drawing and highlighting
         * constraints.
         */
        constraintHandler: mxConstraintHandler;
        /**
         * Variable: error
         *
         * Holds the current validation error while a connection is being changed.
         */
        error: any;
        /**
         * Variable: shape
         *
         * Holds the <mxShape> that represents the preview edge.
         */
        shape: mxShape;
        /**
         * Variable: bends
         *
         * Holds the <mxShapes> that represent the points.
         */
        bends: any[];
        /**
         * Variable: labelShape
         *
         * Holds the <mxShape> that represents the label position.
         */
        labelShape: mxShape;
        /**
         * Variable: cloneEnabled
         *
         * Specifies if cloning by control-drag is enabled. Default is true.
         */
        cloneEnabled: boolean;
        /**
         * Variable: addEnabled
         *
         * Specifies if adding bends by shift-click is enabled. Default is false.
         * Note: This experimental feature is not recommended for production use.
         */
        addEnabled: boolean;
        /**
         * Variable: removeEnabled
         *
         * Specifies if removing bends by shift-click is enabled. Default is false.
         * Note: This experimental feature is not recommended for production use.
         */
        removeEnabled: boolean;
        /**
         * Variable: dblClickRemoveEnabled
         *
         * Specifies if removing bends by double click is enabled. Default is false.
         */
        dblClickRemoveEnabled: boolean;
        /**
         * Variable: mergeRemoveEnabled
         *
         * Specifies if removing bends by dropping them on other bends is enabled.
         * Default is false.
         */
        mergeRemoveEnabled: boolean;
        /**
         * Variable: straightRemoveEnabled
         *
         * Specifies if removing bends by creating straight segments should be enabled.
         * If enabled, this can be overridden by holding down the alt key while moving.
         * Default is false.
         */
        straightRemoveEnabled: boolean;
        /**
         * Variable: virtualBendsEnabled
         *
         * Specifies if virtual bends should be added in the center of each
         * segments. These bends can then be used to add new waypoints.
         * Default is false.
         */
        virtualBendsEnabled: boolean;
        /**
         * Variable: virtualBendOpacity
         *
         * Opacity to be used for virtual bends (see <virtualBendsEnabled>).
         * Default is 20.
         */
        virtualBendOpacity: number;
        /**
         * Variable: parentHighlightEnabled
         *
         * Specifies if the parent should be highlighted if a child cell is selected.
         * Default is false.
         */
        parentHighlightEnabled: boolean;
        /**
         * Variable: preferHtml
         *
         * Specifies if bends should be added to the graph container. This is updated
         * in <init> based on whether the edge or one of its terminals has an HTML
         * label in the container.
         */
        preferHtml: boolean;
        /**
         * Variable: allowHandleBoundsCheck
         *
         * Specifies if the bounds of handles should be used for hit-detection in IE
         * Default is true.
         */
        allowHandleBoundsCheck: boolean;
        /**
         * Variable: snapToTerminals
         *
         * Specifies if waypoints should snap to the routing centers of terminals.
         * Default is false.
         */
        snapToTerminals: boolean;
        /**
         * Variable: handleImage
         *
         * Optional <mxImage> to be used as handles. Default is null.
         */
        handleImage: mxImage;
        /**
         * Variable: tolerance
         *
         * Optional tolerance for hit-detection in <getHandleForEvent>. Default is 0.
         */
        tolerance: number;
        /**
         * Variable: outlineConnect
         *
         * Specifies if connections to the outline of a highlighted target should be
         * enabled. This will allow to place the connection point along the outline of
         * the highlighted target. Default is false.
         */
        outlineConnect: boolean;
        /**
         * Variable: manageLabelHandle
         *
         * Specifies if the label handle should be moved if it intersects with another
         * handle. Uses <checkLabelHandle> for checking and moving. Default is false.
         */
        manageLabelHandle: boolean;
        /**
         * Function: isParentHighlightVisible
         *
         * Returns true if the parent highlight should be visible. This implementation
         * always returns true.
         */
        isParentHighlightVisible: boolean;
        /**
         * Function: updateParentHighlight
         *
         * Updates the highlight of the parent if <parentHighlightEnabled> is true.
         */
        updateParentHighlight: boolean;
        escapeHandler: any;
        points: mxPoint[];
        abspoints: mxPoint[];
        label: mxPoint;
        customHandles: any[];
        labelHandleImage: any;
        virtualBends: any;
        snapPoint: mxPoint;
        startX: number;
        startY: number;
        isSource: boolean;
        isTarget: boolean;
        isLabel: boolean;
        index: any;
        currentPoint: mxPoint;
        active: boolean;
        sizers: any[];
        livePreview: boolean;
        parentHighlight: any;
        /**
         * Function: init
         *
         * Initializes the shapes required for this edge handler.
         */
        init(): void;
        /**
         * Function: createCustomHandles
         *
         * Returns an array of custom handles. This implementation returns null.
         */
        createCustomHandles(): any;
        /**
         * Function: isVirtualBendsEnabled
         *
         * Returns true if virtual bends should be added. This returns true if
         * <virtualBendsEnabled> is true and the current style allows and
         * renders custom waypoints.
         */
        isVirtualBendsEnabled(evt: any): boolean;
        /**
         * Function: isCellEnabled
         *
         * Returns true if the given cell allows new connections to be created. This implementation
         * always returns true.
         */
        isCellEnabled(cell: mxCell): boolean;
        /**
         * Function: isAddPointEvent
         *
         * Returns true if the given event is a trigger to add a new point. This
         * implementation returns true if shift is pressed.
         */
        isAddPointEvent(evt: any): boolean;
        /**
         * Function: isRemovePointEvent
         *
         * Returns true if the given event is a trigger to remove a point. This
         * implementation returns true if shift is pressed.
         */
        isRemovePointEvent(evt: any): boolean;
        /**
         * Function: getSelectionPoints
         *
         * Returns the list of points that defines the selection stroke.
         */
        getSelectionPoints(state: any): any;
        /**
         * Function: createParentHighlightShape
         *
         * Creates the shape used to draw the selection border.
         */
        createParentHighlightShape(bounds: any): mxRectangleShape;
        /**
         * Function: createSelectionShape
         *
         * Creates the shape used to draw the selection border.
         */
        createSelectionShape(points: any): any;
        /**
         * Function: getSelectionColor
         *
         * Returns <mxConstants.EDGE_SELECTION_COLOR>.
         */
        getSelectionColor(): string;
        /**
         * Function: getSelectionStrokeWidth
         *
         * Returns <mxConstants.EDGE_SELECTION_STROKEWIDTH>.
         */
        getSelectionStrokeWidth(): number;
        /**
         * Function: isSelectionDashed
         *
         * Returns <mxConstants.EDGE_SELECTION_DASHED>.
         */
        isSelectionDashed(): boolean;
        /**
         * Function: isConnectableCell
         *
         * Returns true if the given cell is connectable. This is a hook to
         * disable floating connections. This implementation returns true.
         */
        isConnectableCell(cell: any): boolean;
        /**
         * Function: getCellAt
         *
         * Creates and returns the <mxCellMarker> used in <marker>.
         */
        getCellAt(x: any, y: any): any;
        /**
         * Function: createMarker
         *
         * Creates and returns the <mxCellMarker> used in <marker>.
         */
        createMarker(): any;
        /**
         * Function: validateConnection
         *
         * Returns the error message or an empty string if the connection for the
         * given source, target pair is not valid. Otherwise it returns null. This
         * implementation uses <mxGraph.getEdgeValidationError>.
         *
         * Parameters:
         *
         * source - <mxCell> that represents the source terminal.
         * target - <mxCell> that represents the target terminal.
         */
        validateConnection(source: any, target: any): any;
        /**
         * Function: createBends
         *
         * Creates and returns the bends used for modifying the edge. This is
         * typically an array of <mxRectangleShapes>.
         */
        createBends(): any[];
        /**
         * Function: createVirtualBends
         *
         * Creates and returns the bends used for modifying the edge. This is
         * typically an array of <mxRectangleShapes>.
         */
        createVirtualBends(): any[];
        /**
         * Function: isHandleEnabled
         *
         * Creates the shape used to display the given bend.
         */
        isHandleEnabled(index: any): boolean;
        /**
         * Function: isHandleVisible
         *
         * Returns true if the handle at the given index is visible.
         */
        isHandleVisible(index: any): boolean;
        /**
         * Function: createHandleShape
         *
         * Creates the shape used to display the given bend. Note that the index may be
         * null for special cases, such as when called from
         * <mxElbowEdgeHandler.createVirtualBend>. Only images and rectangles should be
         * returned if support for HTML labels with not foreign objects is required.
         * Index if null for virtual handles.
         */
        createHandleShape(index: any): any;
        /**
         * Function: createLabelHandleShape
         *
         * Creates the shape used to display the the label handle.
         */
        createLabelHandleShape(): any;
        /**
         * Function: initBend
         *
         * Helper method to initialize the given bend.
         *
         * Parameters:
         *
         * bend - <mxShape> that represents the bend to be initialized.
         */
        initBend(bend: any, dblClick: any): void;
        /**
         * Function: getHandleForEvent
         *
         * Returns the index of the handle for the given event.
         */
        getHandleForEvent(me: any): any;
        /**
         * Function: isAddVirtualBendEvent
         *
         * Returns true if the given event allows virtual bends to be added. This
         * implementation returns true.
         */
        isAddVirtualBendEvent(me: any): boolean;
        /**
         * Function: isCustomHandleEvent
         *
         * Returns true if the given event allows custom handles to be changed. This
         * implementation returns true.
         */
        isCustomHandleEvent(me: any): boolean;
        /**
         * Function: mouseDown
         *
         * Handles the event by checking if a special element of the handler
         * was clicked, in which case the index parameter is non-null. The
         * indices may be one of <LABEL_HANDLE> or the number of the respective
         * control point. The source and target points are used for reconnecting
         * the edge.
         */
        mouseDown(sender: any, me: any): void;
        /**
         * Function: start
         *
         * Starts the handling of the mouse gesture.
         */
        start(x: any, y: any, index: any): void;
        /**
         * Function: clonePreviewState
         *
         * Returns a clone of the current preview state for the given point and terminal.
         */
        clonePreviewState(point: any, terminal: any): any;
        /**
         * Function: getSnapToTerminalTolerance
         *
         * Returns the tolerance for the guides. Default value is
         * gridSize * scale / 2.
         */
        getSnapToTerminalTolerance(): number;
        /**
         * Function: updateHint
         *
         * Hook for subclassers do show details while the handler is active.
         */
        updateHint(me: any, point: any): void;
        /**
         * Function: removeHint
         *
         * Hooks for subclassers to hide details when the handler gets inactive.
         */
        removeHint(): void;
        /**
         * Function: roundLength
         *
         * Hook for rounding the unscaled width or height. This uses Math.round.
         */
        roundLength(length: any): number;
        /**
         * Function: isSnapToTerminalsEvent
         *
         * Returns true if <snapToTerminals> is true and if alt is not pressed.
         */
        isSnapToTerminalsEvent(me: any): boolean;
        /**
         * Function: getPointForEvent
         *
         * Returns the point for the given event.
         */
        getPointForEvent(me: any): mxPoint;
        /**
         * Function: getPreviewTerminalState
         *
         * Updates the given preview state taking into account the state of the constraint handler.
         */
        getPreviewTerminalState(me: any): any;
        /**
         * Function: getPreviewPoints
         *
         * Updates the given preview state taking into account the state of the constraint handler.
         *
         * Parameters:
         *
         * pt - <mxPoint> that contains the current pointer position.
         * me - Optional <mxMouseEvent> that contains the current event.
         */
        getPreviewPoints(pt: any, me: any): any;
        /**
         * Function: isOutlineConnectEvent
         *
         * Returns true if <outlineConnect> is true and the source of the event is the outline shape
         * or shift is pressed.
         */
        isOutlineConnectEvent(me: any): any;
        /**
         * Function: updatePreviewState
         *
         * Updates the given preview state taking into account the state of the constraint handler.
         */
        updatePreviewState(edge: any, point: any, terminalState: any, me: any, outline: any): void;
        /**
         * Function: mouseMove
         *
         * Handles the event by updating the preview.
         */
        mouseMove(sender: any, me: any): void;
        /**
         * Function: mouseUp
         *
         * Handles the event to applying the previewed changes on the edge by
         * using <moveLabel>, <connect> or <changePoints>.
         */
        mouseUp(sender: any, me: any): void;
        /**
         * Function: reset
         *
         * Resets the state of this handler.
         */
        reset(): void;
        /**
         * Function: setPreviewColor
         *
         * Sets the color of the preview to the given value.
         */
        setPreviewColor(color: any): void;
        /**
         * Function: convertPoint
         *
         * Converts the given point in-place from screen to unscaled, untranslated
         * graph coordinates and applies the grid. Returns the given, modified
         * point instance.
         *
         * Parameters:
         *
         * point - <mxPoint> to be converted.
         * gridEnabled - Boolean that specifies if the grid should be applied.
         */
        convertPoint(point: any, gridEnabled: any): any;
        /**
         * Function: moveLabel
         *
         * Changes the coordinates for the label of the given edge.
         *
         * Parameters:
         *
         * edge - <mxCell> that represents the edge.
         * x - Integer that specifies the x-coordinate of the new location.
         * y - Integer that specifies the y-coordinate of the new location.
         */
        moveLabel(edgeState: any, x: any, y: any): void;
        /**
         * Function: connect
         *
         * Changes the terminal or terminal point of the given edge in the graph
         * model.
         *
         * Parameters:
         *
         * edge - <mxCell> that represents the edge to be reconnected.
         * terminal - <mxCell> that represents the new terminal.
         * isSource - Boolean indicating if the new terminal is the source or
         * target terminal.
         * isClone - Boolean indicating if the new connection should be a clone of
         * the old edge.
         * me - <mxMouseEvent> that contains the mouse up event.
         */
        connect(edge: any, terminal: any, isSource: any, isClone: any, me: any): any;
        /**
         * Function: changeTerminalPoint
         *
         * Changes the terminal point of the given edge.
         */
        changeTerminalPoint(edge: any, point: any, isSource: any, clone: any): any;
        /**
         * Function: changePoints
         *
         * Changes the control points of the given edge in the graph model.
         */
        changePoints(edge: any, points: any, clone: any): any;
        /**
         * Function: addPoint
         *
         * Adds a control point for the given state and event.
         */
        addPoint(state: any, evt: any): void;
        /**
         * Function: addPointAt
         *
         * Adds a control point at the given point.
         */
        addPointAt(state: any, x: any, y: any): void;
        /**
         * Function: removePoint
         *
         * Removes the control point at the given index from the given state.
         */
        removePoint(state: any, index: any): void;
        /**
         * Function: getHandleFillColor
         *
         * Returns the fillcolor for the handle at the given index.
         */
        getHandleFillColor(index: any): string;
        /**
         * Function: redraw
         *
         * Redraws the preview, and the bends- and label control points.
         */
        redraw(): void;
        /**
         * Function: redrawHandles
         *
         * Redraws the handles.
         */
        redrawHandles(): void;
        /**
         * Function: isCustomHandleVisible
         *
         * Returns true if the given custom handle is visible.
         */
        isCustomHandleVisible(handle: any): boolean;
        /**
         * Function: setHandlesVisible
         *
         * Shortcut to <hideSizers>.
         */
        setHandlesVisible(visible: any): void;
        /**
         * Function: redrawInnerBends
         *
         * Updates and redraws the inner bends.
         *
         * Parameters:
         *
         * p0 - <mxPoint> that represents the location of the first point.
         * pe - <mxPoint> that represents the location of the last point.
         */
        redrawInnerBends(p0: any, pe: any): void;
        /**
         * Function: checkLabelHandle
         *
         * Checks if the label handle intersects the given bounds and moves it if it
         * intersects.
         */
        checkLabelHandle(b: any): void;
        /**
         * Function: drawPreview
         *
         * Redraws the preview.
         */
        drawPreview(): void;
        /**
         * Function: refresh
         *
         * Refreshes the bends of this handler.
         */
        refresh(): void;
        /**
         * Function: isDestroyed
         *
         * Returns true if <destroy> was called.
         */
        isDestroyed(): boolean;
        /**
         * Function: destroyBends
         *
         * Destroys all elements in <bends>.
         */
        destroyBends(bends: any): void;
        /**
         * Function: destroy
         *
         * Destroys the handler and all its resources and DOM nodes. This does
         * normally not need to be called as handlers are destroyed automatically
         * when the corresponding cell is deselected.
         */
        destroy(): void;
    }
    /**
     * Graph event handler that reconnects edges and modifies control points and
     * the edge label location. Uses <mxTerminalMarker> for finding and
     * highlighting new source and target vertices. This handler is automatically
     * created in <mxGraph.createHandler>. It extends <mxEdgeHandler>.
     *
     * Constructor: mxEdgeHandler
     *
     * Constructs an edge handler for the specified <mxCellState>.
     *
     * Parameters:
     *
     * state - <mxCellState> of the cell to be modified.
     */
    class mxElbowEdgeHandler extends mxEdgeHandler {
        constructor(state: any);
        /**
         * Overrides <mxEdgeHandler.createBends> to create custom bends.
         */
        createBends(): any[];
        /**
         * Creates a virtual bend that supports double clicking and calls
         * <mxGraph.flipEdge>.
         */
        createVirtualBend(dblClickHandler: any): any;
        /**
         * Returns the cursor to be used for the bend.
         */
        getCursorForBend(): "row-resize" | "col-resize";
        /**
         * Returns the tooltip for the given node.
         */
        getTooltipForNode(node: any): any;
        /**
         * Converts the given point in-place from screen to unscaled, untranslated
         * graph coordinates and applies the grid.
         *
         * Parameters:
         *
         * point - <mxPoint> to be converted.
         * gridEnabled - Boolean that specifies if the grid should be applied.
         */
        convertPoint(point: any, gridEnabled: any): any;
        /**
         * Updates and redraws the inner bends.
         *
         * Parameters:
         *
         * p0 - <mxPoint> that represents the location of the first point.
         * pe - <mxPoint> that represents the location of the last point.
         */
        redrawInnerBends(p0: any, pe: any): void;
    }
    class mxEdgeSegmentHandler extends mxElbowEdgeHandler {
        constructor(state: any);
        /**
         * Returns the current absolute points.
         */
        getCurrentPoints(): any;
        /**
         * Updates the given preview state taking into account the state of the constraint handler.
         */
        getPreviewPoints(point: any): any;
        /**
         * Overridden to perform optimization of the edge style result.
         */
        updatePreviewState(edge: any, point: any, terminalState: any, me: any): void;
        /**
         * Overriden to merge edge segments.
         */
        connect(edge: any, terminal: any, isSource: any, isClone: any, me: any): any;
        /**
         * Returns no tooltips.
         */
        getTooltipForNode(node: any): any;
        /**
         * Adds custom bends for the center of each segment.
         */
        start(x: any, y: any, index: any): void;
        /**
         * Adds custom bends for the center of each segment.
         */
        createBends(): any[];
        /**
         * Overridden to invoke <refresh> before the redraw.
         */
        redraw(): void;
        /**
         * Updates the position of the custom bends.
         */
        redrawInnerBends(p0: any, pe: any): void;
    }
    /**
     * Event handler that listens to keystroke events. This is not a singleton,
     * however, it is normally only required once if the target is the document
     * element (default).
     *
     * This handler installs a key event listener in the topmost DOM node and
     * processes all events that originate from descandants of <mxGraph.container>
     * or from the topmost DOM node. The latter means that all unhandled keystrokes
     * are handled by this object regardless of the focused state of the <graph>.
     *
     * Example:
     *
     * The following example creates a key handler that listens to the delete key
     * (46) and deletes the selection cells if the graph is enabled.
     *
     * (code)
     * var keyHandler = new mxKeyHandler(graph);
     * keyHandler.bindKey(46, function(evt)
     * {
     *   if (graph.isEnabled())
     *   {
     *     graph.removeCells();
     *   }
     * });
     * (end)
     *
     * Keycodes:
     *
     * See http://tinyurl.com/yp8jgl or http://tinyurl.com/229yqw for a list of
     * keycodes or install a key event listener into the document element and print
     * the key codes of the respective events to the console.
     *
     * To support the Command key and the Control key on the Mac, the following
     * code can be used.
     *
     * (code)
     * keyHandler.getFunction = function(evt)
     * {
     *   if (evt != null)
     *   {
     *     return (mxEvent.isControlDown(evt) || (mxClient.IS_MAC && evt.metaKey)) ? this.controlKeys[evt.keyCode] : this.normalKeys[evt.keyCode];
     *   }
     *
     *   return null;
     * };
     * (end)
     *
     * Constructor: mxKeyHandler
     *
     * Constructs an event handler that executes functions bound to specific
     * keystrokes.
     *
     * Parameters:
     *
     * graph - Reference to the associated <mxGraph>.
     * target - Optional reference to the event target. If null, the document
     * element is used as the event target, that is, the object where the key
     * event listener is installed.
     */
    class mxKeyHandler {
        constructor(graph: any, target?: any);
        /**
         * Returns true if events are handled. This implementation returns
         * <enabled>.
         */
        isEnabled(): any;
        /**
         * Enables or disables event handling by updating <enabled>.
         *
         * Parameters:
         *
         * enabled - Boolean that specifies the new enabled state.
         */
        setEnabled(enabled: any): void;
        /**
         * Binds the specified keycode to the given function. This binding is used
         * if the control key is not pressed.
         *
         * Parameters:
         *
         * code - Integer that specifies the keycode.
         * funct - JavaScript function that takes the key event as an argument.
         */
        bindKey(code: any, funct: any): void;
        /**
         * Binds the specified keycode to the given function. This binding is used
         * if the shift key is pressed.
         *
         * Parameters:
         *
         * code - Integer that specifies the keycode.
         * funct - JavaScript function that takes the key event as an argument.
         */
        bindShiftKey(code: any, funct: any): void;
        /**
         * Binds the specified keycode to the given function. This binding is used
         * if the control key is pressed.
         *
         * Parameters:
         *
         * code - Integer that specifies the keycode.
         * funct - JavaScript function that takes the key event as an argument.
         */
        bindControlKey(code: any, funct: any): void;
        /**
         * Binds the specified keycode to the given function. This binding is used
         * if the control and shift key are pressed.
         *
         * Parameters:
         *
         * code - Integer that specifies the keycode.
         * funct - JavaScript function that takes the key event as an argument.
         */
        bindControlShiftKey(code: any, funct: any): void;
        /**
         * Returns true if the control key is pressed. This uses <mxEvent.isControlDown>.
         *
         * Parameters:
         *
         * evt - Key event whose control key pressed state should be returned.
         */
        isControlDown(evt: any): boolean;
        /**
         * Returns the function associated with the given key event or null if no
         * function is associated with the given event.
         *
         * Parameters:
         *
         * evt - Key event whose associated function should be returned.
         */
        getFunction(evt: any): any;
        /**
         * Returns true if the event should be processed by this handler, that is,
         * if the event source is either the target, one of its direct children, a
         * descendant of the <mxGraph.container>, or the <mxGraph.cellEditor> of the
         * <graph>.
         *
         * Parameters:
         *
         * evt - Key event that represents the keystroke.
         */
        isGraphEvent(evt: any): any;
        /**
         * Handles the event by invoking the function bound to the respective keystroke
         * if <isEnabledForEvent> returns true for the given event and if
         * <isEventIgnored> returns false, except for escape for which
         * <isEventIgnored> is not invoked.
         *
         * Parameters:
         *
         * evt - Key event that represents the keystroke.
         */
        keyDown(evt: any): void;
        /**
         * Returns true if the given event should be handled. <isEventIgnored> is
         * called later if the event is not an escape key stroke, in which case
         * <escape> is called. This implementation returns true if <isEnabled>
         * returns true for both, this handler and <graph>, if the event is not
         * consumed and if <isGraphEvent> returns true.
         *
         * Parameters:
         *
         * evt - Key event that represents the keystroke.
         */
        isEnabledForEvent(evt: any): any;
        /**
         * Returns true if the given keystroke should be ignored. This returns
         * graph.isEditing().
         *
         * Parameters:
         *
         * evt - Key event that represents the keystroke.
         */
        isEventIgnored(evt: any): any;
        /**
         * Hook to process ESCAPE keystrokes. This implementation invokes
         * <mxGraph.stopEditing> to cancel the current editing, connecting
         * and/or other ongoing modifications.
         *
         * Parameters:
         *
         * evt - Key event that represents the keystroke. Possible keycode in this
         * case is 27 (ESCAPE).
         */
        escape(evt: any): void;
        /**
         * Destroys the handler and all its references into the DOM. This does
         * normally not need to be called, it is called automatically when the
         * window unloads (in IE).
         */
        destroy(): void;
    }
    /**
     * Graph event handler that displays tooltips. <mxGraph.getTooltip> is used to
     * get the tooltip for a cell or handle. This handler is built-into
     * <mxGraph.tooltipHandler> and enabled using <mxGraph.setTooltips>.
     *
     * Example:
     *
     * (code>
     * new mxTooltipHandler(graph);
     * (end)
     *
     * Constructor: mxTooltipHandler
     *
     * Constructs an event handler that displays tooltips with the specified
     * delay (in milliseconds). If no delay is specified then a default delay
     * of 500 ms (0.5 sec) is used.
     *
     * Parameters:
     *
     * graph - Reference to the enclosing <mxGraph>.
     * delay - Optional delay in milliseconds.
     */
    class mxTooltipHandler {
        /**
         * Function: getStateForEvent
         *
         * Returns the <mxCellState> to be used for showing a tooltip for this event.
         */
        getStateForEvent(me: any): any;
        constructor(graph: any, delay?: number);
        /**
         * Returns true if events are handled. This implementation
         * returns <enabled>.
         */
        isEnabled(): any;
        /**
         * Enables or disables event handling. This implementation
         * updates <enabled>.
         */
        setEnabled(enabled: any): void;
        /**
         * Returns <hideOnHover>.
         */
        isHideOnHover(): any;
        /**
         * Sets <hideOnHover>.
         */
        setHideOnHover(value: any): void;
        /**
         * Initializes the DOM nodes required for this tooltip handler.
         */
        init(): void;
        /**
         * Handles the event by initiating a rubberband selection. By consuming the
         * event all subsequent events of the gesture are redirected to this
         * handler.
         */
        mouseDown(sender: any, me: any): void;
        /**
         * Handles the event by updating the rubberband selection.
         */
        mouseMove(sender: any, me: any): void;
        /**
         * Handles the event by resetting the tooltip timer or hiding the existing
         * tooltip.
         */
        mouseUp(sender: any, me: any): void;
        /**
         * Resets the timer.
         */
        resetTimer(): void;
        /**
         * Resets and/or restarts the timer to trigger the display of the tooltip.
         */
        reset(me: any, restart: any): void;
        /**
         * Hides the tooltip and resets the timer.
         */
        hide(): void;
        /**
         * Hides the tooltip.
         */
        hideTooltip(): void;
        /**
         * Shows the tooltip for the specified cell and optional index at the
         * specified location (with a vertical offset of 10 pixels).
         */
        show(tip: any, x: any, y: any): void;
        /**
         * Destroys the handler and all its resources and DOM nodes.
         */
        destroy(): void;
    }
    /**
     * Event handler that highlights cells. Inherits from <mxCellMarker>.
     *
     * Example:
     *
     * (code)
     * new mxCellTracker(graph, '#00FF00');
     * (end)
     *
     * For detecting dragEnter, dragOver and dragLeave on cells, the following
     * code can be used:
     *
     * (code)
     * graph.addMouseListener(
     * {
     *   cell: null,
     *   mouseDown: function(sender: any, me: any): void; { },
     *   mouseMove: function(sender: any, me: any): void;
     *   {
     *     var tmp = me.getCell();
     *
     *     if (tmp != this.cell)
     *     {
     *       if (this.cell != null)
     *       {
     *         this.dragLeave(me.getEvent(), this.cell);
     *       }
     *
     *       this.cell = tmp;
     *
     *       if (this.cell != null)
     *       {
     *         this.dragEnter(me.getEvent(), this.cell);
     *       }
     *     }
     *
     *     if (this.cell != null)
     *     {
     *       this.dragOver(me.getEvent(), this.cell);
     *     }
     *   },
     *   mouseUp: function(sender: any, me: any): void; { },
     *   dragEnter: function(evt, cell)
     *   {
     *     mxLog.debug('dragEnter', cell.value);
     *   },
     *   dragOver: function(evt, cell)
     *   {
     *     mxLog.debug('dragOver', cell.value);
     *   },
     *   dragLeave: function(evt, cell)
     *   {
     *     mxLog.debug('dragLeave', cell.value);
     *   }
     * });
     * (end)
     *
     * Constructor: mxCellTracker
     *
     * Constructs an event handler that highlights cells.
     *
     * Parameters:
     *
     * graph - Reference to the enclosing <mxGraph>.
     * color - Color of the highlight. Default is blue.
     * funct - Optional JavaScript function that is used to override
     * <mxCellMarker.getCell>.
     */
    class mxCellTracker extends mxCellMarker {
        constructor(graph: any, color?: any, funct?: any);
        /**
         * Ignores the event. The event is not consumed.
         */
        mouseDown(sender: any, me: any): void;
        /**
         * Handles the event by highlighting the cell under the mousepointer if it
         * is over the hotspot region of the cell.
         */
        mouseMove(sender: any, me: any): void;
        /**
         * Handles the event by reseting the highlight.
         */
        mouseUp(sender: any, me: any): void;
        /**
         * Destroys the object and all its resources and DOM nodes. This doesn't
         * normally need to be called. It is called automatically when the window
         * unloads.
         */
        destroy(): void;
    }
    /**
     * A helper class to highlight cells. Here is an example for a given cell.
     *
     * (code)
     * var highlight = new mxCellHighlight(graph, '#ff0000', 2);
     * highlight.highlight(graph.view.getState(cell)));
     * (end)
     *
     * Constructor: mxCellHighlight
     *
     * Constructs a cell highlight.
     */
    class mxCellHighlight {
        /**
         * Variable: keepOnTop
         *
         * Specifies if the highlights should appear on top of everything
         * else in the overlay pane. Default is false.
         */
        keepOnTop: boolean;
        /**
         * Variable: state
         *
         * Reference to the <mxCellState>.
         */
        state: mxCellState;
        constructor(graph: any, highlightColor: any, strokeWidth: any, dashed: any);
        /**
         * Sets the color of the rectangle used to highlight drop targets.
         *
         * Parameters:
         *
         * color - String that represents the new highlight color.
         */
        setHighlightColor(color: any): void;
        /**
         * Creates and returns the highlight shape for the given state.
         */
        drawHighlight(): void;
        /**
         * Creates and returns the highlight shape for the given state.
         */
        createShape(): any;
        /**
         * Updates the highlight after a change of the model or view.
         */
        getStrokeWidth(state: any): any;
        /**
         * Updates the highlight after a change of the model or view.
         */
        repaint(): void;
        /**
         * Resets the state of the cell marker.
         */
        hide(): void;
        /**
         * Marks the <markedState> and fires a <mark> event.
         */
        highlight(state: any): void;
        /**
         * Returns true if this highlight is at the given position.
         */
        isHighlightAt(x: any, y: any): boolean;
        /**
         * Destroys the handler and all its resources and DOM nodes.
         */
        destroy(): void;
    }
    /**
     * Binds keycodes to actionnames in an editor. This aggregates an internal
     * <handler> and extends the implementation of <mxKeyHandler.escape> to not
     * only cancel the editing, but also hide the properties dialog and fire an
     * <mxEditor.escape> event via <editor>. An instance of this class is created
     * by <mxEditor> and stored in <mxEditor.keyHandler>.
     *
     * Example:
     *
     * Bind the delete key to the delete action in an existing editor.
     *
     * (code)
     * var keyHandler = new mxDefaultKeyHandler(editor);
     * keyHandler.bindAction(46, 'delete');
     * (end)
     *
     * Codec:
     *
     * This class uses the <mxDefaultKeyHandlerCodec> to read configuration
     * data into an existing instance. See <mxDefaultKeyHandlerCodec> for a
     * description of the configuration format.
     *
     * Keycodes:
     *
     * See <mxKeyHandler>.
     *
     * An <mxEvent.ESCAPE> event is fired via the editor if the escape key is
     * pressed.
     *
     * Constructor: mxDefaultKeyHandler
     *
     * Constructs a new default key handler for the <mxEditor.graph> in the
     * given <mxEditor>. (The editor may be null if a prototypical instance for
     * a <mxDefaultKeyHandlerCodec> is created.)
     *
     * Parameters:
     *
     * editor - Reference to the enclosing <mxEditor>.
     */
    class mxDefaultKeyHandler {
        constructor(editor: any);
        /**
         * Binds the specified keycode to the given action in <editor>. The
         * optional control flag specifies if the control key must be pressed
         * to trigger the action.
         *
         * Parameters:
         *
         * code - Integer that specifies the keycode.
         * action - Name of the action to execute in <editor>.
         * control - Optional boolean that specifies if control must be pressed.
         * Default is false.
         */
        bindAction(code: any, action: any, control: any): void;
        /**
         * Destroys the <handler> associated with this object. This does normally
         * not need to be called, the <handler> is destroyed automatically when the
         * window unloads (in IE) by <mxEditor>.
         */
        destroy(): void;
    }
    /**
     * Creates popupmenus for mouse events. This object holds an XML node
     * which is a description of the popup menu to be created. In
     * <createMenu>, the configuration is applied to the context and
     * the resulting menu items are added to the menu dynamically. See
     * <createMenu> for a description of the configuration format.
     *
     * This class does not create the DOM nodes required for the popup menu, it
     * only parses an XML description to invoke the respective methods on an
     * <mxPopupMenu> each time the menu is displayed.
     *
     * Codec:
     *
     * This class uses the <mxDefaultPopupMenuCodec> to read configuration
     * data into an existing instance, however, the actual parsing is done
     * by this class during program execution, so the format is described
     * below.
     *
     * Constructor: mxDefaultPopupMenu
     *
     * Constructs a new popupmenu-factory based on given configuration.
     *
     * Paramaters:
     *
     * config - XML node that contains the configuration data.
     */
    class mxDefaultPopupMenu {
        constructor(config: any);
        /**
         * This function is called from <mxEditor> to add items to the
         * given menu based on <config>. The config is a sequence of
         * the following nodes and attributes.
         *
         * Child Nodes:
         *
         * add - Adds a new menu item. See below for attributes.
         * separator - Adds a separator. No attributes.
         * condition - Adds a custom condition. Name attribute.
         *
         * The add-node may have a child node that defines a function to be invoked
         * before the action is executed (or instead of an action to be executed).
         *
         * Attributes:
         *
         * as - Resource key for the label (needs entry in property file).
         * action - Name of the action to execute in enclosing editor.
         * icon - Optional icon (relative/absolute URL).
         * iconCls - Optional CSS class for the icon.
         * if - Optional name of condition that must be true (see below).
         * enabled-if - Optional name of condition that specifies if the menu item
         * should be enabled.
         * name - Name of custom condition. Only for condition nodes.
         *
         * Conditions:
         *
         * nocell - No cell under the mouse.
         * ncells - More than one cell selected.
         * notRoot - Drilling position is other than home.
         * cell - Cell under the mouse.
         * notEmpty - Exactly one cell with children under mouse.
         * expandable - Exactly one expandable cell under mouse.
         * collapsable - Exactly one collapsable cell under mouse.
         * validRoot - Exactly one cell which is a possible root under mouse.
         * swimlane - Exactly one cell which is a swimlane under mouse.
         *
         * Example:
         *
         * To add a new item for a given action to the popupmenu:
         *
         * (code)
         * <mxDefaultPopupMenu as="popupHandler">
         *   <add as="delete" action="delete" icon="images/delete.gif" if="cell"/>
         * </mxDefaultPopupMenu>
         * (end)
         *
         * To add a new item for a custom function:
         *
         * (code)
         * <mxDefaultPopupMenu as="popupHandler">
         *   <add as="action1"><![CDATA[
         *		function (editor, cell, evt)
        *		{
        *			editor.execute('action1', cell, 'myArg');
        *		}
        *   ]]></add>
        * </mxDefaultPopupMenu>
        * (end)
        *
        * The above example invokes action1 with an additional third argument via
        * the editor instance. The third argument is passed to the function that
        * defines action1. If the add-node has no action-attribute, then only the
        * function defined in the text content is executed, otherwise first the
        * function and then the action defined in the action-attribute is
        * executed. The function in the text content has 3 arguments, namely the
        * <mxEditor> instance, the <mxCell> instance under the mouse, and the
        * native mouse event.
        *
        * Custom Conditions:
        *
        * To add a new condition for popupmenu items:
        *
        * (code)
        * <condition name="condition1"><![CDATA[
        *   function (editor, cell, evt)
        *   {
        *     return cell != null;
        *   }
        * ]]></condition>
        * (end)
        *
        * The new condition can then be used in any item as follows:
        *
        * (code)
        * <add as="action1" action="action1" icon="action1.gif" if="condition1"/>
        * (end)
        *
        * The order in which the items and conditions appear is not significant as
        * all connditions are evaluated before any items are created.
        *
        * Parameters:
        *
        * editor - Enclosing <mxEditor> instance.
        * menu - <mxPopupMenu> that is used for adding items and separators.
        * cell - Optional <mxCell> which is under the mousepointer.
        * evt - Optional mouse event which triggered the menu.
        */
        createMenu(editor: any, menu: any, cell: any, evt: any): void;
        /**
         * Recursively adds the given items and all of its children into the given menu.
         *
         * Parameters:
         *
         * editor - Enclosing <mxEditor> instance.
         * menu - <mxPopupMenu> that is used for adding items and separators.
         * cell - Optional <mxCell> which is under the mousepointer.
         * evt - Optional mouse event which triggered the menu.
         * conditions - Array of names boolean conditions.
         * item - XML node that represents the current menu item.
         * parent - DOM node that represents the parent menu item.
         */
        addItems(editor: any, menu: any, cell: any, evt: any, conditions: any, item: any, parent: any): void;
        /**
         * Helper method to bind an action to a new menu item.
         *
         * Parameters:
         *
         * menu - <mxPopupMenu> that is used for adding items and separators.
         * editor - Enclosing <mxEditor> instance.
         * lab - String that represents the label of the menu item.
         * icon - Optional URL that represents the icon of the menu item.
         * action - Optional name of the action to execute in the given editor.
         * funct - Optional function to execute before the optional action. The
         * function takes an <mxEditor>, the <mxCell> under the mouse and the
         * mouse event that triggered the call.
         * cell - Optional <mxCell> to use as an argument for the action.
         * parent - DOM node that represents the parent menu item.
         * iconCls - Optional CSS class for the menu icon.
         * enabled - Optional boolean that specifies if the menu item is enabled.
         * Default is true.
         */
        addAction(menu: any, editor: any, lab: any, icon: any, funct: any, action: any, cell: any, parent: any, iconCls: any, enabled: any): any;
        /**
         * Evaluates the default conditions for the given context.
         */
        createConditions(editor: any, cell: any, evt: any): any[];
    }
    /**
     * Toolbar for the editor. This modifies the state of the graph
     * or inserts new cells upon mouse clicks.
     *
     * Example:
     *
     * Create a toolbar with a button to copy the selection into the clipboard,
     * and a combo box with one action to paste the selection from the clipboard
     * into the graph.
     *
     * (code)
     * var toolbar = new mxDefaultToolbar(container, editor);
     * toolbar.addItem('Copy', null, 'copy');
     *
     * var combo = toolbar.addActionCombo('More actions...');
     * toolbar.addActionOption(combo, 'Paste', 'paste');
     * (end)
     *
     * Codec:
     *
     * This class uses the <mxDefaultToolbarCodec> to read configuration
     * data into an existing instance. See <mxDefaultToolbarCodec> for a
     * description of the configuration format.
     *
     * Constructor: mxDefaultToolbar
     *
     * Constructs a new toolbar for the given container and editor. The
     * container and editor may be null if a prototypical instance for a
     * <mxDefaultKeyHandlerCodec> is created.
     *
     * Parameters:
     *
     * container - DOM node that contains the toolbar.
     * editor - Reference to the enclosing <mxEditor>.
     */
    class mxDefaultToolbar {
        constructor(container: any, editor: any);
        /**
         * Constructs the <toolbar> for the given container and installs a listener
         * that updates the <mxEditor.insertFunction> on <editor> if an item is
         * selected in the toolbar. This assumes that <editor> is not null.
         *
         * Parameters:
         *
         * container - DOM node that contains the toolbar.
         */
        init(container: any): void;
        /**
         * Adds a new item that executes the given action in <editor>. The title,
         * icon and pressedIcon are used to display the toolbar item.
         *
         * Parameters:
         *
         * title - String that represents the title (tooltip) for the item.
         * icon - URL of the icon to be used for displaying the item.
         * action - Name of the action to execute when the item is clicked.
         * pressed - Optional URL of the icon for the pressed state.
         */
        addItem(title: any, icon: any, action: any, pressed: any): any;
        /**
         * Adds a vertical separator using the optional icon.
         *
         * Parameters:
         *
         * icon - Optional URL of the icon that represents the vertical separator.
         * Default is <mxClient.imageBasePath> + '/separator.gif'.
         */
        addSeparator(icon: any): void;
        /**
         * Helper method to invoke <mxToolbar.addCombo> on <toolbar> and return the
         * resulting DOM node.
         */
        addCombo(): any;
        /**
         * Helper method to invoke <mxToolbar.addActionCombo> on <toolbar> using
         * the given title and return the resulting DOM node.
         *
         * Parameters:
         *
         * title - String that represents the title of the combo.
         */
        addActionCombo(title: any): any;
        /**
         * Binds the given action to a option with the specified label in the
         * given combo. Combo is an object returned from an earlier call to
         * <addCombo> or <addActionCombo>.
         *
         * Parameters:
         *
         * combo - DOM node that represents the combo box.
         * title - String that represents the title of the combo.
         * action - Name of the action to execute in <editor>.
         */
        addActionOption(combo: any, title: any, action: any): void;
        /**
         * Helper method to invoke <mxToolbar.addOption> on <toolbar> and return
         * the resulting DOM node that represents the option.
         *
         * Parameters:
         *
         * combo - DOM node that represents the combo box.
         * title - String that represents the title of the combo.
         * value - Object that represents the value of the option.
         */
        addOption(combo: any, title: any, value: any): any;
        /**
         * Creates an item for selecting the given mode in the <editor>'s graph.
         * Supported modenames are select, connect and pan.
         *
         * Parameters:
         *
         * title - String that represents the title of the item.
         * icon - URL of the icon that represents the item.
         * mode - String that represents the mode name to be used in
         * <mxEditor.setMode>.
         * pressed - Optional URL of the icon that represents the pressed state.
         * funct - Optional JavaScript function that takes the <mxEditor> as the
         * first and only argument that is executed after the mode has been
         * selected.
         */
        addMode(title: any, icon: any, mode: any, pressed: any, funct: any): any;
        /**
         * Creates an item for inserting a clone of the specified prototype cell into
         * the <editor>'s graph. The ptype may either be a cell or a function that
         * returns a cell.
         *
         * Parameters:
         *
         * title - String that represents the title of the item.
         * icon - URL of the icon that represents the item.
         * ptype - Function or object that represents the prototype cell. If ptype
         * is a function then it is invoked with no arguments to create new
         * instances.
         * pressed - Optional URL of the icon that represents the pressed state.
         * insert - Optional JavaScript function that handles an insert of the new
         * cell. This function takes the <mxEditor>, new cell to be inserted, mouse
         * event and optional <mxCell> under the mouse pointer as arguments.
         * toggle - Optional boolean that specifies if the item can be toggled.
         * Default is true.
         */
        addPrototype(title: any, icon: any, ptype: any, pressed: any, insert: any, toggle: any): any;
        /**
         * Handles a drop from a toolbar item to the graph. The given vertex
         * represents the new cell to be inserted. This invokes <insert> or
         * <connect> depending on the given target cell.
         *
         * Parameters:
         *
         * vertex - <mxCell> to be inserted.
         * evt - Mouse event that represents the drop.
         * target - Optional <mxCell> that represents the drop target.
         */
        drop(vertex: any, evt: any, target: any): void;
        /**
         * Handles a drop by inserting the given vertex into the given parent cell
         * or the default parent if no parent is specified.
         *
         * Parameters:
         *
         * vertex - <mxCell> to be inserted.
         * evt - Mouse event that represents the drop.
         * parent - Optional <mxCell> that represents the parent.
         */
        insert(vertex: any, evt: any, target: any): any;
        /**
         * Handles a drop by connecting the given vertex to the given source cell.
         *
         * vertex - <mxCell> to be inserted.
         * evt - Mouse event that represents the drop.
         * source - Optional <mxCell> that represents the source terminal.
         */
        connect(vertex: any, evt: any, source: any): void;
        /**
         * Makes the given img draggable using the given function for handling a
         * drop event.
         *
         * Parameters:
         *
         * img - DOM node that represents the image.
         * dropHandler - Function that handles a drop of the image.
         */
        installDropHandler(img: any, dropHandler: any): void;
        /**
         * Destroys the <toolbar> associated with this object and removes all
         * installed listeners. This does normally not need to be called, the
         * <toolbar> is destroyed automatically when the window unloads (in IE) by
         * <mxEditor>.
         */
        destroy(): void;
    }
    /**
     * Extends <mxEventSource> to implement a application wrapper for a graph that
     * adds <actions>, I/O using <mxCodec>, auto-layout using <mxLayoutManager>,
     * command history using <undoManager>, and standard dialogs and widgets, eg.
     * properties, help, outline, toolbar, and popupmenu. It also adds <templates>
     * to be used as cells in toolbars, auto-validation using the <validation>
     * flag, attribute cycling using <cycleAttributeValues>, higher-level events
     * such as <root>, and backend integration using <urlPost> and <urlImage>.
     *
     * Actions:
     *
     * Actions are functions stored in the <actions> array under their names. The
     * functions take the <mxEditor> as the first, and an optional <mxCell> as the
     * second argument and are invoked using <execute>. Any additional arguments
     * passed to execute are passed on to the action as-is.
     *
     * A list of built-in actions is available in the <addActions> description.
     *
     * Read/write Diagrams:
     *
     * To read a diagram from an XML string, for example from a textfield within the
     * page, the following code is used:
     *
     * (code)
     * var doc = mxUtils.parseXML(xmlString);
     * var node = doc.documentElement;
     * editor.readGraphModel(node);
     * (end)
     *
     * For reading a diagram from a remote location, use the <open> method.
     *
     * To save diagrams in XML on a server, you can set the <urlPost> variable.
     * This variable will be used in <getUrlPost> to construct a URL for the post
     * request that is issued in the <save> method. The post request contains the
     * XML representation of the diagram as returned by <writeGraphModel> in the
     * xml parameter.
     *
     * On the server side, the post request is processed using standard
     * technologies such as Java Servlets, CGI, .NET or ASP.
     *
     * Here are some examples of processing a post request in various languages.
     *
     * - Java: URLDecoder.decode(request.getParameter("xml"), "UTF-8").replace("\n", "&#xa;")
     *
     * Note that the linefeeds should only be replaced if the XML is
     * processed in Java, for example when creating an image, but not
     * if the XML is passed back to the client-side.
     *
     * - .NET: HttpUtility.UrlDecode(context.Request.Params["xml"])
     * - PHP: urldecode($_POST["xml"])
     *
     * Creating images:
     *
     * A backend (Java, PHP or C#) is required for creating images. The
     * distribution contains an example for each backend (ImageHandler.java,
     * ImageHandler.cs and graph.php). More information about using a backend
     * to create images can be found in the readme.html files. Note that the
     * preview is implemented using VML/SVG in the browser and does not require
     * a backend. The backend is only required to creates images (bitmaps).
     *
     * Special characters:
     *
     * Note There are five characters that should always appear in XML content as
     * escapes, so that they do not interact with the syntax of the markup. These
     * are part of the language for all documents based on XML and for HTML.
     *
     * - &lt; (<)
     * - &gt; (>)
     * - &amp; (&)
     * - &quot; (")
     * - &apos; (')
     *
     * Although it is part of the XML language, &apos; is not defined in HTML.
     * For this reason the XHTML specification recommends instead the use of
     * &#39; if text may be passed to a HTML user agent.
     *
     * If you are having problems with special characters on the server-side then
     * you may want to try the <escapePostData> flag.
     *
     * For converting decimal escape sequences inside strings, a user has provided
     * us with the following function:
     *
     * (code)
     * function html2js(text)
     * {
     *   var entitySearch = /&#[0-9]+;/;
     *   var entity;
     *
     *   while (entity = entitySearch.exec(text))
     *   {
     *     var charCode = entity[0].substring(2, entity[0].length -1);
     *     text = text.substring(0, entity.index)
     *            + String.fromCharCode(charCode)
     *            + text.substring(entity.index + entity[0].length);
     *   }
     *
     *   return text;
     * }
     * (end)
     *
     * Otherwise try using hex escape sequences and the built-in unescape function
     * for converting such strings.
     *
     * Local Files:
     *
     * For saving and opening local files, no standardized method exists that
     * works across all browsers. The recommended way of dealing with local files
     * is to create a backend that streams the XML data back to the browser (echo)
     * as an attachment so that a Save-dialog is displayed on the client-side and
     * the file can be saved to the local disk.
     *
     * For example, in PHP the code that does this looks as follows.
     *
     * (code)
     * $xml = stripslashes($_POST["xml"]);
     * header("Content-Disposition: attachment; filename=\"diagram.xml\"");
     * echo($xml);
     * (end)
     *
     * To open a local file, the file should be uploaded via a form in the browser
     * and then opened from the server in the editor.
     *
     * Cell Properties:
     *
     * The properties displayed in the properties dialog are the attributes and
     * values of the cell's user object, which is an XML node. The XML node is
     * defined in the templates section of the config file.
     *
     * The templates are stored in <mxEditor.templates> and contain cells which
     * are cloned at insertion time to create new vertices by use of drag and
     * drop from the toolbar. Each entry in the toolbar for adding a new vertex
     * must refer to an existing template.
     *
     * In the following example, the task node is a business object and only the
     * mxCell node and its mxGeometry child contain graph information:
     *
     * (code)
     * <Task label="Task" description="">
     *   <mxCell vertex="true">
     *     <mxGeometry as="geometry" width="72" height="32"/>
     *   </mxCell>
     * </Task>
     * (end)
     *
     * The idea is that the XML representation is inverse from the in-memory
     * representation: The outer XML node is the user object and the inner node is
     * the cell. This means the user object of the cell is the Task node with no
     * children for the above example:
     *
     * (code)
     * <Task label="Task" description=""/>
     * (end)
     *
     * The Task node can have any tag name, attributes and child nodes. The
     * <mxCodec> will use the XML hierarchy as the user object, while removing the
     * "known annotations", such as the mxCell node. At save-time the cell data
     * will be "merged" back into the user object. The user object is only modified
     * via the properties dialog during the lifecycle of the cell.
     *
     * In the default implementation of <createProperties>, the user object's
     * attributes are put into a form for editing. Attributes are changed using
     * the <mxCellAttributeChange> action in the model. The dialog can be replaced
     * by overriding the <createProperties> hook or by replacing the showProperties
     * action in <actions>. Alternatively, the entry in the config file's popupmenu
     * section can be modified to invoke a different action.
     *
     * If you want to displey the properties dialog on a doubleclick, you can set
     * <mxEditor.dblClickAction> to showProperties as follows:
     *
     * (code)
     * editor.dblClickAction = 'showProperties';
     * (end)
     *
     * Popupmenu and Toolbar:
     *
     * The toolbar and popupmenu are typically configured using the respective
     * sections in the config file, that is, the popupmenu is defined as follows:
     *
     * (code)
     * <mxEditor>
     *   <mxDefaultPopupMenu as="popupHandler">
     * 		<add as="cut" action="cut" icon="images/cut.gif"/>
     *      ...
     * (end)
     *
     * New entries can be added to the toolbar by inserting an add-node into the
     * above configuration. Existing entries may be removed and changed by
     * modifying or removing the respective entries in the configuration.
     * The configuration is read by the <mxDefaultPopupMenuCodec>, the format of the
     * configuration is explained in <mxDefaultPopupMenu.decode>.
     *
     * The toolbar is defined in the mxDefaultToolbar section. Items can be added
     * and removed in this section.
     *
     * (code)
     * <mxEditor>
     *   <mxDefaultToolbar>
     *     <add as="save" action="save" icon="images/save.gif"/>
     *     <add as="Swimlane" template="swimlane" icon="images/swimlane.gif"/>
     *     ...
     * (end)
     *
     * The format of the configuration is described in
     * <mxDefaultToolbarCodec.decode>.
     *
     * Ids:
     *
     * For the IDs, there is an implicit behaviour in <mxCodec>: It moves the Id
     * from the cell to the user object at encoding time and vice versa at decoding
     * time. For example, if the Task node from above has an id attribute, then
     * the <mxCell.id> of the corresponding cell will have this value. If there
     * is no Id collision in the model, then the cell may be retrieved using this
     * Id with the <mxGraphModel.getCell> function. If there is a collision, a new
     * Id will be created for the cell using <mxGraphModel.createId>. At encoding
     * time, this new Id will replace the value previously stored under the id
     * attribute in the Task node.
     *
     * See <mxEditorCodec>, <mxDefaultToolbarCodec> and <mxDefaultPopupMenuCodec>
     * for information about configuring the editor and user interface.
     *
     * Programmatically inserting cells:
     *
     * For inserting a new cell, say, by clicking a button in the document,
     * the following code can be used. This requires an reference to the editor.
     *
     * (code)
     * var userObject = new Object();
     * var parent = editor.graph.getDefaultParent();
     * var model = editor.graph.model;
     * model.beginUpdate();
     * try
     * {
     *   editor.graph.insertVertex(parent, null, userObject, 20, 20, 80, 30);
     * }
     * finally
     * {
     *   model.endUpdate();
     * }
     * (end)
     *
     * If a template cell from the config file should be inserted, then a clone
     * of the template can be created as follows. The clone is then inserted using
     * the add function instead of addVertex.
     *
     * (code)
     * var template = editor.templates['task'];
     * var clone = editor.graph.model.cloneCell(template);
     * (end)
     *
     * Resources:
     *
     * resources/editor - Language resources for mxEditor
     *
     * Callback: onInit
     *
     * Called from within the constructor. In the callback,
     * "this" refers to the editor instance.
     *
     * Cookie: mxgraph=seen
     *
     * Set when the editor is started. Never expires. Use
     * <resetFirstTime> to reset this cookie. This cookie
     * only exists if <onInit> is implemented.
     *
     * Event: mxEvent.OPEN
     *
     * Fires after a file was opened in <open>. The <code>filename</code> property
     * contains the filename that was used. The same value is also available in
     * <filename>.
     *
     * Event: mxEvent.SAVE
     *
     * Fires after the current file was saved in <save>. The <code>url</code>
     * property contains the URL that was used for saving.
     *
     * Event: mxEvent.POST
     *
     * Fires if a successful response was received in <postDiagram>. The
     * <code>request</code> property contains the <mxXmlRequest>, the
     * <code>url</code> and <code>data</code> properties contain the URL and the
     * data that were used in the post request.
     *
     * Event: mxEvent.ROOT
     *
     * Fires when the current root has changed, or when the title of the current
     * root has changed. This event has no properties.
     *
     * Event: mxEvent.BEFORE_ADD_VERTEX
     *
     * Fires before a vertex is added in <addVertex>. The <code>vertex</code>
     * property contains the new vertex and the <code>parent</code> property
     * contains its parent.
     *
     * Event: mxEvent.ADD_VERTEX
     *
     * Fires between begin- and endUpdate in <addVertex>. The <code>vertex</code>
     * property contains the vertex that is being inserted.
     *
     * Event: mxEvent.AFTER_ADD_VERTEX
     *
     * Fires after a vertex was inserted and selected in <addVertex>. The
     * <code>vertex</code> property contains the new vertex.
     *
     * Example:
     *
     * For starting an in-place edit after a new vertex has been added to the
     * graph, the following code can be used.
     *
     * (code)
     * editor.addListener(mxEvent.AFTER_ADD_VERTEX, function(sender, evt)
     * {
     *   var vertex = evt.getProperty('vertex');
     *
     *   if (editor.graph.isCellEditable(vertex))
     *   {
     *   	editor.graph.startEditingAtCell(vertex);
     *   }
     * });
     * (end)
     *
     * Event: mxEvent.ESCAPE
     *
     * Fires when the escape key is pressed. The <code>event</code> property
     * contains the key event.
     *
     * Constructor: mxEditor
     *
     * Constructs a new editor. This function invokes the <onInit> callback
     * upon completion.
     *
     * Example:
     *
     * (code)
     * var config = mxUtils.load('config/diagrameditor.xml').getDocumentElement();
     * var editor = new mxEditor(config);
     * (end)
     *
     * Parameters:
     *
     * config - Optional XML node that contains the configuration.
     */
    class mxEditor extends mxEventSource {
        constructor(config: any);
        /**
         * Returns <modified>.
         */
        isModified(): any;
        /**
         * Sets <modified> to the specified boolean value.
         */
        setModified(value: any): void;
        /**
         * Adds the built-in actions to the editor instance.
         *
         * save - Saves the graph using <urlPost>.
         * print - Shows the graph in a new print preview window.
         * show - Shows the graph in a new window.
         * exportImage - Shows the graph as a bitmap image using <getUrlImage>.
         * refresh - Refreshes the graph's display.
         * cut - Copies the current selection into the clipboard
         * and removes it from the graph.
         * copy - Copies the current selection into the clipboard.
         * paste - Pastes the clipboard into the graph.
         * delete - Removes the current selection from the graph.
         * group - Puts the current selection into a new group.
         * ungroup - Removes the selected groups and selects the children.
         * undo - Undoes the last change on the graph model.
         * redo - Redoes the last change on the graph model.
         * zoom - Sets the zoom via a dialog.
         * zoomIn - Zooms into the graph.
         * zoomOut - Zooms out of the graph
         * actualSize - Resets the scale and translation on the graph.
         * fit - Changes the scale so that the graph fits into the window.
         * showProperties - Shows the properties dialog.
         * selectAll - Selects all cells.
         * selectNone - Clears the selection.
         * selectVertices - Selects all vertices.
         * selectEdges = Selects all edges.
         * edit - Starts editing the current selection cell.
         * enterGroup - Drills down into the current selection cell.
         * exitGroup - Moves up in the drilling hierachy
         * home - Moves to the topmost parent in the drilling hierarchy
         * selectPrevious - Selects the previous cell.
         * selectNext - Selects the next cell.
         * selectParent - Selects the parent of the selection cell.
         * selectChild - Selects the first child of the selection cell.
         * collapse - Collapses the currently selected cells.
         * expand - Expands the currently selected cells.
         * bold - Toggle bold text style.
         * italic - Toggle italic text style.
         * underline - Toggle underline text style.
         * alignCellsLeft - Aligns the selection cells at the left.
         * alignCellsCenter - Aligns the selection cells in the center.
         * alignCellsRight - Aligns the selection cells at the right.
         * alignCellsTop - Aligns the selection cells at the top.
         * alignCellsMiddle - Aligns the selection cells in the middle.
         * alignCellsBottom - Aligns the selection cells at the bottom.
         * alignFontLeft - Sets the horizontal text alignment to left.
         * alignFontCenter - Sets the horizontal text alignment to center.
         * alignFontRight - Sets the horizontal text alignment to right.
         * alignFontTop - Sets the vertical text alignment to top.
         * alignFontMiddle - Sets the vertical text alignment to middle.
         * alignFontBottom - Sets the vertical text alignment to bottom.
         * toggleTasks - Shows or hides the tasks window.
         * toggleHelp - Shows or hides the help window.
         * toggleOutline - Shows or hides the outline window.
         * toggleConsole - Shows or hides the console window.
         */
        addActions(): void;
        /**
         * Configures the editor using the specified node. To load the
         * configuration from a given URL the following code can be used to obtain
         * the XML node.
         *
         * (code)
         * var node = mxUtils.load(url).getDocumentElement();
         * (end)
         *
         * Parameters:
         *
         * node - XML node that contains the configuration.
         */
        configure(node: any): void;
        /**
         * Resets the cookie that is used to remember if the editor has already
         * been used.
         */
        resetFirstTime(): void;
        /**
         * Resets the command history, modified state and counters.
         */
        resetHistory(): void;
        /**
         * Binds the specified actionname to the specified function.
         *
         * Parameters:
         *
         * actionname - String that specifies the name of the action
         * to be added.
         * funct - Function that implements the new action. The first
         * argument of the function is the editor it is used
         * with, the second argument is the cell it operates
         * upon.
         *
         * Example:
         * (code)
         * editor.addAction('test', function(editor, cell)
         * {
         * 		mxUtils.alert("test "+cell);
         * });
         * (end)
         */
        addAction(actionname: any, funct: any): void;
        /**
         * Executes the function with the given name in <actions> passing the
         * editor instance and given cell as the first and second argument. All
         * additional arguments are passed to the action as well. This method
         * contains a try-catch block and displays an error message if an action
         * causes an exception. The exception is re-thrown after the error
         * message was displayed.
         *
         * Example:
         *
         * (code)
         * editor.execute("showProperties", cell);
         * (end)
         */
        execute(actionname: any, cell: any, evt: any): void;
        /**
         * Adds the specified template under the given name in <templates>.
         */
        addTemplate(name: any, template: any): void;
        /**
         * Returns the template for the given name.
         */
        getTemplate(name: any): any;
        /**
         * Creates the <graph> for the editor. The graph is created with no
         * container and is initialized from <setGraphContainer>.
         */
        createGraph(): any;
        /**
         * Sets the graph's container using <mxGraph.init>.
         */
        createSwimlaneManager(graph: any): any;
        /**
         * Creates a layout manager for the swimlane and diagram layouts, that
         * is, the locally defined inter- and intraswimlane layouts.
         */
        createLayoutManager(graph: any): mxLayoutManager;
        /**
         * Sets the graph's container using <mxGraph.init>.
         */
        setGraphContainer(container: any): void;
        /**
         * Overrides <mxGraph.dblClick> to invoke <dblClickAction>
         * on a cell and reset the selection tool in the toolbar.
         */
        installDblClickHandler(graph: any): void;
        /**
         * Adds the <undoManager> to the graph model and the view.
         */
        installUndoHandler(graph: any): void;
        /**
         * Installs listeners for dispatching the <root> event.
         */
        installDrillHandler(graph: any): void;
        /**
         * Installs the listeners required to automatically validate
         * the graph. On each change of the root, this implementation
         * fires a <root> event.
         */
        installChangeHandler(graph: any): void;
        /**
         * Installs the handler for invoking <insertFunction> if
         * one is defined.
         */
        installInsertHandler(graph: any): void;
        /**
         * Creates the layout instance used to layout the
         * swimlanes in the diagram.
         */
        createDiagramLayout(): any;
        /**
         * Creates the layout instance used to layout the
         * children of each swimlane.
         */
        createSwimlaneLayout(): any;
        /**
         * Creates the <toolbar> with no container.
         */
        createToolbar(): mxDefaultToolbar;
        /**
         * Initializes the toolbar for the given container.
         */
        setToolbarContainer(container: any): void;
        /**
         * Creates the <status> using the specified container.
         *
         * This implementation adds listeners in the editor to
         * display the last saved time and the current filename
         * in the status bar.
         *
         * Parameters:
         *
         * container - DOM node that will contain the statusbar.
         */
        setStatusContainer(container: any): void;
        /**
         * Display the specified message in the status bar.
         *
         * Parameters:
         *
         * message - String the specified the message to
         * be displayed.
         */
        setStatus(message: any): void;
        /**
         * Creates a listener to update the inner HTML of the
         * specified DOM node with the value of <getTitle>.
         *
         * Parameters:
         *
         * container - DOM node that will contain the title.
         */
        setTitleContainer(container: any): void;
        /**
         * Executes a vertical or horizontal compact tree layout
         * using the specified cell as an argument. The cell may
         * either be a group or the root of a tree.
         *
         * Parameters:
         *
         * cell - <mxCell> to use in the compact tree layout.
         * horizontal - Optional boolean to specify the tree's
         * orientation. Default is true.
         */
        treeLayout(cell: any, horizontal: any): void;
        /**
         * Returns the string value for the current root of the
         * diagram.
         */
        getTitle(): string;
        /**
         * Returns the string value of the root cell in
         * <mxGraph.model>.
         */
        getRootTitle(): any;
        /**
         * Undo the last change in <graph>.
         */
        undo(): void;
        /**
         * Redo the last change in <graph>.
         */
        redo(): void;
        /**
         * Invokes <createGroup> to create a new group cell and the invokes
         * <mxGraph.groupCells>, using the grid size of the graph as the spacing
         * in the group's content area.
         */
        groupCells(): any;
        /**
         * Creates and returns a clone of <defaultGroup> to be used
         * as a new group cell in <group>.
         */
        createGroup(): any;
        /**
         * Opens the specified file synchronously and parses it using
         * <readGraphModel>. It updates <filename> and fires an <open>-event after
         * the file has been opened. Exceptions should be handled as follows:
         *
         * (code)
         * try
         * {
         *   editor.open(filename);
         * }
         * catch (e)
         * {
         *   mxUtils.error('Cannot open ' + filename +
         *     ': ' + e.message, 280, true);
         * }
         * (end)
         *
         * Parameters:
         *
         * filename - URL of the file to be opened.
         */
        open(filename: any): void;
        /**
         * Reads the specified XML node into the existing graph model and resets
         * the command history and modified state.
         */
        readGraphModel(node: any): void;
        /**
         * Posts the string returned by <writeGraphModel> to the given URL or the
         * URL returned by <getUrlPost>. The actual posting is carried out by
         * <postDiagram>. If the URL is null then the resulting XML will be
         * displayed using <mxUtils.popup>. Exceptions should be handled as
         * follows:
         *
         * (code)
         * try
         * {
         *   editor.save();
         * }
         * catch (e)
         * {
         *   mxUtils.error('Cannot save : ' + e.message, 280, true);
         * }
         * (end)
         */
        save(url: any, linefeed: any): void;
        /**
         * Hook for subclassers to override the posting of a diagram
         * represented by the given node to the given URL. This fires
         * an asynchronous <post> event if the diagram has been posted.
         *
         * Example:
         *
         * To replace the diagram with the diagram in the response, use the
         * following code.
         *
         * (code)
         * editor.addListener(mxEvent.POST, function(sender, evt)
         * {
         *   // Process response (replace diagram)
         *   var req = evt.getProperty('request');
         *   var root = req.getDocumentElement();
         *   editor.graph.readGraphModel(root)
         * });
         * (end)
         */
        postDiagram(url: any, data: any): void;
        /**
         * Hook to create the string representation of the diagram. The default
         * implementation uses an <mxCodec> to encode the graph model as
         * follows:
         *
         * (code)
         * var enc = new mxCodec();
         * var node = enc.encode(this.graph.getModel());
         * return mxUtils.getXml(node, this.linefeed);
         * (end)
         *
         * Parameters:
         *
         * linefeed - Optional character to be used as the linefeed. Default is
         * <linefeed>.
         */
        writeGraphModel(linefeed: any): any;
        /**
         * Returns the URL to post the diagram to. This is used
         * in <save>. The default implementation returns <urlPost>,
         * adding <code>?draft=true</code>.
         */
        getUrlPost(): any;
        /**
         * Returns the URL to create the image with. This is typically
         * the URL of a backend which accepts an XML representation
         * of a graph view to create an image. The function is used
         * in the image action to create an image. This implementation
         * returns <urlImage>.
         */
        getUrlImage(): any;
        /**
         * Swaps the styles for the given names in the graph's
         * stylesheet and refreshes the graph.
         */
        swapStyles(first: any, second: any): void;
        /**
         * Creates and shows the properties dialog for the given
         * cell. The content area of the dialog is created using
         * <createProperties>.
         */
        showProperties(cell: any): void;
        /**
         * Returns true if the properties dialog is currently visible.
         */
        isPropertiesVisible(): boolean;
        /**
         * Creates and returns the DOM node that represents the contents
         * of the properties dialog for the given cell. This implementation
         * works for user objects that are XML nodes and display all the
         * node attributes in a form.
         */
        createProperties(cell: any): any;
        /**
         * Hides the properties dialog.
         */
        hideProperties(): void;
        /**
         * Shows the tasks window. The tasks window is created using <createTasks>. The
         * default width of the window is 200 pixels, the y-coordinate of the location
         * can be specifies in <tasksTop> and the x-coordinate is right aligned with a
         * 20 pixel offset from the right border. To change the location of the tasks
         * window, the following code can be used:
         *
         * (code)
         * var oldShowTasks = mxEditor.prototype.showTasks;
         * mxEditor.prototype.showTasks = function()
         * {
         *   oldShowTasks.apply(this, arguments); // "supercall"
         *
         *   if (this.tasks != null)
         *   {
         *     this.tasks.setLocation(10, 10);
         *   }
         * };
         * (end)
         */
        showTasks(): void;
        /**
         * Updates the contents of the tasks window using <createTasks>.
         */
        refreshTasks(div: any): void;
        /**
         * Updates the contents of the given DOM node to
         * display the tasks associated with the current
         * editor state. This is invoked whenever there
         * is a possible change of state in the editor.
         * Default implementation is empty.
         */
        createTasks(div: any): void;
        /**
         * Shows the help window. If the help window does not exist
         * then it is created using an iframe pointing to the resource
         * for the <code>urlHelp</code> key or <urlHelp> if the resource
         * is undefined.
         */
        showHelp(tasks: any): void;
        /**
         * Shows the outline window. If the window does not exist, then it is
         * created using an <mxOutline>.
         */
        showOutline(): void;
        /**
         * Puts the graph into the specified mode. The following modenames are
         * supported:
         *
         * select - Selects using the left mouse button, new connections
         * are disabled.
         * connect - Selects using the left mouse button or creates new
         * connections if mouse over cell hotspot. See <mxConnectionHandler>.
         * pan - Pans using the left mouse button, new connections are disabled.
         */
        setMode(modename: any): void;
        /**
         * Uses <popupHandler> to create the menu in the graph's
         * panning handler. The redirection is setup in
         * <setToolbarContainer>.
         */
        createPopupMenu(menu: any, cell: any, evt: any): void;
        /**
         * Uses <defaultEdge> as the prototype for creating new edges
         * in the connection handler of the graph. The style of the
         * edge will be overridden with the value returned by
         * <getEdgeStyle>.
         */
        createEdge(source: any, target: any): any;
        /**
         * Returns a string identifying the style of new edges.
         * The function is used in <createEdge> when new edges
         * are created in the graph.
         */
        getEdgeStyle(): any;
        /**
         * Returns the next attribute in <cycleAttributeValues>
         * or null, if not attribute should be used in the
         * specified cell.
         */
        consumeCycleAttribute(cell: any): any;
        /**
         * Uses the returned value from <consumeCycleAttribute>
         * as the value for the <cycleAttributeName> key in
         * the given cell's style.
         */
        cycleAttribute(cell: any): void;
        /**
         * Adds the given vertex as a child of parent at the specified
         * x and y coordinate and fires an <addVertex> event.
         */
        addVertex(parent: any, vertex: any, x: any, y: any): any;
        /**
         * Removes the editor and all its associated resources. This does not
         * normally need to be called, it is called automatically when the window
         * unloads.
         */
        destroy(): void;
    }
    var mxCodecRegistry: {
        codecs: any[];
        aliases: any[];
        register(codec: any): any;
        addAlias(classname: any, codecname: any): void;
        getCodec(ctor: any): any;
    };
    /**
     * XML codec for JavaScript object graphs. See <mxObjectCodec> for a
     * description of the general encoding/decoding scheme. This class uses the
     * codecs registered in <mxCodecRegistry> for encoding/decoding each object.
     *
     * References:
     *
     * In order to resolve references, especially forward references, the mxCodec
     * constructor must be given the document that contains the referenced
     * elements.
     *
     * Examples:
     *
     * The following code is used to encode a graph model.
     *
     * (code)
     * var encoder = new mxCodec();
     * var result = encoder.encode(graph.getModel());
     * var xml = mxUtils.getXml(result);
     * (end)
     *
     * Example:
     *
     * Using the code below, an XML document is decoded into an existing model. The
     * document may be obtained using one of the functions in mxUtils for loading
     * an XML file, eg. <mxUtils.get>, or using <mxUtils.parseXml> for parsing an
     * XML string.
     *
     * (code)
     * var doc = mxUtils.parseXml(xmlString);
     * var codec = new mxCodec(doc);
     * codec.decode(doc.documentElement, graph.getModel());
     * (end)
     *
     * Example:
     *
     * This example demonstrates parsing a list of isolated cells into an existing
     * graph model. Note that the cells do not have a parent reference so they can
     * be added anywhere in the cell hierarchy after parsing.
     *
     * (code)
     * var xml = '<root><mxCell id="2" value="Hello," vertex="1"><mxGeometry x="20" y="20" width="80" height="30" as="geometry"/></mxCell><mxCell id="3" value="World!" vertex="1"><mxGeometry x="200" y="150" width="80" height="30" as="geometry"/></mxCell><mxCell id="4" value="" edge="1" source="2" target="3"><mxGeometry relative="1" as="geometry"/></mxCell></root>';
     * var doc = mxUtils.parseXml(xml);
     * var codec = new mxCodec(doc);
     * var elt = doc.documentElement.firstChild;
     * var cells = [];
     *
     * while (elt != null)
     * {
     *   cells.push(codec.decode(elt));
     *   elt = elt.nextSibling;
     * }
     *
     * graph.addCells(cells);
     * (end)
     *
     * Example:
     *
     * Using the following code, the selection cells of a graph are encoded and the
     * output is displayed in a dialog box.
     *
     * (code)
     * var enc = new mxCodec();
     * var cells = graph.getSelectionCells();
     * mxUtils.alert(mxUtils.getPrettyXml(enc.encode(cells)));
     * (end)
     *
     * Newlines in the XML can be converted to <br>, in which case a '<br>' argument
     * must be passed to <mxUtils.getXml> as the second argument.
     *
     * Debugging:
     *
     * For debugging I/O you can use the following code to get the sequence of
     * encoded objects:
     *
     * (code)
     * var oldEncode = mxCodec.prototype.encode;
     * mxCodec.prototype.encode = function(obj)
     * {
     *   mxLog.show();
     *   mxLog.debug('mxCodec.encode: obj='+mxUtils.getFunctionName(obj.constructor));
     *
     *   return oldEncode.apply(this, arguments);
     * };
     * (end)
     *
     * Note that the I/O system adds object codecs for new object automatically. For
     * decoding those objects, the constructor should be written as follows:
     *
     * (code)
     * var MyObj = function(name)
     * {
     *   // ...
     * };
     * (end)
     *
     * Constructor: mxCodec
     *
     * Constructs an XML encoder/decoder for the specified
     * owner document.
     *
     * Parameters:
     *
     * document - Optional XML document that contains the data.
     * If no document is specified then a new document is created
     * using <mxUtils.createXmlDocument>.
     */
    class mxCodec {
        constructor(document?: any);
        /**
         * Assoiates the given object with the given ID and returns the given object.
         *
         * Parameters
         *
         * id - ID for the object to be associated with.
         * obj - Object to be associated with the ID.
         */
        putObject(id: any, obj: any): any;
        /**
         * Returns the decoded object for the element with the specified ID in
         * <document>. If the object is not known then <lookup> is used to find an
         * object. If no object is found, then the element with the respective ID
         * from the document is parsed using <decode>.
         */
        getObject(id: any): any;
        /**
         * Hook for subclassers to implement a custom lookup mechanism for cell IDs.
         * This implementation always returns null.
         *
         * Example:
         *
         * (code)
         * var codec = new mxCodec();
         * codec.lookup = function(id)
         * {
         *   return model.getCell(id);
         * };
         * (end)
         *
         * Parameters:
         *
         * id - ID of the object to be returned.
         */
        lookup(id: any): any;
        /**
         * Returns the element with the given ID from <document>.
         *
         * Parameters:
         *
         * id - String that contains the ID.
         */
        getElementById(id: any): any;
        /**
         * Adds the given element to <elements> if it has an ID.
         */
        addElement(node: any): void;
        /**
         * Returns the ID of the specified object. This implementation
         * calls <reference> first and if that returns null handles
         * the object as an <mxCell> by returning their IDs using
         * <mxCell.getId>. If no ID exists for the given cell, then
         * an on-the-fly ID is generated using <mxCellPath.create>.
         *
         * Parameters:
         *
         * obj - Object to return the ID for.
         */
        getId(obj: any): any;
        /**
         * Hook for subclassers to implement a custom method
         * for retrieving IDs from objects. This implementation
         * always returns null.
         *
         * Example:
         *
         * (code)
         * var codec = new mxCodec();
         * codec.reference = function(obj)
         * {
         *   return obj.getCustomId();
         * };
         * (end)
         *
         * Parameters:
         *
         * obj - Object whose ID should be returned.
         */
        reference(obj: any): any;
        /**
         * Encodes the specified object and returns the resulting
         * XML node.
         *
         * Parameters:
         *
         * obj - Object to be encoded.
         */
        encode(obj: any): any;
        /**
         * Decodes the given XML node. The optional "into"
         * argument specifies an existing object to be
         * used. If no object is given, then a new instance
         * is created using the constructor from the codec.
         *
         * The function returns the passed in object or
         * the new instance if no object was given.
         *
         * Parameters:
         *
         * node - XML node to be decoded.
         * into - Optional object to be decodec into.
         */
        decode(node: any, into?: any): any;
        /**
         * Encoding of cell hierarchies is built-into the core, but
         * is a higher-level function that needs to be explicitely
         * used by the respective object encoders (eg. <mxModelCodec>,
         * <mxChildChangeCodec> and <mxRootChangeCodec>). This
         * implementation writes the given cell and its children as a
         * (flat) sequence into the given node. The children are not
         * encoded if the optional includeChildren is false. The
         * function is in charge of adding the result into the
         * given node and has no return value.
         *
         * Parameters:
         *
         * cell - <mxCell> to be encoded.
         * node - Parent XML node to add the encoded cell into.
         * includeChildren - Optional boolean indicating if the
         * function should include all descendents. Default is true.
         */
        encodeCell(cell: any, node: any, includeChildren: any): void;
        /**
         * Returns true if the given codec is a cell codec. This uses
         * <mxCellCodec.isCellCodec> to check if the codec is of the
         * given type.
         */
        isCellCodec(codec: any): any;
        /**
         * Decodes cells that have been encoded using inversion, ie.
         * where the user object is the enclosing node in the XML,
         * and restores the group and graph structure in the cells.
         * Returns a new <mxCell> instance that represents the
         * given node.
         *
         * Parameters:
         *
         * node - XML node that contains the cell data.
         * restoreStructures - Optional boolean indicating whether
         * the graph structure should be restored by calling insert
         * and insertEdge on the parent and terminals, respectively.
         * Default is true.
         */
        decodeCell(node: any, restoreStructures: any): any;
        /**
         * Inserts the given cell into its parent and terminal cells.
         */
        insertIntoGraph(cell: any): void;
        /**
         * Sets the attribute on the specified node to value. This is a
         * helper method that makes sure the attribute and value arguments
         * are not null.
         *
         * Parameters:
         *
         * node - XML node to set the attribute for.
         * attributes - Attributename to be set.
         * value - New value of the attribute.
         */
        setAttribute(node: any, attribute: any, value: any): void;
        /**
         * Function: updateElements
         *
         * Returns the element with the given ID from <document>.
         *
         * Parameters:
         *
         * id - String that contains the ID.
         */
        updateElements(): void;
    }
    /**
     * Class: mxCellCodec
     *
     * Codec for <mxCell>s. This class is created and registered
     * dynamically at load time and used implicitely via <mxCodec>
     * and the <mxCodecRegistry>.
     *
     * Transient Fields:
     *
     * - children
     * - edges
     * - overlays
     * - mxTransient
     *
     * Reference Fields:
     *
     * - parent
     * - source
     * - target
     *
     * Transient fields can be added using the following code:
     *
     * mxCodecRegistry.getCodec(mxCell).exclude.push('name_of_field');
     *
     * To subclass <mxCell>, replace the template and add an alias as
     * follows.
     *
     * (code)
     * function CustomCell(value, geometry, style)
     * {
     *   mxCell.apply(this, arguments);
     * }
     *
     * mxUtils.extend(CustomCell, mxCell);
     *
     * mxCodecRegistry.getCodec(mxCell).template = new CustomCell();
     * mxCodecRegistry.addAlias('CustomCell', 'mxCell');
     * (end)
     */
    class mxCellCodec extends mxObjectCodec {
        /**
         * Function: isCellCodec
         *
         * Returns true since this is a cell codec.
         */
        isCellCodec(): boolean;
        /**
         * Overidden to disable conversion of value to number.
         */
        isNumericAttribute(dec: any, attr: any, obj: any): boolean;
        /**
         * Function: isExcluded
         *
         * Excludes user objects that are XML nodes.
         */
        isExcluded(obj: any, attr: any, value: any, isWrite: any): boolean;
        /**
         * Function: afterEncode
         *
         * Encodes an <mxCell> and wraps the XML up inside the
         * XML of the user object (inversion).
         */
        afterEncode(enc: any, obj: any, node: any): any;
        /**
         * Function: beforeDecode
         *
         * Decodes an <mxCell> and uses the enclosing XML node as
         * the user object for the cell (inversion).
         */
        beforeDecode(dec: any, node: any, obj: any): any;
    }
    /**
     * Class: mxChildChangeCodec
     *
     * Codec for <mxChildChange>s. This class is created and registered
     * dynamically at load time and used implicitely via <mxCodec> and
     * the <mxCodecRegistry>.
     *
     * Transient Fields:
     *
     * - model
     * - previous
     * - previousIndex
     * - child
     *
     * Reference Fields:
     *
     * - parent
     */
    class mxChildChangeCodec extends mxObjectCodec {
        /**
         * Function: isReference
         *
         * Returns true for the child attribute if the child
         * cell had a previous parent or if we're reading the
         * child as an attribute rather than a child node, in
         * which case it's always a reference.
         */
        isReference(obj: any, attr: any, value: any, isWrite: any): boolean;
        /**
         * Function: isExcluded
         *
         * Excludes references to parent or previous if not in the model.
         */
        isExcluded(obj: any, attr: any, value: any, write: any): boolean;
        /**
         * Function: afterEncode
         *
         * Encodes the child recusively and adds the result
         * to the given node.
         */
        afterEncode(enc: any, obj: any, node: any): any;
        /**
         * Function: beforeDecode
         *
         * Decodes the any child nodes as using the respective
         * codec from the registry.
         */
        beforeDecode(dec: any, node: any, obj: any): any;
        /**
         * Function: afterDecode
         *
         * Restores object state in the child change.
         */
        afterDecode(dec: any, node: any, obj: any): any;
    }
    /**
     * Class: mxDefaultKeyHandlerCodec
     *
     * Custom codec for configuring <mxDefaultKeyHandler>s. This class is created
     * and registered dynamically at load time and used implicitely via
     * <mxCodec> and the <mxCodecRegistry>. This codec only reads configuration
     * data for existing key handlers, it does not encode or create key handlers.
     */
    class mxDefaultKeyHandlerCodec extends mxObjectCodec {
        /**
         * Function: encode
         *
         * Returns null.
         */
        encode(enc: any, obj: any): any;
        /**
         * Function: decode
         *
         * Reads a sequence of the following child nodes
         * and attributes:
         *
         * Child Nodes:
         *
         * add - Binds a keystroke to an actionname.
         *
         * Attributes:
         *
         * as - Keycode.
         * action - Actionname to execute in editor.
         * control - Optional boolean indicating if
         * 		the control key must be pressed.
         *
         * Example:
         *
         * (code)
         * <mxDefaultKeyHandler as="keyHandler">
         *   <add as="88" control="true" action="cut"/>
         *   <add as="67" control="true" action="copy"/>
         *   <add as="86" control="true" action="paste"/>
         * </mxDefaultKeyHandler>
         * (end)
         *
         * The keycodes are for the x, c and v keys.
         *
         * See also: <mxDefaultKeyHandler.bindAction>,
         * http://www.js-examples.com/page/tutorials__key_codes.html
         */
        decode(dec: any, node: any, into: any): any;
    }
    /**
     * Class: mxDefaultPopupMenuCodec
     *
     * Custom codec for configuring <mxDefaultPopupMenu>s. This class is created
     * and registered dynamically at load time and used implicitely via
     * <mxCodec> and the <mxCodecRegistry>. This codec only reads configuration
     * data for existing popup menus, it does not encode or create menus. Note
     * that this codec only passes the configuration node to the popup menu,
     * which uses the config to dynamically create menus. See
     * <mxDefaultPopupMenu.createMenu>.
     */
    class mxDefaultPopupMenuCodec extends mxObjectCodec {
        /**
         * Function: encode
         *
         * Returns null.
         */
        encode(enc: any, obj: any): any;
        /**
         * Function: decode
         *
         * Uses the given node as the config for <mxDefaultPopupMenu>.
         */
        decode(dec: any, node: any, into: any): any;
    }
    /**
     * Class: mxDefaultToolbarCodec
     *
     * Custom codec for configuring <mxDefaultToolbar>s. This class is created
     * and registered dynamically at load time and used implicitely via
     * <mxCodec> and the <mxCodecRegistry>. This codec only reads configuration
     * data for existing toolbars handlers, it does not encode or create toolbars.
     */
    class mxDefaultToolbarCodec extends mxObjectCodec {
        /**
         * Variable: allowEval
         *
         * Static global switch that specifies if the use of eval is allowed for
         * evaluating text content. Default is true. Set this to false if stylesheets
         * may contain user input
         */
        allowEval: boolean;
        /**
         * Function: encode
         *
         * Returns null.
         */
        encode(enc: any, obj: any): any;
        /**
         * Function: decode
         *
         * Reads a sequence of the following child nodes
         * and attributes:
         *
         * Child Nodes:
         *
         * add - Adds a new item to the toolbar. See below for attributes.
         * separator - Adds a vertical separator. No attributes.
         * hr - Adds a horizontal separator. No attributes.
         * br - Adds a linefeed. No attributes.
         *
         * Attributes:
         *
         * as - Resource key for the label.
         * action - Name of the action to execute in enclosing editor.
         * mode - Modename (see below).
         * template - Template name for cell insertion.
         * style - Optional style to override the template style.
         * icon - Icon (relative/absolute URL).
         * pressedIcon - Optional icon for pressed state (relative/absolute URL).
         * id - Optional ID to be used for the created DOM element.
         * toggle - Optional 0 or 1 to disable toggling of the element. Default is
         * 1 (true).
         *
         * The action, mode and template attributes are mutually exclusive. The
         * style can only be used with the template attribute. The add node may
         * contain another sequence of add nodes with as and action attributes
         * to create a combo box in the toolbar. If the icon is specified then
         * a list of the child node is expected to have its template attribute
         * set and the action is ignored instead.
         *
         * Nodes with a specified template may define a function to be used for
         * inserting the cloned template into the graph. Here is an example of such
         * a node:
         *
         * (code)
         * <add as="Swimlane" template="swimlane" icon="images/swimlane.gif"><![CDATA[
         *   function (editor, cell, evt, targetCell)
         *   {
         *     var pt = mxUtils.convertPoint(
         *       editor.graph.container, mxEvent.getClientX(evt),
         *         mxEvent.getClientY(evt));
         *     return editor.addVertex(targetCell, cell, pt.x, pt.y);
         *   }
         * ]]></add>
         * (end)
         *
         * In the above function, editor is the enclosing <mxEditor> instance, cell
         * is the clone of the template, evt is the mouse event that represents the
         * drop and targetCell is the cell under the mousepointer where the drop
         * occurred. The targetCell is retrieved using <mxGraph.getCellAt>.
         *
         * Futhermore, nodes with the mode attribute may define a function to
         * be executed upon selection of the respective toolbar icon. In the
         * example below, the default edge style is set when this specific
         * connect-mode is activated:
         *
         * (code)
         * <add as="connect" mode="connect"><![CDATA[
         *   function (editor)
         *   {
         *     if (editor.defaultEdge != null)
         *     {
         *       editor.defaultEdge.style = 'straightEdge';
         *     }
         *   }
         * ]]></add>
         * (end)
         *
         * Both functions require <mxDefaultToolbarCodec.allowEval> to be set to true.
         *
         * Modes:
         *
         * select - Left mouse button used for rubberband- & cell-selection.
         * connect - Allows connecting vertices by inserting new edges.
         * pan - Disables selection and switches to panning on the left button.
         *
         * Example:
         *
         * To add items to the toolbar:
         *
         * (code)
         * <mxDefaultToolbar as="toolbar">
         *   <add as="save" action="save" icon="images/save.gif"/>
         *   <br/><hr/>
         *   <add as="select" mode="select" icon="images/select.gif"/>
         *   <add as="connect" mode="connect" icon="images/connect.gif"/>
         * </mxDefaultToolbar>
         * (end)
         */
        decode(dec: any, node: any, into: any): any;
    }
    /**
     * Class: mxEditorCodec
     *
     * Codec for <mxEditor>s. This class is created and registered
     * dynamically at load time and used implicitely via <mxCodec>
     * and the <mxCodecRegistry>.
     *
     * Transient Fields:
     *
     * - modified
     * - lastSnapshot
     * - ignoredChanges
     * - undoManager
     * - graphContainer
     * - toolbarContainer
     */
    class mxEditorCodec extends mxObjectCodec {
        /**
         * Function: beforeDecode
         *
         * Decodes the ui-part of the configuration node by reading
         * a sequence of the following child nodes and attributes
         * and passes the control to the default decoding mechanism:
         *
         * Child Nodes:
         *
         * stylesheet - Adds a CSS stylesheet to the document.
         * resource - Adds the basename of a resource bundle.
         * add - Creates or configures a known UI element.
         *
         * These elements may appear in any order given that the
         * graph UI element is added before the toolbar element
         * (see Known Keys).
         *
         * Attributes:
         *
         * as - Key for the UI element (see below).
         * element - ID for the element in the document.
         * style - CSS style to be used for the element or window.
         * x - X coordinate for the new window.
         * y - Y coordinate for the new window.
         * width - Width for the new window.
         * height - Optional height for the new window.
         * name - Name of the stylesheet (absolute/relative URL).
         * basename - Basename of the resource bundle (see <mxResources>).
         *
         * The x, y, width and height attributes are used to create a new
         * <mxWindow> if the element attribute is not specified in an add
         * node. The name and basename are only used in the stylesheet and
         * resource nodes, respectively.
         *
         * Known Keys:
         *
         * graph - Main graph element (see <mxEditor.setGraphContainer>).
         * title - Title element (see <mxEditor.setTitleContainer>).
         * toolbar - Toolbar element (see <mxEditor.setToolbarContainer>).
         * status - Status bar element (see <mxEditor.setStatusContainer>).
         *
         * Example:
         *
         * (code)
         * <ui>
         *   <stylesheet name="css/process.css"/>
         *   <resource basename="resources/app"/>
         *   <add as="graph" element="graph"
         *     style="left:70px;right:20px;top:20px;bottom:40px"/>
         *   <add as="status" element="status"/>
         *   <add as="toolbar" x="10" y="20" width="54"/>
         * </ui>
         * (end)
         */
        afterDecode(dec: any, node: any, obj: any): any;
        /**
         * Function: decodeChild
         *
         * Overrides decode child to handle special child nodes.
         */
        decodeChild(dec: any, child: any, obj: any): any;
        /**
         * Function: decodeTemplates
         *
         * Decodes the cells from the given node as templates.
         */
        decodeUi(dec: any, node: any, editor: any): any;
        /**
         * Function: decodeTemplates
         *
         * Decodes the cells from the given node as templates.
         */
        decodeTemplates(dec: any, node: any, editor: any): any;
    }
    /**
     * Class: mxGenericChangeCodec
     *
     * Codec for <mxValueChange>s, <mxStyleChange>s, <mxGeometryChange>s,
     * <mxCollapseChange>s and <mxVisibleChange>s. This class is created
     * and registered dynamically at load time and used implicitely
     * via <mxCodec> and the <mxCodecRegistry>.
     *
     * Transient Fields:
     *
     * - model
     * - previous
     *
     * Reference Fields:
     *
     * - cell
     *
     * Constructor: mxGenericChangeCodec
     *
     * Factory function that creates a <mxObjectCodec> for
     * the specified change and fieldname.
     *
     * Parameters:
     *
     * obj - An instance of the change object.
     * variable - The fieldname for the change data.
     */
    class mxGenericChangeCodec {
        constructor(obj: any, variable: any);
        /**
         * Function: afterDecode
         *
         * Restores the state by assigning the previous value.
         */
        afterDecode(dec: any, node: any, obj: any): any;
    }
    /**
     * Class: mxGraphCodec
     *
     * Codec for <mxGraph>s. This class is created and registered
     * dynamically at load time and used implicitely via <mxCodec>
     * and the <mxCodecRegistry>.
     *
     * Transient Fields:
     *
     * - graphListeners
     * - eventListeners
     * - view
     * - container
     * - cellRenderer
     * - editor
     * - selection
     */
    class mxGraphCodec extends mxObjectCodec {
    }
    /**
     * Class: mxGraphViewCodec
     *
     * Custom encoder for <mxGraphView>s. This class is created
     * and registered dynamically at load time and used implicitely via
     * <mxCodec> and the <mxCodecRegistry>. This codec only writes views
     * into a XML format that can be used to create an image for
     * the graph, that is, it contains absolute coordinates with
     * computed perimeters, edge styles and cell styles.
     */
    class mxGraphViewCodec extends mxObjectCodec {
        /**
         * Function: encode
         *
         * Encodes the given <mxGraphView> using <encodeCell>
         * starting at the model's root. This returns the
         * top-level graph node of the recursive encoding.
         */
        encode(enc: any, view: any): any;
        /**
         * Function: encodeCell
         *
         * Recursively encodes the specifed cell. Uses layer
         * as the default nodename. If the cell's parent is
         * null, then graph is used for the nodename. If
         * <mxGraphModel.isEdge> returns true for the cell,
         * then edge is used for the nodename, else if
         * <mxGraphModel.isVertex> returns true for the cell,
         * then vertex is used for the nodename.
         *
         * <mxGraph.getLabel> is used to create the label
         * attribute for the cell. For graph nodes and vertices
         * the bounds are encoded into x, y, width and height.
         * For edges the points are encoded into a points
         * attribute as a space-separated list of comma-separated
         * coordinate pairs (eg. x0,y0 x1,y1 ... xn,yn). All
         * values from the cell style are added as attribute
         * values to the node.
         */
        encodeCell(enc: any, view: any, cell: any): any;
    }
    /**
     * Class: mxModelCodec
     *
     * Codec for <mxGraphModel>s. This class is created and registered
     * dynamically at load time and used implicitely via <mxCodec>
     * and the <mxCodecRegistry>.
     */
    class mxModelCodec extends mxObjectCodec {
        /**
         * Function: encodeObject
         *
         * Encodes the given <mxGraphModel> by writing a (flat) XML sequence of
         * cell nodes as produced by the <mxCellCodec>. The sequence is
         * wrapped-up in a node with the name root.
         */
        encodeObject(enc: any, obj: any, node: any): any;
        /**
         * Function: decodeChild
         *
         * Overrides decode child to handle special child nodes.
         */
        decodeChild(dec: any, child: any, obj: any): any;
        /**
         * Function: decodeRoot
         *
         * Reads the cells into the graph model. All cells
         * are children of the root element in the node.
         */
        decodeRoot(dec: any, root: any, model: any): any;
    }
    /**
     * Class: mxRootChangeCodec
     *
     * Codec for <mxRootChange>s. This class is created and registered
     * dynamically at load time and used implicitely via <mxCodec> and
     * the <mxCodecRegistry>.
     *
     * Transient Fields:
     *
     * - model
     * - previous
     * - root
     */
    class mxRootChangeCodec extends mxObjectCodec {
        /**
         * Function: onEncode
         *
         * Encodes the child recursively.
         */
        afterEncode(enc: any, obj: any, node: any): any;
        /**
         * Function: beforeDecode
         *
         * Decodes the optional children as cells
         * using the respective decoder.
         */
        beforeDecode(dec: any, node: any, obj: any): any;
        /**
         * Function: afterDecode
         *
         * Restores the state by assigning the previous value.
         */
        afterDecode(dec: any, node: any, obj: any): any;
    }
    /**
     * Class: mxStylesheetCodec
     *
     * Codec for <mxStylesheet>s. This class is created and registered
     * dynamically at load time and used implicitely via <mxCodec>
     * and the <mxCodecRegistry>.
     */
    class mxStylesheetCodec extends mxObjectCodec {
        /**
         * Variable: allowEval
         *
         * Static global switch that specifies if the use of eval is allowed for
         * evaluating text content. Default is true. Set this to false if stylesheets
         * may contain user input.
         */
        allowEval: boolean;
        /**
         * Function: encode
         *
         * Encodes a stylesheet. See <decode> for a description of the
         * format.
         */
        encode(enc: any, obj: any): any;
        /**
         * Function: getStringValue
         *
         * Returns the string for encoding the given value.
         */
        getStringValue(key: any, value: any): any;
        /**
         * Function: decode
         *
         * Reads a sequence of the following child nodes
         * and attributes:
         *
         * Child Nodes:
         *
         * add - Adds a new style.
         *
         * Attributes:
         *
         * as - Name of the style.
         * extend - Name of the style to inherit from.
         *
         * Each node contains another sequence of add and remove nodes with the following
         * attributes:
         *
         * as - Name of the style (see <mxConstants>).
         * value - Value for the style.
         *
         * Instead of the value-attribute, one can put Javascript expressions into
         * the node as follows if <mxStylesheetCodec.allowEval> is true:
         * <add as="perimeter">mxPerimeter.RectanglePerimeter</add>
         *
         * A remove node will remove the entry with the name given in the as-attribute
         * from the style.
         *
         * Example:
         *
         * (code)
         * <mxStylesheet as="stylesheet">
         *   <add as="text">
         *     <add as="fontSize" value="12"/>
         *   </add>
         *   <add as="defaultVertex" extend="text">
         *     <add as="shape" value="rectangle"/>
         *   </add>
         * </mxStylesheet>
         * (end)
         */
        decode(dec: any, node: any, into: any): any;
    }
    /**
     * Class: mxTerminalChangeCodec
     *
     * Codec for <mxTerminalChange>s. This class is created and registered
     * dynamically at load time and used implicitely via <mxCodec> and
     * the <mxCodecRegistry>.
     *
     * Transient Fields:
     *
     * - model
     * - previous
     *
     * Reference Fields:
     *
     * - cell
     * - terminal
     */
    class mxTerminalChangeCodec extends mxObjectCodec {
        /**
         * Function: afterDecode
         *
         * Restores the state by assigning the previous value.
         */
        afterDecode(dec: any, node: any, obj: any): any;
    }
    /**
     * Generic codec for JavaScript objects that implements a mapping between
     * JavaScript objects and XML nodes that maps each field or element to an
     * attribute or child node, and vice versa.
     *
     * Atomic Values:
     *
     * Consider the following example.
     *
     * (code)
     * var obj = new Object();
     * obj.foo = "Foo";
     * obj.bar = "Bar";
     * (end)
     *
     * This object is encoded into an XML node using the following.
     *
     * (code)
     * var enc = new mxCodec();
     * var node = enc.encode(obj);
     * (end)
     *
     * The output of the encoding may be viewed using <mxLog> as follows.
     *
     * (code)
     * mxLog.show();
     * mxLog.debug(mxUtils.getPrettyXml(node));
     * (end)
     *
     * Finally, the result of the encoding looks as follows.
     *
     * (code)
     * <Object foo="Foo" bar="Bar"/>
     * (end)
     *
     * In the above output, the foo and bar fields have been mapped to attributes
     * with the same names, and the name of the constructor was used for the
     * nodename.
     *
     * Booleans:
     *
     * Since booleans are numbers in JavaScript, all boolean values are encoded
     * into 1 for true and 0 for false. The decoder also accepts the string true
     * and false for boolean values.
     *
     * Objects:
     *
     * The above scheme is applied to all atomic fields, that is, to all non-object
     * fields of an object. For object fields, a child node is created with a
     * special attribute that contains the fieldname. This special attribute is
     * called "as" and hence, as is a reserved word that should not be used for a
     * fieldname.
     *
     * Consider the following example where foo is an object and bar is an atomic
     * property of foo.
     *
     * (code)
     * var obj = {foo: {bar: "Bar"}};
     * (end)
     *
     * This will be mapped to the following XML structure by mxObjectCodec.
     *
     * (code)
     * <Object>
     *   <Object bar="Bar" as="foo"/>
     * </Object>
     * (end)
     *
     * In the above output, the inner Object node contains the as-attribute that
     * specifies the fieldname in the enclosing object. That is, the field foo was
     * mapped to a child node with an as-attribute that has the value foo.
     *
     * Arrays:
     *
     * Arrays are special objects that are either associative, in which case each
     * key, value pair is treated like a field where the key is the fieldname, or
     * they are a sequence of atomic values and objects, which is mapped to a
     * sequence of child nodes. For object elements, the above scheme is applied
     * without the use of the special as-attribute for creating each child. For
     * atomic elements, a special add-node is created with the value stored in the
     * value-attribute.
     *
     * For example, the following array contains one atomic value and one object
     * with a field called bar. Furthermore it contains two associative entries
     * called bar with an atomic value, and foo with an object value.
     *
     * (code)
     * var obj = ["Bar", {bar: "Bar"}];
     * obj["bar"] = "Bar";
     * obj["foo"] = {bar: "Bar"};
     * (end)
     *
     * This array is represented by the following XML nodes.
     *
     * (code)
     * <Array bar="Bar">
     *   <add value="Bar"/>
     *   <Object bar="Bar"/>
     *   <Object bar="Bar" as="foo"/>
     * </Array>
     * (end)
     *
     * The Array node name is the name of the constructor. The additional
     * as-attribute in the last child contains the key of the associative entry,
     * whereas the second last child is part of the array sequence and does not
     * have an as-attribute.
     *
     * References:
     *
     * Objects may be represented as child nodes or attributes with ID values,
     * which are used to lookup the object in a table within <mxCodec>. The
     * <isReference> function is in charge of deciding if a specific field should
     * be encoded as a reference or not. Its default implementation returns true if
     * the fieldname is in <idrefs>, an array of strings that is used to configure
     * the <mxObjectCodec>.
     *
     * Using this approach, the mapping does not guarantee that the referenced
     * object itself exists in the document. The fields that are encoded as
     * references must be carefully chosen to make sure all referenced objects
     * exist in the document, or may be resolved by some other means if necessary.
     *
     * For example, in the case of the graph model all cells are stored in a tree
     * whose root is referenced by the model's root field. A tree is a structure
     * that is well suited for an XML representation, however, the additional edges
     * in the graph model have a reference to a source and target cell, which are
     * also contained in the tree. To handle this case, the source and target cell
     * of an edge are treated as references, whereas the children are treated as
     * objects. Since all cells are contained in the tree and no edge references a
     * source or target outside the tree, this setup makes sure all referenced
     * objects are contained in the document.
     *
     * In the case of a tree structure we must further avoid infinite recursion by
     * ignoring the parent reference of each child. This is done by returning true
     * in <isExcluded>, whose default implementation uses the array of excluded
     * fieldnames passed to the mxObjectCodec constructor.
     *
     * References are only used for cells in mxGraph. For defining other
     * referencable object types, the codec must be able to work out the ID of an
     * object. This is done by implementing <mxCodec.reference>. For decoding a
     * reference, the XML node with the respective id-attribute is fetched from the
     * document, decoded, and stored in a lookup table for later reference. For
     * looking up external objects, <mxCodec.lookup> may be implemented.
     *
     * Expressions:
     *
     * For decoding JavaScript expressions, the add-node may be used with a text
     * content that contains the JavaScript expression. For example, the following
     * creates a field called foo in the enclosing object and assigns it the value
     * of <mxConstants.ALIGN_LEFT>.
     *
     * (code)
     * <Object>
     *   <add as="foo">mxConstants.ALIGN_LEFT</add>
     * </Object>
     * (end)
     *
     * The resulting object has a field called foo with the value "left". Its XML
     * representation looks as follows.
     *
     * (code)
     * <Object foo="left"/>
     * (end)
     *
     * This means the expression is evaluated at decoding time and the result of
     * the evaluation is stored in the respective field. Valid expressions are all
     * JavaScript expressions, including function definitions, which are mapped to
     * functions on the resulting object.
     *
     * Expressions are only evaluated if <allowEval> is true.
     *
     * Constructor: mxObjectCodec
     *
     * Constructs a new codec for the specified template object.
     * The variables in the optional exclude array are ignored by
     * the codec. Variables in the optional idrefs array are
     * turned into references in the XML. The optional mapping
     * may be used to map from variable names to XML attributes.
     * The argument is created as follows:
     *
     * (code)
     * var mapping = new Object();
     * mapping['variableName'] = 'attribute-name';
     * (end)
     *
     * Parameters:
     *
     * template - Prototypical instance of the object to be
     * encoded/decoded.
     * exclude - Optional array of fieldnames to be ignored.
     * idrefs - Optional array of fieldnames to be converted to/from
     * references.
     * mapping - Optional mapping from field- to attributenames.
     */
    class mxObjectCodec {
        constructor(template: any, exclude?: any, idrefs?: any, mapping?: any);
        /**
         * Variable: exclude
         *
         * Array containing the variable names that should be
         * ignored by the codec.
         */
        exclude: string[];
        /**
         * Returns the name used for the nodenames and lookup of the codec when
         * classes are encoded and nodes are decoded. For classes to work with
         * this the codec registry automatically adds an alias for the classname
         * if that is different than what this returns. The default implementation
         * returns the classname of the template class.
         */
        getName(): any;
        /**
         * Returns a new instance of the template for this codec.
         */
        cloneTemplate(): any;
        /**
         * Returns the fieldname for the given attributename.
         * Looks up the value in the <reverse> mapping or returns
         * the input if there is no reverse mapping for the
         * given name.
         */
        getFieldName(attributename: any): any;
        /**
         * Returns the attributename for the given fieldname.
         * Looks up the value in the <mapping> or returns
         * the input if there is no mapping for the
         * given name.
         */
        getAttributeName(fieldname: any): any;
        /**
         * Returns true if the given attribute is to be ignored by the codec. This
         * implementation returns true if the given fieldname is in <exclude> or
         * if the fieldname equals <mxObjectIdentity.FIELD_NAME>.
         *
         * Parameters:
         *
         * obj - Object instance that contains the field.
         * attr - Fieldname of the field.
         * value - Value of the field.
         * write - Boolean indicating if the field is being encoded or decoded.
         * Write is true if the field is being encoded, else it is being decoded.
         */
        isExcluded(obj: any, attr: any, value: any, write: any): boolean;
        /**
         * Returns true if the given fieldname is to be treated
         * as a textual reference (ID). This implementation returns
         * true if the given fieldname is in <idrefs>.
         *
         * Parameters:
         *
         * obj - Object instance that contains the field.
         * attr - Fieldname of the field.
         * value - Value of the field.
         * write - Boolean indicating if the field is being encoded or decoded.
         * Write is true if the field is being encoded, else it is being decoded.
         */
        isReference(obj: any, attr: any, value: any, write: any): boolean;
        /**
         * Encodes the specified object and returns a node
         * representing then given object. Calls <beforeEncode>
         * after creating the node and <afterEncode> with the
         * resulting node after processing.
         *
         * Enc is a reference to the calling encoder. It is used
         * to encode complex objects and create references.
         *
         * This implementation encodes all variables of an
         * object according to the following rules:
         *
         * - If the variable name is in <exclude> then it is ignored.
         * - If the variable name is in <idrefs> then <mxCodec.getId>
         * is used to replace the object with its ID.
         * - The variable name is mapped using <mapping>.
         * - If obj is an array and the variable name is numeric
         * (ie. an index) then it is not encoded.
         * - If the value is an object, then the codec is used to
         * create a child node with the variable name encoded into
         * the "as" attribute.
         * - Else, if <encodeDefaults> is true or the value differs
         * from the template value, then ...
         * - ... if obj is not an array, then the value is mapped to
         * an attribute.
         * - ... else if obj is an array, the value is mapped to an
         * add child with a value attribute or a text child node,
         * if the value is a function.
         *
         * If no ID exists for a variable in <idrefs> or if an object
         * cannot be encoded, a warning is issued using <mxLog.warn>.
         *
         * Returns the resulting XML node that represents the given
         * object.
         *
         * Parameters:
         *
         * enc - <mxCodec> that controls the encoding process.
         * obj - Object to be encoded.
         */
        encode(enc: any, obj: any): any;
        /**
         * Encodes the value of each member in then given obj into the given node using
         * <encodeValue>.
         *
         * Parameters:
         *
         * enc - <mxCodec> that controls the encoding process.
         * obj - Object to be encoded.
         * node - XML node that contains the encoded object.
         */
        encodeObject(enc: any, obj: any, node: any): void;
        /**
         * Converts the given value according to the mappings
         * and id-refs in this codec and uses <writeAttribute>
         * to write the attribute into the given node.
         *
         * Parameters:
         *
         * enc - <mxCodec> that controls the encoding process.
         * obj - Object whose property is going to be encoded.
         * name - XML node that contains the encoded object.
         * value - Value of the property to be encoded.
         * node - XML node that contains the encoded object.
         */
        encodeValue(enc: any, obj: any, name: any, value: any, node: any): void;
        /**
         * Writes the given value into node using <writePrimitiveAttribute>
         * or <writeComplexAttribute> depending on the type of the value.
         */
        writeAttribute(enc: any, obj: any, name: any, value: any, node: any): void;
        /**
         * Writes the given value as an attribute of the given node.
         */
        writePrimitiveAttribute(enc: any, obj: any, name: any, value: any, node: any): void;
        /**
         * Writes the given value as a child node of the given node.
         */
        writeComplexAttribute(enc: any, obj: any, name: any, value: any, node: any): void;
        /**
         * Converts true to "1" and false to "0" is <isBooleanAttribute> returns true.
         * All other values are not converted.
         *
         * Parameters:
         *
         * enc - <mxCodec> that controls the encoding process.
         * obj - Objec to convert the attribute for.
         * name - Name of the attribute to be converted.
         * value - Value to be converted.
         */
        convertAttributeToXml(enc: any, obj: any, name: any, value: any): any;
        /**
         * Returns true if the given object attribute is a boolean value.
         *
         * Parameters:
         *
         * enc - <mxCodec> that controls the encoding process.
         * obj - Objec to convert the attribute for.
         * name - Name of the attribute to be converted.
         * value - Value of the attribute to be converted.
         */
        isBooleanAttribute(enc: any, obj: any, name: any, value: any): boolean;
        /**
         * Converts booleans and numeric values to the respective types. Values are
         * numeric if <isNumericAttribute> returns true.
         *
         * Parameters:
         *
         * dec - <mxCodec> that controls the decoding process.
         * attr - XML attribute to be converted.
         * obj - Objec to convert the attribute for.
         */
        convertAttributeFromXml(dec: any, attr: any, obj: any): any;
        /**
         * Returns true if the given XML attribute is a numeric value.
         *
         * Parameters:
         *
         * dec - <mxCodec> that controls the decoding process.
         * attr - XML attribute to be converted.
         * obj - Objec to convert the attribute for.
         */
        isNumericAttribute(dec: any, attr: any, obj: any): any;
        /**
         * Hook for subclassers to pre-process the object before
         * encoding. This returns the input object. The return
         * value of this function is used in <encode> to perform
         * the default encoding into the given node.
         *
         * Parameters:
         *
         * enc - <mxCodec> that controls the encoding process.
         * obj - Object to be encoded.
         * node - XML node to encode the object into.
         */
        beforeEncode(enc: any, obj: any, node: any): any;
        /**
         * Hook for subclassers to post-process the node
         * for the given object after encoding and return the
         * post-processed node. This implementation returns
         * the input node. The return value of this method
         * is returned to the encoder from <encode>.
         *
         * Parameters:
         *
         * enc - <mxCodec> that controls the encoding process.
         * obj - Object to be encoded.
         * node - XML node that represents the default encoding.
         */
        afterEncode(enc: any, obj: any, node: any): any;
        /**
         * Parses the given node into the object or returns a new object
         * representing the given node.
         *
         * Dec is a reference to the calling decoder. It is used to decode
         * complex objects and resolve references.
         *
         * If a node has an id attribute then the object cache is checked for the
         * object. If the object is not yet in the cache then it is constructed
         * using the constructor of <template> and cached in <mxCodec.objects>.
         *
         * This implementation decodes all attributes and childs of a node
         * according to the following rules:
         *
         * - If the variable name is in <exclude> or if the attribute name is "id"
         * or "as" then it is ignored.
         * - If the variable name is in <idrefs> then <mxCodec.getObject> is used
         * to replace the reference with an object.
         * - The variable name is mapped using a reverse <mapping>.
         * - If the value has a child node, then the codec is used to create a
         * child object with the variable name taken from the "as" attribute.
         * - If the object is an array and the variable name is empty then the
         * value or child object is appended to the array.
         * - If an add child has no value or the object is not an array then
         * the child text content is evaluated using <mxUtils.eval>.
         *
         * For add nodes where the object is not an array and the variable name
         * is defined, the default mechanism is used, allowing to override/add
         * methods as follows:
         *
         * (code)
         * <Object>
         *   <add as="hello"><![CDATA[
         *     function(arg1) {
         *       mxUtils.alert('Hello '+arg1);
         *     }
         *   ]]></add>
         * </Object>
         * (end)
         *
         * If no object exists for an ID in <idrefs> a warning is issued
         * using <mxLog.warn>.
         *
         * Returns the resulting object that represents the given XML node
         * or the object given to the method as the into parameter.
         *
         * Parameters:
         *
         * dec - <mxCodec> that controls the decoding process.
         * node - XML node to be decoded.
         * into - Optional objec to encode the node into.
         */
        decode(dec: any, node: any, into?: any): any;
        /**
         * Calls <decodeAttributes> and <decodeChildren> for the given node.
         *
         * Parameters:
         *
         * dec - <mxCodec> that controls the decoding process.
         * node - XML node to be decoded.
         * obj - Objec to encode the node into.
         */
        decodeNode(dec: any, node: any, obj: any): void;
        /**
         * Decodes all attributes of the given node using <decodeAttribute>.
         *
         * Parameters:
         *
         * dec - <mxCodec> that controls the decoding process.
         * node - XML node to be decoded.
         * obj - Objec to encode the node into.
         */
        decodeAttributes(dec: any, node: any, obj: any): void;
        /**
         * Returns true if the given attribute should be ignored. This implementation
         * returns true if the attribute name is "as" or "id".
         *
         * Parameters:
         *
         * dec - <mxCodec> that controls the decoding process.
         * attr - XML attribute to be decoded.
         * obj - Objec to encode the attribute into.
         */
        isIgnoredAttribute(dec: any, attr: any, obj: any): boolean;
        /**
         * Reads the given attribute into the specified object.
         *
         * Parameters:
         *
         * dec - <mxCodec> that controls the decoding process.
         * attr - XML attribute to be decoded.
         * obj - Objec to encode the attribute into.
         */
        decodeAttribute(dec: any, attr: any, obj: any): void;
        /**
         * Decodes all children of the given node using <decodeChild>.
         *
         * Parameters:
         *
         * dec - <mxCodec> that controls the decoding process.
         * node - XML node to be decoded.
         * obj - Objec to encode the node into.
         */
        decodeChildren(dec: any, node: any, obj: any): void;
        /**
         * Reads the specified child into the given object.
         *
         * Parameters:
         *
         * dec - <mxCodec> that controls the decoding process.
         * child - XML child element to be decoded.
         * obj - Objec to encode the node into.
         */
        decodeChild(dec: any, child: any, obj: any): void;
        /**
         * Returns the template instance for the given field. This returns the
         * value of the field, null if the value is an array or an empty collection
         * if the value is a collection. The value is then used to populate the
         * field for a new instance. For strongly typed languages it may be
         * required to override this to return the correct collection instance
         * based on the encoded child.
         */
        getFieldTemplate(obj: any, fieldname: any, child: any): any;
        /**
         * Sets the decoded child node as a value of the given object. If the
         * object is a map, then the value is added with the given fieldname as a
         * key. If the fieldname is not empty, then setFieldValue is called or
         * else, if the object is a collection, the value is added to the
         * collection. For strongly typed languages it may be required to
         * override this with the correct code to add an entry to an object.
         */
        addObjectValue(obj: any, fieldname: any, value: any, template: any): void;
        /**
         * Returns true if the given node is an include directive and
         * executes the include by decoding the XML document. Returns
         * false if the given node is not an include directive.
         *
         * Parameters:
         *
         * dec - <mxCodec> that controls the encoding/decoding process.
         * node - XML node to be checked.
         * into - Optional object to pass-thru to the codec.
         */
        processInclude(dec: any, node: any, into: any): boolean;
        /**
         * Hook for subclassers to pre-process the node for
         * the specified object and return the node to be
         * used for further processing by <decode>.
         * The object is created based on the template in the
         * calling method and is never null. This implementation
         * returns the input node. The return value of this
         * function is used in <decode> to perform
         * the default decoding into the given object.
         *
         * Parameters:
         *
         * dec - <mxCodec> that controls the decoding process.
         * node - XML node to be decoded.
         * obj - Object to encode the node into.
         */
        beforeDecode(dec: any, node: any, obj: any): any;
        /**
         * Hook for subclassers to post-process the object after
         * decoding. This implementation returns the given object
         * without any changes. The return value of this method
         * is returned to the decoder from <decode>.
         *
         * Parameters:
         *
         * enc - <mxCodec> that controls the encoding process.
         * node - XML node to be decoded.
         * obj - Object that represents the default decoding.
         */
        afterDecode(dec: any, node: any, obj: any): any;
    }
    /**
        * A hierarchical layout algorithm.
        *
        * Constructor: mxHierarchicalLayout
        *
        * Constructs a new hierarchical layout algorithm.
        *
        * Arguments:
        *
        * graph - Reference to the enclosing <mxGraph>.
        * orientation - Optional constant that defines the orientation of this
        * layout.
        * deterministic - Optional boolean that specifies if this layout should be
        * deterministic. Default is true.
        */
    class mxHierarchicalLayout extends mxGraphLayout {
        parallelEdgeSpacing: any;
        interHierarchySpacing: any;
        interRankCellSpacing: any;
        intraCellSpacing: any;
        maintainParentLocation: boolean;
        parentBorder: any;
        resizeParent: boolean;
        constructor(graph: any, orientation?: any, deterministic?: any);
        /**
         * Returns the internal <mxGraphHierarchyModel> for this layout algorithm.
         */
        getModel(): any;
        /**
         * Executes the layout for the children of the specified parent.
         *
         * Parameters:
         *
         * parent - Parent <mxCell> that contains the children to be laid out.
         * roots - Optional starting roots of the layout.
         */
        execute(parent: any, roots?: any): void;
        /**
         * Returns all visible children in the given parent which do not have
         * incoming edges. If the result is empty then the children with the
         * maximum difference between incoming and outgoing edges are returned.
         * This takes into account edges that are being promoted to the given
         * root due to invisible children or collapsed cells.
         *
         * Parameters:
         *
         * parent - <mxCell> whose children should be checked.
         * vertices - array of vertices to limit search to
         */
        findRoots(parent: any, vertices: any): any[];
        /**
         * Returns the connected edges for the given cell.
         *
         * Parameters:
         *
         * cell - <mxCell> whose edges should be returned.
         */
        getEdges(cell: any): any;
        /**
         * Helper function to return visible terminal for edge allowing for ports
         *
         * Parameters:
         *
         * edge - <mxCell> whose edges should be returned.
         * source - Boolean that specifies whether the source or target terminal is to be returned
         */
        getVisibleTerminal(edge: any, source: any): any;
        /**
         * The API method used to exercise the layout upon the graph description
         * and produce a separate description of the vertex position and edge
         * routing changes made. It runs each stage of the layout that has been
         * created.
         */
        run(parent: any): void;
        /**
         * Creates an array of descendant cells
         */
        filterDescendants(cell: any, result: any): void;
        /**
         * Returns true if the given cell is a "port", that is, when connecting to
         * it, its parent is the connecting vertex in terms of graph traversal
         *
         * Parameters:
         *
         * cell - <mxCell> that represents the port.
         */
        isPort(cell: any): boolean;
        /**
         * Returns the edges between the given source and target. This takes into
         * account collapsed and invisible cells and ports.
         *
         * Parameters:
         *
         * source -
         * target -
         * directed -
         */
        getEdgesBetween(source: any, target: any, directed: any): any[];
        /**
         * Traverses the (directed) graph invoking the given function for each
         * visited vertex and edge. The function is invoked with the current vertex
         * and the incoming edge as a parameter. This implementation makes sure
         * each vertex is only visited once. The function may return false if the
         * traversal should stop at the given vertex.
         *
         * Parameters:
         *
         * vertex - <mxCell> that represents the vertex where the traversal starts.
         * directed - boolean indicating if edges should only be traversed
         * from source to target. Default is true.
         * edge - Optional <mxCell> that represents the incoming edge. This is
         * null for the first step of the traversal.
         * allVertices - Array of cell paths for the visited cells.
         */
        traverse(vertex: any, directed: any, edge: any, allVertices: any, currentComp: any, hierarchyVertices: any, filledVertexSet: any): any;
        /**
         * Executes the cycle stage using mxMinimumCycleRemover.
         */
        cycleStage(parent: any): void;
        /**
         * Implements first stage of a Sugiyama layout.
         */
        layeringStage(): void;
        /**
         * Executes the crossing stage using mxMedianHybridCrossingReduction.
         */
        crossingStage(parent: any): void;
        /**
         * Executes the placement stage using mxCoordinateAssignment.
         */
        placementStage(initialX: any, parent: any): any;
    }
    var mxHierarchicalEdgeStyle: {
        ORTHOGONAL: number;
        POLYLINE: number;
        STRAIGHT: number;
        CURVE: number;
    };
    /**
        * A hierarchical layout algorithm.
        *
        * Constructor: mxSwimlaneLayout
        *
        * Constructs a new hierarchical layout algorithm.
        *
        * Arguments:
        *
        * graph - Reference to the enclosing <mxGraph>.
        * orientation - Optional constant that defines the orientation of this
        * layout.
        * deterministic - Optional boolean that specifies if this layout should be
        * deterministic. Default is true.
        */
    class mxSwimlaneLayout extends mxGraphLayout {
        constructor(graph: any, orientation?: any, deterministic?: any);
        /**
         * Returns the internal <mxSwimlaneModel> for this layout algorithm.
         */
        getModel(): any;
        /**
         * Executes the layout for the children of the specified parent.
         *
         * Parameters:
         *
         * parent - Parent <mxCell> that contains the children to be laid out.
         * swimlanes - Ordered array of swimlanes to be laid out
         */
        execute(parent: any, swimlanes?: any): void;
        /**
         * Updates the bounds of the given array of groups so that it includes
         * all child vertices.
         *
         */
        updateGroupBounds(): void;
        /**
         * Returns all visible children in the given parent which do not have
         * incoming edges. If the result is empty then the children with the
         * maximum difference between incoming and outgoing edges are returned.
         * This takes into account edges that are being promoted to the given
         * root due to invisible children or collapsed cells.
         *
         * Parameters:
         *
         * parent - <mxCell> whose children should be checked.
         * vertices - array of vertices to limit search to
         */
        findRoots(parent: any, vertices: any): any[];
        /**
         * Returns the connected edges for the given cell.
         *
         * Parameters:
         *
         * cell - <mxCell> whose edges should be returned.
         */
        getEdges(cell: any): any;
        /**
         * Helper function to return visible terminal for edge allowing for ports
         *
         * Parameters:
         *
         * edge - <mxCell> whose edges should be returned.
         * source - Boolean that specifies whether the source or target terminal is to be returned
         */
        getVisibleTerminal(edge: any, source: any): any;
        /**
         * The API method used to exercise the layout upon the graph description
         * and produce a separate description of the vertex position and edge
         * routing changes made. It runs each stage of the layout that has been
         * created.
         */
        run(parent: any): void;
        /**
         * Creates an array of descendant cells
         */
        filterDescendants(cell: any, result: any): void;
        /**
         * Returns true if the given cell is a "port", that is, when connecting to
         * it, its parent is the connecting vertex in terms of graph traversal
         *
         * Parameters:
         *
         * cell - <mxCell> that represents the port.
         */
        isPort(cell: any): boolean;
        /**
         * Returns the edges between the given source and target. This takes into
         * account collapsed and invisible cells and ports.
         *
         * Parameters:
         *
         * source -
         * target -
         * directed -
         */
        getEdgesBetween(source: any, target: any, directed: any): any[];
        /**
         * Traverses the (directed) graph invoking the given function for each
         * visited vertex and edge. The function is invoked with the current vertex
         * and the incoming edge as a parameter. This implementation makes sure
         * each vertex is only visited once. The function may return false if the
         * traversal should stop at the given vertex.
         *
         * Parameters:
         *
         * vertex - <mxCell> that represents the vertex where the traversal starts.
         * directed - boolean indicating if edges should only be traversed
         * from source to target. Default is true.
         * edge - Optional <mxCell> that represents the incoming edge. This is
         * null for the first step of the traversal.
         * allVertices - Array of cell paths for the visited cells.
         * swimlaneIndex - the laid out order index of the swimlane vertex is contained in
         */
        traverse(vertex: any, directed: any, edge: any, allVertices: any, currentComp: any, hierarchyVertices: any, filledVertexSet: any, swimlaneIndex: any): any;
        /**
         * Executes the cycle stage using mxMinimumCycleRemover.
         */
        cycleStage(parent: any): void;
        /**
         * Implements first stage of a Sugiyama layout.
         */
        layeringStage(): void;
        /**
         * Executes the crossing stage using mxMedianHybridCrossingReduction.
         */
        crossingStage(parent: any): void;
        /**
         * Executes the placement stage using mxCoordinateAssignment.
         */
        placementStage(initialX: any, parent: any): any;
    }
    /**
        * The specific layout interface for hierarchical layouts. It adds a
        * <code>run</code> method with a parameter for the hierarchical layout model
        * that is shared between the layout stages.
        *
        * Constructor: mxHierarchicalLayoutStage
        *
        * Constructs a new hierarchical layout stage.
        */
    class mxHierarchicalLayoutStage {
        /**
         * Takes the graph detail and configuration information within the facade
         * and creates the resulting laid out graph within that facade for further
         * use.
         */
        execute(parent: any): void;
    }
    /**
        * Sets the horizontal locations of node and edge dummy nodes on each layer.
        * Uses median down and up weighings as well heuristic to straighten edges as
        * far as possible.
        *
        * Constructor: mxMedianHybridCrossingReduction
        *
        * Creates a coordinate assignment.
        *
        * Arguments:
        *
        * intraCellSpacing - the minimum buffer between cells on the same rank
        * interRankCellSpacing - the minimum distance between cells on adjacent ranks
        * orientation - the position of the root node(s) relative to the graph
        * initialX - the leftmost coordinate node placement starts at
        */
    class mxMedianHybridCrossingReduction extends mxHierarchicalLayoutStage {
        constructor(layout: any);
        /**
         * Performs a vertex ordering within ranks as described by Gansner et al
         * 1993
         */
        execute(parent: any): void;
        /**
         * Calculates the total number of edge crossing in the current graph.
         * Returns the current number of edge crossings in the hierarchy graph
         * model in the current candidate layout
         *
         * Parameters:
         *
         * model - the internal model describing the hierarchy
         */
        calculateCrossings(model: any): number;
        /**
         * Calculates the number of edges crossings between the specified rank and
         * the rank below it. Returns the number of edges crossings with the rank
         * beneath
         *
         * Parameters:
         *
         * i -  the topmost rank of the pair ( higher rank value )
         * model - the internal model describing the hierarchy
         */
        calculateRankCrossing(i: any, model: any): number;
        /**
         * Takes each possible adjacent cell pair on each rank and checks if
         * swapping them around reduces the number of crossing
         *
         * Parameters:
         *
         * mainLoopIteration - the iteration number of the main loop
         * model - the internal model describing the hierarchy
         */
        transpose(mainLoopIteration: any, model: any): void;
        /**
         * Sweeps up or down the layout attempting to minimise the median placement
         * of connected cells on adjacent ranks
         *
         * Parameters:
         *
         * iteration - the iteration number of the main loop
         * model - the internal model describing the hierarchy
         */
        weightedMedian(iteration: any, model: any): void;
        /**
         * Attempts to minimise the median placement of connected cells on this rank
         * and one of the adjacent ranks
         *
         * Parameters:
         *
         * rankValue - the layer number of this rank
         * downwardSweep - whether or not this is a downward sweep through the graph
         */
        medianRank(rankValue: any, downwardSweep: any): void;
        /**
         * Calculates the median rank order positioning for the specified cell using
         * the connected cells on the specified rank. Returns the median rank
         * ordering value of the connected cells
         *
         * Parameters:
         *
         * connectedCells - the cells on the specified rank connected to the
         * specified cell
         * rankValue - the rank that the connected cell lie upon
         */
        medianValue(connectedCells: any, rankValue: any): any;
    }
    /**
        * A utility class used to track cells whilst sorting occurs on the median
        * values. Does not violate (x.compareTo(y)==0) == (x.equals(y))
        *
        * Constructor: MedianCellSorter
        *
        * Constructs a new median cell sorter.
        */
    class MedianCellSorter {
        /**
         * Compares two MedianCellSorters.
         */
        compare(a: any, b: any): 1 | 0 | -1;
    }
    /**
        * An implementation of the first stage of the Sugiyama layout. Straightforward
        * longest path calculation of layer assignment
        *
        * Constructor: mxMinimumCycleRemover
        *
        * Creates a cycle remover for the given internal model.
        */
    class mxMinimumCycleRemover extends mxHierarchicalLayoutStage {
        constructor(layout: any);
        /**
         * Takes the graph detail and configuration information within the facade
         * and creates the resulting laid out graph within that facade for further
         * use.
         */
        execute(parent: any): void;
    }
    /**
        * Sets the horizontal locations of node and edge dummy nodes on each layer.
        * Uses median down and up weighings as well as heuristics to straighten edges as
        * far as possible.
        *
        * Constructor: mxCoordinateAssignment
        *
        * Creates a coordinate assignment.
        *
        * Arguments:
        *
        * intraCellSpacing - the minimum buffer between cells on the same rank
        * interRankCellSpacing - the minimum distance between cells on adjacent ranks
        * orientation - the position of the root node(s) relative to the graph
        * initialX - the leftmost coordinate node placement starts at
        */
    class mxCoordinateAssignment extends mxHierarchicalLayoutStage {
        constructor(layout: any, intraCellSpacing: any, interRankCellSpacing: any, orientation: any, initialX: any, parallelEdgeSpacing: any);
        /**
         * Utility method to display current positions
         */
        printStatus(): void;
        /**
         * A basic horizontal coordinate assignment algorithm
         */
        execute(parent: any): void;
        /**
         * Performs one median positioning sweep in both directions
         */
        minNode(model: any): void;
        /**
         * Performs one median positioning sweep in one direction
         *
         * Parameters:
         *
         * i - the iteration of the whole process
         * model - an internal model of the hierarchical layout
         */
        medianPos(i: any, model: any): void;
        /**
         * Performs median minimisation over one rank.
         *
         * Parameters:
         *
         * rankValue - the layer number of this rank
         * model - an internal model of the hierarchical layout
         * nextRankValue - the layer number whose connected cels are to be laid out
         * relative to
         */
        rankMedianPosition(rankValue: any, model: any, nextRankValue: any): void;
        /**
         * Calculates the priority the specified cell has based on the type of its
         * cell and the cells it is connected to on the next layer
         *
         * Parameters:
         *
         * currentCell - the cell whose weight is to be calculated
         * collection - the cells the specified cell is connected to
         */
        calculatedWeightedValue(currentCell: any, collection: any): number;
        /**
         * Calculates the median position of the connected cell on the specified
         * rank
         *
         * Parameters:
         *
         * connectedCells - the cells the candidate connects to on this level
         * rankValue - the layer number of this rank
         */
        medianXValue(connectedCells: any, rankValue: any): any;
        /**
         * Sets up the layout in an initial positioning. The ranks are all centered
         * as much as possible along the middle vertex in each rank. The other cells
         * are then placed as close as possible on either side.
         *
         * Parameters:
         *
         * facade - the facade describing the input graph
         * model - an internal model of the hierarchical layout
         */
        initialCoords(facade: any, model: any): void;
        /**
         * Sets up the layout in an initial positioning. All the first cells in each
         * rank are moved to the left and the rest of the rank inserted as close
         * together as their size and buffering permits. This method works on just
         * the specified rank.
         *
         * Parameters:
         *
         * rankValue - the current rank being processed
         * graph - the facade describing the input graph
         * model - an internal model of the hierarchical layout
         */
        rankCoordinates(rankValue: any, graph: any, model: any): void;
        /**
         * Calculates the width rank in the hierarchy. Also set the y value of each
         * rank whilst performing the calculation
         *
         * Parameters:
         *
         * graph - the facade describing the input graph
         * model - an internal model of the hierarchical layout
         */
        calculateWidestRank(graph: any, model: any): void;
        /**
         * Straightens out chains of virtual nodes where possibleacade to those stored after this layout
         * processing step has completed.
         *
         * Parameters:
         *
         * graph - the facade describing the input graph
         * model - an internal model of the hierarchical layout
         */
        minPath(graph: any, model: any): void;
        /**
         * Determines whether or not a node may be moved to the specified x
         * position on the specified rank
         *
         * Parameters:
         *
         * model - the layout model
         * cell - the cell being analysed
         * rank - the layer of the cell
         * position - the x position being sought
         */
        repositionValid(model: any, cell: any, rank: any, position: any): boolean;
        /**
         * Sets the cell locations in the facade to those stored after this layout
         * processing step has completed.
         *
         * Parameters:
         *
         * graph - the input graph
         * model - the layout model
         */
        setCellLocations(graph: any, model: any): void;
        /**
         * Separates the x position of edges as they connect to vertices
         *
         * Parameters:
         *
         * model - the layout model
         */
        localEdgeProcessing(model: any): void;
        /**
         * Fixes the control points
         */
        setEdgePosition(cell: any): void;
        /**
         * Fixes the position of the specified vertex.
         *
         * Parameters:
         *
         * cell - the vertex to position
         */
        setVertexLocation(cell: any): void;
        /**
         * Hook to add additional processing
         *
         * Parameters:
         *
         * edge - the hierarchical model edge
         * realEdge - the real edge in the graph
         */
        processReversedEdge(graph: any, model: any): void;
    }
    /**
        * An implementation of the first stage of the Sugiyama layout. Straightforward
        * longest path calculation of layer assignment
        *
        * Constructor: mxSwimlaneOrdering
        *
        * Creates a cycle remover for the given internal model.
        */
    class mxSwimlaneOrdering extends mxHierarchicalLayoutStage {
        constructor(layout: any);
        /**
         * Takes the graph detail and configuration information within the facade
         * and creates the resulting laid out graph within that facade for further
         * use.
         */
        execute(parent: any): void;
    }
    /**
        * An abstraction of an internal hierarchy node or edge
        *
        * Constructor: mxGraphAbstractHierarchyCell
        *
        * Constructs a new hierarchical layout algorithm.
        *
        * Arguments:
        *
        * graph - Reference to the enclosing <mxGraph>.
        * deterministic - Optional boolean that specifies if this layout should be
        * deterministic. Default is true.
        */
    class mxGraphAbstractHierarchyCell {
        constructor();
        /**
         * Returns the cells this cell connects to on the next layer up
         */
        getNextLayerConnectedCells(layer: any): any;
        /**
         * Returns the cells this cell connects to on the next layer down
         */
        getPreviousLayerConnectedCells(layer: any): any;
        /**
         * Returns whether or not this cell is an edge
         */
        isEdge(): boolean;
        /**
         * Returns whether or not this cell is a node
         */
        isVertex(): boolean;
        /**
         * Gets the value of temp for the specified layer
         */
        getGeneralPurposeVariable(layer: any): any;
        /**
         * Set the value of temp for the specified layer
         */
        setGeneralPurposeVariable(layer: any, value: any): any;
        /**
         * Set the value of x for the specified layer
         */
        setX(layer: any, value: any): void;
        /**
         * Gets the value of x on the specified layer
         */
        getX(layer: any): any;
        /**
         * Set the value of y for the specified layer
         */
        setY(layer: any, value: any): void;
    }
    /**
        * An abstraction of a hierarchical edge for the hierarchy layout
        *
        * Constructor: mxGraphHierarchyNode
        *
        * Constructs an internal node to represent the specified real graph cell
        *
        * Arguments:
        *
        * cell - the real graph cell this node represents
        */
    class mxGraphHierarchyNode extends mxGraphAbstractHierarchyCell {
        constructor(cell: any);
        /**
         * Returns the integer value of the layer that this node resides in
         */
        getRankValue(layer: any): any;
        /**
         * Returns the cells this cell connects to on the next layer up
         */
        getNextLayerConnectedCells(layer: any): any;
        /**
         * Returns the cells this cell connects to on the next layer down
         */
        getPreviousLayerConnectedCells(layer: any): any;
        /**
         * Returns true.
         */
        isVertex(): boolean;
        /**
         * Gets the value of temp for the specified layer
         */
        getGeneralPurposeVariable(layer: any): any;
        /**
         * Set the value of temp for the specified layer
         */
        setGeneralPurposeVariable(layer: any, value: any): void;
        /**
         * Function: isAncestor
         */
        isAncestor(otherNode: any): boolean;
        /**
         * Gets the core vertex associated with this wrapper
         */
        getCoreCell(): any;
    }
    /**
        * An abstraction of a hierarchical edge for the hierarchy layout
        *
        * Constructor: mxGraphHierarchyEdge
        *
        * Constructs a hierarchy edge
        *
        * Arguments:
        *
        * edges - a list of real graph edges this abstraction represents
        */
    class mxGraphHierarchyEdge extends mxGraphAbstractHierarchyCell {
        constructor(edges: any);
        /**
         * Inverts the direction of this internal edge(s)
         */
        invert(layer: any): void;
        /**
         * Returns the cells this cell connects to on the next layer up
         */
        getNextLayerConnectedCells(layer: any): any;
        /**
         * Returns the cells this cell connects to on the next layer down
         */
        getPreviousLayerConnectedCells(layer: any): any;
        /**
         * Returns true.
         */
        isEdge(): boolean;
        /**
         * Gets the value of temp for the specified layer
         */
        getGeneralPurposeVariable(layer: any): any;
        /**
         * Set the value of temp for the specified layer
         */
        setGeneralPurposeVariable(layer: any, value: any): void;
        /**
         * Gets the first core edge associated with this wrapper
         */
        getCoreCell(): any;
    }
    /**
        * Internal model of a hierarchical graph. This model stores nodes and edges
        * equivalent to the real graph nodes and edges, but also stores the rank of the
        * cells, the order within the ranks and the new candidate locations of cells.
        * The internal model also reverses edge direction were appropriate , ignores
        * self-loop and groups parallels together under one edge object.
        *
        * Constructor: mxGraphHierarchyModel
        *
        * Creates an internal ordered graph model using the vertices passed in. If
        * there are any, leftward edge need to be inverted in the internal model
        *
        * Arguments:
        *
        * graph - the facade describing the graph to be operated on
        * vertices - the vertices for this hierarchy
        * ordered - whether or not the vertices are already ordered
        * deterministic - whether or not this layout should be deterministic on each
        * tightenToSource - whether or not to tighten vertices towards the sources
        * scanRanksFromSinks - Whether rank assignment is from the sinks or sources.
        * usage
        */
    class mxGraphHierarchyModel {
        constructor(layout: any, vertices: any, roots: any, parent: any, tightenToSource: any);
        /**
         * Creates all edges in the internal model
         *
         * Parameters:
         *
         * layout - Reference to the <mxHierarchicalLayout> algorithm.
         * vertices - Array of <mxCells> that represent the vertices whom are to
         * have an internal representation created.
         * internalVertices - The array of <mxGraphHierarchyNodes> to have their
         * information filled in using the real vertices.
         */
        createInternalCells(layout: any, vertices: any, internalVertices: any): void;
        /**
         * Basic determination of minimum layer ranking by working from from sources
         * or sinks and working through each node in the relevant edge direction.
         * Starting at the sinks is basically a longest path layering algorithm.
         */
        initialRank(): void;
        /**
         * Fixes the layer assignments to the values stored in the nodes. Also needs
         * to create dummy nodes for edges that cross layers.
         */
        fixRanks(): void;
        /**
         * A depth first search through the internal heirarchy model.
         *
         * Parameters:
         *
         * visitor - The visitor function pattern to be called for each node.
         * trackAncestors - Whether or not the search is to keep track all nodes
         * directly above this one in the search path.
         */
        visit(visitor: any, dfsRoots: any, trackAncestors: any, seenNodes: any): void;
        /**
         * Performs a depth first search on the internal hierarchy model
         *
         * Parameters:
         *
         * parent - the parent internal node of the current internal node
         * root - the current internal node
         * connectingEdge - the internal edge connecting the internal node and the parent
         * internal node, if any
         * visitor - the visitor pattern to be called for each node
         * seen - a set of all nodes seen by this dfs a set of all of the
         * ancestor node of the current node
         * layer - the layer on the dfs tree ( not the same as the model ranks )
         */
        dfs(parent: any, root: any, connectingEdge: any, visitor: any, seen: any, layer: any): void;
        /**
         * Performs a depth first search on the internal hierarchy model. This dfs
         * extends the default version by keeping track of cells ancestors, but it
         * should be only used when necessary because of it can be computationally
         * intensive for deep searches.
         *
         * Parameters:
         *
         * parent - the parent internal node of the current internal node
         * root - the current internal node
         * connectingEdge - the internal edge connecting the internal node and the parent
         * internal node, if any
         * visitor - the visitor pattern to be called for each node
         * seen - a set of all nodes seen by this dfs
         * ancestors - the parent hash code
         * childHash - the new hash code for this node
         * layer - the layer on the dfs tree ( not the same as the model ranks )
         */
        extendedDfs(parent: any, root: any, connectingEdge: any, visitor: any, seen: any, ancestors: any, childHash: any, layer: any): void;
    }
    /**
        * Internal model of a hierarchical graph. This model stores nodes and edges
        * equivalent to the real graph nodes and edges, but also stores the rank of the
        * cells, the order within the ranks and the new candidate locations of cells.
        * The internal model also reverses edge direction were appropriate , ignores
        * self-loop and groups parallels together under one edge object.
        *
        * Constructor: mxSwimlaneModel
        *
        * Creates an internal ordered graph model using the vertices passed in. If
        * there are any, leftward edge need to be inverted in the internal model
        *
        * Arguments:
        *
        * graph - the facade describing the graph to be operated on
        * vertices - the vertices for this hierarchy
        * ordered - whether or not the vertices are already ordered
        * deterministic - whether or not this layout should be deterministic on each
        * tightenToSource - whether or not to tighten vertices towards the sources
        * scanRanksFromSinks - Whether rank assignment is from the sinks or sources.
        * usage
        */
    class mxSwimlaneModel {
        constructor(layout: any, vertices: any, roots: any, parent: any, tightenToSource: any);
        /**
         * Creates all edges in the internal model
         *
         * Parameters:
         *
         * layout - Reference to the <mxHierarchicalLayout> algorithm.
         * vertices - Array of <mxCells> that represent the vertices whom are to
         * have an internal representation created.
         * internalVertices - The array of <mxGraphHierarchyNodes> to have their
         * information filled in using the real vertices.
         */
        createInternalCells(layout: any, vertices: any, internalVertices: any): void;
        /**
         * Basic determination of minimum layer ranking by working from from sources
         * or sinks and working through each node in the relevant edge direction.
         * Starting at the sinks is basically a longest path layering algorithm.
         */
        initialRank(): void;
        /**
         * Performs a depth first search on the internal hierarchy model. This dfs
         * extends the default version by keeping track of chains within groups.
         * Any cycles should be removed prior to running, but previously seen cells
         * are ignored.
         *
         * Parameters:
         *
         * parent - the parent internal node of the current internal node
         * root - the current internal node
         * connectingEdge - the internal edge connecting the internal node and the parent
         * internal node, if any
         * seen - a set of all nodes seen by this dfs
         * chainCount - the number of edges in the chain of vertices going through
         * the current swimlane
         */
        maxChainDfs(parent: any, root: any, connectingEdge: any, seen: any, chainCount: any): void;
        /**
         * Fixes the layer assignments to the values stored in the nodes. Also needs
         * to create dummy nodes for edges that cross layers.
         */
        fixRanks(): void;
        /**
         * A depth first search through the internal heirarchy model.
         *
         * Parameters:
         *
         * visitor - The visitor function pattern to be called for each node.
         * trackAncestors - Whether or not the search is to keep track all nodes
         * directly above this one in the search path.
         */
        visit(visitor: any, dfsRoots: any, trackAncestors: any, seenNodes: any): void;
        /**
         * Performs a depth first search on the internal hierarchy model
         *
         * Parameters:
         *
         * parent - the parent internal node of the current internal node
         * root - the current internal node
         * connectingEdge - the internal edge connecting the internal node and the parent
         * internal node, if any
         * visitor - the visitor pattern to be called for each node
         * seen - a set of all nodes seen by this dfs a set of all of the
         * ancestor node of the current node
         * layer - the layer on the dfs tree ( not the same as the model ranks )
         */
        dfs(parent: any, root: any, connectingEdge: any, visitor: any, seen: any, layer: any): void;
        /**
         * Performs a depth first search on the internal hierarchy model. This dfs
         * extends the default version by keeping track of cells ancestors, but it
         * should be only used when necessary because of it can be computationally
         * intensive for deep searches.
         *
         * Parameters:
         *
         * parent - the parent internal node of the current internal node
         * root - the current internal node
         * connectingEdge - the internal edge connecting the internal node and the parent
         * internal node, if any
         * visitor - the visitor pattern to be called for each node
         * seen - a set of all nodes seen by this dfs
         * ancestors - the parent hash code
         * childHash - the new hash code for this node
         * layer - the layer on the dfs tree ( not the same as the model ranks )
         */
        extendedDfs(parent: any, root: any, connectingEdge: any, visitor: any, seen: any, ancestors: any, childHash: any, layer: any): void;
    }
}