// Type definitions for mxgraph v3.8.0
// Project: https://github.com/jgraph/mxgraph
// Definitions by: Lars Gleim <https://github.com/lgleim>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped

export default MxGraphFactory

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 mxgraph

export namespace mxgraph {
  export var mxClient: {
    VERSION: string
    IS_IE: boolean
    IS_IE6: boolean
    IS_IE11: boolean
    IS_EDGE: boolean
    IS_QUIRKS: boolean
    IS_EM: boolean
    VML_PREFIX: string
    OFFICE_PREFIX: string
    IS_NS: boolean
    IS_OP: boolean
    IS_OT: boolean
    IS_SF: boolean
    IS_IOS: boolean
    IS_GC: boolean
    IS_CHROMEAPP: boolean
    IS_FF: boolean
    IS_MT: boolean
    IS_SVG: boolean
    NO_FO: boolean
    IS_VML: boolean
    IS_WIN: boolean
    IS_MAC: boolean
    IS_TOUCH: boolean
    IS_POINTER: boolean
    IS_LOCAL: boolean
    isBrowserSupported(): boolean
    link(rel: any, href: any, doc?: any): void
    include(src: any): void
    dispose(): void
    basePath: any
    imageBasePath: any
    language: any
    languages: any
    defaultLanguage: any
  }

  /**
   * Implements a generic shape which is based on a XML node as a description.
   *
   * shape:
   *
   * The outer element is *shape*, that has attributes:
   *
   * - "name", string, required. The stencil name that uniquely identifies the shape.
   * - "w" and "h" are optional decimal view bounds. This defines your co-ordinate
   * system for the graphics operations in the shape. The default is 100,100.
   * - "aspect", optional string. Either "variable", the default, or "fixed". Fixed
   * means always render the shape with the aspect ratio defined by the ratio w/h.
   * Variable causes the ratio to match that of the geometry of the current vertex.
   * - "strokewidth", optional string. Either an integer or the string "inherit".
   * "inherit" indicates that the strokeWidth of the cell is only changed on scaling,
   * not on resizing. Default is "1".
   * If numeric values are used, the strokeWidth of the cell is changed on both
   * scaling and resizing and the value defines the multiple that is applied to
   * the width.
   *
   * connections:
   *
   * If you want to define specific fixed connection points on the shape use the
   * *connections* element. Each *constraint* element within connections defines
   * a fixed connection point on the shape. Constraints have attributes:
   *
   * - "perimeter", required. 1 or 0. 0 sets the connection point where specified
   * by x,y. 1 Causes the position of the connection point to be extrapolated from
   * the center of the shape, through x,y to the point of intersection with the
   * perimeter of the shape.
   * - "x" and "y" are the position of the fixed point relative to the bounds of
   * the shape. They can be automatically adjusted if perimeter=1. So, (0,0) is top
   * left, (0.5,0.5) the center, (1,0.5) the center of the right hand edge of the
   * bounds, etc. Values may be less than 0 or greater than 1 to be positioned
   * outside of the shape.
   * - "name", optional string. A unique identifier for the port on the shape.
   *
   * background and foreground:
   *
   * The path of the graphics drawing is split into two elements, *foreground* and
   * *background*. The split is to define which part any shadow applied to the shape
   * is derived from (the background). This, generally, means the background is the
   * line tracing of the outside of the shape, but not always.
   *
   * Any stroke, fill or fillstroke of a background must be the first element of the
   * foreground element, they must not be used within *background*. If the background
   * is empty, this is not required.
   *
   * Because the background cannot have any fill or stroke, it can contain only one
   * *path*, *rect*, *roundrect* or *ellipse* element (or none). It can also not
   * include *image*, *text* or *include-shape*.
   *
   * Note that the state, styling and drawing in mxGraph stencils is very close in
   * design to that of HTML 5 canvas. Tutorials on this subject, if you're not
   * familiar with the topic, will give a good high-level introduction to the
   * concepts used.
   *
   * State:
   *
   * Rendering within the foreground and background elements has the concept of
   * state. There are two types of operations other than state save/load, styling
   * and drawing. The styling operations change the current state, so you can save
   * the current state with <save/> and pull the last saved state from the state
   * stack using <restore/>.
   *
   * Styling:
   *
   * The elements that change colors within the current state all take a hash
   * prefixed hex color code ("#FFEA80").
   *
   * - *strokecolor*, this sets the color that drawing paths will be rendered in
   * when a stroke or fillstroke command is issued.
   * - *fillcolor*, this sets the color that the inside of closed paths will be
   * rendered in when a fill or fillstroke command is issued.
   * - *fontcolor*, this sets the color that fonts are rendered in when text is drawn.
   *
   * *alpha* defines the degree of transparency used between 1.0 for fully opaque
   * and 0.0 for fully transparent.
   *
   * *strokewidth* defines the integer thickness of drawing elements rendered by
   * stroking. Use fixed="1" to apply the value as-is, without scaling.
   *
   * *dashed* is "1" for dashing enabled and "0" for disabled.
   *
   * When *dashed* is enabled the current dash pattern, defined by *dashpattern*,
   * is used on strokes. dashpattern is a sequence of space separated "on, off"
   * lengths that define what distance to paint the stroke for, then what distance
   * to paint nothing for, repeat... The default is "3 3". You could define a more
   * complex pattern with "5 3 2 6", for example. Generally, it makes sense to have
   * an even number of elements in the dashpattern, but that's not required.
   *
   * *linejoin*, *linecap* and *miterlimit* are best explained by the Mozilla page
   * on Canvas styling (about halfway down). The values are all the same except we
   * use "flat" for linecap, instead of Canvas' "butt".
   *
   * For font styling there are.
   *
   * - *fontsize*, an integer,
   * - *fontstyle*, an ORed bit pattern of bold (1), italic (2) and underline (4),
   * i.e bold underline is "5".
   * - *fontfamily*, is a string defining the typeface to be used.
   *
   * Drawing:
   *
   * Most drawing is contained within a *path* element. Again, the graphic
   * primitives are very similar to that of HTML 5 canvas.
   *
   * - *move* to attributes required decimals (x,y).
   * - *line* to attributes required decimals (x,y).
   * - *quad* to required decimals (x2,y2) via control point required decimals
   * (x1,y1).
   * - *curve* to required decimals (x3,y3), via control points required decimals
   * (x1,y1) and (x2,y2).
   * - *arc*, this doesn't follow the HTML Canvas signatures, instead it's a copy
   * of the SVG arc command. The SVG specification documentation gives the best
   * description of its behaviors. The attributes are named identically, they are
   * decimals and all required.
   * - *close* ends the current subpath and causes an automatic straight line to
   * be drawn from the current point to the initial point of the current subpath.
   *
   * Complex drawing:
   *
   * In addition to the graphics primitive operations there are non-primitive
   * operations. These provide an easy method to draw some basic shapes.
   *
   * - *rect*, attributes "x", "y", "w", "h", all required decimals
   * - *roundrect*, attributes "x", "y", "w", "h", all required decimals. Also
   * "arcsize" an optional decimal attribute defining how large, the corner curves
   * are.
   * - *ellipse*, attributes "x", "y", "w", "h", all required decimals.
   *
   * Note that these 3 shapes and all paths must be followed by either a fill,
   * stroke, or fillstroke.
   *
   * Text:
   *
   * *text* elements have the following attributes.
   *
   * - "str", the text string to display, required.
   * - "x" and "y", the decimal location (x,y) of the text element, required.
   * - "align", the horizontal alignment of the text element, either "left",
   * "center" or "right". Optional, default is "left".
   * - "valign", the vertical alignment of the text element, either "top", "middle"
   * or "bottom". Optional, default is "top".
   * - "localized", 0 or 1, if 1 then the "str" actually contains a key to use to
   * fetch the value out of mxResources. Optional, default is
   * <mxStencil.defaultLocalized>.
   * - "vertical", 0 or 1, if 1 the label is rendered vertically (rotated by 90
   * degrees). Optional, default is 0.
   * - "rotation", angle in degrees (0 to 360). The angle to rotate the text by.
   * Optional, default is 0.
   * - "align-shape", 0 or 1, if 0 ignore the rotation of the shape when setting
   * the text rotation. Optional, default is 1.
   *
   * If <allowEval> is true, then the text content of the this element can define
   * a function which is invoked with the shape as the only argument and returns
   * the value for the text element (ignored if the str attribute is not null).
   *
   * Images:
   *
   * *image* elements can either be external URLs, or data URIs, where supported
   * (not in IE 7-). Attributes are:
   *
   * - "src", required string. Either a data URI or URL.
   * - "x", "y", required decimals. The (x,y) position of the image.
   * - "w", "h", required decimals. The width and height of the image.
   * - "flipH" and "flipV", optional 0 or 1. Whether to flip the image along the
   * horizontal/vertical axis. Default is 0 for both.
   *
   * If <allowEval> is true, then the text content of the this element can define
   * a function which is invoked with the shape as the only argument and returns
   * the value for the image source (ignored if the src attribute is not null).
   *
   * Sub-shapes:
   *
   * *include-shape* allow stencils to be rendered within the current stencil by
   * referencing the sub-stencil by name. Attributes are:
   *
   * - "name", required string. The unique shape name of the stencil.
   * - "x", "y", "w", "h", required decimals. The (x,y) position of the sub-shape
   * and its width and height.
   */
  export 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
  }

  /**
   * Base class for all shapes. A shape in mxGraph is a
   * separate implementation for SVG, VML and HTML. Which
   * implementation to use is controlled by the <dialect>
   * property which is assigned from within the <mxCellRenderer>
   * when the shape is created. The dialect must be assigned
   * for a shape, and it does normally depend on the browser and
   * the confiuration of the graph (see <mxGraph> rendering hint).
   *
   * For each supported shape in SVG and VML, a corresponding
   * shape exists in mxGraph, namely for text, image, rectangle,
   * rhombus, ellipse and polyline. The other shapes are a
   * combination of these shapes (eg. label and swimlane)
   * or they consist of one or more (filled) path objects
   * (eg. actor and cylinder). The HTML implementation is
   * optional but may be required for a HTML-only view of
   * the graph.
   *
   * Custom Shapes:
   *
   * To extend from this class, the basic code looks as follows.
   * In the special case where the custom shape consists only of
   * one filled region or one filled region and an additional stroke
   * the <mxActor> and <mxCylinder> should be subclassed,
   * respectively.
   *
   * (code)
   * function CustomShape() { }
   *
   * CustomShape.prototype = new mxShape();
   * CustomShape.prototype.constructor = CustomShape;
   * (end)
   *
   * To register a custom shape in an existing graph instance,
   * one must register the shape under a new name in the graph's
   * cell renderer as follows:
   *
   * (code)
   * mxCellRenderer.registerShape('customShape', CustomShape);
   * (end)
   *
   * The second argument is the name of the constructor.
   *
   * In order to use the shape you can refer to the given name above
   * in a stylesheet. For example, to change the shape for the default
   * vertex style, the following code is used:
   *
   * (code)
   * var style = graph.getStylesheet().getDefaultVertexStyle();
   * style[mxConstants.STYLE_SHAPE] = 'customShape';
   * (end)
   */
  export class mxShape {
    constraints: 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: any, x: any, y: any, w: any, h: any): void
    /**
     * Hook for subclassers. This implementation is empty.
     */
    paintBackground(c: any, x: any, y: any, w: any, h: any): void
    /**
     * Hook for subclassers. This implementation is empty.
     */
    paintForeground(c: any, x: any, y: any, w: any, h: any): 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)
   */
  export var mxStencilRegistry: {
    stencils: {}
    addStencil(name: any, stencil: any): void
    getStencil(name: any): any
  }

  export 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>.
   */
  export class mxActor 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): 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>.
   */
  export 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>.
   */
  export 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: any, x: any, y: any, w: any, h: any): void
    /**
     * Generic background painting implementation.
     */
    paintForeground(c: any, x: any, y: any, w: any, h: any): 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>.
   */
  export 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>.
   */
  export class mxDoubleEllipse extends mxShape {
    constructor(bounds: any, fill: any, stroke: any, strokewidth: any)
    /**
     * Paints the background.
     */
    paintBackground(c: any, x: any, y: any, w: any, h: any): void
    /**
     * Paints the foreground.
     */
    paintForeground(c: any, x: any, y: any, w: any, h: any): 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>.
   */
  export 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>.
   */
  export 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>.
   */
  export 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>.
   */
  export 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;
   */
  export 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.
   */
  export 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.
   */
  export class mxHexagon extends mxActor {
    constructor()
    /**
     * Draws the path for this shape.
     */
    redrawPath(c: any, x: any, y: any, w: any, h: any): void
  }

  /**
   * 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>.
   */
  export class mxLine extends mxShape {
    constructor(bounds: any, stroke: any, strokewidth: any)
    /**
     * 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>.
   */
  export 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>.
   */
  export 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>.
   */
  export 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>.
   */
  export 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>.
   */
  export 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
  }

  export 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(): void
    warn(): void
    write(): void
    writeln(): void
  }

  export 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.
   */
  export class mxDictionary {
    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
  }

  export 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.
   */
  export 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.
   */
  export 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
  }

  export 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
  }

  export var mxUtils: {
    errorResource: 'error' | ''
    closeResource: 'close' | ''
    errorImage: string
    removeCursors: (element: HTMLElement) => void
    extend: (ctor: any, superCtor: any) => void
    getValue: (array: string[], key: string, defaultValue: any) => any

    // https://jgraph.github.io/mxgraph/docs/js-api/files/util/mxUtils-js.html#mxUtils.clone

    /**
     *
     * @param obj Object to be cloned.
     * @param transients Optional array of strings representing the fieldname to be ignored.
     * @param shallow Optional boolean argument to specify if a shallow clone should be created, that is, one where all object references are not cloned or, in other words, one where only atomic (strings, numbers) values are cloned.  Default is false.
     */
    clone: (obj: object, transients?: string[], shallow?: boolean) => void
    isAncestorNode: (ancestor: HTMLElement | any, child: HTMLElement | any) => boolean

    makeDraggable: (
      element: HTMLElement,
      graphF: any,
      funct: any,
      dragElement: HTMLElement,
      dx?: number | null,
      dy?: number | null,
      autoscroll?: boolean | null,
      scalePreview?: boolean,
      highlightDropTargets?: boolean,
      getDropTarget?: any
    ) => void
  }

  export var mxConstants: {
    DEFAULT_HOTSPOT: number
    MIN_HOTSPOT_SIZE: number
    MAX_HOTSPOT_SIZE: number
    RENDERING_HINT_EXACT: string
    RENDERING_HINT_FASTER: string
    RENDERING_HINT_FASTEST: string
    DIALECT_SVG: string
    DIALECT_VML: string
    DIALECT_MIXEDHTML: string
    DIALECT_PREFERHTML: string
    DIALECT_STRICTHTML: string
    NS_SVG: string
    NS_XHTML: string
    NS_XLINK: string
    SHADOWCOLOR: string
    VML_SHADOWCOLOR: string
    SHADOW_OFFSET_X: number
    SHADOW_OFFSET_Y: number
    SHADOW_OPACITY: number
    NODETYPE_ELEMENT: number
    NODETYPE_ATTRIBUTE: number
    NODETYPE_TEXT: number
    NODETYPE_CDATA: number
    NODETYPE_ENTITY_REFERENCE: number
    NODETYPE_ENTITY: number
    NODETYPE_PROCESSING_INSTRUCTION: number
    NODETYPE_COMMENT: number
    NODETYPE_DOCUMENT: number
    NODETYPE_DOCUMENTTYPE: number
    NODETYPE_DOCUMENT_FRAGMENT: number
    NODETYPE_NOTATION: number
    TOOLTIP_VERTICAL_OFFSET: number
    DEFAULT_VALID_COLOR: string
    DEFAULT_INVALID_COLOR: string
    OUTLINE_HIGHLIGHT_COLOR: string
    OUTLINE_HIGHLIGHT_STROKEWIDTH: number
    HIGHLIGHT_STROKEWIDTH: number
    HIGHLIGHT_SIZE: number
    HIGHLIGHT_OPACITY: number
    CURSOR_MOVABLE_VERTEX: string
    CURSOR_MOVABLE_EDGE: string
    CURSOR_LABEL_HANDLE: string
    CURSOR_TERMINAL_HANDLE: string
    CURSOR_BEND_HANDLE: string
    CURSOR_VIRTUAL_BEND_HANDLE: string
    CURSOR_CONNECT: string
    HIGHLIGHT_COLOR: string
    CONNECT_TARGET_COLOR: string
    INVALID_CONNECT_TARGET_COLOR: string
    DROP_TARGET_COLOR: string
    VALID_COLOR: string
    INVALID_COLOR: string
    EDGE_SELECTION_COLOR: string
    VERTEX_SELECTION_COLOR: string
    VERTEX_SELECTION_STROKEWIDTH: number
    EDGE_SELECTION_STROKEWIDTH: number
    VERTEX_SELECTION_DASHED: boolean
    EDGE_SELECTION_DASHED: boolean
    GUIDE_COLOR: string
    GUIDE_STROKEWIDTH: number
    OUTLINE_COLOR: string
    OUTLINE_STROKEWIDTH: number
    HANDLE_SIZE: number
    LABEL_HANDLE_SIZE: number
    HANDLE_FILLCOLOR: string
    HANDLE_STROKECOLOR: string
    LABEL_HANDLE_FILLCOLOR: string
    CONNECT_HANDLE_FILLCOLOR: string
    LOCKED_HANDLE_FILLCOLOR: string
    OUTLINE_HANDLE_FILLCOLOR: string
    OUTLINE_HANDLE_STROKECOLOR: string
    DEFAULT_FONTFAMILY: string
    DEFAULT_FONTSIZE: number
    DEFAULT_TEXT_DIRECTION: string
    LINE_HEIGHT: number
    WORD_WRAP: string
    ABSOLUTE_LINE_HEIGHT: boolean
    DEFAULT_FONTSTYLE: number
    DEFAULT_STARTSIZE: number
    DEFAULT_MARKERSIZE: number
    DEFAULT_IMAGESIZE: number
    ENTITY_SEGMENT: number
    RECTANGLE_ROUNDING_FACTOR: number
    LINE_ARCSIZE: number
    ARROW_SPACING: number
    ARROW_WIDTH: number
    ARROW_SIZE: number
    PAGE_FORMAT_A4_PORTRAIT: mxRectangle
    PAGE_FORMAT_A4_LANDSCAPE: mxRectangle
    PAGE_FORMAT_LETTER_PORTRAIT: mxRectangle
    PAGE_FORMAT_LETTER_LANDSCAPE: mxRectangle
    NONE: string
    STYLE_PERIMETER: string
    STYLE_SOURCE_PORT: string
    STYLE_TARGET_PORT: string
    STYLE_PORT_CONSTRAINT: string
    STYLE_PORT_CONSTRAINT_ROTATION: string
    STYLE_SOURCE_PORT_CONSTRAINT: string
    STYLE_TARGET_PORT_CONSTRAINT: string
    STYLE_OPACITY: string
    STYLE_FILL_OPACITY: string
    STYLE_STROKE_OPACITY: string
    STYLE_TEXT_OPACITY: string
    STYLE_TEXT_DIRECTION: string
    STYLE_OVERFLOW: string
    STYLE_ORTHOGONAL: string
    STYLE_EXIT_X: string
    STYLE_EXIT_Y: string
    STYLE_EXIT_PERIMETER: string
    STYLE_ENTRY_X: string
    STYLE_ENTRY_Y: string
    STYLE_ENTRY_PERIMETER: string
    STYLE_WHITE_SPACE: string
    STYLE_ROTATION: string
    STYLE_FILLCOLOR: string
    STYLE_POINTER_EVENTS: string
    STYLE_SWIMLANE_FILLCOLOR: string
    STYLE_MARGIN: string
    STYLE_GRADIENTCOLOR: string
    STYLE_GRADIENT_DIRECTION: string
    STYLE_STROKECOLOR: string
    STYLE_SEPARATORCOLOR: string
    STYLE_STROKEWIDTH: string
    STYLE_ALIGN: string
    STYLE_VERTICAL_ALIGN: string
    STYLE_LABEL_WIDTH: string
    STYLE_LABEL_POSITION: string
    STYLE_VERTICAL_LABEL_POSITION: string
    STYLE_IMAGE_ASPECT: string
    STYLE_IMAGE_ALIGN: string
    STYLE_IMAGE_VERTICAL_ALIGN: string
    STYLE_GLASS: string
    STYLE_IMAGE: string
    STYLE_IMAGE_WIDTH: string
    STYLE_IMAGE_HEIGHT: string
    STYLE_IMAGE_BACKGROUND: string
    STYLE_IMAGE_BORDER: string
    STYLE_FLIPH: string
    STYLE_FLIPV: string
    STYLE_NOLABEL: string
    STYLE_NOEDGESTYLE: string
    STYLE_LABEL_BACKGROUNDCOLOR: string
    STYLE_LABEL_BORDERCOLOR: string
    STYLE_LABEL_PADDING: string
    STYLE_INDICATOR_SHAPE: string
    STYLE_INDICATOR_IMAGE: string
    STYLE_INDICATOR_COLOR: string
    STYLE_INDICATOR_STROKECOLOR: string
    STYLE_INDICATOR_GRADIENTCOLOR: string
    STYLE_INDICATOR_SPACING: string
    STYLE_INDICATOR_WIDTH: string
    STYLE_INDICATOR_HEIGHT: string
    STYLE_INDICATOR_DIRECTION: string
    STYLE_SHADOW: string
    STYLE_SEGMENT: string
    STYLE_ENDARROW: string
    STYLE_STARTARROW: string
    STYLE_ENDSIZE: string
    STYLE_STARTSIZE: string
    STYLE_SWIMLANE_LINE: string
    STYLE_ENDFILL: string
    STYLE_STARTFILL: string
    STYLE_DASHED: string
    STYLE_DASH_PATTERN: string
    STYLE_FIX_DASH: string
    STYLE_ROUNDED: string
    STYLE_CURVED: string
    STYLE_ARCSIZE: string
    STYLE_ABSOLUTE_ARCSIZE: string
    STYLE_SOURCE_PERIMETER_SPACING: string
    STYLE_TARGET_PERIMETER_SPACING: string
    STYLE_PERIMETER_SPACING: string
    STYLE_SPACING: string
    STYLE_SPACING_TOP: string
    STYLE_SPACING_LEFT: string
    STYLE_SPACING_BOTTOM: string
    STYLE_SPACING_RIGHT: string
    STYLE_HORIZONTAL: string
    STYLE_DIRECTION: string
    STYLE_ELBOW: string
    STYLE_FONTCOLOR: string
    STYLE_FONTFAMILY: string
    STYLE_FONTSIZE: string
    STYLE_FONTSTYLE: string
    STYLE_ASPECT: string
    STYLE_AUTOSIZE: string
    STYLE_FOLDABLE: string
    STYLE_EDITABLE: string
    STYLE_BENDABLE: string
    STYLE_MOVABLE: string
    STYLE_RESIZABLE: string
    STYLE_RESIZE_WIDTH: string
    STYLE_RESIZE_HEIGHT: string
    STYLE_ROTATABLE: string
    STYLE_CLONEABLE: string
    STYLE_DELETABLE: string
    STYLE_SHAPE: string
    STYLE_EDGE: string
    STYLE_JETTY_SIZE: string
    STYLE_SOURCE_JETTY_SIZE: string
    STYLE_TARGET_JETTY_SIZE: string
    STYLE_LOOP: string
    STYLE_ORTHOGONAL_LOOP: string
    STYLE_ROUTING_CENTER_X: string
    STYLE_ROUTING_CENTER_Y: string
    FONT_BOLD: number
    FONT_ITALIC: number
    FONT_UNDERLINE: number
    SHAPE_RECTANGLE: string
    SHAPE_ELLIPSE: string
    SHAPE_DOUBLE_ELLIPSE: string
    SHAPE_RHOMBUS: string
    SHAPE_LINE: string
    SHAPE_IMAGE: string
    SHAPE_ARROW: string
    SHAPE_ARROW_CONNECTOR: string
    SHAPE_LABEL: string
    SHAPE_CYLINDER: string
    SHAPE_SWIMLANE: string
    SHAPE_CONNECTOR: string
    SHAPE_ACTOR: string
    SHAPE_CLOUD: string
    SHAPE_TRIANGLE: string
    SHAPE_HEXAGON: string
    ARROW_CLASSIC: string
    ARROW_CLASSIC_THIN: string
    ARROW_BLOCK: string
    ARROW_BLOCK_THIN: string
    ARROW_OPEN: string
    ARROW_OPEN_THIN: string
    ARROW_OVAL: string
    ARROW_DIAMOND: string
    ARROW_DIAMOND_THIN: string
    ALIGN_LEFT: string
    ALIGN_CENTER: string
    ALIGN_RIGHT: string
    ALIGN_TOP: string
    ALIGN_MIDDLE: string
    ALIGN_BOTTOM: string
    DIRECTION_NORTH: string
    DIRECTION_SOUTH: string
    DIRECTION_EAST: string
    DIRECTION_WEST: string
    TEXT_DIRECTION_DEFAULT: string
    TEXT_DIRECTION_AUTO: string
    TEXT_DIRECTION_LTR: string
    TEXT_DIRECTION_RTL: string
    DIRECTION_MASK_NONE: number
    DIRECTION_MASK_WEST: number
    DIRECTION_MASK_NORTH: number
    DIRECTION_MASK_SOUTH: number
    DIRECTION_MASK_EAST: number
    DIRECTION_MASK_ALL: number
    ELBOW_VERTICAL: string
    ELBOW_HORIZONTAL: string
    EDGESTYLE_ELBOW: string
    EDGESTYLE_ENTITY_RELATION: string
    EDGESTYLE_LOOP: string
    EDGESTYLE_SIDETOSIDE: string
    EDGESTYLE_TOPTOBOTTOM: string
    EDGESTYLE_ORTHOGONAL: string
    EDGESTYLE_SEGMENT: string
    PERIMETER_ELLIPSE: string
    PERIMETER_RECTANGLE: string
    PERIMETER_RHOMBUS: string
    PERIMETER_HEXAGON: string
    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
   */
  export 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.
   *
   */
  export 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() { };
   *
   * MyClass.prototype = new mxEventSource();
   * MyClass.prototype.constructor = MyClass;
   * (end)
   *
   * Known Subclasses:
   *
   * <mxGraphModel>, <mxGraph>, <mxGraphView>, <mxEditor>, <mxCellOverlay>,
   * <mxToolbar>, <mxWindow>
   */
  export 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: (sender: mxGraph, evt: mxEventObject) => void): 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
  }

  export var mxEvent: {
    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: any, target: any): 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: any): any
    getClientY(e: any): any
    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.
   */
  export 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
  }

  export 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.
   */
  export class mxWindow extends mxEventSource {
    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(): any
    /**
     * 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.
   */
  export 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.
   */
  export 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.
   */
  export 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.
   */
  export class mxDragSource {
    constructor(element: any, dropHandler: any)
    /**
     * Returns <enabled>.
     */
    isEnabled(): any
    /**
     * Sets <enabled>.
     */
    setEnabled(value: any): void
    /**
     * Returns <guidesEnabled>.
     */
    isGuidesEnabled(): any
    /**
     * 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.
   */
  export 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.
   */
  export 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.
   */
  export class mxUndoManager extends mxEventSource {
    /**
     * Maximum command history size.  0 means unlimited history.  Default is 100.
     */
    size: number

    /**
     * Array that contains the steps of the command history.
     */
    history: any[]

    /**
     * Index of the element to be added next.
     */
    indexOfNextAdd: number

    /**
     *  If no history size is given, then a default size of 100 steps is used.
     */
    constructor(size?: any)

    /**
     * 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.
   */
  export 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.
   */
  export 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>.
   */
  export class mxPopupMenu extends mxEventSource {
    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: any, 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.
   */
  export 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>.
   */
  export 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>.
   */
  export 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.
   */
  export 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 instance to be used with an export 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('export', 'format=png&w=' + w +
   * 		'&h=' + h + '&bg=#F9F7ED&xml=' + encodeURIComponent(xml))
   * 		.simulate(document, '_blank');
   * (end)
   *
   * Constructor: mxImageExport
   *
   * Constructs a new image export.
   */
  export 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.
   */
  export class mxAbstractCanvas2D {
    constructor()
    /**
     * 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.
   */
  export 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.
   */
  export 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 export.
     */
    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.
   */
  export 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.
   */
  export 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
   */
  export class mxGraphLayout {
    constructor(graph: any)
    /**
     * 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
    /**
     * 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.
   */
  export class mxStackLayout extends mxGraphLayout {
    /**
     * Variable: horizontal
     *
     * Specifies the orientation of the layout. Default is true.
     */
    horizontal: boolean

    /**
     * Variable: spacing
     *
     * Specifies the spacing between the cells. Default is 0.
     */
    spacing: number
    /**
     * Variable: x0
     *
     * Specifies the horizontal origin of the layout. Default is 0.
     */
    x0: number
    /**
     * Variable: y0
     *
     * Specifies the vertical origin of the layout. Default is 0.
     */
    y0: number
    /**
     * Variable: border
     *
     * Border to be added if fill is true. Default is 0.
     */
    border: number
    /**
     * Variable: marginTop
     *
     * Top margin for the child area. Default is 0.
     */
    marginTop: number
    /**
     * Variable: marginLeft
     *
     * Left margin for the child area. Default is 0.
     */
    marginLeft: number
    /**
     * Variable: marginRight
     *
     * Right margin for the child area. Default is 0.
     */
    marginRight: number
    /**
     * Variable: marginBottom
     *
     * Bottom margin for the child area. Default is 0.
     */
    marginBottom: number
    /**
     * Variable: keepFirstLocation
     *
     * Boolean indicating if the location of the first cell should be
     * kept, that is, it will not be moved to x0 or y0.
     */
    keeoFirstLocation: boolean
    /**
     * Variable: fill
     *
     * Boolean indicating if dimension should be changed to fill out the parent
     * cell. Default is false.
     */
    fill: boolean
    /**
     * Variable: resizeParent
     *
     * If the parent should be resized to match the width/height of the
     * stack. Default is false.
     */
    resizeParent: boolean
    /**
     * Variable: resizeParentMax
     *
     * Use maximum of existing value and new value for resize of parent.
     * Default is false.
     */
    resizeParentMax: boolean
    /**
     * Variable: resizeLast
     *
     * If the last element should be resized to fill out the parent. Default is
     * false. If <resizeParent> is true then this is ignored.
     */
    resizeLast: boolean
    /**
     * Variable: wrap
     *
     * Value at which a new column or row should be created. Default is null.
     */
    wrap: boolean
    /**
     * Variable: borderCollapse
     *
     * If the strokeWidth should be ignored. Default is true.
     */
    borderCollapse: boolean
    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.
   */
  export 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
  }

  /**
   * 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.
   */
  export class mxCompactTreeLayout extends mxGraphLayout {
    /**
     * Variable: horizontal
     *
     * Specifies the orientation of the layout. Default is true.
     */
    horizontal: boolean

    /**
     * Variable: invert
     *
     * Specifies if edge directions should be inverted. Default is false.
     */
    invert: boolean

    /**
     * Variable: resizeParent
     *
     * If the parents should be resized to match the width/height of the
     * children. Default is true.
     */
    resizeParent: 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

    /**
     * Variable: groupPadding
     *
     * Padding added to resized parents. Default is 10.
     */
    groupPadding: number

    /**
     * Variable: groupPaddingTop
     *
     * Top padding added to resized parents. Default is 0.
     */
    groupPaddingTop: number

    /**
     * Variable: groupPaddingRight
     *
     * Right padding added to resized parents. Default is 0.
     */
    groupPaddingRight: number

    /**
     * Variable: groupPaddingBottom
     *
     * Bottom padding added to resized parents. Default is 0.
     */
    groupPaddingBottom: number

    /**
     * Variable: groupPaddingLeft
     *
     * Left padding added to resized parents. Default is 0.
     */
    groupPaddingLeft: number

    /**
     * Variable: parentsChanged
     *
     * A set of the parents that need updating based on children
     * process as part of the layout.
     */
    parentsChanged: any

    /**
     * Variable: moveTree
     *
     * Specifies if the tree should be moved to the top, left corner
     * if it is inside a top-level layer. Default is false.
     */
    moveTree: boolean

    /**
     * Variable: visited
     *
     * Specifies if the tree should be moved to the top, left corner
     * if it is inside a top-level layer. Default is false.
     */
    visited: any

    /**
     * Variable: levelDistance
     *
     * Holds the levelDistance. Default is 10.
     */
    levelDistance: number

    /**
     * Variable: nodeDistance
     *
     * Holds the nodeDistance. Default is 20.
     */
    nodeDistance: number

    /**
     * Variable: resetEdges
     *
     * Specifies if all edge points of traversed edges should be removed.
     * Default is true.
     */
    resetEdges: boolean

    /**
     * Variable: prefHozEdgeSep
     *
     * The preferred horizontal distance between edges exiting a vertex.
     */
    prefHozEdgeSep: number

    /**
     * Variable: prefVertEdgeOff
     *
     * The preferred vertical offset between edges exiting a vertex.
     */
    prefVertEdgeOff: number

    /**
     * Variable: minEdgeJetty
     *
     * The minimum distance for an edge jetty from a vertex.
     */
    minEdgeJetty: number

    /**
     * Variable: channelBuffer
     *
     * The size of the vertical buffer in the center of inter-rank channels
     * where edge control points should not be placed.
     */
    channelBuffer: number

    /**
     * Variable: edgeRouting
     *
     * Whether or not to apply the internal tree edge routing.
     */
    edgeRouting: boolean

    /**
     * Variable: sortEdges
     *
     * Specifies if edges should be sorted according to the order of their
     * opposite terminal cell in the model.
     */
    sortEdges: boolean

    /**
     * Variable: alignRanks
     *
     * Whether or not the tops of cells in each rank should be aligned
     * across the rank
     */
    alignRanks: boolean

    /**
     * Variable: maxRankHeight
     *
     * An array of the maximum height of cells (relative to the layout direction)
     * per rank
     */
    maxRankHeight: any

    /**
     * Variable: root
     *
     * The cell to use as the root of the tree
     */
    root: any

    /**
     * Variable: node
     *
     * The internal node representation of the root cell. Do not set directly
     * , this value is only exposed to assist with post-processing functionality
     */
    node: any

    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.
   */
  export 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
   */
  export 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
   * var layout = new mxFastOrganicLayout(graph);
   * layout.execute(graph.getDefaultParent());
   */
  export class mxFastOrganicLayout extends mxGraphLayout {
    /**
     * Specifies if the top left corner of the input cells should be the origin
     * of the layout result. Default is true.
     */
    useInputOrigin: boolean

    /**
     * Specifies if all edge points of traversed edges should be removed.
     * Default is true.
     */
    resetEdges: boolean

    /**
     * Specifies if the STYLE_NOEDGESTYLE flag should be set on edges that are
     * modified by the result. Default is true.
     */
    disableEdgeStyle: boolean

    /**
     * The force constant by which the attractive forces are divided and the
     * replusive forces are multiple by the square of. The value equates to the
     * average radius there is of free space around each node. Default is 50.
     */
    forceConstant: number
    /**
     * Cache of <forceConstant>^2 for performance.
     */
    forceConstantSquared: number

    /**
     * Minimal distance limit. Default is 2. Prevents of
     * dividing by zero.
     */
    minDistanceLimit: number

    /**
     * Minimal distance limit. Default is 2. Prevents of
     * dividing by zero.
     */
    maxDistanceLimit: number

    /**
     * Cached version of <minDistanceLimit> squared.
     */
    minDistanceLimitSquared: number

    /**
     * Start value of temperature. Default is 200.
     */
    initialTemp: number

    /**
     * Temperature to limit displacement at later stages of layout.
     */
    temperature: number

    /**
     * Total number of iterations to run the layout though.
     */
    maxIterations: number

    /**
     * Current iteration count.
     */
    iteration: number

    /**
     * An array of all vertices to be laid out.
     */
    vertexArray: any

    /**
     * An array of locally stored X co-ordinate displacements for the vertices.
     */
    dispX: any

    /**
     * An array of locally stored Y co-ordinate displacements for the vertices.
     */
    dispY: any

    /**
     * An array of locally stored co-ordinate positions for the vertices.
     */
    cellLocation: any

    /**
     * The approximate radius of each cell, nodes only.
     */
    radius: any

    /**
     * The approximate radius squared of each cell, nodes only.
     */
    radiusSquared: any

    /**
     * Array of booleans representing the movable states of the vertices.
     */
    isMoveable: any

    /**
     * Local copy of cell neighbours.
     */
    neighbours: any

    /**
     * Hashtable from cells to local indices.
     */
    indices: any

    /**
     * Boolean flag that specifies if the layout is allowed to run. If this is
     * set to false, then the layout exits in the following iteration.
     */
    allowedToRun: boolean

    /**
     * Constructs a new fast organic layout for the specified graph.
     */
    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.
   */
  export 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.
   */
  export 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.
   */
  export 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.
   */
  export 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
  }

  /**
   * 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.
   */
  export class mxGraphModel extends mxEventSource {
    /**
     * 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: any
    /**
     * Maps from Ids to cells.
     */
    cells: any
    /**
     * Specifies if edges should automatically be moved into the nearest common
     * ancestor of their terminals. Default is true.
     */
    maintainEdgeParent: boolean
    /**
     * Specifies if relative edge parents should be ignored for finding the nearest
     * common ancestors of an edge's terminals. Default is true.
     */
    ignoreRelativeEdgeParent: boolean
    /**
     * Specifies if the model should automatically create Ids for new cells.
     * Default is true.
     */
    createIds: boolean
    /**
     * Defines the prefix of new Ids. Default is an empty string.
     */
    prefix: string
    /**
     * Defines the postfix of new Ids. Default is an empty string.
     */
    postfix: string
    /**
     * Specifies the next Id to be created. Initial value is 0.
     */
    nextId: number
    /**
     * 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
    /**
     * 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
    /**
     * True if the program flow is currently inside endUpdate.
     */
    endingUpdate: boolean
    constructor(root?: any)
    /**
     * Sets a new root using <createRoot>.
     */
    clear(): void
    /**
     * Returns <createIds>.
     */
    isCreateIds(): boolean
    /**
     * Sets <createIds>.
     */
    setCreateIds(value: any): void
    /**
     * Creates a new root cell with a default layer (child 0).
     */
    createRoot(): mxCell
    /**
     * Returns the <mxCell> for the specified Id or null if no cell can be
     * found for the given Id.
     *
     * @param id - A string representing the Id of the cell.
     */
    getCell(id: string): mxCell
    /**
     * Returns the cells from the given array where the given filter function
     * returns true.
     */
    filterCells(cells: mxCell[], filter: (cell: mxCell) => boolean): mxCell[]
    /**
     * Returns all descendants of the given cell and the cell itself in an array.
     *
     * @param parent - <mxCell> whose descendants should be returned.
     */
    getDescendants(parent: mxCell): mxCell[]
    /**
     * 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>.
     *
     * The following example extracts all vertices from a given model:
     * @example
     * var filter = function(cell)
     * {
     * 	return model.isVertex(cell);
     * }
     * var vertices = model.filterDescendants(filter);
     *
     * @param filter - JavaScript function that takes an <mxCell> as an argument
     * and returns a boolean.
     * @param parent - Optional <mxCell> that is used as the root of the recursion.
     */
    filterDescendants(
      filter: (cell: mxCell) => boolean,
      parent?: mxCell
    ): mxCell[]
    /**
     * Returns the root of the model or the topmost parent of the given cell.
     *
     * @param cell - Optional <mxCell> that specifies the child.
     */
    getRoot(cell?: mxCell): mxCell
    /**
     * 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
     * var root = new mxCell();
     * root.insert(new mxCell());
     * model.setRoot(root);
     *
     * @param root - <mxCell> that specifies the new root.
     */
    setRoot(root: mxCell): mxCell
    /**
     * Inner callback to change the root of the model and update the internal
     * datastructures, such as <cells> and <nextId>. Returns the previous root.
     *
     * @param root - <mxCell> that specifies the new root.
     */
    rootChanged(root: mxCell): mxCell
    /**
     * Returns true if the given cell is the root of the model and a non-null
     * value.
     *
     * @param cell - <mxCell> that represents the possible root.
     */
    isRoot(cell: mxCell): boolean
    /**
     * Returns true if <isRoot> returns true for the parent of the given cell.
     *
     * @param cell - <mxCell> that represents the possible layer.
     */
    isLayer(cell: mxCell): boolean
    /**
     * Returns true if the given parent is an ancestor of the given child.
     *
     * @param parent - <mxCell> that specifies the parent.
     * @param child - <mxCell> that specifies the child.
     */
    isAncestor(parent: mxCell, child: mxCell): boolean
    /**
     * Returns true if the model contains the given <mxCell>.
     *
     * @param cell - <mxCell> that specifies the cell.
     */
    contains(cell: mxCell): boolean
    /**
     * Returns the parent of the given cell.
     *
     * @param cell - <mxCell> whose parent should be returned.
     */
    getParent(cell: mxCell): mxCell
    /**
     * 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.
     *
     * @param parent - <mxCell> that specifies the parent to contain the child.
     * @param child - <mxCell> that specifies the child to be inserted.
     * @param index - Optional integer that specifies the index of the child.
     */
    add(parent: mxCell, child: mxCell, index?: number): mxCell
    /**
     * 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.
     *
     * @param cell - <mxCell> that specifies the cell that has been added.
     */
    cellAdded(cell: mxCell): void
    /**
     * 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.
     *
     * @param cell - <mxCell> to create the Id for.
     */
    createId(cell: mxCell): string
    /**
     * Updates the parent for all edges that are connected to cell or one of
     * its descendants using <updateEdgeParent>.
     */
    updateEdgeParents(cell: mxCell, root?: mxCell): void
    /**
     * Returns the absolute, accumulated origin for the children inside the
     * given parent as an <mxPoint>.
     */
    getOrigin(cell: mxCell): mxPoint
    /**
     * Returns the nearest common ancestor for the specified cells.
     *
     * @param cell1 - <mxCell> that specifies the first cell in the tree.
     * @param cell2 - <mxCell> that specifies the second cell in the tree.
     */
    getNearestCommonAncestor(cell1: mxCell, cell2: mxCell): mxCell
    /**
     * 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.
     *
     * @param cell - <mxCell> that should be removed.
     */
    remove(cell: mxCell): mxCell
    /**
     * Inner callback to update <cells> when a cell has been removed.
     *
     * @param cell - <mxCell> that specifies the cell that has been removed.
     */
    cellRemoved(cell: mxCell): void
    /**
     * Inner callback to update the parent of a cell using <mxCell.insert>
     * on the parent and return the previous parent.
     *
     * @param cell - <mxCell> to update the parent for.
     * @param parent - <mxCell> that specifies the new parent of the cell.
     * @param index - Optional integer that defines the index of the child
     * in the parent's child array.
     */
    parentForCellChanged(cell: mxCell, parent: mxCell, index?: number): mxCell
    /**
     * Returns the number of children in the given cell.
     *
     * @param cell - <mxCell> whose number of children should be returned.
     */
    getChildCount(cell: mxCell): number
    /**
     * Returns the child of the given <mxCell> at the given index.
     *
     * @param cell - <mxCell> that represents the parent.
     * @param index - Integer that specifies the index of the child to be returned.
     */
    getChildAt(cell: mxCell, index: number): mxCell
    /**
     * Returns all children of the given <mxCell> as an array of <mxCells>. The
     * return value should be only be read.
     *
     * @param cell - <mxCell> the represents the parent.
     */
    getChildren(cell: mxCell): mxCell[]
    /**
     * Returns the child vertices of the given parent.
     *
     * @param cell - <mxCell> whose child vertices should be returned.
     */
    getChildVertices(parent: mxCell): mxCell[]
    /**
     * Returns the child edges of the given parent.
     *
     * @param cell - <mxCell> whose child edges should be returned.
     */
    getChildEdges(parent: mxCell): mxCell[]
    /**
     * Returns the children of the given cell that are vertices and/or edges
     * depending on the arguments.
     *
     * @param cell - <mxCell> the represents the parent.
     * @param vertices - Boolean indicating if child vertices should be returned.
     * Default is false.
     * @param edges - Boolean indicating if child edges should be returned.
     * Default is false.
     */
    getChildCells(
      parent: mxCell,
      vertices?: boolean,
      edges?: boolean
    ): mxCell[]
    /**
     * Returns the source or target <mxCell> of the given edge depending on the
     * value of the boolean parameter.
     *
     * @param edge - <mxCell> that specifies the edge.
     * @param isSource - Boolean indicating which end of the edge should be returned.
     */
    getTerminal(edge: mxCell, isSource: boolean): mxCell
    /**
     * 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.
     *
     * @param edge - <mxCell> that specifies the edge.
     * @param terminal - <mxCell> that specifies the new terminal.
     * @param isSource - Boolean indicating if the terminal is the new source or
     * target terminal of the edge.
     */
    setTerminal(edge: mxCell, terminal: mxCell, isSource: boolean): mxCell
    /**
     * Sets the source and target <mxCell> of the given <mxCell> in a single
     * transaction using <setTerminal> for each end of the edge.
     *
     * @param edge - <mxCell> that specifies the edge.
     * @param source - <mxCell> that specifies the new source terminal.
     * @param target - <mxCell> that specifies the new target terminal.
     */
    setTerminals(edge: mxCell, source: mxCell, target: mxCell): void
    /**
     * Inner helper function to update the terminal of the edge using
     * <mxCell.insertEdge> and return the previous terminal.
     *
     * @param edge - <mxCell> that specifies the edge to be updated.
     * @param terminal - <mxCell> that specifies the new terminal.
     * @param isSource - Boolean indicating if the terminal is the new source or
     * target terminal of the edge.
     */
    terminalForCellChanged(
      edge: mxCell,
      terminal: mxCell,
      isSource: boolean
    ): mxCell
    /**
     * Returns the number of distinct edges connected to the given cell.
     *
     * @param cell - <mxCell> that represents the vertex.
     */
    getEdgeCount(cell: mxCell): number
    /**
     * Returns the edge of cell at the given index.
     *
     * @param cell - <mxCell> that specifies the vertex.
     * @param index - Integer that specifies the index of the edge
     * to return.
     */
    getEdgeAt(cell: mxCell, index: number): mxCell
    /**
     * Returns the number of incoming or outgoing edges, ignoring the given
     * edge.
     *
     * @param cell - <mxCell> whose edge count should be returned.
     * @param outgoing - Boolean that specifies if the number of outgoing or
     * incoming edges should be returned.
     * @param ignoredEdge - <mxCell> that represents an edge to be ignored.
     */
    getDirectedEdgeCount(
      cell: mxCell,
      outgoing: boolean,
      ignoredEdge?: mxCell
    ): number
    /**
     * Returns all edges of the given cell without loops.
     *
     * @param cell - <mxCell> whose edges should be returned.
     */
    getConnections(cell: mxCell): mxCell[]
    /**
     * Returns the incoming edges of the given cell without loops.
     *
     * @param cell - <mxCell> whose incoming edges should be returned.
     */
    getIncomingEdges(cell: mxCell): mxCell[]
    /**
     * Returns the outgoing edges of the given cell without loops.
     *
     * @param cell - <mxCell> whose outgoing edges should be returned.
     */
    getOutgoingEdges(cell: mxCell): mxCell[]
    /**
     * 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.
     *
     * @param cell - <mxCell> that specifies the cell.
     * @param incoming - Optional boolean that specifies if incoming edges should be
     * returned. Default is true.
     * @param outgoing - Optional boolean that specifies if outgoing edges should be
     * returned. Default is true.
     * @param includeLoops - Optional boolean that specifies if loops should be returned.
     * Default is true.
     */
    getEdges(
      cell: mxCell,
      incoming?: boolean,
      outgoing?: boolean,
      includeLoops?: boolean
    ): mxCell[]
    /**
     * 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.
     *
     * @param source - <mxCell> that defines the source terminal of the edge to be
     * returned.
     * @param target - <mxCell> that defines the target terminal of the edge to be
     * returned.
     * @param 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[]
    /**
     * 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>.
     *
     * @param edges - Array of <mxCells> that contain the edges to be examined.
     * @param terminal - <mxCell> that specifies the known end of the edges.
     * @param sources - Boolean that specifies if source terminals should be contained
     * in the result. Default is true.
     * @param 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[]
    /**
     * 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.
     *
     * @param cells - Array of <mxCells> whose topmost ancestors should be returned.
     */
    getTopmostCells(cells: mxCell[]): mxCell[]
    /**
     * Returns true if the given cell is a vertex.
     *
     * @param cell - <mxCell> that represents the possible vertex.
     */
    isVertex(cell: mxCell): boolean
    /**
     * Returns true if the given cell is an edge.
     *
     * @param cell - <mxCell> that represents the possible edge.
     */
    isEdge(cell: mxCell): boolean
    /**
     * 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>.
     *
     * @param cell - <mxCell> whose connectable state should be returned.
     */
    isConnectable(cell: mxCell): boolean
    /**
     * Returns the user object of the given <mxCell> using <mxCell.getValue>.
     *
     * @param cell - <mxCell> whose user object should be returned.
     */
    getValue(cell: mxCell): Value
    /**
     * Sets the user object of then given <mxCell> using <mxValueChange>
     * and adds the change to the current transaction.
     *
     * @param cell - <mxCell> whose user object should be changed.
     * @param value - Object that defines the new user object.
     */
    setValue(cell: mxCell, value: Object): Object
    /**
     * Returns the <mxGeometry> of the given <mxCell>.
     *
     * @param cell - <mxCell> whose geometry should be returned.
     */
    getGeometry(cell: mxCell): mxGeometry
    /**
     * 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.
     *
     * @param cell - <mxCell> whose geometry should be changed.
     * @param geometry - <mxGeometry> that defines the new geometry.
     */
    setGeometry(cell: mxCell, geometry: mxGeometry): mxGeometry
    /**
     * Returns the style of the given <mxCell>.
     *
     * @param cell - <mxCell> whose style should be returned.
     */
    getStyle(cell: mxCell): string
    /**
     * Sets the style of the given <mxCell> using <mxStyleChange> and
     * adds the change to the current transaction.
     *
     * @param cell - <mxCell> whose style should be changed.
     * @param style - String of the form [stylename;|key=value;] to specify
     * the new cell style.
     */
    setStyle(cell: mxCell, style: string): string
    /**
     * Inner callback to update the style of the given <mxCell>
     * using <mxCell.setStyle> and return the previous style.
     *
     * @param cell - <mxCell> that specifies the cell to be updated.
     * @param style - String of the form [stylename;|key=value;] to specify
     * the new cell style.
     */
    styleForCellChanged(cell: mxCell, style: string): string
    /**
     * Returns true if the given <mxCell> is collapsed.
     *
     * @param cell - <mxCell> whose collapsed state should be returned.
     */
    isCollapsed(cell: mxCell): boolean
    /**
     * Sets the collapsed state of the given <mxCell> using <mxCollapseChange>
     * and adds the change to the current transaction.
     *
     * @param cell - <mxCell> whose collapsed state should be changed.
     * @param collapsed - Boolean that specifies the new collpased state.
     */
    setCollapsed(cell: mxCell, collapsed: boolean): boolean
    /**
     * Inner callback to update the collapsed state of the
     * given <mxCell> using <mxCell.setCollapsed> and return
     * the previous collapsed state.
     *
     * @param cell - <mxCell> that specifies the cell to be updated.
     * @param collapsed - Boolean that specifies the new collpased state.
     */
    collapsedStateForCellChanged(cell: mxCell, collapsed: boolean): boolean
    /**
     * Returns true if the given <mxCell> is visible.
     *
     * @param cell - <mxCell> whose visible state should be returned.
     */
    isVisible(cell: mxCell): boolean
    /**
     * Sets the visible state of the given <mxCell> using <mxVisibleChange> and
     * adds the change to the current transaction.
     *
     * @param cell - <mxCell> whose visible state should be changed.
     * @param visible - Boolean that specifies the new visible state.
     */
    setVisible(cell: mxCell, visible: boolean): boolean
    /**
     * Inner callback to update the visible state of the
     * given <mxCell> using <mxCell.setCollapsed> and return
     * the previous visible state.
     *
     * @param cell - <mxCell> that specifies the cell to be updated.
     * @param visible - Boolean that specifies the new visible state.
     */
    visibleStateForCellChanged(cell: mxCell, visible: boolean): boolean
    /**
     * 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
    /**
     * 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
    /**
     * 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
    /**
     * Creates a new <mxUndoableEdit> that implements the
     * notify function to fire a <change> and <notify> event
     * through the <mxUndoableEdit>'s source.
     */
    createUndoableEdit(): mxUndoableEdit
    /**
     * 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: any): void
    /**
     * 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
    /**
     * 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[]
    /**
     * Returns a deep clone of the given <mxCell> (including
     * the children) which is created using <cloneCells>.
     *
     * Parameters:
     *
     * cell - <mxCell> to be cloned.
     */
    cloneCell(cell: any): any
    /**
     * 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 - Boolean indicating if the cells should be cloned
     * with all descendants.
     * mapping - Optional mapping for existing clones.
     */
    cloneCells(cells: mxCell[], includeChildren: boolean, mapping?: any): any[]
    /**
     * Inner helper method for cloning cells recursively.
     */
    cloneCellImpl(cell: any, mapping: any, includeChildren: any): any
    /**
     * Hook for cloning the cell. This returns cell.clone() or
     * any possible exceptions.
     */
    cellCloned(cell: any): any
    /**
     * Inner helper method for restoring the connections in
     * a network of cloned cells.
     */
    restoreClone(clone: any, cell: any, mapping: any): void
  }
  /**
   * Action to change the root in a model.
   *
   * Constructor: mxRootChange
   *
   * Constructs a change of the root in the
   * specified model.
   */
  export class mxRootChange {
    model: mxGraphModel
    root: any
    previous: mxCell
    constructor(model: any, root: any)
    /**
     * Carries out a change of the root using
     * <mxGraphModel.rootChanged>.
     */
    execute(): void
  }
  /**
   * Action to add or remove a child in a model.
   *
   * Constructor: mxChildChange
   *
   * Constructs a change of a child in the
   * specified model.
   */
  export class mxChildChange {
    parent: any
    previous: any
    child: mxCell
    index: any
    previousIndex: any
    constructor(model: any, parent: any, child: mxCell, index?: number)
    /**
     * Changes the parent of <child> using
     * <mxGraphModel.parentForCellChanged> and
     * removes or restores the cell's
     * connections.
     */
    execute(): void
    /**
     * Disconnects the given cell recursively from its
     * terminals and stores the previous terminal in the
     * cell's terminals.
     */
    connect(cell: any, isConnect: any): void
  }
  /**
   * Action to change a terminal in a model.
   *
   * Constructor: mxTerminalChange
   *
   * Constructs a change of a terminal in the
   * specified model.
   */
  export class mxTerminalChange {
    model: any
    cell: mxCell
    terminal: any
    previous: mxCell
    source: any
    constructor(model: any, cell: any, terminal: any, source: any)
    /**
     * Changes the terminal of <cell> to <previous> using
     * <mxGraphModel.terminalForCellChanged>.
     */
    execute(): void
  }
  /**
   * Action to change a user object in a model.
   *
   * Constructor: mxValueChange
   *
   * Constructs a change of a user object in the
   * specified model.
   */
  export class mxValueChange {
    model: any
    cell: any
    value: any
    previous: any
    constructor(model: any, cell: any, value: any)
    /**
     * Changes the value of <cell> to <previous> using
     * <mxGraphModel.valueForCellChanged>.
     */
    execute(): void
  }
  /**
   * Action to change a cell's style in a model.
   *
   * Constructor: mxStyleChange
   *
   * Constructs a change of a style in the
   * specified model.
   */
  export class mxStyleChange {
    model: any
    cell: any
    style: any
    previous: any
    constructor(model: any, cell: any, style: any)
    /**
     * Changes the style of <cell> to <previous> using
     * <mxGraphModel.styleForCellChanged>.
     */
    execute(): void
  }
  /**
   * Action to change a cell's geometry in a model.
   *
   * Constructor: mxGeometryChange
   *
   * Constructs a change of a geometry in the
   * specified model.
   */
  export class mxGeometryChange {
    model: any
    cell: any
    geometry: any
    previous: any
    constructor(model: any, cell: any, geometry: any)
    /**
     * Changes the geometry of <cell> ro <previous> using
     * <mxGraphModel.geometryForCellChanged>.
     */
    execute(): void
  }
  /**
   * Action to change a cell's collapsed state in a model.
   *
   * Constructor: mxCollapseChange
   *
   * Constructs a change of a collapsed state in the
   * specified model.
   */
  export class mxCollapseChange {
    model: any
    cell: any
    collapsed: any
    previous: any
    constructor(model: any, cell: any, collapsed: any)
    /**
     * Changes the collapsed state of <cell> to <previous> using
     * <mxGraphModel.collapsedStateForCellChanged>.
     */
    execute(): void
  }
  /**
   * Action to change a cell's visible state in a model.
   *
   * Constructor: mxVisibleChange
   *
   * Constructs a change of a visible state in the
   * specified model.
   */
  export class mxVisibleChange {
    model: any
    cell: any
    visible: any
    previous: any
    constructor(model: any, cell: any, visible: any)
    /**
     * Changes the visible state of <cell> to <previous> using
     * <mxGraphModel.visibleStateForCellChanged>.
     */
    execute(): void
  }
  /**
   * 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>.
   */
  export class mxCellAttributeChange {
    cell: any
    attribute: any
    value: any
    previous: any
    constructor(cell: any, attribute: any, value: any)
    /**
     * Changes the attribute of the cell's user object by
     * using <mxCell.setAttribute>.
     */
    execute(): void
  }

  type Value = any

  /**
        * 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', '')
        *   }
        * };
        *
        * va    invalidating: any;    invalidating: any;    [x: string]: any;

    r 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)
        */
  export class mxCell {
    /**
     * Holds the Id. Default is null.
     */
    id: string
    /**
     * Holds the user object. Default is null.
     */
    value: Value
    /**
     * Holds the <mxGeometry>. Default is null.
     */
    geometry: mxGeometry
    /**
     * Holds the style as a string of the form [(stylename|key=value);]. Default is
     * null.
     */
    style: string
    /**
     * Specifies whether the cell is a vertex. Default is false.
     */
    vertex: boolean
    /**
     * Specifies whether the cell is an edge. Default is false.
     */
    edge: boolean
    /**
     * Specifies whether the cell is connectable. Default is true.
     */
    connectable: boolean
    /**
     * Specifies whether the cell is visible. Default is true.
     */
    visible: boolean
    /**
     * Specifies whether the cell is collapsed. Default is false.
     */
    collapsed: boolean
    /**
     * Reference to the parent cell.
     */
    parent: mxCell
    /**
     * Reference to the source terminal.
     */
    source: mxCell
    /**
     * Reference to the target terminal.
     */
    target: mxCell
    /**
     * Holds the child cells.
     */
    children: mxCell[]
    /**
     * Holds the edges.
     */
    edges: mxCell[]
    /**
     * 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[]
    /**
     * Constructs a new cell to be used in a graph model.
     * This method invokes <onInit> upon completion.
     *
     * @param value - Optional object that represents the cell value.
     * @param geometry - Optional <mxGeometry> that specifies the geometry.
     * @param style - Optional formatted string that defines the style.
     */
    constructor(value?: any, geometry?: mxGeometry, style?: string)
    /**
     * Returns the Id of the cell as a string.
     */
    getId(): string
    /**
     * Sets the Id of the cell to the given string.
     */
    setId(id: string): void
    /**
     * Returns the user object of the cell. The user
     * object is stored in <value>.
     */
    getValue(): Value
    /**
     * Sets the user object of the cell. The user object
     * is stored in <value>.
     */
    setValue(value: Value): void
    /**
     * 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): Value
    /**
     * Returns the <mxGeometry> that describes the <geometry>.
     */
    getGeometry(): mxGeometry
    /**
     * Sets the <mxGeometry> to be used as the <geometry>.
     */
    setGeometry(geometry: mxGeometry): void
    /**
     * Returns a string that describes the <style>.
     */
    getStyle(): string
    /**
     * Sets the string to be used as the <style>.
     */
    setStyle(style: string): void
    /**
     * Returns true if the cell is a vertex.
     */
    isVertex(): boolean
    /**
     * Specifies if the cell is a vertex. This should only be assigned at
     * construction of the cell and not be changed during its lifecycle.
     *
     * @param vertex - Boolean that specifies if the cell is a vertex.
     */
    setVertex(vertex: boolean): void
    /**
     * Returns true if the cell is an edge.
     */
    isEdge(): boolean
    /**
     * Specifies if the cell is an edge. This should only be assigned at
     * construction of the cell and not be changed during its lifecycle.
     *
     * @param edge - Boolean that specifies if the cell is an edge.
     */
    setEdge(edge: boolean): void
    /**
     * Returns true if the cell is connectable.
     */
    isConnectable(): boolean
    /**
     * Sets the connectable state.
     *
     * @param connectable - Boolean that specifies the new connectable state.
     */
    setConnectable(connectable: boolean): void
    /**
     * Returns true if the cell is visibile.
     */
    isVisible(): boolean
    /**
     * Specifies if the cell is visible.
     *
     * @param visible - Boolean that specifies the new visible state.
     */
    setVisible(visible: boolean): void
    /**
     * Returns true if the cell is collapsed.
     */
    isCollapsed(): boolean
    /**
     * Sets the collapsed state.
     *
     * @param collapsed - Boolean that specifies the new collapsed state.
     */
    setCollapsed(collapsed: boolean): void
    /**
     * Returns the cell's parent.
     */
    getParent(): mxCell
    /**
     * Sets the parent cell.
     *
     * @param parent - <mxCell> that represents the new parent.
     */
    setParent(parent: mxCell): void
    /**
     * Returns the source or target terminal.
     *
     * @param source - Boolean that specifies if the source terminal should be
     * returned. (true:source, false:target)
     */
    getTerminal(source: boolean): mxCell
    /**
     * Sets the source or target terminal and returns the new terminal.
     *
     * @param terminal - <mxCell> that represents the new source or target terminal.
     * @param isSource - Boolean that specifies if the source or target terminal
     * should be set.
     */
    setTerminal(terminal: mxCell, isSource: boolean): mxCell
    /**
     * Returns the number of child cells.
     */
    getChildCount(): number
    /**
     * Returns the index of the specified child in the child array.
     *
     * @param child - Child whose index should be returned.
     */
    getIndex(child: mxCell): any
    /**
     * Returns the child at the specified index.
     *
     * @param index - Integer that specifies the child to be returned.
     */
    getChildAt(index: number): mxCell
    /**
     * 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.
     *
     * @param child - <mxCell> to be inserted or appended to the child array.
     * @param index - Optional integer that specifies the index at which the child
     * should be inserted into the child array.
     */
    insert(child: mxCell, index?: number): mxCell
    /**
     * 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.
     *
     * @param index - Integer that specifies the index of the child to be
     * removed.
     */
    remove(index: number): any
    /**
     * Removes the cell from its parent.
     */
    removeFromParent(): void
    /**
     * Returns the number of edges in the edge array.
     */
    getEdgeCount(): number
    /**
     * Returns the index of the specified edge in <edges>.
     *
     * @param edge - <mxCell> whose index in <edges> should be returned.
     */
    getEdgeIndex(edge: mxCell): any
    /**
     * Returns the edge at the specified index in <edges>.
     *
     * @param index - Integer that specifies the index of the edge to be returned.
     */
    getEdgeAt(index: number): mxCell
    /**
     * Inserts the specified edge into the edge array and returns the edge.
     * Will update the respective terminal reference of the edge.
     *
     * @param edge - <mxCell> to be inserted into the edge array.
     * @param isOutgoing - Boolean that specifies if the edge is outgoing.
     */
    insertEdge(edge: mxCell, isOutgoing: boolean): mxCell
    /**
     * Removes the specified edge from the edge array and returns the edge.
     * Will remove the respective terminal reference from the edge.
     *
     * @param edge - <mxCell> to be removed from the edge array.
     * @param isOutgoing - Boolean that specifies if the edge is outgoing.
     */
    removeEdge(edge: mxCell, isOutgoing: boolean): mxCell
    /**
     * Removes the edge from its source or target terminal.
     *
     * @param isSource - Boolean that specifies if the edge should be removed from its
     * source or target terminal.
     */
    removeFromTerminal(isSource: boolean): void
    /**
     * Returns true if the user object is an XML node that contains the given
     * attribute.
     *
     * @param name - Name of the attribute.
     */
    hasAttribute(name: string): any
    /**
     * Returns the specified attribute from the user object if it is an XML
     * node.
     *
     * @param name - Name of the attribute whose value should be returned.
     * @param defaultValue - Optional default value to use if the attribute has no
     * value.
     */
    getAttribute(name: string, defaultValue?: string): any
    /**
     * Sets the specified attribute on the user object if it is an XML node.
     *
     * @param name - Name of the attribute whose value should be set.
     * @param value - New value of the attribute.
     */
    setAttribute(name: string, value: string): void
    /**
     * Returns a clone of the cell. Uses <cloneValue> to clone
     * the user object. All fields in <mxTransient> are ignored
     * during the cloning.
     */
    clone(): any
    /**
     * Returns a clone of the cell's user object.
     */
    cloneValue(): any
  }

  /**
   * 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.
   */
  export class mxGeometry extends mxRectangle {
    /**
     * Global switch to translate the points in translate. Default is true.
     */
    TRANSLATE_CONTROL_POINTS: boolean
    /**
     * Stores alternate values for x, y, width and height in a rectangle. See
     * <swap> to exchange the values. Default is null.
     */
    alternateBounds: any
    /**
     * 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
    /**
     * 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
    /**
     * 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: any
    /**
     * 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
    /**
     * 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
    /**
     * Constructs a new object to describe the size and location of a vertex or
     * the control points of an edge.
     * @param x
     * @param y
     * @param width
     * @param height
     */
    constructor(x?: number, y?: number, width?: number, height?: number)
    /**
     * 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
    /**
     * 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: any): any
    /**
     * 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: any, isSource: any): any
    /**
     * 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: any, cx: any): void
    /**
     * 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: any, dy: any): void
    /**
     * 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: any, sy: any, fixedAspect: any): void
    /**
     * Returns true if the given object equals this geometry.
     */
    equals(obj: any): any
  }

  export var mxCellPath: {
    PATH_SEPARATOR: string
    create(cell: any): string
    getParentPath(path: any): any
    resolve(root: any, path: any): any
    compare(p1: any, p2: any): number
  }

  export var mxPerimeter: {
    RectanglePerimeter(
      bounds: any,
      vertex: any,
      next: any,
      orthogonal: any
    ): mxPoint
    EllipsePerimeter(
      bounds: any,
      vertex: any,
      next: any,
      orthogonal: any
    ): mxPoint
    RhombusPerimeter(bounds: any, vertex: any, next: any, orthogonal: any): any
    TrianglePerimeter(
      bounds: any,
      vertex: any,
      next: any,
      orthogonal: any
    ): any
    HexagonPerimeter(
      bounds: any,
      vertex: any,
      next: any,
      orthogonal: any
    ): 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.
   */
  export class mxPrintPreview {
    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.
   */
  export 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;
   */
  export 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.
   */
  export 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.
   */
  export 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>.
   */
  export class mxCellEditor {
    constructor(graph: any)
    /**
     * 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

    // https://jgraph.github.io/mxgraph/docs/js-api/files/view/mxCellEditor-js.html#mxCellEditor.escapeCancelsEditing
    escapeCancelsEditing: boolean

    // https://jgraph.github.io/mxgraph/docs/js-api/files/view/mxCellEditor-js.html#mxCellEditor.blurEnabled
    blurEnabled: boolean
  }

  /**
   * 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.
   */
  export class mxCellRenderer {
    /**
     * 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
  }

  export 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
  }

  export var mxStyleRegistry: {
    values: 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.
   */
  export class mxGraphView extends mxEventSource {
    /**
     *
     */
    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: HTMLCanvasElement
    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 <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(): HTMLCanvasElement
    /**
     * 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.
   */
  export 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.
   */
  export 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',
  }
  /**
   * 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- 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)
   *
   * 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.
   */
  export class mxGraph extends mxEventSource {
    /**
     * Immutable empty array instance.
     */
    readonly EMPTY_ARRAY: any[]
    /**
     * Holds the mouse event listeners. See <fireMouseEvent>.
     */
    mouseListeners: any
    /**
     * Holds the state of the mouse button.
     */
    isMouseDown: boolean
    /**
     * Holds the <mxGraphModel> that contains the cells to be displayed.
     */
    model: mxGraphModel
    /**
     * Holds the <mxGraphView> that caches the <mxCellStates> for the cells.
     */
    view: mxGraphView
    /**
     * 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
    /**
     * Holds the <mxGraphSelectionModel> that models the current selection.
     */
    selectionModel: mxGraphSelectionModel
    /**
     * Holds the <mxCellEditor> that is used as the in-place editing.
     */
    cellEditor: mxCellEditor
    /**
     * Holds the <mxCellRenderer> for rendering the cells in the graph.
     */
    cellRenderer: mxCellRenderer
    /**
     * An array of <mxMultiplicities> describing the allowed
     * connections in a graph.
     */
    multiplicities: mxMultiplicity[]
    /**
     * RenderHint as it was passed to the constructor.
     */
    renderHint: any
    /**
     * Dialect to be used for drawing the graph. Possible values are all
     * constants in <mxConstants> with a DIALECT-prefix.
     */
    dialect: any
    /**
     * Specifies the grid size. Default is 10.
     */
    gridSize: number
    /**
     * Specifies if the grid is enabled. This is used in <snap>. Default is
     * true.
     */
    gridEnabled: boolean
    /**
     * Specifies if ports are enabled. This is used in <cellConnected> to update
     * the respective style. Default is true.
     */
    portsEnabled: boolean
    /**
     * Specifies if native double click events should be detected. Default is true.
     */
    nativeDblClickEnabled: boolean
    /**
     * Specifies if double taps on touch-based devices should be handled as a
     * double click. Default is true.
     */
    doubleTapEnabled: boolean
    /**
     * Specifies the timeout for double taps and non-native double clicks. Default
     * is 500 ms.
     */
    doubleTapTimeout: number
    /**
     * Specifies the tolerance for double taps and double clicks in quirks mode.
     * Default is 25 pixels.
     */
    doubleTapTolerance: number
    /**
     * Holds the x-coordinate of the last touch event for double tap detection.
     */
    lastTouchX: number
    /**
     * Holds the y-coordinate of the last touch event for double tap detection.
     */
    lastTouchY: number
    /**
     * Holds the time of the last touch event for double click detection.
     */
    lastTouchTime: number
    /**
     * Specifies if tap and hold should be used for starting connections on touch-based
     * devices. Default is true.
     */
    tapAndHoldEnabled: boolean
    /**
     * Specifies the time for a tap and hold. Default is 500 ms.
     */
    tapAndHoldDelay: number
    /**
     * True if the timer for tap and hold events is running.
     */
    tapAndHoldInProgress: boolean
    /**
     * True as long as the timer is running and the touch events
     * stay within the given <tapAndHoldTolerance>.
     */
    tapAndHoldValid: boolean
    /**
     * Holds the x-coordinate of the intial touch event for tap and hold.
     */
    initialTouchX: number
    /**
     * Holds the y-coordinate of the intial touch event for tap and hold.
     */
    initialTouchY: number
    /**
     * Tolerance for a move to be handled as a single click.
     * Default is 4 pixels.
     */
    tolerance: number
    /**
     * 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
    /**
     * Specifies the default parent to be used to insert new cells.
     * This is used in <getDefaultParent>. Default is null.
     */
    defaultParent: any
    /**
     * Specifies the alternate edge style to be used if the main control point
     * on an edge is being doubleclicked. Default is null.
     */
    alternateEdgeStyle: any
    /**
     * 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
    /**
     * Specifies if the background page should be visible. Default is false.
     * Not yet implemented.
     */
    pageVisible: boolean
    /**
     * 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
    /**
     * Specifies the color for page breaks. Default is 'gray'.
     */
    pageBreakColor: string
    /**
     * Specifies the page breaks should be dashed. Default is true.
     */
    pageBreakDashed: boolean
    /**
     * Specifies the minimum distance for page breaks to be visible. Default is
     * 20 (in pixels).
     */
    minPageBreakDist: number
    /**
     * 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
    /**
     * 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
    /**
     * Specifies the scale of the background page. Default is 1.5.
     * Not yet implemented.
     */
    pageScale: number
    /**
     * Specifies the return value for <isEnabled>. Default is true.
     */
    enabled: boolean
    /**
     * Specifies if <mxKeyHandler> should invoke <escape> when the escape key
     * is pressed. Default is true.
     */
    escapeEnabled: boolean
    /**
     * 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
    /**
     * 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
    /**
     * 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
    /**
     * Specifies the return value for <canExportCell>. Default is true.
     */
    exportEnabled: boolean
    /**
     * Specifies the return value for <canImportCell>. Default is true.
     */
    importEnabled: boolean
    /**
     * Specifies the return value for <isCellLocked>. Default is false.
     */
    cellsLocked: boolean
    /**
     * Specifies the return value for <isCellCloneable>. Default is true.
     */
    cellsCloneable: boolean
    /**
     * Specifies if folding (collapse and expand via an image icon in the graph
     * should be enabled). Default is true.
     */
    foldingEnabled: boolean
    /**
     * Specifies the return value for <isCellEditable>. Default is true.
     */
    cellsEditable: boolean
    /**
     * Specifies the return value for <isCellDeletable>. Default is true.
     */
    cellsDeletable: boolean
    /**
     * Specifies the return value for <isCellMovable>. Default is true.
     */
    cellsMovable: boolean
    /**
     * Specifies the return value for edges in <isLabelMovable>. Default is true.
     */
    edgeLabelsMovable: boolean
    /**
     * Specifies the return value for vertices in <isLabelMovable>. Default is false.
     */
    vertexLabelsMovable: boolean
    /**
     * Specifies the return value for <isDropEnabled>. Default is false.
     */
    dropEnabled: boolean
    /**
     * 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
    /**
     * Specifies the return value for <isCellResizable>. Default is true.
     */
    cellsResizable: boolean
    /**
     * Specifies the return value for <isCellsBendable>. Default is true.
     */
    cellsBendable: boolean
    /**
     * Specifies the return value for <isCellSelectable>. Default is true.
     */
    cellsSelectable: boolean
    /**
     * Specifies the return value for <isCellDisconntable>. Default is true.
     */
    cellsDisconnectable: boolean
    /**
     * Specifies if the graph should automatically update the cell size after an
     * edit. This is used in <isAutoSizeCell>. Default is false.
     */
    autoSizeCells: boolean
    /**
     * Specifies if autoSize style should be applied when cells are added. Default is false.
     */
    autoSizeCellsOnAdd: boolean
    /**
     * 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
    /**
     * 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
    /**
     * 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
    /**
     * 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
    /**
     * 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
    /**
     * 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
    /**
     * <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: any
    /**
     * <mxRectangle> that specifies the minimum size of the graph. This is ignored
     * if the graph container has no scrollbars. Default is null.
     */
    minimumGraphSize: any
    /**
     * <mxRectangle> that specifies the minimum size of the <container> if
     * <resizeContainer> is true.
     */
    minimumContainerSize: any
    /**
     * <mxRectangle> that specifies the maximum size of the container if
     * <resizeContainer> is true.
     */
    maximumContainerSize: any
    /**
     * Specifies if the container should be resized to the graph size when
     * the graph size has changed. Default is false.
     */
    resizeContainer: boolean
    /**
     * 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
    /**
     * 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
    /**
     * 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
    /**
     * Specifies if negative coordinates for vertices are allowed. Default is true.
     */
    allowNegativeCoordinates: boolean
    /**
     * Specifies if a child should be constrained inside the parent bounds after a
     * move or resize of the child. Default is true.
     */
    constrainChildren: boolean
    /**
     * 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
    /**
     * 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
    /**
     * Specifies if parents should be extended according to the <extendParents>
     * switch if cells are added. Default is true.
     */
    extendParentsOnAdd: boolean
    /**
     * Specifies if parents should be extended according to the <extendParents>
     * switch if cells are added. Default is false for backwards compatiblity.
     */
    extendParentsOnMove: boolean
    /**
     * Specifies the return value for <isRecursiveResize>. Default is
     * false for backwards compatiblity.
     */
    recursiveResize: boolean
    /**
     * Specifies if the cell size should be changed to the preferred size when
     * a cell is first collapsed. Default is true.
     */
    collapseToPreferredSize: boolean
    /**
     * Specifies the factor used for <zoomIn> and <zoomOut>. Default is 1.2
     * (120%).
     */
    zoomFactor: number
    /**
     * Specifies if the viewport should automatically contain the selection cells
     * after a zoom operation. Default is false.
     */
    keepSelectionVisibleOnZoom: boolean
    /**
     * 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
    /**
     * Specifies if the scale and translate should be reset if the root changes in
     * the model. Default is true.
     */
    resetViewOnRootChange: boolean
    /**
     * Specifies if edge control points should be reset after the resize of a
     * connected cell. Default is false.
     */
    resetEdgesOnResize: boolean
    /**
     * Specifies if edge control points should be reset after the move of a
     * connected cell. Default is false.
     */
    resetEdgesOnMove: boolean
    /**
     * Specifies if edge control points should be reset after the the edge has been
     * reconnected. Default is true.
     */
    resetEdgesOnConnect: boolean
    /**
     * Specifies if loops (aka self-references) are allowed. Default is false.
     */
    allowLoops: boolean
    /**
     * <mxEdgeStyle> to be used for loops. This is a fallback for loops if the
     * <mxConstants.STYLE_LOOP> is undefined. Default is <mxEdgeStyle.Loop>.
     */
    defaultLoopStyle: (
      state: any,
      source: any,
      target: any,
      points: any,
      result: any
    ) => void

    /**
     * Specifies if multiple edges in the same direction between the same pair of
     * vertices are allowed. Default is true.
     */
    multigraph: boolean
    /**
     * Specifies if edges are connectable. Default is false. This overrides the
     * connectable field in edges.
     */
    connectableEdges: boolean
    /**
     * Specifies if edges with disconnected terminals are allowed in the graph.
     * Default is true.
     */
    allowDanglingEdges: boolean
    /**
     * Specifies if edges that are cloned should be validated and only inserted
     * if they are valid. Default is true.
     */
    cloneInvalidEdges: boolean
    /**
     * Specifies if edges should be disconnected from their terminals when they
     * are moved. Default is true.
     */
    disconnectOnMove: boolean
    /**
     * Specifies if labels should be visible. This is used in <getLabel>. Default
     * is true.
     */
    labelsVisible: boolean
    /**
     * Specifies the return value for <isHtmlLabel>. Default is false.
     */
    htmlLabels: boolean
    /**
     * Specifies if swimlanes should be selectable via the content if the
     * mouse is released. Default is true.
     */
    swimlaneSelectionEnabled: boolean
    /**
     * Specifies if nesting of swimlanes is allowed. Default is true.
     */
    swimlaneNesting: boolean
    /**
     * 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
    /**
     * Holds the list of image bundles.
     */
    imageBundles: any
    /**
     * Specifies the minimum scale to be applied in <fit>. Default is 0.1. Set this
     * to null to allow any value.
     */
    minFitScale: number
    /**
     * Specifies the maximum scale to be applied in <fit>. Default is 8. Set this
     * to null to allow any value.
     */
    maxFitScale: number
    /**
     * Current horizontal panning value. Default is 0.
     */
    panDx: number
    /**
     * Current vertical panning value. Default is 0.
     */
    panDy: number
    /**
     * Specifies the <mxImage> to indicate a collapsed state.
     * Default value is mxClient.imageBasePath + '/collapsed.gif'
     */
    collapsedImage: mxImage
    /**
     * Specifies the <mxImage> to indicate a expanded state.
     * Default value is mxClient.imageBasePath + '/expanded.gif'
     */
    expandedImage: mxImage
    /**
     * 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
    /**
     * 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
    /**
     * 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
    /**
     * 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'.
     */
    tooltipHandler: mxTooltipHandler
    selectionCellsHandler: mxSelectionCellsHandler
    connectionHandler: mxConnectionHandler
    graphHandler: mxGraphHandler
    panningHandler: mxPanningHandler
    popupMenuHandler: mxPopupMenuHandler
    graphModelChangeListener: any
    panningManager: any
    collapseExpandResource: string
    container: HTMLScriptElement
    /**
     * Constructs a new mxGraph in the specified container.
     *
     * Model is an optional {@link 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 - see {@link renderingHint}
     *
     * To create a graph inside a DOM node with an id of graph:
     * @example
     * var container = document.getElementById('graph');
     * var graph = new mxGraph(container);
     *
     * @param 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>.
     * @param model - Optional <mxGraphModel> that constitutes the graph data.
     * @param renderHint - Optional string that specifies the display accuracy and
     * performance. Default is mxConstants.DIALECT_MIXEDHTML (for IE).
     * @param stylesheet - Optional <mxStylesheet> to be used in the graph.
     */
    constructor(
      container?: Element,
      model?: mxGraphModel,
      renderHint?: renderingHint,
      stylesheet?: mxStylesheet
    )
    /**
     * Initializes the <container> and creates the respective datastructures.
     *
     * container - DOM node that will contain the graph display.
     */
    init(container: HTMLScriptElement): void

    createEdge(
      parent: mxCell,
      id?: string,
      value?: any,
      source?: mxCell,
      target?: mxCell,
      style?: any
    ): mxCell
    /**
     * Creates the tooltip-, panning-, connection- and graph-handler (in this
     * order). This is called in the constructor before <init> is called.
     */
    createHandlers(): void
    /**
     * Creates and returns a new <mxTooltipHandler> to be used in this graph.
     */
    createTooltipHandler(): mxTooltipHandler
    /**
     * Creates and returns a new <mxTooltipHandler> to be used in this graph.
     */
    createSelectionCellsHandler(): mxSelectionCellsHandler
    /**
     * Creates and returns a new <mxConnectionHandler> to be used in this graph.
     */
    createConnectionHandler(): mxConnectionHandler
    /**
     * Creates and returns a new <mxGraphHandler> to be used in this graph.
     */
    createGraphHandler(): mxGraphHandler
    /**
     * Creates and returns a new <mxPanningHandler> to be used in this graph.
     */
    createPanningHandler(): mxPanningHandler
    /**
     * Creates and returns a new <mxPopupMenuHandler> to be used in this graph.
     */
    createPopupMenuHandler(): mxPopupMenuHandler
    /**
     * Creates a new <mxGraphSelectionModel> to be used in this graph.
     */
    createSelectionModel(): mxGraphSelectionModel
    /**
     * Creates a new <mxGraphSelectionModel> to be used in this graph.
     */
    createStylesheet(): mxStylesheet
    /**
     * Creates a new <mxGraphView> to be used in this graph.
     */
    createGraphView(): mxGraphView
    /**
     * Creates a new <mxCellRenderer> to be used in this graph.
     */
    createCellRenderer(): mxCellRenderer
    /**
     * Creates a new <mxCellEditor> to be used in this graph.
     */
    createCellEditor(): mxCellEditor
    /**
     * Returns the <mxGraphModel> that contains the cells.
     */
    getModel(): mxGraphModel
    /**
     * Returns the <mxGraphView> that contains the <mxCellStates>.
     */
    getView(): mxGraphView
    /**
     * Returns the <mxStylesheet> that defines the style.
     */
    getStylesheet(): mxStylesheet
    /**
     * Sets the <mxStylesheet> that defines the style.
     */
    setStylesheet(stylesheet: mxStylesheet): void
    /**
     * Returns the <mxGraphSelectionModel> that contains the selection.
     */
    getSelectionModel(): mxGraphSelectionModel
    /**
     * Sets the <mxGraphSelectionModel> that contains the selection.
     */
    setSelectionModel(selectionModel: mxGraphSelectionModel): void
    /**
     * Returns the cells to be selected for the given array of changes.
     */
    getSelectionCellsForChanges(
      changes: (
        | mxRootChange
        | mxChildChange
        | {
          cell: mxCell
        })[]
    ): mxCell[]
    /**
     * Called when the graph model changes. Invokes <processChange> on each
     * item of the given array to update the view accordingly.
     *
     * changes - Array that contains the individual changes.
     */
    graphModelChanged(changes: any): void
    /**
     * Returns the cells that have been removed from the model.
     */
    getRemovedCellsForChanges(changes: any): mxCell[]
    /**
     * 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.
     *
     * change - Object that represents the change on the model.
     */
    processChange(change: any): void
    /**
     * 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
    /**
     * Adds an <mxCellOverlay> for the specified cell. This method fires an
     * <addoverlay> event and returns the new <mxCellOverlay>.
     *
     * cell - <mxCell> to add the overlay for.
     * overlay - <mxCellOverlay> to be added for the cell.
     */
    addCellOverlay(cell: mxCell, overlay: mxCellOverlay): mxCellOverlay
    /**
     * Returns the array of <mxCellOverlays> for the given cell or null, if
     * no overlays are defined.
     *
     * cell - <mxCell> whose overlays should be returned.
     */
    getCellOverlays(cell: mxCell): mxCellOverlay[]
    /**
     * 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>.
     *
     * cell - <mxCell> whose overlay should be removed.
     * overlay - Optional <mxCellOverlay> to be removed.
     */
    removeCellOverlay(cell: mxCell, overlay: mxCellOverlay): mxCellOverlay
    /**
     * 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.
     *
     * cell - <mxCell> whose overlays should be removed
     */
    removeCellOverlays(cell: mxCell): mxCellOverlay[]
    /**
     * 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.
     *
     * 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
    /**
     * 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)
     *
     * 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
    /**
     * Calls <startEditingAtCell> using the given cell or the first selection
     * cell.
     *
     * evt - Optional mouse event that triggered the editing.
     */
    startEditing(evt: any): void
    /**
     * Fires a <startEditing> event and invokes <mxCellEditor.startEditing>
     * on <editor>. After editing was started, a <editingStarted> event is
     * fired.
     *
     * cell - <mxCell> to start the in-place editor for.
     * evt - Optional mouse event that triggered the editing.
     */
    startEditingAtCell(cell: any, evt: any): void
    /**
     * 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.
     *
     * cell - <mxCell> for which the initial editing value should be returned.
     * evt - Optional mouse event that triggered the editor.
     */
    getEditingValue(cell: any, evt: any): string
    /**
     * Stops the current editing  and fires a <editingStopped> event.
     *
     * cancel - Boolean that specifies if the current editing value
     * should be stored.
     */
    stopEditing(cancel: any): void
    /**
     * 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.
     *
     * cell - <mxCell> whose label should be changed.
     * value - New label to be assigned.
     * evt - Optional event that triggered the change.
     */
    labelChanged(cell: any, value: any, evt: any): any
    /**
     * 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)
     *
     * cell - <mxCell> whose label should be changed.
     * value - New label to be assigned.
     * autoSize - Boolean that specifies if <cellSizeUpdated> should be called.
     */
    cellLabelChanged(cell: any, value: any, autoSize: any): void
    /**
     * Processes an escape keystroke.
     *
     * evt - Mouseevent that represents the keystroke.
     */
    escape(evt: any): void
    /**
     * 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)
     *
     * me - <mxMouseEvent> that represents the single click.
     */
    click(me: any): void
    /**
     * 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)
     *
     * evt - Mouseevent that represents the doubleclick.
     * cell - Optional <mxCell> under the mousepointer.
     */
    dblClick(evt: any, cell: any): void
    /**
     * Handles the <mxMouseEvent> by highlighting the <mxCellState>.
     *
     * me - <mxMouseEvent> that represents the touch event.
     * state - Optional <mxCellState> that is associated with the event.
     */
    tapAndHold(me: any): void
    /**
     * Scrolls the graph to the given point, extending the graph container if
     * specified.
     */
    scrollPointToVisible(x: any, y: any, extend: any, border: any): void
    /**
     * Creates and returns an <mxPanningManager>.
     */
    createPanningManager(): any
    /**
     * 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
    /**
     * Returns the preferred size of the background page if <preferPageSize> is true.
     */
    getPreferredPageSize(bounds: any, width: any, height: any): mxRectangle
    /**
     * 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.
     *
     * @example
     * graph.fit();
     * graph.view.rendering = true;
     * graph.refresh();
     *
     * @example <caption>To fit and center the graph, the following code can be used.</caption>
     * var margin = 100;
     * var max = 2;
     *
     * 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);
     *
     * @param border - Optional number that specifies the border. Default is <border>.
     * @param keepOrigin - Optional boolean that specifies if the translate should be
     * changed. Default is false.
     * @param margin - Optional margin in pixels. Default is 0.
     * @param enabled - Optional boolean that specifies if the scale should be set or
     * just returned. Default is true.
     * @param ignoreWidth - Optional boolean that specifies if the width should be
     * ignored. Default is false.
     * @param ignoreHeight - Optional boolean that specifies if the height should be
     * ignored. Default is false.
     * @param maxHeight - Optional maximum height.
     */
    fit(
      border?: number,
      keepOrigin?: boolean,
      margin?: number,
      enabled?: boolean,
      ignoreWidth?: boolean,
      ignoreHeight?: boolean,
      maxHeight?: number
    ): number
    /**
     * 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
    /**
     * Resizes the container for the given graph width and height.
     */
    doResizeContainer(width: any, height: any): void
    /**
     * Invokes from <sizeDidChange> to redraw the page breaks.
     *
     * 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: any, width: any, height: any): void
    /**
     * 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 <EMPTY_ARRAY>,
     * if not 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.
     *
     * cell - <mxCell> whose style should be returned as an array.
     */
    getCellStyle(cell: any): any
    /**
     * 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
    /**
     * Sets the style of the specified cells. If no cells are given, then the
     * selection cells are changed.
     *
     * 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: any): void
    /**
     * 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: any, defaultValue: any, cell: any): any
    /**
     * 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: any, defaultValue: any, cells: any): any
    /**
     * 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.
     *
     * 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: any, value: any, cells: any): void
    /**
     * Toggles the given bit for the given key in the styles of the specified
     * cells.
     *
     * 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: any, flag: any, cells: any): void
    /**
     * Sets or toggles the given bit for the given key in the styles of the
     * specified cells.
     *
     * 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: any, flag: any, value: any, cells: any): void
    /**
     * Aligns the given cells vertically or horizontally according to the given
     * alignment using the optional parameter as the coordinate.
     *
     * 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: any, param: any): any
    /**
     * 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 state = this.view.getState(edge);
     *     var style = (state != null) ? state.style : this.getCellStyle(edge);
     *
     *     if (style != null)
     *     {
     *       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)
     *
     * edge - <mxCell> whose style should be changed.
     */
    flipEdge(edge: any): any
    /**
     * Adds the specified <mxImageBundle>.
     */
    addImageBundle(bundle: any): void
    /**
     * Removes the specified <mxImageBundle>.
     */
    removeImageBundle(bundle: any): void
    /**
     * 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
    /**
     * 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.
     *
     * 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: any, cells: any): any
    /**
     * Moves the given cells to the front or back. This method fires
     * <mxEvent.CELLS_ORDERED> while the transaction is in progress.
     *
     * cells - Array of <mxCells> whose order should be changed.
     * back - Boolean that specifies if the cells should be moved to back.
     */
    cellsOrdered(cells: any, back: any): void
    /**
     * 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.
     *
     * 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: any, border: any, cells: any): any
    /**
     * Returns the cells with the same parent as the first cell
     * in the given array.
     */
    getCellsForGroup(cells: any): any[]
    /**
     * Returns the bounds to be used for the given group and children.
     */
    getBoundsForGroup(group: any, children: any, border: any): mxRectangle
    /**
     * 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: any): mxCell
    /**
     * 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.
     *
     * cells - Array of cells to be ungrouped. If null is specified then the
     * selection cells are used.
     */
    ungroupCells(cells: any): any[]
    /**
     * Hook to remove the groups after <ungroupCells>.
     *
     * cells - Array of <mxCells> that were ungrouped.
     */
    removeCellsAfterUngroup(cells: any): void
    /**
     * Removes the specified cells from their parents and adds them to the
     * default parent. Returns the cells that were removed from their parents.
     *
     * cells - Array of <mxCells> to be removed from their parents.
     */
    removeCellsFromParent(cells: any): any
    /**
     * 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.
     *
     * 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: any,
      border: any,
      moveGroup: any,
      topBorder: any,
      rightBorder: any,
      bottomBorder: any,
      leftBorder: any
    ): any
    /**
     * Returns the bounding box for the given array of <mxCells>. The bounding box for
     * each cell and its descendants is computed using <mxGraphView.getBoundingBox>.
     *
     * cells - Array of <mxCells> whose bounding box should be returned.
     */
    getBoundingBox(cells: any): any
    /**
     * 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.
     *
     * @param cells - Array of <mxCells> to be cloned.
     * @param allowInvalidEdges - Optional boolean that specifies if invalid edges
     * should be cloned. Default is true.
     * @param mapping - Optional mapping for existing clones.
     */
    cloneCells(
      cells: mxCell[],
      allowInvalidEdges?: boolean,
      mapping?: any
    ): any
    /**
     * Adds a new vertex into the given parent {@link mxCell} using value as the user
     * object and the given coordinates as the {@link mxGeometry} of the new vertex.
     * The id and style are used for the respective properties of the new
     * {@link 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 {@link 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 {@link mxGraph} for more information on using images.
     *
     * @param {mxCell} parent Specifies the parent of the new vertex.
     * @param {?string} id Optional string that defines the Id of the new vertex.
     * @param {Object} value User defined data object.
     * @param {number} x Integer that defines the x coordinate of the vertex.
     * @param {number} y Integer that defines the y coordinate of the vertex.
     * @param {number} width Integer that defines the width of the vertex.
     * @param {number} height Integer that defines the height of the vertex.
     * @param {string} [style] Optional string that defines the cell style.
     * @param {boolean} [relative] Optional boolean that specifies if the geometry is relative.
     * Default is false.
     */
    insertVertex(
      parent: mxCell,
      id: string,
      value: Object,
      x: number,
      y: number,
      width: number,
      height: number,
      style?: string,
      relative?: boolean
    ): mxCell
    /**
     * Adds a new edge into the given parent {@link 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
     * {@link mxCell}, which is returned.
     *
     * @param {mxCell} parent specifies the parent of the new edge.
     * @param {?string} id Optional string that defines the Id of the new edge.
     * @param {Object} value User defined data object.
     * @param {mxCell} source Source of the edge.
     * @param {mxCell} target Target of the edge.
     * @param {string} [style] Optional string that defines the cell style.
     */
    insertEdge(
      parent: mxCell,
      id: string,
      value: Object,
      source: mxCell,
      target: mxCell,
      style?: string
    ): mxCell
    /**
     * 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.
     *
     * @param edge - <mxCell> to be inserted into the given parent.
     * @param parent - <mxCell> that represents the new parent. If no parent is
     * given then the default parent is used.
     * @param source - Optional <mxCell> that represents the source terminal.
     * @param target - Optional <mxCell> that represents the target terminal.
     * @param index - Optional index to insert the cells at. Default is to append.
     */
    addEdge(
      edge: mxCell,
      parent: mxCell,
      source?: mxCell,
      target?: mxCell,
      index?: number
    ): mxCell
    /**
     * 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.
     *
     * @param cell - <mxCell> to be inserted into the given parent.
     * @param parent - <mxCell> that represents the new parent. If no parent is
     * given then the default parent is used.
     * @param index - Optional index to insert the cells at. Default is to append.
     * @param source - Optional <mxCell> that represents the source terminal.
     * @param target - Optional <mxCell> that represents the target terminal.
     */
    addCell(
      cell: mxCell,
      parent?: mxCell,
      index?: number,
      source?: mxCell,
      target?: mxCell
    ): mxCell
    /**
     * 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.
     *
     * @param cells - Array of <mxCells> to be inserted.
     * @param parent - <mxCell> that represents the new parent. If no parent is
     * given then the default parent is used.
     * @param index - Optional index to insert the cells at. Default is to append.
     * @param source - Optional source <mxCell> for all inserted cells.
     * @param target - Optional target <mxCell> for all inserted cells.
     */
    addCells(
      cells: mxCell[],
      parent: mxCell,
      index?: number,
      source?: mxCell,
      target?: mxCell
    ): mxCell[]
    /**
     * Resizes the specified cell to just fit around the its label and/or children
     *
     * @param cell - <mxCells> to be resized.
     * @param recurse - Optional boolean which specifies if all descendants should be
     * autosized. Default is true.
     */
    autoSizeCell(cell: mxCell, recurse?: boolean): void
    /**
     * 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.
     *
     * 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?: any, includeEdges?: any): any
    /**
     * Removes the given cells from the model. This method fires
     * <mxEvent.CELLS_REMOVED> while the transaction is in progress.
     *
     * cells - Array of <mxCells> to remove.
     */
    cellsRemoved(cells: any): void
    /**
     * 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.
     *
     * 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.
     */
    splitEdge(edge: any, cells: any, newEdge: any, dx: any, dy: any): any
    /**
     * 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.
     *
     * 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: any, cells: any, includeEdges: any): any
    /**
     * Sets the visible state of the specified cells.
     *
     * cells - Array of <mxCells> whose visible state should be changed.
     * show - Boolean that specifies the visible state to be assigned.
     */
    cellsToggled(cells: any, show: any): void
    /**
     * 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.
     *
     * @param collapsed - Boolean indicating the collapsed state to be assigned.
     * @param recurse - Optional boolean indicating if the collapsed state of all
     * descendants should be set. Default is false.
     * @param cells - Array of <mxCells> whose collapsed state should be set. If
     * null is specified then the foldable selection cells are used.
     * @param checkFoldable - Optional boolean indicating of isCellFoldable should be
     * checked. Default is false.
     * @param evt - Optional native event that triggered the invocation.
     */
    foldCells(
      collapse: boolean,
      recurse?: boolean,
      cells?: mxCell[],
      checkFoldable?: boolean,
      evt?: Event
    ): mxCell[]
    /**
     * 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.
     *
     * @param cells - Array of <mxCells> whose collapsed state should be set.
     * @param collapsed - Boolean indicating the collapsed state to be assigned.
     * @param recurse - Boolean indicating if the collapsed state of all descendants
     * should be set.
     * @param checkFoldable - Optional boolean indicating of isCellFoldable should be
     * checked. Default is false.
     */
    cellsFolded(
      cells: mxCell[],
      collapse: boolean,
      recurse: boolean,
      checkFoldable?: boolean
    ): void
    /**
     * Swaps the alternate and the actual bounds in the geometry of the given
     * cell invoking <updateAlternateBounds> before carrying out the swap.
     *
     * cell - <mxCell> for which the bounds should be swapped.
     * willCollapse - Boolean indicating if the cell is going to be collapsed.
     */
    swapBounds(cell: any, willCollapse: any): void
    /**
     * 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.
     *
     * 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: any, geo: any, willCollapse: any): void
    /**
     * Returns an array with the given cells and all edges that are connected
     * to a cell or one of its descendants.
     */
    addAllEdges(cells: any): any
    /**
     * Returns all edges connected to the given cells or its descendants.
     */
    getAllEdges(cells: any): any[]
    /**
     * 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.
     *
     * @param cell - <mxCell> whose size should be updated.
     */
    updateCellSize(cell: mxCell, ignoreChildren?: boolean): mxCell
    /**
     * Updates the size of the given cell in the model using
     * <getPreferredSizeForCell> to get the new size.
     *
     * cell - <mxCell> for which the size should be changed.
     */
    cellSizeUpdated(cell: any, ignoreChildren: any): void
    /**
     * 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)
     *
     * cell - <mxCell> for which the preferred size should be returned.
     */
    getPreferredSizeForCell(cell: any): any
    /**
     * Sets the bounds of the given cell using <resizeCells>. Returns the
     * cell which was passed to the function.
     *
     * @param cell - <mxCell> whose bounds should be changed.
     * @param bounds - <mxRectangle> that represents the new bounds.
     * @param recurse - Recursively resize children
     */
    resizeCell(cell: mxCell, bounds: mxRectangle, recurse?: any): mxCell
    /**
     * 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.
     *
     * @param cells - Array of <mxCells> whose bounds should be changed.
     * @param bounds - Array of <mxRectangles> that represent the new bounds.
     * @param recurse - Recursively resize children
     */
    resizeCells(
      cells: mxCell[],
      bounds: mxRectangle[],
      recurse?: any
    ): mxCell[]
    /**
     * 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.
     *
     * @example
     * 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);
     *         }
     *       }
     *     }
     *   }
     * });
     *
     * @param cells - Array of <mxCells> whose bounds should be changed.
     * @param bounds - Array of <mxRectangles> that represent the new bounds.
     * @param recurse - Optional boolean that specifies if the children should be resized.
     */
    cellsResized(
      cells: mxCell[],
      bounds: mxRectangle[],
      recurse?: boolean
    ): void
    /**
     * Resizes the parents recursively so that they contain the complete area
     * of the resized child cell.
     *
     * @param cell - <mxCell> whose bounds should be changed.
     * @param bounds - <mxRectangles> that represent the new bounds.
     * @param ignoreRelative - Boolean that indicates if relative cells should be ignored.
     * @param recurse - Optional boolean that specifies if the children should be resized.
     */
    cellResized(
      cell: mxCell,
      bounds: mxRectangle,
      ignoreRelative: boolean,
      recurse: boolean
    ): void
    /**
     * Resizes the child cells of the given cell for the given new geometry with
     * respect to the current geometry of the cell.
     *
     * @param cell - <mxCell> that has been resized.
     * @param newGeo - <mxGeometry> that represents the new bounds.
     */
    resizeChildCells(cell: mxCell, newGeo: mxGeometry): void
    /**
     * Constrains the children of the given cell using <constrainChild>.
     *
     * cell - <mxCell> that has been resized.
     */
    constrainChildCells(cell: any): void
    /**
     * Scales the points, position and size of the given cell according to the
     * given vertical and horizontal scaling factors.
     *
     * @param cell - <mxCell> whose geometry should be scaled.
     * @param dx - Horizontal scaling factor.
     * @param dy - Vertical scaling factor.
     * @param recurse - Boolean indicating if the child cells should be scaled.
     */
    scaleCell(cell: mxCell, dx: number, dy: number, recurse: boolean): void
    /**
     * Resizes the parents recursively so that they contain the complete area
     * of the resized child cell.
     *
     * @param cell - <mxCell> that has been resized.
     */
    extendParent(cell: mxCell): void
    /**
     * 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.
     *
     * @param cells - Array of <mxCells> to be imported.
     * @param dx - Integer that specifies the x-coordinate of the vector. Default is 0.
     * @param dy - Integer that specifies the y-coordinate of the vector. Default is 0.
     * @param target - <mxCell> that represents the new parent of the cells.
     * @param evt - Mouseevent that triggered the invocation.
     * @param mapping - Optional mapping for existing clones.
     */
    importCells(
      cells: mxCell[],
      dx: number,
      dy: number,
      target: mxCell,
      evt: Event,
      mapping: any
    ): mxCell[]
    /**
     * 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.
     *
     * @example graph.moveCells(graph.getChildCells(null, true, true), 10, 10);
     *
     * @param cells - Array of <mxCells> to be moved, cloned or added to the target.
     * @param dx - Integer that specifies the x-coordinate of the vector. Default is 0.
     * @param dy - Integer that specifies the y-coordinate of the vector. Default is 0.
     * @param clone - Boolean indicating if the cells should be cloned. Default is false.
     * @param target - <mxCell> that represents the new parent of the cells.
     * @param evt - Mouseevent that triggered the invocation.
     * @param mapping - Optional mapping for existing clones.
     */
    moveCells(
      cells: mxCell[],
      dx?: number,
      dy?: number,
      clone?: boolean,
      target?: mxCell,
      evt?: Event,
      mapping?: any
    ): mxCell[]
    /**
     * 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
    /**
     * Translates the geometry of the given cell and stores the new,
     * translated geometry in the model as an atomic change.
     */
    translateCell(cell: any, dx: any, dy: any): void
    /**
     * Returns the <mxRectangle> inside which a cell is to be kept.
     *
     * cell - <mxCell> for which the area should be returned.
     */
    getCellContainmentArea(cell: any): mxRectangle
    /**
     * Returns the bounds inside which the diagram should be kept as an
     * <mxRectangle>.
     */
    getMaximumGraphBounds(): any
    /**
     * 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.
     *
     * cells - <mxCell> which should be constrained.
     * sizeFirst - Specifies if the size should be changed first. Default is true.
     */
    constrainChild(cell: mxCell, sizeFirst?: boolean): void
    /**
     * 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.
     *
     * cells - Array of <mxCells> for which the connected edges should be
     * reset.
     */
    resetEdges(cells: mxCell[]): void
    /**
     * Resets the control points of the given edge.
     *
     * edge - <mxCell> whose points should be reset.
     */
    resetEdge(edge: any): any
    /**
     * Returns the constraint used to connect to the outline of the given state.
     */
    getOutlineConstraint(
      point: any,
      terminalState: any,
      me: any
    ): mxConnectionConstraint
    /**
     * 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.
     *
     * terminal - <mxCellState> that represents the terminal.
     * source - Boolean that specifies if the terminal is the source or target.
     */
    getAllConnectionConstraints(terminal: any, source: any): any
    /**
     * Returns an <mxConnectionConstraint> that describes the given connection
     * point. This result can then be passed to <getConnectionPoint>.
     *
     * @param edge - <mxCellState> that represents the edge.
     * @param terminal - <mxCellState> that represents the terminal.
     * @param source - Boolean indicating if the terminal is the source or target.
     */
    getConnectionConstraint(
      edge: mxCellState,
      terminal: mxCellState,
      source: boolean
    ): mxConnectionConstraint
    /**
     * 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.
     *
     * @param edge - <mxCell> that represents the edge.
     * @param terminal - <mxCell> that represents the terminal.
     * @param source - Boolean indicating if the terminal is the source or target.
     * @param constraint - Optional <mxConnectionConstraint> to be used for this
     * connection.
     */
    setConnectionConstraint(
      edge: mxCell,
      terminal: mxCell,
      source: boolean,
      constraint?: mxConnectionConstraint
    ): void
    /**
     * Returns the nearest point in the list of absolute points or the center
     * of the opposite terminal.
     *
     * @param vertex - <mxCellState> that represents the vertex.
     * @param constraint - <mxConnectionConstraint> that represents the connection point
     * constraint as returned by <getConnectionConstraint>.
     */
    getConnectionPoint(
      vertex: mxCellState,
      constraint: mxConnectionConstraint
    ): mxPoint
    /**
     * 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.
     *
     * @param edge - <mxCell> whose terminal should be updated.
     * @param terminal - <mxCell> that represents the new terminal to be used.
     * @param source - Boolean indicating if the new terminal is the source or target.
     * @param constraint - Optional <mxConnectionConstraint> to be used for this
     * connection.
     */
    connectCell(
      edge: mxCell,
      terminal: mxCell,
      source: boolean,
      constraint?: mxConnectionConstraint
    ): mxCell
    /**
     * 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.
     *
     * @param edge - <mxCell> whose terminal should be updated.
     * @param terminal - <mxCell> that represents the new terminal to be used.
     * @param source - Boolean indicating if the new terminal is the source or target.
     * @param constraint - <mxConnectionConstraint> to be used for this connection.
     */
    cellConnected(
      edge: mxCell,
      terminal: mxCell,
      source: boolean,
      constraint?: mxConnectionConstraint
    ): void
    /**
     * Disconnects the given edges from the terminals which are not in the
     * given array.
     *
     * @param cells - Array of <mxCells> to be disconnected.
     */
    disconnectGraph(cells: mxCell[]): void
    /**
     * Returns the current root of the displayed cell hierarchy. This is a
     * shortcut to <mxGraphView.currentRoot> in <view>.
     */
    getCurrentRoot(): mxCell
    /**
     * 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)
     *
     * @param cell - <mxCell> that represents the root.
     */
    getTranslateForRoot(cell: mxCell): any
    /**
     * 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)
     *
     * @param cell - <mxCell> that represents the port.
     */
    isPort(cell: mxCell): boolean
    /**
     * Returns the terminal to be used for a given port. This implementation
     * always returns the parent cell.
     *
     * @param cell - <mxCell> that represents the port.
     * @param source - If the cell is the source or target port.
     */
    getTerminalForPort(cell: mxCell, source: any): mxCell
    /**
     * 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.
     *
     * @param cell - <mxCell> whose offset should be returned.
     */
    getChildOffsetForCell(cell: mxCell): any
    /**
     * 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.
     *
     * @param cell - Optional <mxCell> to be used as the new root. Default is the
     * selection cell.
     */
    enterGroup(cell?: mxCell): void
    /**
     * Changes the current root to the next valid root in the displayed cell
     * hierarchy.
     */
    exitGroup(): void
    /**
     * Uses the root of the model as the root of the displayed cell hierarchy
     * and selects the previous root.
     */
    home(): void
    /**
     * Returns true if the given cell is a valid root for the cell display
     * hierarchy. This implementation returns true for all non-null values.
     *
     * cell - <mxCell> which should be checked as a possible root.
     */
    isValidRoot(cell: any): boolean
    /**
     * Returns the bounds of the visible graph. Shortcut to
     * <mxGraphView.getGraphBounds>. See also: <getBoundingBoxFromGeometry>.
     */
    getGraphBounds(): mxRectangle
    /**
     * Returns the scaled, translated bounds for the given cell. See
     * <mxGraphView.getBounds> for arrays.
     *
     * @param cell - <mxCell> whose bounds should be returned.
     * @param includeEdge - Optional boolean that specifies if the bounds of
     * the connected edges should be included. Default is false.
     * @param 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
    /**
     * 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)
     *
     * @param cells - Array of <mxCells> whose bounds should be returned.
     * @param 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
    /**
     * 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.
     *
     * @param cell - Optional <mxCell> for which the cell states should be cleared.
     */
    refresh(cell?: mxCell): void
    /**
     * Snaps the given numeric value to the grid if <gridEnabled> is true.
     *
     * value - Numeric value to be snapped to the grid.
     */
    snap(value: any): any
    /**
     * 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>.
     *
     * dx - Amount to shift the graph along the x-axis.
     * dy - Amount to shift the graph along the y-axis.
     */
    panGraph(dx: any, dy: any): void
    /**
     * Zooms into the graph by <zoomFactor>.
     */
    zoomIn(): void
    /**
     * Zooms out of the graph by <zoomFactor>.
     */
    zoomOut(): void
    /**
     * Resets the zoom and panning in the view.
     */
    zoomActual(): void
    /**
     * Zooms the graph to the given scale with an optional boolean center
     * argument, which is passd to <zoom>.
     */
    zoomTo(scale: any, center: any): void
    /**
     * Centers the graph in the container.
     *
     * 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: any, vertical: any, cx: any, cy: any): void
    /**
     * 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
    /**
     * 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.
     *
     * rect - The un-scaled and un-translated rectangluar region that should be just visible
     * after the operation
     */
    zoomToRect(rect: any): void
    /**
     * 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]
     *
     * cell - <mxCell> to be made visible.
     * center - Optional boolean flag. Default is false.
     */
    scrollCellToVisible(cell: any, center: any): void
    /**
     * Pans the graph so that it shows the given rectangle.
     *
     * rect - <mxRectangle> to be made visible.
     */
    scrollRectToVisible(rect: any): boolean
    /**
     * 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.
     *
     * cell - <mxCell> whose geometry should be returned.
     */
    getCellGeometry(cell: any): mxGeometry
    /**
     * 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.
     *
     * cell - <mxCell> whose visible state should be returned.
     */
    isCellVisible(cell: any): boolean
    /**
     * 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.
     *
     * cell - <mxCell> whose collapsed state should be returned.
     */
    isCellCollapsed(cell: any): boolean
    /**
     * 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.
     *
     * cell - <mxCell> whose connectable state should be returned.
     */
    isCellConnectable(cell: any): boolean
    /**
     * Returns true if perimeter points should be computed such that the
     * resulting edge has only horizontal or vertical segments.
     *
     * edge - <mxCellState> that represents the edge.
     */
    isOrthogonal(edge: mxCellState): any
    /**
     * Returns true if the given cell state is a loop.
     *
     * state - <mxCellState> that represents a potential loop.
     */
    isLoop(state: any): boolean
    /**
     * Returns true if the given event is a clone event. This implementation
     * returns true if control is pressed.
     */
    isCloneEvent(evt: any): boolean
    /**
     * 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
    /**
     * 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
    /**
     * Returns true if the given mouse event should be aligned to the grid.
     */
    isGridEnabledEvent(evt: any): boolean
    /**
     * Returns true if the given mouse event should be aligned to the grid.
     */
    isConstrainedEvent(evt: any): boolean
    /**
     * Returns true if the given mouse event should not allow any connections to be
     * made. This implementation returns false.
     */
    isIgnoreTerminalEvent(evt: any): boolean
    /**
     * Displays the given validation error in a dialog. This implementation uses
     * mxUtils.alert.
     */
    validationAlert(message: any): void
    /**
     * Checks if the return value of <getEdgeValidationError> for the given
     * arguments is null.
     *
     * edge - <mxCell> that represents the edge to validate.
     * source - <mxCell> that represents the source terminal.
     * target - <mxCell> that represents the target terminal.
     */
    isEdgeValid(edge: any, source: any, target: any): boolean
    /**
     * 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)
     *
     * edge - <mxCell> that represents the edge to validate.
     * source - <mxCell> that represents the source terminal.
     * target - <mxCell> that represents the target terminal.
     */
    getEdgeValidationError(edge: any, source: any, target: any): string
    /**
     * Hook method for subclassers to return an error message for the given
     * edge and terminals. This implementation returns null.
     *
     * edge - <mxCell> that represents the edge to validate.
     * source - <mxCell> that represents the source terminal.
     * target - <mxCell> that represents the target terminal.
     */
    validateEdge(edge: any, source: any, target: any): any
    /**
     * 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: any, context: any): any
    /**
     * Checks all <multiplicities> that cannot be enforced while the graph is
     * being modified, namely, all multiplicities that require a minimum of
     * 1 edge.
     *
     * cell - <mxCell> for which the multiplicities should be checked.
     */
    getCellValidationError(cell: any): string
    /**
     * 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.
     *
     * cell - <mxCell> that represents the cell to validate.
     * context - Object that represents the global validation state.
     */
    validateCell(cell: any, context: any): any
    /**
     * Returns the <backgroundImage> as an <mxImage>.
     */
    getBackgroundImage(): mxImage
    /**
     * Sets the new <backgroundImage>.
     *
     * image - New <mxImage> to be used for the background.
     */
    setBackgroundImage(image: any): void
    /**
     * Returns the <mxImage> used to display the collapsed state of
     * the specified cell state. This returns null for all edges.
     */
    getFoldingImage(state: any): mxImage
    /**
     * 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>.
     *
     * cell - <mxCell> whose textual representation should be returned.
     */
    convertValueToString(cell: any): string
    /**
     * 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)
     *
     * cell - <mxCell> whose label should be returned.
     */
    getLabel(cell: any): string
    /**
     * Returns true if the label must be rendered as HTML markup. The default
     * implementation returns <htmlLabels>.
     *
     * cell - <mxCell> whose label should be displayed as HTML markup.
     */
    isHtmlLabel(cell: any): boolean
    /**
     * Returns <htmlLabels>.
     */
    isHtmlLabels(): boolean
    /**
     * Sets <htmlLabels>.
     */
    setHtmlLabels(value: any): void
    /**
     * 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.
     *
     * state - <mxCell> whose label should be wrapped.
     */
    isWrapping(cell: any): boolean
    /**
     * 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'.
     *
     * state - <mxCell> whose label should be clipped.
     */
    isLabelClipped(cell: any): boolean
    /**
     * 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.
     *
     * 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: any, node: any, x: any, y: any): any
    /**
     * 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!
     *
     * cell - <mxCell> whose tooltip should be returned.
     */
    getTooltipForCell(cell: any): any
    /**
     * Returns the cursor value to be used for the CSS of the shape for the
     * given event. This implementation calls <getCursorForCell>.
     *
     * me - <mxMouseEvent> whose cursor should be returned.
     */
    getCursorForMouseEvent(me: any): any
    /**
     * Returns the cursor value to be used for the CSS of the shape for the
     * given cell. This implementation returns null.
     *
     * cell - <mxCell> whose cursor should be returned.
     */
    getCursorForCell(cell: any): any
    /**
     * 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.
     *
     * swimlane - <mxCell> whose start size should be returned.
     */
    getStartSize(swimlane: any): mxRectangle
    /**
     * Returns the image URL for the given cell state. This implementation
     * returns the value stored under <mxConstants.STYLE_IMAGE> in the cell
     * style.
     *
     * state - <mxCellState> whose image URL should be returned.
     */
    getImage(state: any): any
    /**
     * Returns the vertical alignment for the given cell state. This
     * implementation returns the value stored under
     * <mxConstants.STYLE_VERTICAL_ALIGN> in the cell style.
     *
     * state - <mxCellState> whose vertical alignment should be
     * returned.
     */
    getVerticalAlign(state: any): any
    /**
     * Returns the indicator color for the given cell state. This
     * implementation returns the value stored under
     * <mxConstants.STYLE_INDICATOR_COLOR> in the cell style.
     *
     * state - <mxCellState> whose indicator color should be
     * returned.
     */
    getIndicatorColor(state: any): any
    /**
     * 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.
     *
     * state - <mxCellState> whose indicator gradient color should be
     * returned.
     */
    getIndicatorGradientColor(state: any): any
    /**
     * Returns the indicator shape for the given cell state. This
     * implementation returns the value stored under
     * <mxConstants.STYLE_INDICATOR_SHAPE> in the cell style.
     *
     * state - <mxCellState> whose indicator shape should be returned.
     */
    getIndicatorShape(state: any): any
    /**
     * Returns the indicator image for the given cell state. This
     * implementation returns the value stored under
     * <mxConstants.STYLE_INDICATOR_IMAGE> in the cell style.
     *
     * state - <mxCellState> whose indicator image should be returned.
     */
    getIndicatorImage(state: any): any
    /**
     * Returns the value of <border>.
     */
    getBorder(): number
    /**
     * Sets the value of <border>.
     *
     * value - Positive integer that represents the border to be used.
     */
    setBorder(value: any): void
    /**
     * 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>.
     *
     * cell - <mxCell> to be checked.
     */
    isSwimlane(cell: any): boolean
    /**
     * Returns <resizeContainer>.
     */
    isResizeContainer(): boolean
    /**
     * Sets <resizeContainer>.
     *
     * value - Boolean indicating if the container should be resized.
     */
    setResizeContainer(value: any): void
    /**
     * Returns true if the graph is <enabled>.
     */
    isEnabled(): boolean
    /**
     * Specifies if the graph should allow any interactions. This
     * implementation updates <enabled>.
     *
     * value - Boolean indicating if the graph should be enabled.
     */
    setEnabled(value: any): void
    /**
     * Returns <escapeEnabled>.
     */
    isEscapeEnabled(): boolean
    /**
     * Sets <escapeEnabled>.
     *
     * enabled - Boolean indicating if escape should be enabled.
     */
    setEscapeEnabled(value: any): void
    /**
     * Returns <invokesStopCellEditing>.
     */
    isInvokesStopCellEditing(): boolean
    /**
     * Sets <invokesStopCellEditing>.
     */
    setInvokesStopCellEditing(value: any): void
    /**
     * Returns <enterStopsCellEditing>.
     */
    isEnterStopsCellEditing(): boolean
    /**
     * Sets <enterStopsCellEditing>.
     */
    setEnterStopsCellEditing(value: any): void
    /**
     * 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.
     *
     * cell - <mxCell> whose locked state should be returned.
     */
    isCellLocked(cell: any): boolean
    /**
     * 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.
     *
     * cell - <mxCell> whose locked state should be returned.
     */
    isCellsLocked(): boolean
    /**
     * Sets if any cell may be moved, sized, bended, disconnected, edited or
     * selected.
     *
     * value - Boolean that defines the new value for <cellsLocked>.
     */
    setCellsLocked(value: any): void
    /**
     * Returns the cells which may be exported in the given array of cells.
     */
    getCloneableCells(cells: any): mxCell[]
    /**
     * 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.
     *
     * cell - Optional <mxCell> whose cloneable state should be returned.
     */
    isCellCloneable(cell: any): boolean
    /**
     * Returns <cellsCloneable>, that is, if the graph allows cloning of cells
     * by using control-drag.
     */
    isCellsCloneable(): boolean
    /**
     * Specifies if the graph should allow cloning of cells by holding down the
     * control key while cells are being moved. This implementation updates
     * <cellsCloneable>.
     *
     * value - Boolean indicating if the graph should be cloneable.
     */
    setCellsCloneable(value: any): void
    /**
     * Returns the cells which may be exported in the given array of cells.
     */
    getExportableCells(cells: any): mxCell[]
    /**
     * Returns true if the given cell may be exported to the clipboard. This
     * implementation returns <exportEnabled> for all cells.
     *
     * cell - <mxCell> that represents the cell to be exported.
     */
    canExportCell(cell: any): boolean
    /**
     * Returns the cells which may be imported in the given array of cells.
     */
    getImportableCells(cells: any): mxCell[]
    /**
     * Returns true if the given cell may be imported from the clipboard.
     * This implementation returns <importEnabled> for all cells.
     *
     * cell - <mxCell> that represents the cell to be imported.
     */
    canImportCell(cell: any): boolean
    /**
     * 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 state = this.view.getState(cell);
     *   var style = (state != null) ? state.style : this.getCellStyle(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)
     *
     * cell - <mxCell> whose selectable state should be returned.
     */
    isCellSelectable(cell: any): boolean
    /**
     * Returns <cellsSelectable>.
     */
    isCellsSelectable(): boolean
    /**
     * Sets <cellsSelectable>.
     */
    setCellsSelectable(value: any): void
    /**
     * Returns the cells which may be exported in the given array of cells.
     */
    getDeletableCells(cells: any): mxCell[]
    /**
     * 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.
     *
     * cell - <mxCell> whose deletable state should be returned.
     */
    isCellDeletable(cell: any): boolean
    /**
     * Returns <cellsDeletable>.
     */
    isCellsDeletable(): boolean
    /**
     * Sets <cellsDeletable>.
     *
     * value - Boolean indicating if the graph should allow deletion of cells.
     */
    setCellsDeletable(value: any): void
    /**
     * 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.
     *
     * cell - <mxCell> whose label should be moved.
     */
    isLabelMovable(cell: any): boolean
    /**
     * 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.
     *
     * cell - <mxCell> whose rotatable state should be returned.
     */
    isCellRotatable(cell: any): boolean
    /**
     * Returns the cells which are movable in the given array of cells.
     */
    getMovableCells(cells: any): mxCell[]
    /**
     * 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.
     *
     * cell - <mxCell> whose movable state should be returned.
     */
    isCellMovable(cell: any): boolean
    /**
     * Returns <cellsMovable>.
     */
    isCellsMovable(): boolean
    /**
     * Specifies if the graph should allow moving of cells. This implementation
     * updates <cellsMsovable>.
     *
     * value - Boolean indicating if the graph should allow moving of cells.
     */
    setCellsMovable(value: any): void
    /**
     * Returns <gridEnabled> as a boolean.
     */
    isGridEnabled(): boolean
    /**
     * Specifies if the grid should be enabled.
     *
     * value - Boolean indicating if the grid should be enabled.
     */
    setGridEnabled(value: any): void
    /**
     * Returns <portsEnabled> as a boolean.
     */
    isPortsEnabled(): boolean
    /**
     * Specifies if the ports should be enabled.
     *
     * value - Boolean indicating if the ports should be enabled.
     */
    setPortsEnabled(value: any): void
    /**
     * Returns <gridSize>.
     */
    getGridSize(): number
    /**
     * Sets <gridSize>.
     */
    setGridSize(value: any): void
    /**
     * Returns <tolerance>.
     */
    getTolerance(): number
    /**
     * Sets <tolerance>.
     */
    setTolerance(value: any): void
    /**
     * Returns <vertexLabelsMovable>.
     */
    isVertexLabelsMovable(): boolean
    /**
     * Sets <vertexLabelsMovable>.
     */
    setVertexLabelsMovable(value: any): void
    /**
     * Returns <edgeLabelsMovable>.
     */
    isEdgeLabelsMovable(): boolean
    /**
     * Sets <edgeLabelsMovable>.
     */
    setEdgeLabelsMovable(value: any): void
    /**
     * Returns <swimlaneNesting> as a boolean.
     */
    isSwimlaneNesting(): boolean
    /**
     * Specifies if swimlanes can be nested by drag and drop. This is only
     * taken into account if dropEnabled is true.
     *
     * value - Boolean indicating if swimlanes can be nested.
     */
    setSwimlaneNesting(value: any): void
    /**
     * Returns <swimlaneSelectionEnabled> as a boolean.
     */
    isSwimlaneSelectionEnabled(): boolean
    /**
     * Specifies if swimlanes should be selected if the mouse is released
     * over their content area.
     *
     * value - Boolean indicating if swimlanes content areas
     * should be selected when the mouse is released over them.
     */
    setSwimlaneSelectionEnabled(value: any): void
    /**
     * Returns <multigraph> as a boolean.
     */
    isMultigraph(): boolean
    /**
     * Specifies if the graph should allow multiple connections between the
     * same pair of vertices.
     *
     * value - Boolean indicating if the graph allows multiple connections
     * between the same pair of vertices.
     */
    setMultigraph(value: any): void
    /**
     * Returns <allowLoops> as a boolean.
     */
    isAllowLoops(): boolean
    /**
     * Specifies if dangling edges are allowed, that is, if edges are allowed
     * that do not have a source and/or target terminal defined.
     *
     * value - Boolean indicating if dangling edges are allowed.
     */
    setAllowDanglingEdges(value: any): void
    /**
     * Returns <allowDanglingEdges> as a boolean.
     */
    isAllowDanglingEdges(): boolean
    /**
     * Specifies if edges should be connectable.
     *
     * value - Boolean indicating if edges should be connectable.
     */
    setConnectableEdges(value: any): void
    /**
     * Returns <connectableEdges> as a boolean.
     */
    isConnectableEdges(): boolean
    /**
     * Specifies if edges should be inserted when cloned but not valid wrt.
     * <getEdgeValidationError>. If false such edges will be silently ignored.
     *
     * value - Boolean indicating if cloned invalid edges should be
     * inserted into the graph or ignored.
     */
    setCloneInvalidEdges(value: any): void
    /**
     * Returns <cloneInvalidEdges> as a boolean.
     */
    isCloneInvalidEdges(): boolean
    /**
     * Specifies if loops are allowed.
     *
     * value - Boolean indicating if loops are allowed.
     */
    setAllowLoops(value: any): void
    /**
     * Returns <disconnectOnMove> as a boolean.
     */
    isDisconnectOnMove(): boolean
    /**
     * Specifies if edges should be disconnected when moved. (Note: Cloned
     * edges are always disconnected.)
     *
     * value - Boolean indicating if edges should be disconnected
     * when moved.
     */
    setDisconnectOnMove(value: any): void
    /**
     * Returns <dropEnabled> as a boolean.
     */
    isDropEnabled(): boolean
    /**
     * Specifies if the graph should allow dropping of cells onto or into other
     * cells.
     *
     * dropEnabled - Boolean indicating if the graph should allow dropping
     * of cells into other cells.
     */
    setDropEnabled(value: any): void
    /**
     * Returns <splitEnabled> as a boolean.
     */
    isSplitEnabled(): boolean
    /**
     * Specifies if the graph should allow dropping of cells onto or into other
     * cells.
     *
     * dropEnabled - Boolean indicating if the graph should allow dropping
     * of cells into other cells.
     */
    setSplitEnabled(value: any): void
    /**
     * 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.
     *
     * cell - <mxCell> whose resizable state should be returned.
     */
    isCellResizable(cell: any): boolean
    /**
     * Returns <cellsResizable>.
     */
    isCellsResizable(): boolean
    /**
     * Specifies if the graph should allow resizing of cells. This
     * implementation updates <cellsResizable>.
     *
     * value - Boolean indicating if the graph should allow resizing of
     * cells.
     */
    setCellsResizable(value: any): void
    /**
     * 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.
     *
     * cell - <mxCell> whose terminal point should be moved.
     * source - Boolean indicating if the source or target terminal should be moved.
     */
    isTerminalPointMovable(cell: any, source: any): boolean
    /**
     * 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.
     *
     * cell - <mxCell> whose bendable state should be returned.
     */
    isCellBendable(cell: any): boolean
    /**
     * Returns <cellsBenadable>.
     */
    isCellsBendable(): boolean
    /**
     * Specifies if the graph should allow bending of edges. This
     * implementation updates <bendable>.
     *
     * value - Boolean indicating if the graph should allow bending of
     * edges.
     */
    setCellsBendable(value: any): void
    /**
     * 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.
     *
     * cell - <mxCell> whose editable state should be returned.
     */
    isCellEditable(cell: any): boolean
    /**
     * Returns <cellsEditable>.
     */
    isCellsEditable(): boolean
    /**
     * Specifies if the graph should allow in-place editing for cell labels.
     * This implementation updates <cellsEditable>.
     *
     * value - Boolean indicating if the graph should allow in-place
     * editing.
     */
    setCellsEditable(value: any): void
    /**
     * 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.
     *
     * 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: any, terminal: any, source: any): boolean
    /**
     * Returns <cellsDisconnectable>.
     */
    isCellsDisconnectable(): boolean
    /**
     * Sets <cellsDisconnectable>.
     */
    setCellsDisconnectable(value: any): void
    /**
     * 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>.
     *
     * cell - <mxCell> that represents a possible source or null.
     */
    isValidSource(cell: any): boolean
    /**
     * Returns <isValidSource> for the given cell. This is called by
     * <isValidConnection>.
     *
     * cell - <mxCell> that represents a possible target or null.
     */
    isValidTarget(cell: any): boolean
    /**
     * 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.
     *
     * source - <mxCell> that represents the source cell.
     * target - <mxCell> that represents the target cell.
     */
    isValidConnection(source: any, target: any): boolean
    /**
     * Specifies if the graph should allow new connections. This implementation
     * updates <mxConnectionHandler.enabled> in <connectionHandler>.
     *
     * connectable - Boolean indicating if new connections should be allowed.
     */
    setConnectable(connectable: any): void
    /**
     * Returns true if the <connectionHandler> is enabled.
     */
    isConnectable(connectable: any): boolean
    /**
     * Specifies if tooltips should be enabled. This implementation updates
     * <mxTooltipHandler.enabled> in <tooltipHandler>.
     *
     * enabled - Boolean indicating if tooltips should be enabled.
     */
    setTooltips(enabled: any): void
    /**
     * Specifies if panning should be enabled. This implementation updates
     * <mxPanningHandler.panningEnabled> in <panningHandler>.
     *
     * enabled - Boolean indicating if panning should be enabled.
     */
    setPanning(enabled: any): void
    /**
     * 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.
     *
     * @param cell - <mxCell> that should be checked.
     */
    isEditing(cell?: mxCell): boolean
    /**
     * 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.
     *
     * cell - <mxCell> that should be resized.
     */
    isAutoSizeCell(cell: any): boolean
    /**
     * Returns <autoSizeCells>.
     */
    isAutoSizeCells(): boolean
    /**
     * 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.
     *
     * value - Boolean indicating if cells should be resized
     * automatically.
     */
    setAutoSizeCells(value: any): void
    /**
     * 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.
     *
     * cell - <mxCell> that has been resized.
     */
    isExtendParent(cell: any): boolean
    /**
     * Returns <extendParents>.
     */
    isExtendParents(): boolean
    /**
     * Sets <extendParents>.
     *
     * value - New boolean value for <extendParents>.
     */
    setExtendParents(value: any): void
    /**
     * Returns <extendParentsOnAdd>.
     */
    isExtendParentsOnAdd(cell: any): boolean
    /**
     * Sets <extendParentsOnAdd>.
     *
     * value - New boolean value for <extendParentsOnAdd>.
     */
    setExtendParentsOnAdd(value: any): void
    /**
     * Returns <extendParentsOnMove>.
     */
    isExtendParentsOnMove(): boolean
    /**
     * Sets <extendParentsOnMove>.
     *
     * value - New boolean value for <extendParentsOnAdd>.
     */
    setExtendParentsOnMove(value: any): void
    /**
     * Returns <recursiveResize>.
     *
     * state - <mxCellState> that is being resized.
     */
    isRecursiveResize(state?: mxCellState): boolean
    /**
     * Sets <recursiveResize>.
     *
     * value - New boolean value for <recursiveResize>.
     */
    setRecursiveResize(value: any): void
    /**
     * 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.
     *
     * cell - <mxCell> that should be constrained.
     */
    isConstrainChild(cell: any): boolean
    /**
     * Returns <constrainChildren>.
     */
    isConstrainChildren(): boolean
    /**
     * Sets <constrainChildren>.
     */
    setConstrainChildren(value: any): void
    /**
     * Returns <constrainRelativeChildren>.
     */
    isConstrainRelativeChildren(): boolean
    /**
     * Sets <constrainRelativeChildren>.
     */
    setConstrainRelativeChildren(value: any): void
    /**
     * Returns <allowNegativeCoordinates>.
     */
    isAllowNegativeCoordinates(): boolean
    /**
     * Sets <allowNegativeCoordinates>.
     */
    setAllowNegativeCoordinates(value: any): void
    /**
     * 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.
     *
     * cell - <mxCell> for which the overlap ratio should be returned.
     */
    getOverlap(cell: any): number
    /**
     * Returns true if the given cell is allowed to be placed outside of the
     * parents area.
     *
     * cell - <mxCell> that represents the child to be checked.
     */
    isAllowOverlapParent(cell: any): boolean
    /**
     * Returns the cells which are movable in the given array of cells.
     */
    getFoldableCells(cells: any, collapse: any): mxCell[]
    /**
     * 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.
     *
     * cell - <mxCell> whose foldable state should be returned.
     */
    isCellFoldable(cell: any, collapse: any): boolean
    /**
     * 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.
     *
     * 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: any, cells: any, evt: any): boolean
    /**
     * Returns true if the given edge may be splitted into two edges with the
     * given cell as a new terminal between the two.
     *
     * target - <mxCell> that represents the edge to be splitted.
     * cells - <mxCells> that should split the edge.
     * evt - Mouseevent that triggered the invocation.
     */
    isSplitTarget(target: any, cells: any, evt: any): boolean
    /**
     * 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.
     *
     * 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: any, evt: any, cell: any, clone: any): any
    /**
     * 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
    /**
     * Sets the <defaultParent> to the given cell. Set this to null to return
     * the first child of the root in getDefaultParent.
     */
    setDefaultParent(cell: any): void
    /**
     * Returns the nearest ancestor of the given cell which is a swimlane, or
     * the given cell, if it is itself a swimlane.
     *
     * cell - <mxCell> for which the ancestor swimlane should be returned.
     */
    getSwimlane(cell: any): any
    /**
     * Returns the bottom-most swimlane that intersects the given point (x, y)
     * in the cell hierarchy that starts at the given parent.
     *
     * 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): any
    /**
     * 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.
     *
     * @param x - X-coordinate of the location to be checked.
     * @param y - Y-coordinate of the location to be checked.
     * @param 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.
     * @param vertices - Optional boolean indicating if vertices should be returned.
     * Default is true.
     * @param edges - Optional boolean indicating if edges should be returned. Default
     * is true.
     * @param 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?: (cell: mxCellState, x: number, y: number) => boolean
    ): any
    /**
     * Returns the bottom-most cell that intersects the given point (x, y) in
     * the cell hierarchy that starts at the given parent.
     *
     * 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: any, x: any, y: any): boolean
    /**
     * Returns true if the given coordinate pair is inside the content
     * are of the given swimlane.
     *
     * swimlane - <mxCell> that specifies the swimlane.
     * x - X-coordinate of the mouse event.
     * y - Y-coordinate of the mouse event.
     */
    hitsSwimlaneContent(swimlane: any, x: any, y: any): boolean
    /**
     * Returns the visible child vertices of the given parent.
     *
     * parent - <mxCell> whose children should be returned.
     */
    getChildVertices(parent: any): mxCell[]
    /**
     * Returns the visible child edges of the given parent.
     *
     * @param parent - <mxCell> whose child vertices should be returned.
     */
    getChildEdges(parent: mxCell): mxCell[]
    /**
     * Returns the visible child vertices or edges in the given parent. If
     * vertices and edges is false, then all children are returned.
     *
     * @param parent - <mxCell> whose children should be returned.
     * @param vertices - Optional boolean that specifies if child vertices should
     * be returned. Default is false.
     * @param edges - Optional boolean that specifies if child edges should
     * be returned. Default is false.
     */
    getChildCells(
      parent: mxCell,
      vertices?: boolean,
      edges?: boolean
    ): mxCell[]
    /**
     * Returns all visible edges connected to the given cell without loops.
     *
     * @param cell - <mxCell> whose connections should be returned.
     * @param parent - Optional parent of the opposite end for a connection to be
     * returned.
     */
    getConnections(cell: mxCell, parent?: mxCell): any[]
    /**
     * 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.
     *
     * @param cell - <mxCell> whose incoming edges should be returned.
     * @param parent - Optional parent of the opposite end for an edge to be
     * returned.
     */
    getIncomingEdges(cell: mxCell, parent?: mxCell): any[]
    /**
     * 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.
     *
     * @param cell - <mxCell> whose outgoing edges should be returned.
     * @param parent - Optional parent of the opposite end for an edge to be
     * returned.
     */
    getOutgoingEdges(cell: mxCell, parent?: mxCell): any[]
    /**
     * 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.
     *
     * @param cell - <mxCell> whose edges should be returned.
     * @param parent - Optional parent of the opposite end for an edge to be
     * returned.
     * @param incoming - Optional boolean that specifies if incoming edges should
     * be included in the result. Default is true.
     * @param outgoing - Optional boolean that specifies if outgoing edges should
     * be included in the result. Default is true.
     * @param includeLoops - Optional boolean that specifies if loops should be
     * included in the result. Default is true.
     * @param 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
    ): any[]
    /**
     * 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.
     *
     * cell - <mxCell> the possible child cell
     * parent - <mxCell> the possible parent cell
     * recurse - boolean whether or not to recurse the child ancestors
     */
    isValidAncestor(cell: any, parent: any, recurse: any): boolean
    /**
     * Returns all distinct visible opposite cells for the specified terminal
     * on the given edges.
     *
     * 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.
     * source - 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: any, terminal: any, sources: any, targets: any): any[]
    /**
     * 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.
     *
     * source -
     * target -
     * directed -
     */
    getEdgesBetween(source: any, target: any, directed: any): any[]
    /**
     * Returns an <mxPoint> representing the given event in the unscaled,
     * non-translated coordinate space of <container> and applies the grid.
     *
     * @param evt - Mousevent that contains the mouse pointer location.
     * @param addOffset - Optional boolean that specifies if the position should be
     * offset by half of the <gridSize>. Default is true.
     */
    getPointForEvent(evt: MouseEvent, addOffset?: boolean): any
    /**
     * 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.
     *
     * @param x - X-coordinate of the rectangle.
     * @param y - Y-coordinate of the rectangle.
     * @param width - Width of the rectangle.
     * @param height - Height of the rectangle.
     * @param 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.
     * @param result - Optional array to store the result in.
     */
    getCells(
      x: number,
      y: number,
      width: number,
      height: number,
      parent?: mxCell,
      result?: mxCell[]
    ): mxCell[]
    /**
     * 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.
     *
     * 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: any,
      y0: any,
      parent: any,
      rightHalfpane: any,
      bottomHalfpane: any
    ): any[]
    /**
     * 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.
     *
     * 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: any, isolate: any, invert: 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)
     *
     * 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: any,
      directed: any,
      func: any,
      edge: any,
      visited: any,
      inverse: any
    ): void
    /**
     * Returns true if the given cell is selected.
     *
     * cell - <mxCell> for which the selection state should be returned.
     */
    isCellSelected(cell: any): boolean
    /**
     * Returns true if the selection is empty.
     */
    isSelectionEmpty(): boolean
    /**
     * Clears the selection using <mxGraphSelectionModel.clear>.
     */
    clearSelection(): void
    /**
     * Returns the number of selected cells.
     */
    getSelectionCount(): number
    /**
     * Returns the first cell from the array of selected <mxCells>.
     */
    getSelectionCell(): mxCell
    /**
     * Returns the array of selected <mxCells>.
     */
    getSelectionCells(): mxCell[]
    /**
     * Sets the selection cell.
     *
     * cell - <mxCell> to be selected.
     */
    setSelectionCell(cell: any): void
    /**
     * Sets the selection cell.
     *
     * cells - Array of <mxCells> to be selected.
     */
    setSelectionCells(cells: any): void
    /**
     * Adds the given cell to the selection.
     *
     * cell - <mxCell> to be add to the selection.
     */
    addSelectionCell(cell: any): void
    /**
     * Adds the given cells to the selection.
     *
     * cells - Array of <mxCells> to be added to the selection.
     */
    addSelectionCells(cells: any): void
    /**
     * Removes the given cell from the selection.
     *
     * cell - <mxCell> to be removed from the selection.
     */
    removeSelectionCell(cell: any): void
    /**
     * Removes the given cells from the selection.
     *
     * cells - Array of <mxCells> to be removed from the selection.
     */
    removeSelectionCells(cells: any): void
    /**
     * Selects and returns the cells inside the given rectangle for the
     * specified event.
     *
     * @param rect - <mxRectangle> that represents the region to be selected.
     * @param evt - Mouseevent that triggered the selection.
     */
    selectRegion(rect: mxRectangle, evt: MouseEvent): mxCell[]
    /**
     * Selects the next cell.
     */
    selectNextCell(): void
    /**
     * Selects the previous cell.
     */
    selectPreviousCell(): void
    /**
     * Selects the parent cell.
     */
    selectParentCell(): void
    /**
     * Selects the first child cell.
     */
    selectChildCell(): void
    /**
     * Selects the next, parent, first child or previous cell, if all arguments
     * are false.
     *
     * @param isNext - Boolean indicating if the next cell should be selected.
     * @param isParent - Boolean indicating if the parent cell should be selected.
     * @param isChild - Boolean indicating if the first child cell should be selected.
     */
    selectCell(isNext?: boolean, isParent?: boolean, isChild?: boolean): void
    /**
     * 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>.
     *
     * 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: any, descendants: any): void
    /**
     * Select all vertices inside the given parent or the default parent.
     */
    selectVertices(parent: any): void
    /**
     * Select all vertices inside the given parent or the default parent.
     */
    selectEdges(parent: any): void
    /**
     * 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.
     *
     * 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>.
     */
    selectCells(vertices: any, edges: any, parent: any): void
    /**
     * 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.
     *
     * cell - <mxCell> to be selected.
     * evt - Optional mouseevent that triggered the selection.
     */
    selectCellForEvent(cell: any, evt: any): void
    /**
     * 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.
     *
     * cells - Array of <mxCells> to be selected.
     * evt - Optional mouseevent that triggered the selection.
     */
    selectCellsForEvent(cells: any, evt: any): void
    /**
     * 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>.
     *
     * state - <mxCellState> whose handler should be created.
     */
    createHandler(state: any): any
    /**
     * Hooks to create a new <mxVertexHandler> for the given <mxCellState>.
     *
     * state - <mxCellState> to create the handler for.
     */
    createVertexHandler(state: any): mxVertexHandler
    /**
     * Hooks to create a new <mxEdgeHandler> for the given <mxCellState>.
     *
     * state - <mxCellState> to create the handler for.
     */
    createEdgeHandler(state: any, edgeStyle: any): any
    /**
     * Hooks to create a new <mxEdgeSegmentHandler> for the given <mxCellState>.
     *
     * state - <mxCellState> to create the handler for.
     */
    createEdgeSegmentHandler(state: any): mxEdgeSegmentHandler
    /**
     * Hooks to create a new <mxElbowEdgeHandler> for the given <mxCellState>.
     *
     * state - <mxCellState> to create the handler for.
     */
    createElbowEdgeHandler(state: any): mxElbowEdgeHandler
    /**
     * 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.
     *
     * listener - Listener to be added to the graph event listeners.
     */
    addMouseListener(listener: any): void
    /**
     * Removes the specified graph listener.
     *
     * listener - Listener to be removed from the graph event listeners.
     */
    removeMouseListener(listener: any): void
    /**
     * Sets the graphX and graphY properties if the given <mxMouseEvent> if
     * required and returned the event.
     *
     * me - <mxMouseEvent> to be updated.
     * evtName - Name of the mouse event.
     */
    updateMouseEvent(me: any, evtName: any): any
    /**
     * Returns the state for the given touch event.
     */
    getStateForTouchEvent(evt: any): mxCellState
    /**
     * Returns true if the event should be ignored in <fireMouseEvent>.
     */
    isEventIgnored(evtName: any, me: any, sender: any): boolean
    /**
     * Hook for ignoring synthetic mouse events after touchend in Firefox.
     */
    isSyntheticEventIgnored(evtName: any, me: any, sender: any): boolean
    /**
     * 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.
     *
     * evtName - The name of the event.
     * me - <mxMouseEvent> that should be ignored.
     */
    isEventSourceIgnored(evtName: any, me: any): boolean
    /**
     * Returns the <mxCellState> to be used when firing the mouse event for the
     * given state. This implementation returns the given state.
     *
     * <mxCellState> - State whose event source should be returned.
     */
    getEventState(state: any): any
    /**
     * 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.
     *
     * 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: any, sender: any): void
    /**
     * Consumes the given <mxMouseEvent> if it's a touchStart event.
     */
    consumeMouseEvent(evtName: any, me: any, sender: any): void
    /**
     * 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)
     *
     * evt - Gestureend event that represents the gesture.
     * cell - Optional <mxCell> associated with the gesture.
     */
    fireGestureEvent(evt: any, cell: any): void
    /**
     * 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.
   */
  export 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.
   */
  export class mxOutline {
    constructor(source: any, container: any)

    /**
     * Specifies if events are handled.  Default is true.
     */
    enabled: boolean
    /**
     * Specifies a viewport rectangle should be shown.  Default is true.
     */
    showViewport: boolean
    /**
     * Border to be added at the bottom and right.  Default is 10.
     */
    border: number
    /**
     * Specifies if update should be called for mxEvent.PAN in the source graph.  Default is false.
     */
    updateOnPan: boolean
    /**
     * Optional boolean flag to suspend updates.  Default is false.  This flag will also suspend repaints of the outline.  To toggle this switch, use the following code.
     */
    suspended: boolean
    /**
     * 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.
   */
  export 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.
   */
  export class mxLayoutManager 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(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(parent: 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.
   */
  export 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.
   */
  export 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>.
   */
  export 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.
   */
  export class mxConnectionConstraint {
    /**
     * <mxPoint> that specifies the fixed location of the connection point.
     */
    point: any
    /**
     * 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
    /**
     * 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)
  }

  /**
   * 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>.
   */
  export class mxGraphHandler {
    /**
     * Variable: graph
     *
     * Reference to the enclosing <mxGraph>.
     */
    graph: any

    /**
     * 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: guide
     *
     * Holds the <mxGuide> instance that is used for alignment.
     */
    guide: any

    /**
     * Variable: currentDx
     *
     * Stores the x-coordinate of the current mouse move.
     */
    currentDx: number

    /**
     * Variable: currentDy
     *
     * Stores the y-coordinate of the current mouse move.
     */
    currentDy: number

    /**
     * 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: connectOnDrop
     *
     * Specifies if drop events are interpreted as new connections if no other
     * drop action is defined. Default is false.
     */
    connectOnDrop: boolean

    /**
     * Variable: scrollOnMove
     *
     * Specifies if the view should be scrolled so that a moved cell is
     * visible. Default is true.
     */
    scrollOnMove: 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: any

    /**
     * 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

    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
    /**
     * Hook to return initial cell for the given event.
     */
    getInitialCellForEvent(me: any): any
    /**
     * Hook to return true for delayed selections.
     */
    isDelayedSelection(cell: any, me: any): any
    /**
     * 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 evnent 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
    /**
     * 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
    /**
     * Creates an array of cell states which should be used as guides.
     */
    getGuideStates(): any
    /**
     * 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
    /**
     * Returns the <mxRectangle> used as the preview bounds for
     * moving the given cells.
     */
    getPreviewBounds(cells: any): any
    /**
     * 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
    /**
     * Creates the shape used to draw the preview for the given bounds.
     */
    createPreviewShape(bounds: any): mxRectangleShape
    /**
     * Starts the handling of the mouse gesture.
     */
    start(cell: any, x: any, y: any): void
    /**
     * Returns true if the guides should be used for the given <mxMouseEvent>.
     * This implementation returns <mxGuide.isEnabledForEvent>.
     */
    useGuidesForEvent(me: any): any
    /**
     * Snaps the given vector to the grid and returns the given mxPoint instance.
     */
    snap(vector: any): any
    /**
     * Returns an <mxPoint> that represents the vector for moving the cells
     * for the given <mxMouseEvent>.
     */
    getDelta(me: any): mxPoint
    /**
     * Hook for subclassers do show details while the handler is active.
     */
    updateHint(me: any): void
    /**
     * Hooks for subclassers to hide details when the handler gets inactive.
     */
    removeHint(): void
    /**
     * Hook for rounding the unscaled vector. This uses Math.round.
     */
    roundLength(length: any): number
    /**
     * Handles the event by highlighting possible drop targets and updating the
     * preview.
     */
    mouseMove(sender: any, me: any): void
    /**
     * Updates the bounds of the preview shape.
     */
    updatePreviewShape(): void
    /**
     * Sets the color of the rectangle used to highlight drop targets.
     *
     * Parameters:
     *
     * color - String that represents the new highlight color.
     */
    setHighlightColor(color: any): void
    /**
     * Handles the event by applying the changes to the selection cells.
     */
    mouseUp(sender: any, me: any): void
    /**
     * Implements the delayed selection for the given mouse event.
     */
    selectDelayed(me: any): void
    /**
     * Resets the state of this handler.
     */
    reset(): void
    /**
     * 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
    /**
     * Moves the given cells by the specified amount.
     */
    moveCells(
      cells: any,
      dx: any,
      dy: any,
      clone: any,
      target: any,
      evt: any
    ): void
    /**
     * Destroy the preview and highlight shapes.
     */
    destroyShapes(): void
    /**
     * 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>.
   */
  export 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>.
   */
  export class mxPopupMenuHandler extends mxPopupMenu {
    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, me)
   *   {
   *     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>.
   */
  export 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>.
   */
  export class mxSelectionCellsHandler extends mxEventSource {
    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
  }

  /**
   * 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.
   */
  export class mxConnectionHandler extends mxEventSource {
    /**
     * Reference to the enclosing <mxGraph>.
     */
    graph: any
    /**
     * 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: boolean
    /**
     * 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
    /**
     * 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
    /**
     * <mxImage> that is used to trigger the creation of a new connection. This
     * is used in <createIcons>. Default is null.
     */
    connectImage: any
    /**
     * Specifies if the connect icon should be centered on the target state
     * while connections are being previewed. Default is false.
     */
    targetConnectImage: boolean
    /**
     * Specifies if events are handled. Default is true.
     */
    enabled: boolean
    /**
     * Specifies if new edges should be selected. Default is true.
     */
    select: boolean
    /**
     * 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
    /**
     * Holds the <mxTerminalMarker> used for finding source and target cells.
     */
    marker: any
    /**
     * Holds the <mxConstraintHandler> used for drawing and highlighting
     * constraints.
     */
    constraintHandler: any
    /**
     * Holds the current validation error while connections are being created.
     */
    error: any
    /**
     * Specifies if single clicks should add waypoints on the new edge. Default is
     * false.
     */
    waypointsEnabled: boolean
    /**
     * 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
    /**
     * Holds the <mxPoint> where the mouseDown took place while the handler is
     * active.
     */
    first: any
    /**
     * 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
    /**
     * Optional <mxCellState> that represents the preview edge while the
     * handler is active. This is created in <createEdgeState>.
     */
    edgeState: any
    /**
     * Holds the change event listener for later removal.
     */
    changeHandler: any
    /**
     * Holds the drill event listener for later removal.
     */
    drillHandler: any
    /**
     * Counts the number of mouseDown events since the start. The initial mouse
     * down event counts as 1.
     */
    mouseDownCounter: number
    /**
     * 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
    /**
     * 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
    /**
     * 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
    /**
     * Specifies the cursor to be used while the handler is active. Default is null.
     */
    cursor: any
    /**
     * Specifies if new edges should be inserted before the source vertex in the
     * cell hierarchy. Default is false for backwards compatibility.
     */
    insertBeforeSource: boolean
    /**
     * Implicit variable declarations
     */
    previous: any
    escapeHandler: any
    /**
     * 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.
     *
     * @param graph - Reference to the enclosing <mxGraph>.
     * @param 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.
     */
    constructor(graph?: any, factoryMethod?: any)
    /**
     * Returns true if events are handled. This implementation
     * returns <enabled>.
     */
    isEnabled(): boolean
    /**
     * Enables or disables event handling. This implementation
     * updates <enabled>.
     *
     * Parameters:
     *
     * enabled - Boolean that specifies the new enabled state.
     */
    setEnabled(enabled: any): void
    /**
     * 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: any,
      source: any,
      target: any,
      evt: any,
      dropTarget: any
    ): boolean
    /**
     * Returns <createTarget>.
     *
     * Parameters:
     *
     * evt - Current active native pointer event.
     */
    isCreateTarget(evt: any): boolean
    /**
     * Sets <createTarget>.
     */
    setCreateTarget(value: any): void
    /**
     * Creates the preview shape for new connections.
     */
    createShape(): any
    /**
     * 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
    /**
     * Returns true if the given cell is connectable. This is a hook to
     * disable floating connections. This implementation returns true.
     */
    isConnectableCell(cell: any): boolean
    /**
     * Creates and returns the <mxCellMarker> used in <marker>.
     */
    createMarker(): any
    /**
     * Starts a new connection for the given state and coordinates.
     */
    start(state: any, x: any, y: any, edgeState: any): void
    /**
     * Returns true if the source terminal has been clicked and a new
     * connection is currently being previewed.
     */
    isConnecting(): boolean
    /**
     * 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: any, me: any): any
    /**
     * 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: any): boolean
    /**
     * 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
    /**
     * 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: any): any
    /**
     * 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: any): boolean
    /**
     * Creates the array <mxImageShapes> that represent the connect icons for
     * the given <mxCellState>.
     *
     * Parameters:
     *
     * state - <mxCellState> whose connect icons should be returned.
     */
    createIcons(state: any): any[]
    /**
     * Redraws the given array of <mxImageShapes>.
     *
     * Parameters:
     *
     * icons - Optional array of <mxImageShapes> to be redrawn.
     */
    redrawIcons(icons: any, state: any): void
    /**
     * Redraws the given array of <mxImageShapes>.
     *
     * Parameters:
     *
     * icons - Optional array of <mxImageShapes> to be redrawn.
     */
    getIconPosition(icon: any, state: any): mxPoint
    /**
     * Destroys the connect icons and resets the respective state.
     */
    destroyIcons(): void
    /**
     * 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
    /**
     * Handles the event by initiating a new connection.
     */
    mouseDown(sender: any, me: any): void
    /**
     * 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: any): boolean
    /**
     * 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): any
    /**
     * Returns true if <outlineConnect> is true and the source of the event is the outline shape
     * or shift is pressed.
     */
    isOutlineConnectEvent(me: any): any
    /**
     * Updates the current state for a given mouse move event by using
     * the <marker>.
     */
    updateCurrentState(me: any, point: any): void
    /**
     * Converts the given point from screen coordinates to model coordinates.
     */
    convertWaypoint(point: any): void
    /**
     * 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: any): void
    /**
     * Handles the event by updating the preview edge or by highlighting
     * a possible source or target terminal.
     */
    mouseMove(sender: any, me: any): void
    /**
     * Updates <edgeState>.
     */
    updateEdgeState(current: any, constraint: any): void
    /**
     * 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: any, me: any): any
    /**
     * 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: any, next: any, me: any): any
    /**
     * 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: any, icons: any, me: any): void
    /**
     * 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
    /**
     * Adds the waypoint for the given event to <waypoints>.
     */
    addWaypointForEvent(me: any): void
    /**
     * Handles the event by inserting the new connection.
     */
    mouseUp(sender: any, me: any): void
    /**
     * Resets the state of this handler.
     */
    reset(): void
    /**
     * Redraws the preview edge using the color and width returned by
     * <getEdgeColor> and <getEdgeWidth>.
     */
    drawPreview(): void
    /**
     * 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: any): void
    /**
     * 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: any): string
    /**
     * 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: any): 1 | 3
    /**
     * 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: any, target: any, evt: any, dropTarget: any): void
    /**
     * 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
    /**
     * 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: any,
      id: any,
      value: any,
      source: any,
      target: any,
      style: any
    ): any
    /**
     * 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: any): any
    /**
     * Returns the tolerance for aligning new targets to sources. This returns the grid size / 2.
     */
    getAlignmentTolerance(evt: any): any
    /**
     * 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: any, target: any, style: any): any
    /**
     * 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.
   */
  export class mxConstraintHandler {
    /**
     * mxImage to be used as the image for fixed connection points.
     */
    pointImage: mxImage
    /**
     * Reference to the enclosing mxGraph.
     */
    graph: mxGraph
    /**
     * Specifies if events are handled.  Default is true.
     */
    enabled: boolean
    /**
     * Specifies the color for the highlight.  Default is mxConstants.DEFAULT_VALID_COLOR.
     */
    highlightColor: string

    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.
   */
  export class mxRubberband {
    /**
     * Variable: defaultOpacity
     *
     * Specifies the default opacity to be used for the rubberband div. Default
     * is 20.
     */
    defaultOpacity: number

    /**
     * Variable: enabled
     *
     * Specifies if events are handled. Default is true.
     */
    enabled: boolean

    /**
     * Variable: div
     *
     * Holds the DIV element which is currently visible.
     */
    div: any

    /**
     * Variable: sharedDiv
     *
     * Holds the DIV element which is used to display the rubberband.
     */
    sharedDiv: any

    /**
     * Variable: currentX
     *
     * Holds the value of the x argument in the last call to <update>.
     */
    currentX: number

    /**
     * Variable: currentY
     *
     * Holds the value of the y argument in the last call to <update>.
     */
    currentY: 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
  }

  /**
   * 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.
   */
  export class mxHandle {
    constructor(state: any, cursor: any, image: any)
    /**
     * Hook for subclassers to return the current position of the handle.
     */
    getPosition(bounds: any): void
    /**
     * Hooks for subclassers to update the style in the <state>.
     */
    setPosition(bounds: any, pt: any, me: any): void
    /**
     * Hook for subclassers to execute the handle.
     */
    execute(): void
    /**
     * Sets the cell style with the given name to the corresponding value in <state>.
     */
    copyStyle(key: any): void
    /**
     * Processes the given <mxMouseEvent> and invokes <setPosition>.
     */
    processEvent(me: any): void
    /**
     * Called after <setPosition> has been called in <processEvent>. This repaints
     * the state using <mxCellRenderer>.
     */
    positionChanged(): void
    /**
     * Returns the rotation defined in the style of the cell.
     */
    getRotation(): any
    /**
     * Returns the rotation from the style and the rotation from the direction of
     * the cell.
     */
    getTotalRotation(): any
    /**
     * Creates and initializes the shapes required for this handle.
     */
    init(): void
    /**
     * Creates and returns the shape for this handle.
     */
    createShape(html: any): mxRectangleShape
    /**
     * Initializes <shape> and sets its cursor.
     */
    initShape(html: any): void
    /**
     * Renders the shape for this handle.
     */
    redraw(): void
    /**
     * Returns true if this handle should be rendered in HTML. This returns true if
     * the text node is in the graph container.
     */
    isHtmlRequired(): boolean
    /**
     * Rotates the point by the given angle.
     */
    rotatePoint(pt: any, alpha: any): any
    /**
     * Flips the given point vertically and/or horizontally.
     */
    flipPoint(pt: any): any
    /**
     * Snaps the given point to the grid if ignore is false. This modifies
     * the given point in-place and also returns it.
     */
    snapPoint(pt: any, ignore: any): any
    /**
     * Shows or hides this handle.
     */
    setVisible(visible: any): void
    /**
     * Resets the state of this handle by setting its visibility to true.
     */
    reset(): void
    /**
     * Destroys this handle.
     */
    destroy(): void
  }

  /**
   * 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.
   */
  export class mxVertexHandler {
    constructor(state: any)
    /**
     * Initializes the shapes required for this vertex handler.
     */
    init(): void
    /**
     * Returns true if the rotation handle should be showing.
     */
    isRotationHandleVisible(): boolean
    /**
     * Returns true if the aspect ratio if the cell should be maintained.
     */
    isConstrainedEvent(me: any): boolean
    /**
     * Returns true if the center of the vertex should be maintained during the resize.
     */
    isCenteredEvent(state: any, me: any): boolean
    /**
     * Returns an array of custom handles. This implementation returns null.
     */
    createCustomHandles(): any
    /**
     * Initializes the shapes required for this vertex handler.
     */
    updateMinBounds(): void
    /**
     * Returns the mxRectangle that defines the bounds of the selection
     * border.
     */
    getSelectionBounds(state: any): mxRectangle
    /**
     * Creates the shape used to draw the selection border.
     */
    createParentHighlightShape(bounds: any): mxRectangleShape
    /**
     * Creates the shape used to draw the selection border.
     */
    createSelectionShape(bounds: any): mxRectangleShape
    /**
     * Returns <mxConstants.VERTEX_SELECTION_COLOR>.
     */
    getSelectionColor(): string
    /**
     * Returns <mxConstants.VERTEX_SELECTION_STROKEWIDTH>.
     */
    getSelectionStrokeWidth(): number
    /**
     * Returns <mxConstants.VERTEX_SELECTION_DASHED>.
     */
    isSelectionDashed(): boolean
    /**
     * Creates a sizer handle for the specified cursor and index and returns
     * the new <mxRectangleShape> that represents the handle.
     */
    createSizer(cursor: any, index: any, size: any, fillColor: any): any
    /**
     * Returns true if the sizer for the given index is visible.
     * This returns true for all given indices.
     */
    isSizerVisible(index: any): boolean
    /**
     * 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: any, index: any, fillColor: any): any
    /**
     * 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: any, x: any, y: any): void
    /**
     * 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): number
    /**
     * Returns true if the given event allows custom handles to be changed. This
     * implementation returns true.
     */
    isCustomHandleEvent(me: any): boolean
    /**
     * 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
    /**
     * Called if <livePreview> is enabled to check if a border should be painted.
     * This implementation returns true if the shape is transparent.
     */
    isLivePreviewBorder(): boolean
    /**
     * Starts the handling of the mouse gesture.
     */
    start(x: any, y: any, index: any): void
    /**
     * Shortcut to <hideSizers>.
     */
    setHandlesVisible(visible: any): void
    /**
     * Hides all sizers except.
     *
     * Starts the handling of the mouse gesture.
     */
    hideSizers(): void
    /**
     * 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
    /**
     * Hook for subclassers do show details while the handler is active.
     */
    updateHint(me: any): void
    /**
     * Hooks for subclassers to hide details when the handler gets inactive.
     */
    removeHint(): void
    /**
     * Hook for rounding the angle. This uses Math.round.
     */
    roundAngle(angle: any): number
    /**
     * Hook for rounding the unscaled width or height. This uses Math.round.
     */
    roundLength(length: any): number
    /**
     * Handles the event by updating the preview.
     */
    mouseMove(sender: any, me: any): void
    /**
     * Rotates the vertex.
     */
    moveLabel(me: any): void
    /**
     * Rotates the vertex.
     */
    rotateVertex(me: any): void
    /**
     * Rotates the vertex.
     */
    resizeVertex(me: any): void
    /**
     * Repaints the live preview.
     */
    updateLivePreview(me: any): void
    /**
     * Handles the event by applying the changes to the geometry.
     */
    mouseUp(sender: any, me: any): void
    /**
     * Rotates the given cell to the given rotation.
     */
    isRecursiveResize(state: any, me: any): any
    /**
     * 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
    /**
     * 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: any, angle: any, parent: any): void
    /**
     * Resets the state of this handler.
     */
    reset(): void
    /**
     * Uses the given vector to change the bounds of the given cell
     * in the graph using <mxGraph.resizeCell>.
     */
    resizeCell(
      cell: any,
      dx: any,
      dy: any,
      index: any,
      gridEnabled: any,
      constrained: any,
      recurse: any
    ): void
    /**
     * Moves the children of the given cell by the given vector.
     */
    moveChildren(cell: any, dx: any, dy: any): void
    /**
     * 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 = mxVertexHandler.prototype.union;
     * mxVertexHandler.prototype.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 = mxVertexHandler.prototype.union;
     * mxVertexHandler.prototype.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: any,
      dx: any,
      dy: any,
      index: any,
      gridEnabled: any,
      scale: any,
      tr: any,
      constrained: any,
      centered: any
    ): mxRectangle
    /**
     * Redraws the handles and the preview.
     */
    redraw(): void
    /**
     * Returns the padding to be used for drawing handles for the current <bounds>.
     */
    getHandlePadding(): mxPoint
    /**
     * Redraws the handles. To hide certain handles the following code can be used.
     *
     * (code)
     * mxVertexHandler.prototype.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
    /**
     * Updates the highlight of the parent if <parentHighlightEnabled> is true.
     */
    updateParentHighlight(): void
    /**
     * Redraws the preview.
     */
    drawPreview(): void
    /**
     * Destroys the handler and all its resources and DOM nodes.
     */
    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> 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.
   */
  export class mxEdgeHandler {
    constructor(state: any)
    /**
     * Initializes the shapes required for this edge handler.
     */
    init(): void
    /**
     * Returns an array of custom handles. This implementation returns null.
     */
    createCustomHandles(): any
    /**
     * 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
    /**
     * 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
    /**
     * 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
    /**
     * Returns the list of points that defines the selection stroke.
     */
    getSelectionPoints(state: any): any
    /**
     * Creates the shape used to draw the selection border.
     */
    createParentHighlightShape(bounds: any): mxRectangleShape
    /**
     * Creates the shape used to draw the selection border.
     */
    createSelectionShape(points: any): any
    /**
     * Returns <mxConstants.EDGE_SELECTION_COLOR>.
     */
    getSelectionColor(): string
    /**
     * Returns <mxConstants.EDGE_SELECTION_STROKEWIDTH>.
     */
    getSelectionStrokeWidth(): number
    /**
     * Returns <mxConstants.EDGE_SELECTION_DASHED>.
     */
    isSelectionDashed(): boolean
    /**
     * Returns true if the given cell is connectable. This is a hook to
     * disable floating connections. This implementation returns true.
     */
    isConnectableCell(cell: any): boolean
    /**
     * Creates and returns the <mxCellMarker> used in <marker>.
     */
    getCellAt(x: any, y: any): any
    /**
     * Creates and returns the <mxCellMarker> used in <marker>.
     */
    createMarker(): any
    /**
     * 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
    /**
     * Creates and returns the bends used for modifying the edge. This is
     * typically an array of <mxRectangleShapes>.
     */
    createBends(): any[]
    /**
     * Creates and returns the bends used for modifying the edge. This is
     * typically an array of <mxRectangleShapes>.
     */
    createVirtualBends(): any[]
    /**
     * Creates the shape used to display the given bend.
     */
    isHandleEnabled(index: any): boolean
    /**
     * Returns true if the handle at the given index is visible.
     */
    isHandleVisible(index: any): boolean
    /**
     * 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
    /**
     * Creates the shape used to display the the label handle.
     */
    createLabelHandleShape(): any
    /**
     * Helper method to initialize the given bend.
     *
     * Parameters:
     *
     * bend - <mxShape> that represents the bend to be initialized.
     */
    initBend(bend: any, dblClick: any): void
    /**
     * Returns the index of the handle for the given event.
     */
    getHandleForEvent(me: any): any
    /**
     * Returns true if the given event allows virtual bends to be added. This
     * implementation returns true.
     */
    isAddVirtualBendEvent(me: any): boolean
    /**
     * Returns true if the given event allows custom handles to be changed. This
     * implementation returns true.
     */
    isCustomHandleEvent(me: any): boolean
    /**
     * 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
    /**
     * Starts the handling of the mouse gesture.
     */
    start(x: any, y: any, index: any): void
    /**
     * Returns a clone of the current preview state for the given point and terminal.
     */
    clonePreviewState(point: any, terminal: any): any
    /**
     * Returns the tolerance for the guides. Default value is
     * gridSize * scale / 2.
     */
    getSnapToTerminalTolerance(): number
    /**
     * Hook for subclassers do show details while the handler is active.
     */
    updateHint(me: any, point: any): void
    /**
     * Hooks for subclassers to hide details when the handler gets inactive.
     */
    removeHint(): void
    /**
     * Hook for rounding the unscaled width or height. This uses Math.round.
     */
    roundLength(length: any): number
    /**
     * Returns true if <snapToTerminals> is true and if alt is not pressed.
     */
    isSnapToTerminalsEvent(me: any): boolean
    /**
     * Returns the point for the given event.
     */
    getPointForEvent(me: any): mxPoint
    /**
     * Updates the given preview state taking into account the state of the constraint handler.
     */
    getPreviewTerminalState(me: any): any
    /**
     * 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
    /**
     * Returns true if <outlineConnect> is true and the source of the event is the outline shape
     * or shift is pressed.
     */
    isOutlineConnectEvent(me: any): any
    /**
     * 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
    /**
     * Handles the event by updating the preview.
     */
    mouseMove(sender: any, me: any): void
    /**
     * Handles the event to applying the previewed changes on the edge by
     * using <moveLabel>, <connect> or <changePoints>.
     */
    mouseUp(sender: any, me: any): void
    /**
     * Resets the state of this handler.
     */
    reset(): void
    /**
     * Sets the color of the preview to the given value.
     */
    setPreviewColor(color: any): void
    /**
     * 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
    /**
     * 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
    /**
     * 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
    /**
     * Changes the terminal point of the given edge.
     */
    changeTerminalPoint(edge: any, point: any, isSource: any, clone: any): any
    /**
     * Changes the control points of the given edge in the graph model.
     */
    changePoints(edge: any, points: any, clone: any): any
    /**
     * Adds a control point for the given state and event.
     */
    addPoint(state: any, evt: any): void
    /**
     * Adds a control point at the given point.
     */
    addPointAt(state: any, x: any, y: any): void
    /**
     * Removes the control point at the given index from the given state.
     */
    removePoint(state: any, index: any): void
    /**
     * Returns the fillcolor for the handle at the given index.
     */
    getHandleFillColor(index: any): string
    /**
     * Redraws the preview, and the bends- and label control points.
     */
    redraw(): void
    /**
     * Redraws the handles.
     */
    redrawHandles(): void
    /**
     * Shortcut to <hideSizers>.
     */
    setHandlesVisible(visible: any): void
    /**
     * 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
    /**
     * Checks if the label handle intersects the given bounds and moves it if it
     * intersects.
     */
    checkLabelHandle(b: any): void
    /**
     * Redraws the preview.
     */
    drawPreview(): void
    /**
     * Refreshes the bends of this handler.
     */
    refresh(): void
    /**
     * Destroys all elements in <bends>.
     */
    destroyBends(bends: any): void
    /**
     * 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.
   */
  export 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
  }

  export 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.
   */
  export 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.
   */
  export class mxTooltipHandler {
    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, me) { },
   *   mouseMove: function(sender, me)
   *   {
   *     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, me) { },
   *   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>.
   */
  export 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.
   */
  export class mxCellHighlight {
    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>.
   */
  export 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

    editor: mxEditor
    handler: mxKeyHandler
  }

  /**
   * 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.
   */
  export 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>.
   */
  export 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.
   */
  export 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
  }

  export 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>.
   */
  export 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
  }

  /**
   * 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.
   */
  export class mxObjectCodec {
    constructor(template: any, exclude: any, idrefs: any, mapping: any)
    /**
     * 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.
   */
  export class mxHierarchicalLayout extends mxGraphLayout {
    constructor(graph: any, orientation?: string, deterministic?: boolean)
    /**
     * 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
  }
  export 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.
   */
  export 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.
   */
  export 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
   */
  export 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.
   */
  export 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.
   */
  export 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
   */
  export 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.
   */
  export 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.
   */
  export 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
   */
  export 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
   */
  export 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
   */
  export 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
   */
  export 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
  }
}