text: /*
   * Copyright 2016 The Closure Compiler Authors.
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *     http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  /**
   * @fileoverview Externs for Ace Editor API v. 1.2.3.
   * @see https://ace.c9.io/#nav=api
   * @externs
   */
  
  /**
   * The main class required to set up an Ace instance in the browser.
   * @const
   * @see https://ace.c9.io/#nav=api&api=ace
   */
  var ace;
  
  /**
   * Creates a new EditSession, and returns the associated Document.
   * @param {(!ace.Document|string)} text
   * @param {?} mode // TODO: define !ace.Mode.
   * @return {!ace.Document}
   */
  ace.createEditSession = function(text, mode) {};
  
  /**
   * Embeds the Ace editor into the DOM, at the element provided by el.
   * @param {(string|!Element)} el
   * @return {!ace.Editor}
   */
  ace.edit = function(el) {};
  
  /**
   * Provides access to require in packed noconflict mode.
   * @param {string} moduleName
   * @return {!Object}
   */
  ace.require = function(moduleName) {};
  
  /**
   * Creates a new Anchor and associates it with a document.
   * @constructor
   * @param {!ace.Document} doc
   * @param {number} row
   * @param {number} column
   * @see https://ace.c9.io/#nav=api&api=anchor
   */
  ace.Anchor = function(doc, row, column) {};
  
  /**
   * Fires whenever the anchor position changes.
   * @param {string} event
   * @param {function(!Object)} fn
   */
  ace.Anchor.prototype.on = function(event, fn) {};
  
  /**
   * When called, the 'change' event listener is removed.
   */
  ace.Anchor.prototype.detach = function() {};
  
  /**
   * Returns the current document.
   * @return {!ace.Document}
   */
  ace.Anchor.prototype.getDocument = function() {};
  
  /**
   * Returns an object identifying the row and column position of the current
   * anchor.
   * @return {!Object}
   */
  ace.Anchor.prototype.getPosition = function() {};
  
  /** Undocumented */
  ace.Anchor.prototype.onChange = function() {};
  
  /**
   * Sets the anchor position to the specified row and column. If noClip is true,
   * the position is not clipped.
   * @param {number} row
   * @param {number} column
   * @param {boolean} noClip
   */
  ace.Anchor.prototype.setPosition = function(row, column, noClip) {};
  
  /**
   * Creates a new BackgroundTokenizer object.
   * @constructor
   * @param {!ace.Tokenizer} tokenizer
   * @param {!ace.Editor} editor
   * @see https://ace.c9.io/#nav=api&api=background_tokenizer
   */
  ace.BackgroundTokenizer = function(tokenizer, editor) {};
  
  /**
   * @param {string} event
   * @param {function(!Object)} fn
   */
  ace.BackgroundTokenizer.prototype.on = function(event, fn) {};
  
  /**
   * Emits the 'update' event. firstRow and lastRow are used to define the
   * boundaries of the region to be updated.
   * @param {number} firstRow
   * @param {number} lastRow
   */
  ace.BackgroundTokenizer.prototype.fireUpdateEvent = function(firstRow, lastRow) {};
  
  /**
   * Returns the state of tokenization at the end of a row.
   * @param {number} row
   * @return {!Object}
   */
  ace.BackgroundTokenizer.prototype.getState = function(row) {};
  
  /**
   * Gives list of tokens of the row (tokens are cached).
   * @param {number} row
   */
  ace.BackgroundTokenizer.prototype.getTokens = function(row) {};
  
  /**
   * Sets a new document to associate with this object.
   * @param {!ace.Document} doc
   */
  ace.BackgroundTokenizer.prototype.setDocument = function(doc) {};
  
  /**
   * Sets a new tokenizer for this object.
   * @param {!ace.Tokenizer} tokenizer
   */
  ace.BackgroundTokenizer.prototype.setTokenizer = function(tokenizer) {};
  
  /**
   * Starts tokenizing at the row indicated.
   * @param {number} startRow
   */
  ace.BackgroundTokenizer.prototype.start = function(startRow) {};
  
  /**
   * Stops tokenizing.
   */
  ace.BackgroundTokenizer.prototype.stop = function() {};
  
  /**
   * Creates a new Document. If text is included, the Document contains those
   * strings; otherwise, it's empty.
   * @constructor
   * @param {(string|!Array<string>)} text
   * @see https://ace.c9.io/#nav=api&api=document
   */
  ace.Document = function(text) {};
  
  /**
   * Fires whenever the document changes.
   * @param {string} event
   * @param {function(!Object)} fn
   */
  ace.Document.prototype.on = function(event, fn) {};
  
  /**
   * Applies all the changes previously accumulated.
   * These can be either 'includeText', 'insertLines', 'removeText', and
   * 'removeLines'.
   * @param {!Object} deltas
   */
  ace.Document.prototype.applyDeltas = function(deltas) {};
  
  /**
   * Creates a new Anchor to define a floating point in the document.
   * @param {number} row
   * @param {number} column
   */
  ace.Document.prototype.createAnchor = function(row, column) {};
  
  /**
   * Returns all lines in the document as string array.
   * @return {!Array<string>}
   */
  ace.Document.prototype.getAllLines = function() {};
  
  /**
   * Returns the number of rows in the document.
   * @return {number}
   */
  ace.Document.prototype.getLength = function() {};
  
  /**
   * Returns a verbatim copy of the given line as it is in the document
   * @param {number} row
   * @return {!Object}
   */
  ace.Document.prototype.getLine = function(row) {};
  
  /**
   * Returns an array of strings of the rows between firstRow and lastRow. This
   * function is inclusive of lastRow.
   * @param {number} firstRow
   * @param {number} lastRow
   * @return {!Array<string>}
   */
  ace.Document.prototype.getLines = function(firstRow, lastRow) {};
  
  /**
   * Returns the newline character that's being used, depending on the value of
   * newLineMode.
   * @return {string}
   */
  ace.Document.prototype.getNewLineCharacter = function() {};
  
  /**
   * Returns the type of newlines being used; either windows, unix, or auto.
   * @return {string}
   */
  ace.Document.prototype.getNewLineMode = function() {};
  
  /**
   * Given a range within the document, this function returns all the text within
   * that range as a single string.
   * @param {!ace.Range} range
   * @return {string}
   */
  ace.Document.prototype.getTextRange = function(range) {};
  
  /**
   * Returns all the lines in the document as a single string, split by the new
   * line character.
   * @return {string}
   */
  ace.Document.prototype.getValue = function() {};
  
  /**
   * Converts an index position in a document to a {row, column} object.
   * @param {number} index
   * @param {number} startRow
   * @return {{row: number, column: number}}
   */
  ace.Document.prototype.indexToPosition = function(index, startRow) {};
  
  /**
   * Inserts a block of text and the indicated position.
   * @param {!Object} position
   * @param {string} text
   * @return {!Object}
   */
  ace.Document.prototype.insert = function(position, text) {};
  
  /**
   * Inserts text into the position at the current row. This method also triggers
   * the 'change' event.
   * @param {!Object} position
   * @param {string} text
   * @return {!Object}
   */
  ace.Document.prototype.insertInLine = function(position, text) {};
  
  /**
   * Inserts the elements in lines into the document, starting at the row index
   * given by row.
   * This method also triggers the 'change' event.
   * @param {number} row
   * @param {!Array<number>} lines
   * @return {!Object}
   */
  ace.Document.prototype.insertLines = function(row, lines) {};
  
  /**
   * Inserts a new line into the document at the current row's position.
   * This method also triggers the 'change' event.
   * @param {!Object} position
   * @return {!Object}
   */
  ace.Document.prototype.insertNewLine = function(position) {};
  
  /**
   * Returns true if text is a newline character (either \r\n, \r, or \n).
   * @param {string} text
   * @return {boolean}
   */
  ace.Document.prototype.isNewLine = function(text) {};
  
  /**
   * Converts the {row, column} position in a document to the character's index.
   * @param {{row: number, column: number}} pos
   * @param {number} startRow
   * @return {number}
   */
  ace.Document.prototype.positionToIndex = function(pos, startRow) {};
  
  /**
   * Removes the range from the document.
   * @param {!ace.Range} range
   * @return {!Object}
   */
  ace.Document.prototype.remove = function(range) {};
  
  /**
   * Removes the specified columns from the row. This method also triggers the
   * 'change' event.
   * @param {number} row
   * @param {number} startColumn
   * @param {number} endColumn
   * @return {!Object}
   */
  ace.Document.prototype.removeInLine = function(row, startColumn, endColumn) {};
  
  /**
   * Removes a range of full lines. This method also triggers the 'change' event.
   * @param {number} firstRow
   * @param {number} lastRow
   * @return {string}
   */
  ace.Document.prototype.removeLines = function(firstRow, lastRow) {};
  
  /**
   * Removes the new line between row and the row immediately following it.
   * This method also triggers the 'change' event.
   * @param {number} row
   */
  ace.Document.prototype.removeNewLine = function(row) {};
  
  /**
   * Replaces a range in the document with the new text.
   * @param {!ace.Range} range
   * @param {string} text
   * @return {!Object}
   */
  ace.Document.prototype.replace = function(range, text) {};
  
  /**
   * Reverts any changes previously applied.
   * These can be either 'includeText', 'insertLines', 'removeText', and
   * 'removeLines'.
   * @param {!Object} deltas
   */
  ace.Document.prototype.revertDeltas = function(deltas) {};
  
  /**
   * Sets the new line mode.
   * @param {string} newLineMode
   */
  ace.Document.prototype.setNewLineMode = function(newLineMode) {};
  
  /**
   * Replaces all the lines in the current Document with the value of text.
   * @param {string} text
   */
  ace.Document.prototype.setValue = function(text) {};
  
  /**
   * Stores all the data about Editor state providing easy way to change editor's
   * state.
   * @constructor
   * @param {(!ace.Document|string)} text
   * @param {?} mode
   * @see https://ace.c9.io/#nav=api&api=edit_session
   */
  ace.EditSession = function(text, mode) {};
  
  /**
   * Adds a dynamic marker to the session.
   * @param {!Object} marker
   * @param {boolean} inFront
   * @return {!Object}
   */
  ace.EditSession.prototype.addDynamicMarker = function(marker, inFront) {};
  
  /**
   * Adds className to the row, to be used for CSS stylings and whatnot.
   * @param {number} row
   * @param {string} className
   */
  ace.EditSession.prototype.addGutterDecoration = function(row, className) {};
  
  /**
   * Adds a new marker to the given Range. If inFront is true, a front marker is
   * defined, and the 'changeFrontMarker' event fires; otherwise, the
   * 'changeBackMarker' event fires.
   * @param {!ace.Range} range
   * @param {string} clazz
   * @param {!Function|string} type
   * @param {boolean} inFront
   * @return {number}
   */
  ace.EditSession.prototype.addMarker = function(range, clazz, type, inFront) {};
  
  /**
   * Clears all the annotations for this session. This function also triggers the
   * 'changeAnnotation' event.
   */
  ace.EditSession.prototype.clearAnnotations = function() {};
  
  /**
   * Removes a breakpoint on the row number given by rows. This function also
   * emits the 'changeBreakpoint' event.
   * @param {number} row
   */
  ace.EditSession.prototype.clearBreakpoint = function(row) {};
  
  /**
   * Removes all breakpoints on the rows. This function also emits the
   * 'changeBreakpoint' event.
   */
  ace.EditSession.prototype.clearBreakpoints = function() {};
  
  /**
   * For the given document row and column, returns the screen column.
   * @param {number} row
   * @param {number} docColumn
   * @return {number}
   */
  ace.EditSession.prototype.documentToScreenColumn = function(row, docColumn) {};
  
  /**
   * Converts document coordinates to screen coordinates.
   * This takes into account code folding, word wrap, tab size, and any other
   * visual modifications.
   * @param {number} docRow
   * @param {number} docColumn
   * @return {!Object}
   */
  ace.EditSession.prototype.documentToScreenPosition = function(docRow, docColumn) {};
  
  /**
   * For the given document row and column, returns the screen row.
   * @param {number} docRow
   * @param {number} docColumn
   * @return {number}
   */
  ace.EditSession.prototype.documentToScreenRow = function(docRow, docColumn) {};
  
  /**
   * Duplicates all the text between firstRow and lastRow.
   * @param {number} firstRow
   * @param {number} lastRow
   * @return {number}
   */
  ace.EditSession.prototype.duplicateLines = function(firstRow, lastRow) {};
  
  /**
   * Returns the annotations for the EditSession.
   * @return {!Object}
   */
  ace.EditSession.prototype.getAnnotations = function() {};
  
  /**
   * Gets the range of a word, including its right whitespace.
   * @param {number} row
   * @param {number} column
   * @return {!ace.Range}
   */
  ace.EditSession.prototype.getAWordRange = function(row, column) {};
  
  /**
   * Returns an array of numbers, indicating which rows have breakpoints.
   * @return {number}
   */
  ace.EditSession.prototype.getBreakpoints = function() {};
  
  /**
   * Returns the Document associated with this session.
   * @return {!ace.Document}
   */
  ace.EditSession.prototype.getDocument = function() {};
  
  /**
   * For the given document row and column, this returns the column position of
   * the last screen row.
   * @param {number} docRow
   * @param {number} docColumn
   * @return {number}
   */
  ace.EditSession.prototype.getDocumentLastRowColumn = function(docRow, docColumn) {};
  
  /**
   * For the given document row and column, this returns the document position of
   * the last row.
   * @param {number} docRow
   * @param {number} docColumn
   * @return {!Object}
   */
  ace.EditSession.prototype.getDocumentLastRowColumnPosition = function(docRow, docColumn) {};
  
  /**
   * Returns the number of rows in the document.
   * @return {number}
   */
  ace.EditSession.prototype.getLength = function() {};
  
  /**
   * Returns a verbatim copy of the given line as it is in the document
   * @param {number} row
   * @return {string}
   */
  ace.EditSession.prototype.getLine = function(row) {};
  
  /**
   * Returns an array of strings of the rows between firstRow and lastRow.
   * This function is inclusive of lastRow.
   * @param {number} firstRow
   * @param {number} lastRow
   * @return {string}
   */
  ace.EditSession.prototype.getLines = function(firstRow, lastRow) {};
  
  /**
   * Returns an array containing the IDs of all the markers, either front or back.
   * @param {boolean} inFront
   * @return {!Array<string>}
   */
  ace.EditSession.prototype.getMarkers = function(inFront) {};
  
  /**
   * Returns the current text mode.
   * @return {!Object}
   */
  ace.EditSession.prototype.getMode = function() {};
  
  /**
   * Returns the current new line mode.
   * @return {string}
   */
  ace.EditSession.prototype.getNewLineMode = function() {};
  
  /**
   * Returns true if overwrites are enabled; false otherwise.
   * @return {boolean}
   */
  ace.EditSession.prototype.getOverwrite = function() {};
  
  /**
   * Returns number of screenrows in a wrapped line.
   * @param {number} row
   * @return {number}
   */
  ace.EditSession.prototype.getRowLength = function(row) {};
  
  /**
   * For the given row, this returns the split data.
   * @param {!Object} row
   * @return {string}
   */
  ace.EditSession.prototype.getRowSplitData = function(row) {};
  
  /**
   * Returns the position (on screen) for the last character in the provided
   * screen row.
   * @param {number} screenRow
   * @return {number}
   */
  ace.EditSession.prototype.getScreenLastRowColumn = function(screenRow) {};
  
  /**
   * Returns the length of the screen.
   * @return {number}
   */
  ace.EditSession.prototype.getScreenLength = function() {};
  
  /**
   * The distance to the next tab stop at the specified screen column.
   * @param {number} screenColumn
   * @return {number}
   */
  ace.EditSession.prototype.getScreenTabSize = function(screenColumn) {};
  
  /**
   * Returns the width of the screen.
   * @return {number}
   */
  ace.EditSession.prototype.getScreenWidth = function() {};
  
  /**
   * Returns the value of the distance between the left of the editor and the
   * leftmost part of the visible content.
   * @return {number}
   */
  ace.EditSession.prototype.getScrollLeft = function() {};
  
  /**
   * Returns the value of the distance between the top of the editor and the
   * topmost part of the visible content.
   * @return {number}
   */
  ace.EditSession.prototype.getScrollTop = function() {};
  
  /**
   * Returns selection object.
   * @return {!Object}
   */
  ace.EditSession.prototype.getSelection = function() {};
  
  /**
   * Returns the state of tokenization at the end of a row.
   * @param {number} row
   * @return {!Object}
   */
  ace.EditSession.prototype.getState = function(row) {};
  
  /**
   * Returns the current tab size.
   * @return {number}
   */
  ace.EditSession.prototype.getTabSize = function() {};
  
  /**
   * Returns the current value for tabs. If the user is using soft tabs, this
   * will be a series of spaces (defined by getTabSize()); otherwise it's simply
   * '\t'.
   * @return {string}
   */
  ace.EditSession.prototype.getTabString = function() {};
  
  /**
   * Given a range within the document, this function returns all the text
   * within that range as a single string.
   * @param {!ace.Range} range
   * @return {string}
   */
  ace.EditSession.prototype.getTextRange = function(range) {};
  
  /**
   * Returns an object indicating the token at the current row. The object has
   * two properties: index and start.
   * @param {number} row
   * @param {number} column
   * @return {!Object}
   */
  ace.EditSession.prototype.getTokenAt = function(row, column) {};
  
  /**
   * Starts tokenizing at the row indicated. Returns a list of objects of the
   * tokenized rows.
   * @param {number} row
   * @return {!Array<!Object>} row
   */
  ace.EditSession.prototype.getTokens = function(row) {};
  
  /**
   * Returns the current undo manager.
   * @return {!ace.UndoManager}
   */
  ace.EditSession.prototype.getUndoManager = function() {};
  
  /**
   * Returns true if soft tabs are being used, false otherwise.
   * @return {boolean}
   */
  ace.EditSession.prototype.getUseSoftTabs = function() {};
  
  /**
   * Returns true if workers are being used.
   * @return {boolean}
   */
  ace.EditSession.prototype.getUseWorker = function() {};
  
  /**
   * Returns true if wrap mode is being used; false otherwise.
   * @return {boolean}
   */
  ace.EditSession.prototype.getUseWrapMode = function() {};
  
  /**
   * Returns the current Document as a string.
   * @return {string}
   */
  ace.EditSession.prototype.getValue = function() {};
  
  /**
   * Given a starting row and column, this method returns the Range of the first
   * word boundary it finds.
   * @param {number} row
   * @param {number} column
   * @return {!ace.Range}
   */
  ace.EditSession.prototype.getWordRange = function(row, column) {};
  
  /**
   * Returns the value of wrap limit.
   * @return {number}
   */
  ace.EditSession.prototype.getWrapLimit = function() {};
  
  /**
   * Returns an object that defines the minimum and maximum of the wrap limit.
   * @return {!Object}
   */
  ace.EditSession.prototype.getWrapLimitRange = function() {};
  
  /** Undocumented */
  ace.EditSession.prototype.highlight = function() {};
  
  /** Undocumented */
  ace.EditSession.prototype.highlightLines = function() {};
  
  /**
   * Indents all the rows, from startRow to endRow (inclusive), by prefixing each
   * row with the token in indentString.
   * @param {number} startRow
   * @param {number} endRow
   * @param {string} indentString
   */
  ace.EditSession.prototype.indentRows = function(startRow, endRow, indentString) {};
  
  /**
   * Inserts a block of text and the indicated position.
   * @param {!Object} position
   * @param {string} text
   * @return {!Object}
   */
  ace.EditSession.prototype.insert = function(position, text) {};
  
  /**
   * Returns true if the character at the position is a soft tab.
   * @param {!Object} position
   * @return {boolean}
   */
  ace.EditSession.prototype.isTabStop = function(position) {};
  
  /**
   * Shifts all the lines in the document down one, starting from firstRow and
   * ending at lastRow.
   * @param {number} firstRow
   * @param {number} lastRow
   * @return {number}
   */
  ace.EditSession.prototype.moveLinesDown = function(firstRow, lastRow) {};
  
  /**
   * Shifts all the lines in the document up one, starting from firstRow and
   * ending at lastRow.
   * @param {number} firstRow
   * @param {number} lastRow
   * @return {number}
   */
  ace.EditSession.prototype.moveLinesUp = function(firstRow, lastRow) {};
  
  /**
   * Moves a range of text from the given range to the given position.toPosition
   * is an object that looks like this:
   * { row: newRowLocation, column: newColumnLocation }
   * @param {!ace.Range} fromRange
   * @param {{row: number, column: number}} toPosition
   * @return {!ace.Range}
   */
  ace.EditSession.prototype.moveText = function(fromRange, toPosition) {};
  
  /**
   * @param {string} event
   * @param {function((Object|number|null))} fn
   */
  ace.EditSession.prototype.on = function(event, fn) {};
  
  /** Undocumented */
  ace.EditSession.prototype.onChange = function() {};
  
  /** Undocumented */
  ace.EditSession.prototype.onChangeFold = function() {};
  
  /**
   * Reloads all the tokens on the current session. This function calls
   * BackgroundTokenizer.start() to all the rows;
   * it also emits the 'tokenizerUpdate' event.
   * @param {!Object} e
   */
  ace.EditSession.prototype.onReloadTokenizer = function(e) {};
  
  /**
   * Outdents all the rows defined by the start and end properties of range.
   * @param {!ace.Range} range
   */
  ace.EditSession.prototype.outdentRows = function(range) {};
  
  /** Undocumented */
  ace.EditSession.prototype.redo = function() {};
  
  /**
   * Re-implements a previously undone change to your document.
   * @param {!Array<!Object>} deltas
   * @param {boolean} dontSelect
   * @return {!ace.Range}
   */
  ace.EditSession.prototype.redoChanges = function(deltas, dontSelect) {};
  
  /**
   * Removes the range from the document.
   * @param {!ace.Range} range
   * @return {!Object}
   */
  ace.EditSession.prototype.remove = function(range) {};
  
  /**
   * Removes className from the row.
   * @param {number} row
   * @param {string} className
   */
  ace.EditSession.prototype.removeGutterDecoration = function(row, className) {};
  
  /**
   * Removes the marker with the specified ID. If this marker was in front, the
   * 'changeFrontMarker' event is emitted.
   * If the marker was in the back, the 'changeBackMarker' event is emitted.
   * @param {number} markerId
   */
  ace.EditSession.prototype.removeMarker = function(markerId) {};
  
  /**
   * Replaces a range in the document with the new text.
   * @param {!ace.Range} range
   * @param {string} text
   * @return {!Object}
   */
  ace.EditSession.prototype.replace = function(range, text) {};
  
  /** Undocumented */
  ace.EditSession.prototype.reset = function() {};
  
  /** Undocumented */
  ace.EditSession.prototype.resetCaches = function() {};
  
  /** Undocumented */
  ace.EditSession.prototype.screenToDocumentColumn = function() {};
  
  /**
   * Converts characters coordinates on the screen to characters coordinates
   * within the document. This takes into account code folding, word wrap, tab
   * size, and any other visual modifications.
   * @param {number} screenRow
   * @param {number} screenColumn
   * @return {!Object}
   */
  ace.EditSession.prototype.screenToDocumentPosition = function(screenRow, screenColumn) {};
  
  /** Undocumented */
  ace.EditSession.prototype.screenToDocumentRow = function() {};
  
  /**
   * Sets annotations for the EditSession. This functions emits the
   * 'changeAnnotation' event.
   * @param {!Array<!Object>} annotations
   */
  ace.EditSession.prototype.setAnnotations = function(annotations) {};
  
  /**
   * Sets a breakpoint on the row number given by rows. This function also emits
   * the 'changeBreakpoint' event.
   * @param {number} row
   * @param {string} className
   */
  ace.EditSession.prototype.setBreakpoint = function(row, className) {};
  
  /**
   * Sets a breakpoint on every row number given by rows. This function also
   * emits the 'changeBreakpoint' event.
   * @param {!Array<number>} rows
   */
  ace.EditSession.prototype.setBreakpoints = function(rows) {};
  
  /**
   * Sets the EditSession to point to a new Document. If a BackgroundTokenizer
   * exists, it also points to doc.
   * @param {!ace.Document} doc
   */
  ace.EditSession.prototype.setDocument = function(doc) {};
  
  /** Undocumented */
  ace.EditSession.prototype.setMode = function() {};
  
  /**
   * Sets the new line mode.
   * @param {string} newLineMode
   */
  ace.EditSession.prototype.setNewLineMode = function(newLineMode) {};
  
  /**
   * Pass in true to enable overwrites in your session, or false to disable.
   * @param {boolean} overwrite
   */
  ace.EditSession.prototype.setOverwrite = function(overwrite) {};
  
  /**
   * Sets the value of the distance between the left of the editor and the
   * leftmost part of the visible content.
   * @param {!Object} scrollLeft
   */
  ace.EditSession.prototype.setScrollLeft = function(scrollLeft) {};
  
  /**
   * This function sets the scroll top value. It also emits the 'changeScrollTop'
   * event.
   * @param {number} scrollTop
   */
  ace.EditSession.prototype.setScrollTop = function(scrollTop) {};
  
  /**
   * @param {boolean} margin
   */
  ace.EditSession.prototype.setShowPrintMargin = function(margin) {};
  
  /**
   * Set the number of spaces that define a soft tab; for example, passing in
   * 4 transforms the soft tabs to be equivalent to four spaces. This function
   * also emits the changeTabSize event.
   * @param {number} tabSize
   */
  ace.EditSession.prototype.setTabSize = function(tabSize) {};
  
  /**
   * Sets the undo manager.
   * @param {!ace.UndoManager} undoManager
   */
  ace.EditSession.prototype.setUndoManager = function(undoManager) {};
  
  /**
   * Enables or disables highlighting of the range where an undo occured.
   * @param {boolean} enable
   */
  ace.EditSession.prototype.setUndoSelect = function(enable) {};
  
  /**
   * Pass true to enable the use of soft tabs. Soft tabs means you're using
   * spaces instead of the tab character ('\t').
   * @param {boolean} useSoftTabs
   */
  ace.EditSession.prototype.setUseSoftTabs = function(useSoftTabs) {};
  
  /**
   * Identifies if you want to use a worker for the EditSession.
   * @param {boolean} useWorker
   */
  ace.EditSession.prototype.setUseWorker = function(useWorker) {};
  
  /**
   * Sets whether or not line wrapping is enabled. If useWrapMode is different
   * than the current value, the 'changeWrapMode' event is emitted.
   * @param {boolean} useWrapMode
   */
  ace.EditSession.prototype.setUseWrapMode = function(useWrapMode) {};
  
  /**
   * Sets the session text.
   * @param {string} text
   */
  ace.EditSession.prototype.setValue = function(text) {};
  
  /**
   * Sets the boundaries of wrap. Either value can be null to have an
   * unconstrained wrap, or, they can be the same number to pin the limit. If the
   * wrap limits for min or max are different, this method also emits the
   * 'changeWrapMode' event.
   * @param {?number} min
   * @param {?number} max
   */
  ace.EditSession.prototype.setWrapLimitRange = function(min, max) {};
  
  /**
   * Sets the value of overwrite to the opposite of whatever it currently is.
   */
  ace.EditSession.prototype.toggleOverwrite = function() {};
  
  /**
   * Returns the current Document as a string.
   * @override
   */
  ace.EditSession.prototype.toString = function() {};
  
  /** Undocumented */
  ace.EditSession.prototype.undo = function() {};
  
  /**
   * Reverts previous changes to your document.
   * @param {!Array<!Object>} deltas
   * @param {boolean} dontSelect
   * @return {!Object}
   */
  ace.EditSession.prototype.undoChanges = function(deltas, dontSelect) {};
  
  /**
   * Creates a new Editor object.
   * @constructor
   * @param {!ace.VirtualRenderer} renderer
   * @param {!ace.EditSession} session
   * @see https://ace.c9.io/#nav=api&api=editor
   */
  ace.Editor = function(renderer, session) {};
  
  /**
   * @param {string} event
   * @param {function((Object|string|null))} fn
   */
  ace.Editor.prototype.on = function(event, fn) {};
  
  /**
   * Adds the selection and cursor.
   * @param {!ace.Range} orientedRange
   * @return {!ace.Range}
   */
  ace.Editor.prototype.addSelectionMarker = function(orientedRange) {};
  
  /**
   * Aligns the cursors or selected text.
   */
  ace.Editor.prototype.alignCursors = function() {};
  
  /**
   * Outdents the current line.
   */
  ace.Editor.prototype.blockOutdent = function() {};
  
  /**
   * Blurs the current textInput.
   */
  ace.Editor.prototype.blur = function() {};
  
  /**
   * Attempts to center the current selection on the screen.
   */
  ace.Editor.prototype.centerSelection = function() {};
  
  /**
   * Empties the selection (by de-selecting it). This function also emits the
   * 'changeSelection' event.
   */
  ace.Editor.prototype.clearSelection = function() {};
  
  /**
   * Copies all the selected lines down one row.
   * @return {number}
   */
  ace.Editor.prototype.copyLinesDown = function() {};
  
  /**
   * Copies all the selected lines up one row.
   * @return {number}
   */
  ace.Editor.prototype.copyLinesUp = function() {};
  
  /**
   * Cleans up the entire editor.
   */
  ace.Editor.prototype.destroy = function() {};
  
  /** Undocumented */
  ace.Editor.prototype.duplicateSelection = function() {};
  
  /** Undocumented */
  ace.Editor.prototype.execCommand = function() {};
  
  /**
   * Removes all the selections except the last added one.
   */
  ace.Editor.prototype.exitMultiSelectMode = function() {};
  
  /**
   * Attempts to find needle within the document. For more information on
   * options, see Search.
   * @param {string} needle
   * @param {!Object} options
   * @param {boolean} animate
   */
  ace.Editor.prototype.find = function(needle, options, animate) {};
  
  /**
   * Finds and selects all the occurences of needle.
   * @param {string} needle
   * @param {!Object} options
   * @param {boolean} keeps
   * @return {number}
   */
  ace.Editor.prototype.findAll = function(needle, options, keeps) {};
  
  /**
   * Performs another search for needle in the document. For more information on
   * options, see Search.
   * @param {!Object} options
   * @param {boolean} animate
   */
  ace.Editor.prototype.findNext = function(options, animate) {};
  
  /**
   * Performs a search for needle backwards. For more information on options, see
   * Search.
   * @param {!Object} options
   * @param {boolean} animate
   */
  ace.Editor.prototype.findPrevious = function(options, animate) {};
  
  /**
   * Brings the current textInput into focus.
   */
  ace.Editor.prototype.focus = function() {};
  
  /**
   * Executes a command for each selection range.
   * @param {string} cmd
   * @param {string} args
   */
  ace.Editor.prototype.forEachSelection = function(cmd, args) {};
  
  /** Undocumented */
  ace.Editor.prototype.getAnimatedScroll = function() {};
  
  /**
   * Returns true if the behaviors are currently enabled.
   * "Behaviors" in this case is the auto-pairing of special characters, like
   * quotation marks, parenthesis, or brackets.
   * @return {boolean}
   */
  ace.Editor.prototype.getBehavioursEnabled = function() {};
  
  /**
   * Returns the string of text currently highlighted.
   * @return {string}
   */
  ace.Editor.prototype.getCopyText = function() {};
  
  /**
   * Gets the current position of the cursor.
   * @return {!Object}
   */
  ace.Editor.prototype.getCursorPosition = function() {};
  
  /**
   * Returns the screen position of the cursor.
   * @return {number}
   */
  ace.Editor.prototype.getCursorPositionScreen = function() {};
  
  /** Undocumented */
  ace.Editor.prototype.getDisplayIndentGuides = function() {};
  
  /**
   * Returns the current mouse drag delay.
   * @return {number}
   */
  ace.Editor.prototype.getDragDelay = function() {};
  
  /** Undocumented */
  ace.Editor.prototype.getFadeFoldWidgets = function() {};
  
  /**
   * Returns the index of the first visible row.
   * @return {number}
   */
  ace.Editor.prototype.getFirstVisibleRow = function() {};
  
  /**
   * Returns true if current lines are always highlighted.
   * @return {boolean}
   */
  ace.Editor.prototype.getHighlightActiveLine = function() {};
  
  /** Undocumented */
  ace.Editor.prototype.getHighlightGutterLine = function() {};
  
  /**
   * Returns true if currently highlighted words are to be highlighted.
   * @return {boolean}
   */
  ace.Editor.prototype.getHighlightSelectedWord = function() {};
  
  /**
   * Returns the keyboard handler, such as "vim" or "windows".
   * @return {string}
   */
  ace.Editor.prototype.getKeyboardHandler = function() {};
  
  /**
   * Returns an object containing all the search options. For more information on
   * options, see Search.
   * @return {!Object}
   */
  ace.Editor.prototype.getLastSearchOptions = function() {};
  
  /**
   * Returns the index of the last visible row.
   * @return {number}
   */
  ace.Editor.prototype.getLastVisibleRow = function() {};
  
  /**
   * Works like EditSession.getTokenAt(), except it returns a number.
   * @param {!Object} row
   * @param {!Object} column
   * @return {number}
   */
  ace.Editor.prototype.getNumberAt = function(row, column) {};
  
  /**
   * Returns true if overwrites are enabled; false otherwise.
   * @return {boolean}
   */
  ace.Editor.prototype.getOverwrite = function() {};
  
  /**
   * Returns the column number of where the print margin is.
   * @return {number}
   */
  ace.Editor.prototype.getPrintMarginColumn = function() {};
  
  /**
   * Returns true if the editor is set to read-only mode.
   * @return {boolean}
   */
  ace.Editor.prototype.getReadOnly = function() {};
  
  /**
   * Returns the value indicating how fast the mouse scroll speed is (in
   * milliseconds).
   * @return {number}
   */
  ace.Editor.prototype.getScrollSpeed = function() {};
  
  /**
   * Returns selection object.
   * @return {!ace.Selection}
   */
  ace.Editor.prototype.getSelection = function() {};
  
  /**
   * Returns the Range for the selected text.
   * @return {!ace.Range}
   */
  ace.Editor.prototype.getSelectionRange = function() {};
  
  /**
   * Returns the current selection style.
   * @return {string}
   */
  ace.Editor.prototype.getSelectionStyle = function() {};
  
  /**
   * Returns the current session being used.
   * @return {!ace.EditSession}
   */
  ace.Editor.prototype.getSession = function() {};
  
  /**
   * Returns true if the fold widgets are shown.
   * @return {boolean}
   */
  ace.Editor.prototype.getShowFoldWidgets = function() {};
  
  /**
   * Returns true if invisible characters are being shown.
   * @return {boolean}
   */
  ace.Editor.prototype.getShowInvisibles = function() {};
  
  /**
   * Returns true if the print margin is being shown.
   * @return {boolean}
   */
  ace.Editor.prototype.getShowPrintMargin = function() {};
  
  /**
   * Returns the path of the current theme.
   * @return {string}
   */
  ace.Editor.prototype.getTheme = function() {};
  
  /**
   * Returns the current session's content.
   * @return {string}
   */
  ace.Editor.prototype.getValue = function() {};
  
  /**
   * Returns true if the wrapping behaviors are currently enabled.
   */
  ace.Editor.prototype.getWrapBehavioursEnabled = function() {};
  
  /**
   * Moves the cursor to the specified line number, and also into the indiciated
   * column.
   * @param {number} lineNumber
   * @param {number} column
   * @param {boolean} animate
   */
  ace.Editor.prototype.gotoLine = function(lineNumber, column, animate) {};
  
  /**
   * Shifts the document to wherever "page down" is, as well as moving the cursor
   * position.
   */
  ace.Editor.prototype.gotoPageDown = function() {};
  
  /**
   * Shifts the document to wherever "page up" is, as well as moving the cursor
   * position.
   */
  ace.Editor.prototype.gotoPageUp = function() {};
  
  /**
   * Indents the current line.
   */
  ace.Editor.prototype.indent = function() {};
  
  /**
   * Inserts text into wherever the cursor is pointing.
   * @param {string} text
   */
  ace.Editor.prototype.insert = function(text) {};
  
  /**
   * Returns true if the current textInput is in focus.
   * @return {boolean}
   */
  ace.Editor.prototype.isFocused = function() {};
  
  /**
   * Indicates if the entire row is currently visible on the screen.
   * @param {number} row
   * @return {boolean}
   */
  ace.Editor.prototype.isRowFullyVisible = function(row) {};
  
  /**
   * Indicates if the row is currently visible on the screen.
   * @param {number} row
   * @return {boolean}
   */
  ace.Editor.prototype.isRowVisible = function(row) {};
  
  /**
   * Moves the cursor's row and column to the next matching bracket.
   * @param {!Object} select
   */
  ace.Editor.prototype.jumpToMatching = function(select) {};
  
  /**
   * If the character before the cursor is a number, this functions changes its
   * value by amount.
   * @param {number} amount
   */
  ace.Editor.prototype.modifyNumber = function(amount) {};
  
  /**
   * Moves the cursor to the specified row and column. Note that this does not
   * de-select the current selection.
   * @param {number} row
   * @param {number} column
   */
  ace.Editor.prototype.moveCursorTo = function(row, column) {};
  
  /**
   * Moves the cursor to the position indicated by pos.row and pos.column.
   * @param {{row: number, column: number}} pos
   */
  ace.Editor.prototype.moveCursorToPosition = function(pos) {};
  
  /**
   * Shifts all the selected lines down one row.
   * @return {number}
   */
  ace.Editor.prototype.moveLinesDown = function() {};
  
  /**
   * Shifts all the selected lines up one row.
   * @return {number}
   */
  ace.Editor.prototype.moveLinesUp = function() {};
  
  /** Undocumented */
  ace.Editor.prototype.moveText = function() {};
  
  /**
   * Moves the cursor down in the document the specified number of times. Note
   * that this does de-select the current selection.
   * @param {number} times
   */
  ace.Editor.prototype.navigateDown = function(times) {};
  
  /**
   * Moves the cursor to the end of the current file. Note that this does
   * de-select the current selection.
   */
  ace.Editor.prototype.navigateFileEnd = function() {};
  
  /**
   * Moves the cursor to the start of the current file. Note that this does
   * de-select the current selection.
   */
  ace.Editor.prototype.navigateFileStart = function() {};
  
  /**
   * Moves the cursor left in the document the specified number of times. Note
   * that this does de-select the current selection.
   * @param {number} times
   */
  ace.Editor.prototype.navigateLeft = function(times) {};
  
  /**
   * Moves the cursor to the end of the current line. Note that this does
   * de-select the current selection.
   */
  ace.Editor.prototype.navigateLineEnd = function() {};
  
  /**
   * Moves the cursor to the start of the current line. Note that this does
   * de-select the current selection.
   */
  ace.Editor.prototype.navigateLineStart = function() {};
  
  /**
   * Moves the cursor right in the document the specified number of times. Note
   * that this does de-select the current selection.
   * @param {number} times
   */
  ace.Editor.prototype.navigateRight = function(times) {};
  
  /**
   * Moves the cursor to the specified row and column. Note that this does
   * de-select the current selection.
   * @param {number} row
   * @param {number} column
   */
  ace.Editor.prototype.navigateTo = function(row, column) {};
  
  /**
   * Moves the cursor up in the document the specified number of times. Note that
   * this does de-select the current selection.
   * @param {number} times
   */
  ace.Editor.prototype.navigateUp = function(times) {};
  
  /**
   * Moves the cursor to the word immediately to the left of the current
   * position. Note that this does de-select the current selection.
   */
  ace.Editor.prototype.navigateWordLeft = function() {};
  
  /**
   * Moves the cursor to the word immediately to the right of the current
   * position. Note that this does de-select the current selection.
   */
  /** Undocumented */
  ace.Editor.prototype.navigateWordRight = function() {};
  
  /** Undocumented */
  ace.Editor.prototype.onBlur = function() {};
  
  /** Undocumented */
  ace.Editor.prototype.onChangeAnnotation = function() {};
  
  /** Undocumented */
  ace.Editor.prototype.onChangeBackMarker = function() {};
  
  /** Undocumented */
  ace.Editor.prototype.onChangeBreakpoint = function() {};
  
  /** Undocumented */
  ace.Editor.prototype.onChangeFold = function() {};
  
  /** Undocumented */
  ace.Editor.prototype.onChangeFrontMarker = function() {};
  
  /** Undocumented */
  ace.Editor.prototype.onChangeMode = function() {};
  
  /** Undocumented */
  ace.Editor.prototype.onChangeWrapLimit = function() {};
  
  /** Undocumented */
  ace.Editor.prototype.onChangeWrapMode = function() {};
  
  /** Undocumented */
  ace.Editor.prototype.onCommandKey = function() {};
  
  /** Undocumented */
  ace.Editor.prototype.onCompositionEnd = function() {};
  
  /** Undocumented */
  ace.Editor.prototype.onCompositionStart = function() {};
  
  /** Undocumented */
  ace.Editor.prototype.onCompositionUpdate = function() {};
  
  /**
   * Called whenever a text "copy" happens.
   */
  ace.Editor.prototype.onCopy = function() {};
  
  /**
   * Emitted when the selection changes.
   */
  ace.Editor.prototype.onCursorChange = function() {};
  
  /**
   * Called whenever a text "cut" happens.
   */
  ace.Editor.prototype.onCut = function() {};
  
  /** Undocumented */
  ace.Editor.prototype.onDocumentChange = function() {};
  
  /** Undocumented */
  ace.Editor.prototype.onFocus = function() {};
  
  /**
   * Called whenever a text "paste" happens.
   * @param {string} text
   */
  ace.Editor.prototype.onPaste = function(text) {};
  
  /** Undocumented */
  ace.Editor.prototype.onScrollLeftChange = function() {};
  
  /** Undocumented */
  ace.Editor.prototype.onScrollTopChange = function() {};
  
  /** Undocumented */
  ace.Editor.prototype.onSelectionChange = function() {};
  
  /** Undocumented */
  ace.Editor.prototype.onTextInput = function() {};
  
  /** Undocumented */
  ace.Editor.prototype.onTokenizerUpdate = function() {};
  
  /**
   * Perform a redo operation on the document, reimplementing the last change.
   */
  ace.Editor.prototype.redo = function() {};
  
  /**
   * Removes words of text from the editor. A "word" is defined as a string of
   * characters bookended by whitespace.
   * @param {string} dir
   */
  ace.Editor.prototype.remove = function(dir) {};
  
  /**
   * Removes all the lines in the current selection.
   */
  ace.Editor.prototype.removeLines = function() {};
  
  /**
   * Removes the selection marker.
   * @param {!ace.Range} range
   */
  ace.Editor.prototype.removeSelectionMarker = function(range) {};
  
  /**
   * Removes all the words to the right of the current selection, until the end
   * of the line.
   */
  ace.Editor.prototype.removeToLineEnd = function() {};
  
  /**
   * Removes all the words to the left of the current selection, until the start
   * of the line.
   */
  ace.Editor.prototype.removeToLineStart = function() {};
  
  /**
   * Removes the word directly to the left of the current selection.
   */
  ace.Editor.prototype.removeWordLeft = function() {};
  
  /**
   * Removes the word directly to the right of the current selection.
   */
  ace.Editor.prototype.removeWordRight = function() {};
  
  /**
   * Replaces the first occurance of options.needle with the value in replacement.
   * @param {string} replacement
   * @return {{needle: string}} options
   */
  ace.Editor.prototype.replace = function(replacement, options) {};
  
  /**
   * Replaces all occurences of options.needle with the value in replacement.
   * @param {string} replacement
   * @return {{needle: string}} options
   */
  ace.Editor.prototype.replaceAll = function(replacement, options) {};
  
  /**
   * Triggers a resize of the editor.
   * @param {boolean} force
   */
  ace.Editor.prototype.resize = function(force) {};
  
  /** Undocumented */
  ace.Editor.prototype.revealRange = function() {};
  
  /**
   * Scrolls the document to wherever "page down" is, without changing the cursor
   * position.
   */
  ace.Editor.prototype.scrollPageDown = function() {};
  
  /**
   * Scrolls the document to wherever "page up" is, without changing the cursor
   * position.
   */
  ace.Editor.prototype.scrollPageUp = function() {};
  
  /**
   * Scrolls to a line. If center is true, it puts the line in middle of screen
   * (or attempts to).
   * @param {number} line
   * @param {boolean} center
   * @param {boolean} animate
   * @param {!Function} callback
   */
  ace.Editor.prototype.scrollToLine = function(line, center, animate, callback) {};
  
  /**
   * Moves the editor to the specified row.
   * @param {!Object} row
   */
  ace.Editor.prototype.scrollToRow = function(row) {};
  
  /**
   * Selects all the text in editor.
   */
  ace.Editor.prototype.selectAll = function() {};
  
  /**
   * Finds the next occurence of text in an active selection and adds it to the
   * selections.
   * @param {number} dir
   * @param {boolean} skip
   */
  ace.Editor.prototype.selectMore = function(dir, skip) {};
  
  /**
   * Adds a cursor above or below the active cursor.
   * @param {number} dir
   * @param {boolean} skip
   */
  ace.Editor.prototype.selectMoreLines = function(dir, skip) {};
  
  /**
   * Selects the text from the current position of the document until where a
   * "page down" finishes.
   */
  ace.Editor.prototype.selectPageDown = function() {};
  
  /**
   * Selects the text from the current position of the document until where a
   * "page up" finishes.
   */
  ace.Editor.prototype.selectPageUp = function() {};
  
  /** Undocumented */
  ace.Editor.prototype.setAnimatedScroll = function() {};
  
  /**
   * Specifies whether to use behaviors or not.
   * "Behaviors" in this case is the auto-pairing of special characters, like
   * quotation marks, parenthesis, or brackets.
   * @param {boolean} enabled
   */
  ace.Editor.prototype.setBehavioursEnabled = function(enabled) {};
  
  /** Undocumented */
  ace.Editor.prototype.setDisplayIndentGuides = function() {};
  
  /**
   * Sets the delay (in milliseconds) of the mouse drag.
   * @param {number} dragDelay
   */
  ace.Editor.prototype.setDragDelay = function(dragDelay) {};
  
  /** Undocumented */
  ace.Editor.prototype.setFadeFoldWidgets = function() {};
  
  /**
   * Set a new font size (in pixels) for the editor text.
   * @param {number} size
   */
  ace.Editor.prototype.setFontSize = function(size) {};
  
  /**
   * Determines whether or not the current line should be highlighted.
   * @param {boolean} shouldHighlight
   */
  ace.Editor.prototype.setHighlightActiveLine = function(shouldHighlight) {};
  
  /** Undocumented */
  ace.Editor.prototype.setHighlightGutterLine = function() {};
  
  /**
   * Determines if the currently selected word should be highlighted.
   * @param {boolean} shouldHighlight
   */
  ace.Editor.prototype.setHighlightSelectedWord = function(shouldHighlight) {};
  
  /**
   * Sets a new key handler, such as "vim" or "windows".
   * @param {string} keyboardHandler
   */
  ace.Editor.prototype.setKeyboardHandler = function(keyboardHandler) {};
  
  /**
   * Pass in true to enable overwrites in your session, or false to disable. If
   * overwrites is enabled, any text you enter will type over any text after it.
   * If the value of overwrite changes, this function also emits the
   * changeOverwrite event.
   * @param {boolean} overwrite
   */
  ace.Editor.prototype.setOverwrite = function(overwrite) {};
  
  /**
   * Sets the column defining where the print margin should be.
   * @param {number} showPrintMargin
   */
  ace.Editor.prototype.setPrintMarginColumn = function(showPrintMargin) {};
  
  /**
   * If readOnly is true, then the editor is set to read-only mode, and none of
   * the content can change.
   * @param {boolean} readOnly
   */
  ace.Editor.prototype.setReadOnly = function(readOnly) {};
  
  /**
   * Sets how fast the mouse scrolling should do.
   * @param {number} speed
   */
  ace.Editor.prototype.setScrollSpeed = function(speed) {};
  
  /**
   * Indicates how selections should occur.
   * @param {string} style
   */
  ace.Editor.prototype.setSelectionStyle = function(style) {};
  
  /**
   * Sets a new editsession to use. This method also emits the 'changeSession'
   * event.
   * @param {!ace.EditSession} session
   */
  ace.Editor.prototype.setSession = function(session) {};
  
  /**
   * Indicates whether the fold widgets are shown or not.
   * @param {boolean} show
   */
  ace.Editor.prototype.setShowFoldWidgets = function(show) {};
  
  /**
   * If showInvisibles is set to true, invisible characters—like spaces or new
   * lines—are show in the editor.
   * @param {boolean} showInvisibles
   */
  ace.Editor.prototype.setShowInvisibles = function(showInvisibles) {};
  
  /**
   * If showPrintMargin is set to true, the print margin is shown in the editor.
   * @param {boolean} showPrintMargin
   */
  ace.Editor.prototype.setShowPrintMargin = function(showPrintMargin) {};
  
  /**
   * Adds a new class, style, to the editor.
   * @param {string} style
   */
  ace.Editor.prototype.setStyle = function(style) {};
  
  /**
   * Sets a new theme for the editor. theme should exist, and be a directory
   * path, like ace/theme/textmate.
   * @param {string} theme
   */
  ace.Editor.prototype.setTheme = function(theme) {};
  
  /**
   * Sets the current document to val.
   * @param {string} val
   * @param {number} cursorPos
   * @return {string}
   */
  ace.Editor.prototype.setValue = function(val, cursorPos) {};
  
  /**
   * Specifies whether to use wrapping behaviors or not, i.e. automatically
   * wrapping the selection with characters such as brackets when such a
   * character is typed in.
   * @param {boolean} enabled
   */
  ace.Editor.prototype.setWrapBehavioursEnabled = function(enabled) {};
  
  /** Undocumented */
  ace.Editor.prototype.sortLines = function() {};
  
  /**
   * Splits the line at the current selection (by inserting an '\n').
   */
  ace.Editor.prototype.splitLine = function() {};
  
  /**
   * Given the currently selected range, this function either comments all the
   * lines, or uncomments all of them.
   */
  ace.Editor.prototype.toggleCommentLines = function() {};
  
  /**
   * Sets the value of overwrite to the opposite of whatever it currently is.
   */
  ace.Editor.prototype.toggleOverwrite = function() {};
  
  /**
   * Converts the current selection entirely into lowercase.
   */
  ace.Editor.prototype.toLowerCase = function() {};
  
  /**
   * Converts the current selection entirely into uppercase.
   */
  ace.Editor.prototype.toUpperCase = function() {};
  
  /**
   * Transposes current line.
   */
  ace.Editor.prototype.transposeLetters = function() {};
  
  /**
   * Transposes the selected ranges.
   * @param {number} dir
   */
  ace.Editor.prototype.transposeSelections = function(dir) {};
  
  /**
   * Perform an undo operation on the document, reverting the last change.
   */
  ace.Editor.prototype.undo = function() {};
  
  /**
   * Removes the class style from the editor.
   * @param {!Object} style
   */
  ace.Editor.prototype.unsetStyle = function(style) {};
  
  /**
   * Updates the cursor and marker layers.
   */
  ace.Editor.prototype.updateSelectionMarkers = function() {};
  
  /**
   * Creates a new Range object with the given starting and ending row and column
   * points.
   * @constructor
   * @param {number} startRow
   * @param {number} startColumn
   * @param {number} endRow
   * @param {number} endColumn
   * @see https://ace.c9.io/#nav=api&api=range
   */
  ace.Range = function(startRow, startColumn, endRow, endColumn) {};
  
  /**
   * Returns the part of the current Range that occurs within the boundaries of
   * firstRow and lastRow as a new Range object.
   * @param {number} firstRow
   * @param {number} lastRow
   * @return {!ace.Range}
   */
  ace.Range.prototype.clipRows = function(firstRow, lastRow) {};
  
  /**
   * Returns a duplicate of the calling range.
   * @return {!ace.Range}
   */
  ace.Range.prototype.clone = function() {};
  
  /**
   * Returns a range containing the starting and ending rows of the original
   * range, but with a column value of 0.
   * @return {!ace.Range}
   */
  ace.Range.prototype.collapseRows = function() {};
  
  /**
   * Checks the row and column points with the row and column points of the
   * calling range.
   * @param {number} row
   * @param {number} column
   * @return {number}
   */
  ace.Range.prototype.compare = function(row, column) {};
  
  /**
   * Checks the row and column points with the row and column points of the
   * calling range.
   * @param {number} row
   * @param {number} column
   * @return {number}
   */
  ace.Range.prototype.compareEnd = function(row, column) {};
  
  /**
   * Checks the row and column points with the row and column points of the
   * calling range.
   * @param {number} row
   * @param {number} column
   * @return {number}
   */
  ace.Range.prototype.compareInside = function(row, column) {};
  
  /**
   * Checks the row and column points of p with the row and column points of the
   * calling range.
   * @param {!ace.Range} range
   * @return {number}
   */
  ace.Range.prototype.comparePoint = function(range)  {};
  
  /**
   * Compares this range (A) with another range (B).
   * @param {!ace.Range} range
   * @return {number}
   */
  ace.Range.prototype.compareRange = function(range) {};
  
  /**
   * Checks the row and column points with the row and column points of the
   * calling range.
   * @param {number} row
   * @param {number} column
   * @return {number}
   */
  ace.Range.prototype.compareStart = function(row, column) {};
  
  /**
   * Returns true if the row and column provided are within the given range.
   * This can better be expressed as returning true if:
   *   this.start.row <= row <= this.end.row &&
   *   this.start.column <= column <= this.end.column
   * @param {number} row
   * @param {number} column
   * @return {boolean}
   */
  ace.Range.prototype.contains = function(row, column) {};
  
  /**
   * Checks the start and end points of range and compares them to the calling
   * range. Returns true if the range is contained within the caller's range.
   * @param {!ace.Range} range
   * @return {boolean}
   */
  ace.Range.prototype.containsRange = function(range) {};
  
  /**
   * Changes the row and column points for the calling range for both the
   * starting and ending points.
   * @param {number} row
   * @param {number} column
   * @return {!ace.Range}
   */
  ace.Range.prototype.extend = function(row, column) {};
  
  /**
   * Creates and returns a new Range based on the row and column of the given
   * parameters.
   * @param {!ace.Range} start
   * @param {!ace.Range} end
   * @return {!ace.Range}
   */
  ace.Range.prototype.fromPoints = function(start, end) {};
  
  /**
   * Returns true if the row and column are within the given range.
   * @param {number} row
   * @param {number} column
   * @return {boolean}
   */
  ace.Range.prototype.inside = function(row, column) {};
  
  /**
   * Returns true if the row and column are within the given range.
   * @param {number} row
   * @param {number} column
   * @return {boolean}
   */
  ace.Range.prototype.insideEnd = function(row, column) {};
  
  /**
   * Returns true if the row and column are within the given range's starting
   * points.
   * @param {number} row
   * @param {number} column
   * @return {boolean}
   */
  ace.Range.prototype.insideStart = function(row, column) {};
  
  /**
   * Returns true if passed in range intersects with the one calling this method.
   * @param {!ace.Range} range
   * @return {boolean}
   */
  ace.Range.prototype.intersects = function(range) {};
  
  /** Undocumented */
  ace.Range.prototype.isEmpty = function() {};
  
  /**
   * Returns true if the caller's ending row point is the same as row, and if the
   * caller's ending column is the same as column.
   * @param {number} row
   * @param {number} column
   * @return {boolean}
   */
  ace.Range.prototype.isEnd = function(row, column) {};
  
  /**
   * Returns true if and only if the starting row and column, and ending row and
   * column, are equivalent to those given by range.
   * @param {!ace.Range} range
   * @return {boolean}
   */
  ace.Range.prototype.isEqual = function(range) {};
  
  /**
   * Returns true if the range spans across multiple lines.
   * @return {boolean}
   */
  ace.Range.prototype.isMultiLine = function()  {};
  
  /**
   * Returns true if the caller's starting row point is the same as row, and if
   * the caller's starting column is the same as column.
   * @param {number} row
   * @param {number} column
   * @return {boolean}
   */
  ace.Range.prototype.isStart = function(row, column) {};
  
  /**
   * Sets the starting row and column for the range.
   * @param {number} row
   * @param {number} column
   * @return {!Object}
   */
  ace.Range.prototype.setEnd = function(row, column) {};
  
  /**
   * Sets the starting row and column for the range.
   * @param {number} row
   * @param {number} column
   * @return {!Object}
   */
  ace.Range.prototype.setStart = function(row, column) {};
  
  /**
   * Given the current Range, this function converts those starting and ending
   * points into screen positions,
   * and then returns a new Range object.
   * @param {!ace.EditSession} session
   * @return {!ace.Range}
   */
  ace.Range.prototype.toScreenRange = function(session) {};
  
  /**
   * Returns a string containing the range's row and column information, given
   * like this:
   *   [start.row/start.column] -> [end.row/end.column]
   * @override
   */
  ace.Range.prototype.toString = function() {};
  
  /**
   * Creates a new ScrollBar. parent is the owner of the scroll bar.
   * @constructor
   * @param {!Element} parent
   * @see https://ace.c9.io/#nav=api&api=scrollbar
   */
  ace.ScrollBar = function(parent) {};
  
  /**
   * Emitted when the scroll bar, well, scrolls.
   * @param {string} event
   * @param {function(!Object)} fn
   */
  ace.ScrollBar.prototype.on = function(event, fn) {};
  
  /**
   * Returns the width of the scroll bar.
   * @return {number}
   */
  ace.ScrollBar.prototype.getWidth = function() {};
  
  /** Undocumented */
  ace.ScrollBar.prototype.onScroll = function() {};
  
  /**
   * Sets the height of the scroll bar, in pixels.
   * @param {number} height
   */
  ace.ScrollBar.prototype.setHeight = function(height) {};
  
  /**
   * Sets the inner height of the scroll bar, in pixels.
   * @param {number} height
   */
  ace.ScrollBar.prototype.setInnerHeight = function(height) {};
  
  /**
   * Sets the scroll top of the scroll bar.
   * @param {number} scrollTop
   */
  ace.ScrollBar.prototype.setScrollTop = function(scrollTop) {};
  
  /**
   * Creates a new Search object.
   * @constructor
   * @see https://ace.c9.io/#nav=api&api=search
   */
  ace.Search = function() {};
  
  /**
   * Searches for options.needle. If found, this method returns the Range where
   * the text first occurs. If options.backwards is true, the search goes
   * backwards in the session.
   * @param {!ace.EditSession} session
   * @return {!ace.Range}
   */
  ace.Search.prototype.find = function(session) {};
  
  /**
   * Searches for all occurances options.needle.
   * If found, this method returns an array of Ranges where the text first occurs.
   * If options.backwards is true, the search goes backwards in the session.
   * @param {!ace.EditSession} session
   * @return {!ace.Range}
   */
  ace.Search.prototype.findAll = function(session) {};
  
  /**
   * Returns an object containing all the search options.
   * @return {!Object}
   */
  ace.Search.prototype.getOptions = function() {};
  
  /**
   * Searches for options.needle in input, and, if found, replaces it with
   * replacement.
   * @param {string} input
   * @param {string} replacement
   * @return {string}
   */
  ace.Search.prototype.replace = function(input, replacement) {};
  
  /**
   * Sets the search options via the options parameter.
   * @param {{needle: string, backwards: boolean}} options
   * @return {!ace.Search}
   */
  ace.Search.prototype.set = function(options) {};
  
  /** Undocumented */
  ace.Search.prototype.setOptions = function() {};
  
  /**
   * Creates a new Selection object.
   * @constructor
   * @param {!ace.EditSession} session
   * @see https://ace.c9.io/#nav=api&api=selection
   */
  ace.Selection = function(session) {};
  
  /**
   * @param {string} event
   * @param {!Function} fn
   */
  ace.Selection.prototype.on = function(event, fn) {};
  
  /**
   * Adds a range to a selection by entering multiselect mode, if necessary.
   * @param {!ace.Range} range
   * @param {boolean} $blockChangeEvents
   */
  ace.Selection.prototype.addRange = function(range, $blockChangeEvents) {};
  
  /**
   * Empties the selection (by de-selecting it). This function also emits the
   * 'changeSelection' event.
   */
  ace.Selection.prototype.clearSelection = function() {};
  
  /** Undocumented */
  ace.Selection.prototype.detach = function() {};
  
  /** Undocumented */
  ace.Selection.prototype.fromOrientedRange = function() {};
  
  /**
   * Returns a concatenation of all the ranges.
   * @return {!Array<!Object>}
   */
  ace.Selection.prototype.getAllRanges = function() {};
  
  /**
   * Gets the current position of the cursor.
   * @return {number}
   */
  ace.Selection.prototype.getCursor = function() {};
  
  /** Undocumented */
  ace.Selection.prototype.getLineRange = function() {};
  
  /**
   * Returns the Range for the selected text.
   * @return {!ace.Range}
   */
  ace.Selection.prototype.getRange = function() {};
  
  /**
   * Returns an object containing the row and column of the calling selection
   * anchor.
   * @return {!Object}
   */
  ace.Selection.prototype.getSelectionAnchor = function() {};
  
  /**
   * Returns an object containing the row and column of the calling selection
   * lead.
   * @return {!Object}
   */
  ace.Selection.prototype.getSelectionLead = function() {};
  
  /**
   * Moves the selection to highlight the entire word.
   * @param {!Object} row
   * @param {!Object} column
   */
  ace.Selection.prototype.getWordRange = function(row, column) {};
  
  /**
   * Returns true if the selection is going backwards in the document.
   * @return {boolean}
   */
  ace.Selection.prototype.isBackwards = function() {};
  
  /**
   * Returns true if the selection is empty.
   * @return {boolean}
   */
  ace.Selection.prototype.isEmpty = function() {};
  
  /**
   * Returns true if the selection is a multi-line.
   * @return {boolean}
   */
  ace.Selection.prototype.isMultiLine = function() {};
  
  /**
   * Merges overlapping ranges ensuring consistency after changes.
   */
  ace.Selection.prototype.mergeOverlappingRanges = function() {};
  
  /**
   * Moves the cursor to position indicated by the parameters. Negative numbers
   * move the cursor backwards in the document.
   * @param {number} rows
   * @param {number} chars
   */
  ace.Selection.prototype.moveCursorBy = function(rows, chars) {};
  
  /**
   * Moves the cursor down one row.
   */
  ace.Selection.prototype.moveCursorDown = function() {};
  
  /**
   * Moves the cursor to the end of the file.
   */
  ace.Selection.prototype.moveCursorFileEnd = function() {};
  
  /**
   * Moves the cursor to the start of the file.
   */
  ace.Selection.prototype.moveCursorFileStart = function() {};
  
  /**
   * Moves the cursor left one column.
   */
  ace.Selection.prototype.moveCursorLeft = function() {};
  
  /**
   * Moves the cursor to the end of the line.
   */
  ace.Selection.prototype.moveCursorLineEnd = function() {};
  
  /**
   * Moves the cursor to the start of the line.
   */
  ace.Selection.prototype.moveCursorLineStart = function() {};
  
  /**
   * Moves the cursor to the word on the left.
   */
  ace.Selection.prototype.moveCursorLongWordLeft = function() {};
  
  /**
   * Moves the cursor to the word on the right.
   */
  ace.Selection.prototype.moveCursorLongWordRight = function() {};
  
  /**
   * Moves the cursor right one column.
   */
  ace.Selection.prototype.moveCursorRight = function() {};
  
  /** Undocumented */
  ace.Selection.prototype.moveCursorShortWordLeft = function() {};
  
  /** Undocumented */
  ace.Selection.prototype.moveCursorShortWordRight = function() {};
  
  /**
   * Moves the cursor to the row and column provided.
   * If preventUpdateDesiredColumn is true, then the cursor stays in the same
   * column position as its original point.
   * @param {number} row
   * @param {number} column
   * @param {boolean} keepDesiredColumn
   */
  ace.Selection.prototype.moveCursorTo = function(row, column, keepDesiredColumn) {};
  
  /**
   * Moves the selection to the position indicated by its row and column.
   * @param {!Object} position
   */
  ace.Selection.prototype.moveCursorToPosition = function(position) {};
  
  /**
   * Moves the cursor to the screen position indicated by row and column.
   * If preventUpdateDesiredColumn is true, then the cursor stays in the same
   * column position as its original point.
   * @param {number} row
   * @param {number} column
   * @param {boolean} keepDesiredColumn
   */
  ace.Selection.prototype.moveCursorToScreen = function(row, column, keepDesiredColumn) {};
  
  /**
   * Moves the cursor up one row.
   */
  ace.Selection.prototype.moveCursorUp = function() {};
  
  /** Undocumented */
  ace.Selection.prototype.moveCursorWordLeft = function() {};
  
  /** Undocumented */
  ace.Selection.prototype.moveCursorWordRight = function() {};
  
  /**
   * Gets list of ranges composing rectangular block on the screen.
   * @param {!Object} screenCursor
   * @param {!ace.Anchor} screenAnchor
   * @param {boolean} includeEmptyLines
   * @return {!ace.Range}
   */
  ace.Selection.prototype.rectangularRangeBlock = function(screenCursor, screenAnchor, includeEmptyLines) {};
  
  /**
   * Selects all the text in the document.
   */
  ace.Selection.prototype.selectAll = function() {};
  
  /**
   * Selects a word, including its right whitespace.
   */
  ace.Selection.prototype.selectAWord = function() {};
  
  /**
   * Moves the selection down one row.
   */
  ace.Selection.prototype.selectDown = function() {};
  
  /**
   * Moves the selection to the end of the file.
   */
  ace.Selection.prototype.selectFileEnd = function() {};
  
  /**
   * Moves the selection to the start of the file.
   */
  ace.Selection.prototype.selectFileStart = function() {};
  
  /**
   * Moves the selection left one column.
   */
  ace.Selection.prototype.selectLeft = function() {};
  
  /**
   * Selects the entire line.
   */
  ace.Selection.prototype.selectLine = function() {};
  
  /**
   * Moves the selection to the end of the current line.
   */
  ace.Selection.prototype.selectLineEnd = function() {};
  
  /**
   * Moves the selection to the beginning of the current line.
   */
  ace.Selection.prototype.selectLineStart = function() {};
  
  /**
   * Moves the selection right one column.
   */
  ace.Selection.prototype.selectRight = function() {};
  
  /**
   * Moves the selection cursor to the indicated row and column.
   * @param {number} row
   * @param {number} column
   */
  ace.Selection.prototype.selectTo = function(row, column) {};
  
  /**
   * Moves the selection cursor to the row and column indicated by pos.
   * @param {!Object} pos
   */
  ace.Selection.prototype.selectToPosition = function(pos) {};
  
  /**
   * Moves the selection up one row.
   */
  ace.Selection.prototype.selectUp = function() {};
  
  /**
   * Selects an entire word boundary.
   */
  ace.Selection.prototype.selectWord = function() {};
  
  /**
   * Moves the selection to the first word on the left.
   */
  ace.Selection.prototype.selectWordLeft = function() {};
  
  /**
   * Moves the selection to the first word on the right.
   */
  ace.Selection.prototype.selectWordRight = function() {};
  
  /**
   * Sets the row and column position of the anchor. This function also emits the
   * 'changeSelection' event.
   * @param {number} row
   * @param {number} column
   */
  ace.Selection.prototype.setSelectionAnchor = function(row, column) {};
  
  /**
   * Sets the selection to the provided range.
   * @param {!ace.Range} range
   * @param {boolean} reverse
   */
  ace.Selection.prototype.setSelectionRange = function(range, reverse) {};
  
  /**
   * Shifts the selection up (or down, if isBackwards() is true) the given number
   * of columns.
   * @param {number} columns
   */
  ace.Selection.prototype.shiftSelection = function(columns) {};
  
  /**
   * Splits all the ranges into lines.
   */
  ace.Selection.prototype.splitIntoLines = function() {};
  
  /**
   * Removes a Range containing pos (if it exists).
   * @param {!ace.Range} pos
   */
  ace.Selection.prototype.substractPoint = function(pos) {};
  
  /** Undocumented */
  ace.Selection.prototype.toggleBlockSelection = function() {};
  
  /** Undocumented */
  ace.Selection.prototype.toOrientedRange = function() {};
  
  /** Undocumented */
  ace.Selection.prototype.toSingleRange = function() {};
  
  /**
   * Creates a new token iterator object. The inital token index is set to the
   * provided row and column coordinates.
   * @constructor
   * @param {!ace.EditSession} session
   * @param {number} initialRow
   * @param {number} initialColumn
   * @see https://ace.c9.io/#nav=api&api=token_iterator
   */
  ace.TokenIterator = function(session, initialRow, initialColumn) {};
  
  /**
   * Returns the current tokenized string.
   * @return {string}
   */
  ace.TokenIterator.prototype.getCurrentToken = function() {};
  
  /**
   * Returns the current column.
   * @return {number}
   */
  ace.TokenIterator.prototype.getCurrentTokenColumn = function() {};
  
  /**
   * Returns the current row.
   * @return {number}
   */
  ace.TokenIterator.prototype.getCurrentTokenRow = function() {};
  
  /**
   * Tokenizes all the items from the current point to the row prior in the
   * document.
   * @return {string}
   */
  ace.TokenIterator.prototype.stepBackward = function() {};
  
  /**
   * Tokenizes all the items from the current point until the next row in the
   * document. If the current point is at the end of the file, this function
   * returns null. Otherwise, it returns the tokenized string.
   * @return {?string}
   */
  ace.TokenIterator.prototype.stepForward = function() {};
  
  /**
   * Constructs a new tokenizer based on the given rules and flags.
   * @constructor
   * @param {!Object} rules
   * @param {string} flag
   * @see https://ace.c9.io/#nav=api&api=tokenizer
   */
  ace.Tokenizer = function(rules, flag) {};
  
  /**
   * Returns an object containing two properties: tokens, which contains all the
   * tokens; and state, the current state.
   * @param {!Object} line
   * @param {!Object} startState
   * @return {{tokens: !Array<!Object>, state: !Object}}
   */
  ace.Tokenizer.prototype.getLineTokens = function(line, startState) {};
  
  /**
   * Resets the current undo state and creates a new UndoManager.
   * @constructor
   * @see https://ace.c9.io/#nav=api&api=undomanager
   */
  ace.UndoManager = function() {};
  
  /**
   * Provides a means for implementing your own undo manager. options has one
   * property, args, an Array, with two elements: deltaSets and doc.
   * @param {{args: !Array<!Object>}} options
   */
  ace.UndoManager.prototype.execute = function(options) {};
  
  /**
   * Returns true if there are redo operations left to perform.
   * @return {boolean}
   */
  ace.UndoManager.prototype.hasRedo = function() {};
  
  /**
   * Returns true if there are undo operations left to perform.
   * @return {boolean}
   */
  ace.UndoManager.prototype.hasUndo = function() {};
  
  /**
   * Perform a redo operation on the document, reimplementing the last change.
   * @param {boolean} dontSelect
   */
  ace.UndoManager.prototype.redo = function(dontSelect) {};
  
  /**
   * Destroys the stack of undo and redo redo operations.
   */
  ace.UndoManager.prototype.reset = function() {};
  
  /**
   * Perform an undo operation on the document, reverting the last change.
   * @param {boolean} dontSelect
   * @return {!ace.Range}
   */
  ace.UndoManager.prototype.undo = function(dontSelect) {};
  
  /**
   * Constructs a new VirtualRenderer within the container specified, applying
   * the given theme.
   * @constructor
   * @param {!Element} container
   * @param {string} theme
   * @see https://ace.c9.io/#nav=api&api=virtual_renderer
   */
  ace.VirtualRenderer = function(container, theme) {};
  
  /** Undocumented */
  ace.VirtualRenderer.prototype._loadTheme = function() {};
  
  /**
   * Deprecated (moved to EditSession)
   * @deprecated
   * @param {!Object} row
   */
  ace.VirtualRenderer.prototype.addGutterDecoration = function(row, className) {};
  
  /**
   * Adjusts the wrap limit, which is the number of characters that can fit
   * within the width of the edit area on screen.
   */
  ace.VirtualRenderer.prototype.adjustWrapLimit = function() {};
  
  /** Undocumented */
  ace.VirtualRenderer.prototype.alignCursor = function() {};
  
  /** Undocumented */
  ace.VirtualRenderer.prototype.animateScrolling = function() {};
  
  /**
   * Destroys the text and cursor layers for this renderer.
   */
  ace.VirtualRenderer.prototype.destroy = function() {};
  
  /**
   * Returns whether an animated scroll happens or not.
   * @return {boolean}
   */
  ace.VirtualRenderer.prototype.getAnimatedScroll = function() {};
  
  /**
   * Returns the root element containing this renderer.
   * @return {!Element}
   */
  ace.VirtualRenderer.prototype.getContainerElement = function() {};
  
  /** Undocumented */
  ace.VirtualRenderer.prototype.getDisplayIndentGuides = function() {};
  
  /** Undocumented */
  ace.VirtualRenderer.prototype.getFadeFoldWidgets = function() {};
  
  /**
   * Returns the index of the first fully visible row.
   * "Fully" here means that the characters in the row are not truncated; that
   * the top and the bottom of the row are on the screen.
   */
  ace.VirtualRenderer.prototype.getFirstFullyVisibleRow = function() {};
  
  /**
   * Returns the index of the first visible row.
   * @return {number}
   */
  ace.VirtualRenderer.prototype.getFirstVisibleRow = function() {};
  
  /** Undocumented */
  ace.VirtualRenderer.prototype.getHighlightGutterLine = function() {};
  
  /**
   * Returns whether the horizontal scrollbar is set to be always visible.
   * @return {boolean}
   */
  ace.VirtualRenderer.prototype.getHScrollBarAlwaysVisible = function() {};
  
  /**
   * Returns the index of the last fully visible row.
   * "Fully" here means that the characters in the row are not truncated; that
   * the top and the bottom of the row are on the screen.
   * @return {number}
   */
  ace.VirtualRenderer.prototype.getLastFullyVisibleRow = function() {};
  
  /**
   * Returns the index of the last visible row.
   * @return {number}
   */
  ace.VirtualRenderer.prototype.getLastVisibleRow = function() {};
  
  /**
   * Returns the element that the mouse events are attached to.
   * @return {!Element}
   */
  ace.VirtualRenderer.prototype.getMouseEventTarget = function() {};
  
  /**
   * Returns whether the print margin column is being shown or not.
   * @return {boolean}
   */
  ace.VirtualRenderer.prototype.getPrintMarginColumn = function() {};
  
  /**
   * Returns the last visible row, regardless of whether it's fully visible or
   * not.
   * @return {number}
   */
  ace.VirtualRenderer.prototype.getScrollBottomRow = function() {};
  
  /**
   * Returns the value of the distance between the left of the editor and the
   * leftmost part of the visible content.
   * @return {number}
   */
  ace.VirtualRenderer.prototype.getScrollLeft = function() {};
  
  /**
   * Returns the value of the distance between the top of the editor and the
   * topmost part of the visible content.
   * @return {number}
   */
  ace.VirtualRenderer.prototype.getScrollTop = function() {};
  
  /**
   * Returns the first visible row, regardless of whether it's fully visible or
   * not.
   * @return {number}
   */
  ace.VirtualRenderer.prototype.getScrollTopRow = function() {};
  
  /**
   * Returns true if the gutter is being shown.
   * @return {boolean}
   */
  ace.VirtualRenderer.prototype.getShowGutter = function() {};
  
  /**
   * Returns whether invisible characters are being shown or not.
   * @return {boolean}
   */
  ace.VirtualRenderer.prototype.getShowInvisibles = function() {};
  
  /**
   * Returns whether the print margin is being shown or not.
   * @return {boolean}
   */
  ace.VirtualRenderer.prototype.getShowPrintMargin = function() {};
  
  /**
   * Returns the element to which the hidden text area is added.
   * @return {!Element}
   */
  ace.VirtualRenderer.prototype.getTextAreaContainer = function() {};
  
  /**
   * Returns the path of the current theme.
   * @return {string}
   */
  ace.VirtualRenderer.prototype.getTheme = function() {};
  
  /**
   * Hides the current composition.
   */
  ace.VirtualRenderer.prototype.hideComposition = function() {};
  
  /**
   * Hides the cursor icon.
   */
  ace.VirtualRenderer.prototype.hideCursor = function() {};
  
  /**
   * Returns true if you can still scroll by either parameter; in other words,
   * you haven't reached the end of the file or line.
   * @param {number} deltaX
   * @param {number} deltaY
   * @return {boolean}
   */
  ace.VirtualRenderer.prototype.isScrollableBy = function(deltaX, deltaY) {};
  
  /** Undocumented */
  ace.VirtualRenderer.prototype.onChangeTabSize = function() {};
  
  /** Undocumented */
  ace.VirtualRenderer.prototype.onGutterResize = function() {};
  
  /**
   * Triggers a resize of the editor.
   * @param {boolean} force
   * @param {number} gutterWidth
   * @param {number} width
   * @param {number} height
   */
  ace.VirtualRenderer.prototype.onResize = function(force, gutterWidth, width, height) {};
  
  /** Undocumented */
  ace.VirtualRenderer.prototype.pixelToScreenCoordinates = function() {};
  
  /**
   * Deprecated (moved to EditSession)
   * @deprecated
   * @param {!Object} row
   * @param {!Object} className
   */
  ace.VirtualRenderer.prototype.removeGutterDecoration = function(row, className) {};
  
  /** Undocumented */
  ace.VirtualRenderer.prototype.screenToTextCoordinates = function() {};
  
  /**
   * Scrolls the editor across both x- and y-axes.
   * @param {number} deltaX
   * @param {number} deltaY
   */
  ace.VirtualRenderer.prototype.scrollBy = function(deltaX, deltaY) {};
  
  /**
   * Scrolls the cursor into the first visibile area of the editor
   * @param {!Object} cursor
   * @param {!Object} offset
   */
  ace.VirtualRenderer.prototype.scrollCursorIntoView = function(cursor, offset) {};
  
  /** Undocumented */
  ace.VirtualRenderer.prototype.scrollSelectionIntoView = function() {};
  
  /**
   * Gracefully scrolls the editor to the row indicated.
   * @param {number} line
   * @param {boolean} center
   * @param {boolean} animate
   * @param {!Function} callback
   */
  ace.VirtualRenderer.prototype.scrollToLine = function(line, center, animate, callback) {};
  
  /**
   * Gracefully scrolls from the top of the editor to the row indicated.
   * @param {number} row
   */
  ace.VirtualRenderer.prototype.scrollToRow = function(row) {};
  
  /**
   * Scrolls the editor across the x-axis to the pixel indicated.
   * @param {number} scrollLeft
   * @return {number}
   */
  ace.VirtualRenderer.prototype.scrollToX = function(scrollLeft) {};
  
  /**
   * Scrolls the editor to the y pixel indicated.
   * @param {number} scrollTop
   * @return {number}
   */
  ace.VirtualRenderer.prototype.scrollToY = function(scrollTop) {};
  
  /**
   * Identifies whether you want to have an animated scroll or not.
   * @param {boolean} shouldAnimate
   */
  ace.VirtualRenderer.prototype.setAnimatedScroll = function(shouldAnimate) {};
  
  /**
   * Sets annotations for the gutter.
   * @param {!Array<!Object>} annotations
   */
  ace.VirtualRenderer.prototype.setAnnotations = function(annotations) {};
  
  /**
   * @param {string} text
   */
  ace.VirtualRenderer.prototype.setCompositionText = function(text) {};
  
  /** Undocumented */
  ace.VirtualRenderer.prototype.setDisplayIndentGuides = function() {};
  
  /** Undocumented */
  ace.VirtualRenderer.prototype.setFadeFoldWidgets = function() {};
  
  /** Undocumented */
  ace.VirtualRenderer.prototype.setHighlightGutterLine = function() {};
  
  /**
   * Identifies whether you want to show the horizontal scrollbar or not.
   * @param {boolean} alwaysVisible
   */
  ace.VirtualRenderer.prototype.setHScrollBarAlwaysVisible = function(alwaysVisible) {};
  
  /**
   * Sets the padding for all the layers.
   * @param {number} padding
   */
  ace.VirtualRenderer.prototype.setPadding = function(padding) {};
  
  /**
   * Identifies whether you want to show the print margin column or not.
   * @param {boolean} showPrintMargin
   */
  ace.VirtualRenderer.prototype.setPrintMarginColumn = function(showPrintMargin) {};
  
  /**
   * Associates the renderer with an EditSession.
   * @param {!ace.EditSession} session
   */
  ace.VirtualRenderer.prototype.setSession = function(session) {};
  
  /**
   * Identifies whether you want to show the gutter or not.
   * @param {boolean} show
   */
  ace.VirtualRenderer.prototype.setShowGutter = function(show) {};
  
  /**
   * Identifies whether you want to show invisible characters or not.
   * @param {boolean} showInvisibles
   */
  ace.VirtualRenderer.prototype.setShowInvisibles = function(showInvisibles) {};
  
  /**
   * Identifies whether you want to show the print margin or not.
   * @param {boolean} showPrintMargin
   */
  ace.VirtualRenderer.prototype.setShowPrintMargin = function(showPrintMargin) {};
  
  /** Undocumented */
  ace.VirtualRenderer.prototype.setStyle = function() {};
  
  /**
   * Sets a new theme for the editor. theme should exist, and be a directory
   * path, like ace/theme/textmate.
   * @param {string} theme
   */
  ace.VirtualRenderer.prototype.setTheme = function(theme) {};
  
  /**
   * Shows the cursor icon.
   */
  ace.VirtualRenderer.prototype.showCursor = function() {};
  
  /**
   * Returns an object containing the pageX and pageY coordinates of the document
   * position.
   * @param {number} row
   * @param {number} column
   * @return {!Object}
   */
  ace.VirtualRenderer.prototype.textToScreenCoordinates = function(row, column) {};
  
  /**
   * Removes the class style from the editor.
   * @param {string} style
   */
  ace.VirtualRenderer.prototype.unsetStyle = function(style) {};
  
  /**
   * Schedules an update to all the back markers in the document.
   */
  ace.VirtualRenderer.prototype.updateBackMarkers = function() {};
  
  /**
   * Redraw breakpoints.
   * @param {!Object} rows
   */
  ace.VirtualRenderer.prototype.updateBreakpoints = function(rows) {};
  
  /** Undocumented */
  ace.VirtualRenderer.prototype.updateCharacterSize = function() {};
  
  /**
   * Updates the cursor icon.
   */
  ace.VirtualRenderer.prototype.updateCursor = function() {};
  
  /**
   * Updates the font size.
   */
  ace.VirtualRenderer.prototype.updateFontSize = function() {};
  
  /**
   * Schedules an update to all the front markers in the document.
   */
  ace.VirtualRenderer.prototype.updateFrontMarkers = function() {};
  
  /**
   * Triggers a full update of all the layers, for all the rows.
   * @param {boolean} force
   */
  ace.VirtualRenderer.prototype.updateFull = function(force) {};
  
  /**
   * Triggers a partial update of the text, from the range given by the two
   * parameters.
   * @param {number} firstRow
   * @param {number} lastRow
   */
  ace.VirtualRenderer.prototype.updateLines = function(firstRow, lastRow) {};
  
  /**
   * Triggers a full update of the text, for all the rows.
   */
  ace.VirtualRenderer.prototype.updateText = function() {};
  
  /**
   * Blurs the current container.
   */
  ace.VirtualRenderer.prototype.visualizeBlur = function() {};
  
  /**
   * Focuses the current container.
   */
  ace.VirtualRenderer.prototype.visualizeFocus = function() {};
  