@types/ace/index.d.ts

TypeScript definitions for ace

declare namespace AceAjax {
    export interface Delta {
        action: "insert" | "remove";
        start: Position;
        end: Position;
        lines: string[];
    }

    export interface EditorCommand {
        name?: string | undefined;
        bindKey?: string | { mac?: string | undefined; win?: string | undefined } | undefined;
        exec: (editor: Editor, args?: any) => void;
        readOnly?: boolean | undefined;
    }

    interface CommandMap {
        [name: string]: EditorCommand;
    }

    type execEventHandler = (obj: {
        editor: Editor;
        command: EditorCommand;
        args: any[];
    }) => void;

    type CommandLike = EditorCommand | ((editor: Editor) => void);

    export interface CommandManager {
        byName: CommandMap;
        commands: CommandMap;
        on(name: "exec", callback: execEventHandler): Function;
        on(name: "afterExec", callback: execEventHandler): Function;
        once(name: string, callback: Function): void;
        setDefaultHandler(name: string, callback: Function): void;
        removeDefaultHandler(name: string, callback: Function): void;
        on(name: string, callback: Function, capturing?: boolean): Function;
        addEventListener(name: string, callback: Function, capturing?: boolean): void;
        off(name: string, callback: Function): void;
        removeListener(name: string, callback: Function): void;
        removeEventListener(name: string, callback: Function): void;
        exec(command: string, editor: Editor, args: any): boolean;
        toggleRecording(editor: Editor): void;
        replay(editor: Editor): void;
        addCommand(command: EditorCommand): void;
        addCommands(commands: EditorCommand[]): void;
        removeCommand(command: EditorCommand | string, keepCommand?: boolean): void;
        removeCommands(command: EditorCommand[]): void;
        bindKey(
            key: string | { mac?: string | undefined; win?: string | undefined },
            command: CommandLike,
            position?: number,
        ): void;
        bindKeys(keys: { [s: string]: Function }): void;
        parseKeys(keyPart: string): { key: string; hashId: number };
        findKeyCommand(hashId: number, keyString: string): string | undefined;
        handleKeyboard(
            data: {},
            hashId: number,
            keyString: string,
            keyCode: string | number,
            // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
        ): void | { command: string };
        getStatusText(editor: Editor, data: {}): string;
        platform: string;
    }

    export interface Annotation {
        row?: number | undefined;
        column?: number | undefined;
        text: string;
        type: string;
    }

    export interface TokenInfo {
        type: string;
        value: string;
        index?: number | undefined;
        start?: number | undefined;
    }

    export interface Position {
        row: number;
        column: number;
    }

    export interface KeyboardHandler {
        handleKeyboard: Function;
    }

    export interface KeyBinding {
        setDefaultHandler(kb: KeyboardHandler): void;
        setKeyboardHandler(kb: KeyboardHandler): void;
        addKeyboardHandler(kb: KeyboardHandler, pos: number): void;
        removeKeyboardHandler(kb: KeyboardHandler): boolean;
        getKeyboardHandler(): KeyboardHandler;
        onCommandKey(e: any, hashId: number, keyCode: number): boolean;
        onTextInput(text: string): boolean;
    }

    export interface TextMode {
        getTokenizer(): Tokenizer;
        toggleCommentLines(state: any, session: IEditSession, startRow: number, endRow: number): void;
        toggleBlockComment(state: any, session: IEditSession, range: Range, cursor: Position): void;
        getNextLineIndent(state: any, line: string, tab: string): string;
        checkOutdent(state: any, line: string, input: string): boolean;
        autoOutdent(state: any, doc: Document, row: number): void;
        createWorker(session: IEditSession): any;
        createModeDelegates(mapping: { [key: string]: string }): void;
        transformAction(state: string, action: string, editor: Editor, session: IEditSession, text: string): any;
        getKeywords(append?: boolean): Array<string | RegExp>;
        getCompletions(state: string, session: IEditSession, pos: Position, prefix: string): Completion[];
    }

    export interface OptionProvider {
        /**
         * Sets a Configuration Option
         */
        setOption(optionName: string, optionValue: any): void;

        /**
         * Sets Configuration Options
         */
        setOptions(keyValueTuples: { [key: string]: any }): void;

        /**
         * Get a Configuration Option
         */
        getOption(name: string): any;

        /**
         * Get Configuration Options
         */
        getOptions(optionNames?: string[] | { [key: string]: any }): { [key: string]: any };
    }

    ////////////////
    /// Ace
    ////////////////

    /**
     * The main class required to set up an Ace instance in the browser.
     */
    export interface Ace {
        /**
         * Provides access to require in packed noconflict mode
         * @param moduleName
         */
        require(moduleName: string): any;

        /**
         * Embeds the Ace editor into the DOM, at the element provided by `el`.
         * @param el Either the id of an element, or the element itself
         */
        edit(el: string): Editor;

        /**
         * Embeds the Ace editor into the DOM, at the element provided by `el`.
         * @param el Either the id of an element, or the element itself
         */
        edit(el: HTMLElement): Editor;

        /**
         * Creates a new [[EditSession]], and returns the associated [[Document]].
         * @param text {:textParam}
         * @param mode {:modeParam}
         */
        createEditSession(text: Document, mode: TextMode): IEditSession;

        /**
         * Creates a new [[EditSession]], and returns the associated [[Document]].
         * @param text {:textParam}
         * @param mode {:modeParam}
         */
        createEditSession(text: string, mode: TextMode): IEditSession;
    }

    ////////////////
    /// Anchor
    ////////////////

    /**
     * Defines the floating pointer in the document. Whenever text is inserted or deleted before the cursor, the position of the cursor is updated.
     */
    export interface Anchor {
        on(event: string, fn: (e: any) => any): void;

        /**
         * Returns an object identifying the `row` and `column` position of the current anchor.
         */
        getPosition(): Position;

        /**
         * Returns the current document.
         */
        getDocument(): Document;

        /**
         * Fires whenever the anchor position changes.
         * Both of these objects have a `row` and `column` property corresponding to the position.
         * Events that can trigger this function include [[Anchor.setPosition `setPosition()`]].
         * @param e An object containing information about the anchor position. It has two properties:
         * - `old`: An object describing the old Anchor position
         * - `value`: An object describing the new Anchor position
         */
        onChange(e: any): void;

        /**
         * Sets the anchor position to the specified row and column. If `noClip` is `true`, the position is not clipped.
         * @param row The row index to move the anchor to
         * @param column The column index to move the anchor to
         * @param noClip Identifies if you want the position to be clipped
         */
        setPosition(row: number, column: number, noClip?: boolean): void;

        /**
         * When called, the `'change'` event listener is removed.
         */
        detach(): void;

        attach(doc: Document): void;
    }
    var Anchor: {
        /**
         * Creates a new `Anchor` and associates it with a document.
         * @param doc The document to associate with the anchor
         * @param row The starting row position
         * @param column The starting column position
         */
        new(doc: Document, row: number, column: number): Anchor;
    };

    ////////////////////////////////
    /// BackgroundTokenizer
    ////////////////////////////////

    /**
     * Tokenizes the current [[Document `Document`]] in the background, and caches the tokenized rows for future use.
     * If a certain row is changed, everything below that row is re-tokenized.
     */
    export interface BackgroundTokenizer {
        states: any[];

        /**
         * Sets a new tokenizer for this object.
         * @param tokenizer The new tokenizer to use
         */
        setTokenizer(tokenizer: Tokenizer): void;

        /**
         * Sets a new document to associate with this object.
         * @param doc The new document to associate with
         */
        setDocument(doc: Document): void;

        /**
         * Emits the `'update'` event. `firstRow` and `lastRow` are used to define the boundaries of the region to be updated.
         * @param firstRow The starting row region
         * @param lastRow The final row region
         */
        fireUpdateEvent(firstRow: number, lastRow: number): void;

        /**
         * Starts tokenizing at the row indicated.
         * @param startRow The row to start at
         */
        start(startRow: number): void;

        /**
         * Stops tokenizing.
         */
        stop(): void;

        /**
         * Gives list of tokens of the row. (tokens are cached)
         * @param row The row to get tokens at
         */
        getTokens(row: number): TokenInfo[];

        /**
         * [Returns the state of tokenization at the end of a row.]{: #BackgroundTokenizer.getState}
         * @param row The row to get state at
         */
        getState(row: number): string;
    }
    var BackgroundTokenizer: {
        /**
         * Creates a new `BackgroundTokenizer` object.
         * @param tokenizer The tokenizer to use
         * @param editor The editor to associate with
         */
        new(tokenizer: Tokenizer, editor: Editor): BackgroundTokenizer;
    };

    ////////////////
    /// Document
    ////////////////

    /**
     * Contains the text of the document. Document can be attached to several [[EditSession `EditSession`]]s.
     * At its core, `Document`s are just an array of strings, with each row in the document matching up to the array index.
     */

    type NewLineMode = "auto" | "unix" | "windows";

    export interface Document {
        on(event: string, fn: (e: any) => any): void;

        /**
         * Replaces all the lines in the current `Document` with the value of `text`.
         * @param text The text to use
         */
        setValue(text: string): void;

        /**
         * Returns all the lines in the document as a single string, split by the new line character.
         */
        getValue(): string;

        /**
         * Creates a new `Anchor` to define a floating point in the document.
         * @param row The row number to use
         * @param column The column number to use
         */
        createAnchor(row: number, column: number): void;

        /**
         * Returns the newline character that's being used, depending on the value of `newLineMode`.
         */
        getNewLineCharacter(): string;

        /**
         * [Sets the new line mode.]{: #Document.setNewLineMode.desc}
         * @param newLineMode [The newline mode to use; can be either `windows`, `unix`, or `auto`]{: #Document.setNewLineMode.param}
         */
        setNewLineMode(newLineMode: NewLineMode): void;

        /**
         * [Returns the type of newlines being used; either `windows`, `unix`, or `auto`]{: #Document.getNewLineMode}
         */
        getNewLineMode(): NewLineMode;

        /**
         * Returns `true` if `text` is a newline character (either `\r\n`, `\r`, or `\n`).
         * @param text The text to check
         */
        isNewLine(text: string): boolean;

        /**
         * Returns a verbatim copy of the given line as it is in the document
         * @param row The row index to retrieve
         */
        getLine(row: number): string;

        /**
         * Returns an array of strings of the rows between `firstRow` and `lastRow`. This function is inclusive of `lastRow`.
         * @param firstRow The first row index to retrieve
         * @param lastRow The final row index to retrieve
         */
        getLines(firstRow: number, lastRow: number): string[];

        /**
         * Returns all lines in the document as string array. Warning: The caller should not modify this array!
         */
        getAllLines(): string[];

        /**
         * Returns the number of rows in the document.
         */
        getLength(): number;

        /**
         * [Given a range within the document, this function returns all the text within that range as a single string.]{: #Document.getTextRange.desc}
         * @param range The range to work with
         */
        getTextRange(range: Range): string;

        getLinesForRange(range: Range): string[];

        /**
         * Inserts a block of `text` and the indicated `position`.
         * @param position The position to start inserting at
         * @param text A chunk of text to insert
         */
        insert(position: Position, text: string): Position;

        /**
         * @deprecated Use the insertFullLines method instead.
         */
        insertLines(row: number, lines: string[]): Position;

        /**
         * Inserts the elements in `lines` into the document as full lines (does not merge with existing line), starting at the row index given by `row`. This method also triggers the `"change"` event.
         * @param {Number} row The index of the row to insert at
         * @param {Array} lines An array of strings
         * @returns {Object} Contains the final row and column, like this:
         *   ```
         *   {row: endRow, column: 0}
         *   ```
         *   If `lines` is empty, this function returns an object containing the current row, and column, like this:
         *   ```
         *   {row: row, column: 0}
         *   ```
         */
        insertFullLines(row: number, lines: string[]): void;

        /**
         * @deprecated Use insertMergedLines(position, ['', '']) instead.
         */
        insertNewLine(position: Position): Position;

        /**
         * Inserts the elements in `lines` into the document, starting at the position index given by `row`. This method also triggers the `"change"` event.
         * @param {Number} row The index of the row to insert at
         * @param {Array} lines An array of strings
         * @returns {Object} Contains the final row and column, like this:
         *   ```
         *   {row: endRow, column: 0}
         *   ```
         *   If `lines` is empty, this function returns an object containing the current row, and column, like this:
         *   ```
         *   {row: row, column: 0}
         *   ```
         */
        insertMergedLines(row: number, lines: string[]): Position;

        /**
         * Inserts `text` into the `position` at the current row. This method also triggers the `'change'` event.
         * @param position The position to insert at
         * @param text A chunk of text
         */
        insertInLine(position: Position, text: string): Position;

        clippedPos(row: number, column: number): Position;
        clonePos(pos: Position): Position;
        pos(row: number, column: number): Position;

        /**
         * Removes the `range` from the document.
         * @param range A specified Range to remove
         */
        remove(range: Range): Position;

        /**
         * Removes the specified columns from the `row`. This method also triggers the `'change'` event.
         * @param row The row to remove from
         * @param startColumn The column to start removing at
         * @param endColumn The column to stop removing at
         */
        removeInLine(row: number, startColumn: number, endColumn: number): Position;

        /**
         * @deprecated Use the removeFullLines method instead.
         */
        removeLines(firstRow: number, lastRow: number): string[];

        /**
         * Removes a range of full lines. This method also triggers the `"change"` event.
         * @param {Number} firstRow The first row to be removed
         * @param {Number} lastRow The last row to be removed
         * @returns {[String]} Returns all the removed lines.
         */
        removeFullLines(firstRow: number, lastRow: number): string[];

        /**
         * Removes the new line between `row` and the row immediately following it. This method also triggers the `'change'` event.
         * @param row The row to check
         */
        removeNewLine(row: number): void;

        /**
         * Replaces a range in the document with the new `text`.
         * @param range A specified Range to replace
         * @param text The new text to use as a replacement
         */
        replace(range: Range, text: string): Position;

        /**
         * Applies all the changes previously accumulated. These can be either `'includeText'`, `'insertLines'`, `'removeText'`, and `'removeLines'`.
         */
        applyDeltas(deltas: Delta[]): void;

        /**
         * Reverts any changes previously applied. These can be either `'includeText'`, `'insertLines'`, `'removeText'`, and `'removeLines'`.
         */
        revertDeltas(deltas: Delta[]): void;

        /**
         * Converts an index position in a document to a `{row, column}` object.
         * Index refers to the "absolute position" of a character in the document. For example:
         * ```javascript
         * var x = 0; // 10 characters, plus one for newline
         * var y = -1;
         * ```
         * Here, `y` is an index 15: 11 characters for the first row, and 5 characters until `y` in the second.
         * @param index An index to convert
         * @param startRow=0 The row from which to start the conversion
         */
        indexToPosition(index: number, startRow: number): Position;

        /**
         * Converts the `{row, column}` position in a document to the character's index.
         * Index refers to the "absolute position" of a character in the document. For example:
         * ```javascript
         * var x = 0; // 10 characters, plus one for newline
         * var y = -1;
         * ```
         * Here, `y` is an index 15: 11 characters for the first row, and 5 characters until `y` in the second.
         * @param pos The `{row, column}` to convert
         * @param startRow=0 The row from which to start the conversion
         */
        positionToIndex(pos: Position, startRow?: number): number;
    }
    var Document: {
        /**
         * Creates a new `Document`. If `text` is included, the `Document` contains those strings; otherwise, it's empty.
         * @param text The starting text
         */
        new(text?: string): Document;
        /**
         * Creates a new `Document`. If `text` is included, the `Document` contains those strings; otherwise, it's empty.
         * @param text The starting text
         */
        new(text?: string[]): Document;
    };

    ////////////////////////////////
    /// EditSession
    ////////////////////////////////

    /**
     * Stores all the data about [[Editor `Editor`]] state providing easy way to change editors state.
     * `EditSession` can be attached to only one [[Document `Document`]]. Same `Document` can be attached to several `EditSession`s.
     */
    export interface IEditSession extends OptionProvider {
        selection: Selection;

        bgTokenizer: BackgroundTokenizer;

        doc: Document;

        on(event: string, fn: (e: any) => any): void;

        findMatchingBracket(position: Position): void;

        addFold(text: string, range: Range): void;

        getFoldAt(row: number, column: number): any;

        removeFold(arg: any): void;

        expandFold(arg: any): void;

        foldAll(startRow?: number, endRow?: number, depth?: number): void;

        unfold(arg1: any, arg2: boolean): void;

        screenToDocumentColumn(row: number, column: number): void;

        getFoldDisplayLine(foldLine: any, docRow: number, docColumn: number): any;

        getFoldsInRange(range: Range): any;

        highlight(text: string): void;

        /**
         * Highlight lines from `startRow` to `EndRow`.
         * @param startRow Define the start line of the highlight
         * @param endRow Define the end line of the highlight
         * @param clazz Set the CSS class for the marker
         * @param inFront Set to `true` to establish a front marker
         */
        highlightLines(startRow: number, endRow: number, clazz: string, inFront: boolean): Range;

        /**
         * Sets the `EditSession` to point to a new `Document`. If a `BackgroundTokenizer` exists, it also points to `doc`.
         * @param doc The new `Document` to use
         */
        setDocument(doc: Document): void;

        /**
         * Returns the `Document` associated with this session.
         */
        getDocument(): Document;

        /**
         * undefined
         * @param row The row to work with
         */
        $resetRowCache(row: number): void;

        /**
         * Sets the session text.
         * @param text The new text to place
         */
        setValue(text: string): void;

        setMode(mode: string): void;

        /**
         * Returns the current [[Document `Document`]] as a string.
         */
        getValue(): string;

        /**
         * Returns the string of the current selection.
         */
        getSelection(): Selection;

        /**
         * {:BackgroundTokenizer.getState}
         * @param row The row to start at
         */
        getState(row: number): string;

        /**
         * Starts tokenizing at the row indicated. Returns a list of objects of the tokenized rows.
         * @param row The row to start at
         */
        getTokens(row: number): TokenInfo[];

        /**
         * Returns an object indicating the token at the current row. The object has two properties: `index` and `start`.
         * @param row The row number to retrieve from
         * @param column The column number to retrieve from
         */
        getTokenAt(row: number, column: number): TokenInfo | null;

        /**
         * Sets the undo manager.
         * @param undoManager The new undo manager
         */
        setUndoManager(undoManager: UndoManager): void;

        /**
         * Returns the current undo manager.
         */
        getUndoManager(): UndoManager;

        /**
         * Returns the current value for tabs. If the user is using soft tabs, this will be a series of spaces (defined by [[EditSession.getTabSize `getTabSize()`]]): void; otherwise it's simply `'\t'`.
         */
        getTabString(): string;

        /**
         * Pass `true` to enable the use of soft tabs. Soft tabs means you're using spaces instead of the tab character (`'\t'`).
         * @param useSoftTabs Value indicating whether or not to use soft tabs
         */
        setUseSoftTabs(useSoftTabs: boolean): void;

        /**
         * Returns `true` if soft tabs are being used, `false` otherwise.
         */
        getUseSoftTabs(): boolean;

        /**
         * 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 tabSize The new tab size
         */
        setTabSize(tabSize: number): void;

        /**
         * Returns the current tab size.
         */
        getTabSize(): number;

        /**
         * Returns `true` if the character at the position is a soft tab.
         * @param position The position to check
         */
        isTabStop(position: any): boolean;

        /**
         * 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 emites the `changeOverwrite` event.
         * @param overwrite Defines wheter or not to set overwrites
         */
        setOverwrite(overwrite: boolean): void;

        /**
         * Returns `true` if overwrites are enabled; `false` otherwise.
         */
        getOverwrite(): boolean;

        /**
         * Sets the value of overwrite to the opposite of whatever it currently is.
         */
        toggleOverwrite(): void;

        /**
         * Adds `className` to the `row`, to be used for CSS stylings and whatnot.
         * @param row The row number
         * @param className The class to add
         */
        addGutterDecoration(row: number, className: string): void;

        /**
         * Removes `className` from the `row`.
         * @param row The row number
         * @param className The class to add
         */
        removeGutterDecoration(row: number, className: string): void;

        /**
         * Returns an array of numbers, indicating which rows have breakpoints.
         */
        getBreakpoints(): number[];

        /**
         * Sets a breakpoint on every row number given by `rows`. This function also emites the `'changeBreakpoint'` event.
         * @param rows An array of row indices
         */
        setBreakpoints(rows: any[]): void;

        /**
         * Removes all breakpoints on the rows. This function also emites the `'changeBreakpoint'` event.
         */
        clearBreakpoints(): void;

        /**
         * Sets a breakpoint on the row number given by `rows`. This function also emites the `'changeBreakpoint'` event.
         * @param row A row index
         * @param className Class of the breakpoint
         */
        setBreakpoint(row: number, className: string): void;

        /**
         * Removes a breakpoint on the row number given by `rows`. This function also emites the `'changeBreakpoint'` event.
         * @param row A row index
         */
        clearBreakpoint(row: number): void;

        /**
         * 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 range Define the range of the marker
         * @param clazz Set the CSS class for the marker
         * @param type Identify the type of the marker
         * @param inFront Set to `true` to establish a front marker
         */
        addMarker(range: Range, clazz: string, type: Function, inFront: boolean): number;

        /**
         * 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 range Define the range of the marker
         * @param clazz Set the CSS class for the marker
         * @param type Identify the type of the marker
         * @param inFront Set to `true` to establish a front marker
         */
        addMarker(range: Range, clazz: string, type: string, inFront: boolean): number;

        /**
         * Adds a dynamic marker to the session.
         * @param marker object with update method
         * @param inFront Set to `true` to establish a front marker
         */
        addDynamicMarker(marker: any, inFront: boolean): void;

        /**
         * 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 markerId A number representing a marker
         */
        removeMarker(markerId: number): void;

        /**
         * Returns an array containing the IDs of all the markers, either front or back.
         * @param inFront If `true`, indicates you only want front markers; `false` indicates only back markers
         */
        getMarkers(inFront: boolean): any[];

        /**
         * Sets annotations for the `EditSession`. This functions emits the `'changeAnnotation'` event.
         * @param annotations A list of annotations
         */
        setAnnotations(annotations: Annotation[]): void;

        /**
         * Returns the annotations for the `EditSession`.
         */
        getAnnotations(): any;

        /**
         * Clears all the annotations for this session. This function also triggers the `'changeAnnotation'` event.
         */
        clearAnnotations(): void;

        /**
         * If `text` contains either the newline (`\n`) or carriage-return ('\r') characters, `$autoNewLine` stores that value.
         * @param text A block of text
         */
        $detectNewLine(text: string): void;

        /**
         * Given a starting row and column, this method returns the `Range` of the first word boundary it finds.
         * @param row The row to start at
         * @param column The column to start at
         */
        getWordRange(row: number, column: number): Range;

        /**
         * Gets the range of a word, including its right whitespace.
         * @param row The row number to start from
         * @param column The column number to start from
         */
        getAWordRange(row: number, column: number): any;

        /**
         * {:Document.setNewLineMode.desc}
         * @param newLineMode {:Document.setNewLineMode.param}
         */
        setNewLineMode(newLineMode: string): void;

        /**
         * Returns the current new line mode.
         */
        getNewLineMode(): string;

        /**
         * Identifies if you want to use a worker for the `EditSession`.
         * @param useWorker Set to `true` to use a worker
         */
        setUseWorker(useWorker: boolean): void;

        /**
         * Returns `true` if workers are being used.
         */
        getUseWorker(): boolean;

        /**
         * Reloads all the tokens on the current session. This function calls [[BackgroundTokenizer.start `BackgroundTokenizer.start ()`]] to all the rows; it also emits the `'tokenizerUpdate'` event.
         */
        onReloadTokenizer(): void;

        /**
         * Sets a new text mode for the `EditSession`. This method also emits the `'changeMode'` event. If a [[BackgroundTokenizer `BackgroundTokenizer`]] is set, the `'tokenizerUpdate'` event is also emitted.
         * @param mode Set a new text mode
         */
        $mode(mode: TextMode): void;

        /**
         * Returns the current text mode.
         */
        getMode(): TextMode;

        /**
         * This function sets the scroll top value. It also emits the `'changeScrollTop'` event.
         * @param scrollTop The new scroll top value
         */
        setScrollTop(scrollTop: number): void;

        /**
         * [Returns the value of the distance between the top of the editor and the topmost part of the visible content.]{: #EditSession.getScrollTop}
         */
        getScrollTop(): number;

        /**
         * [Sets the value of the distance between the left of the editor and the leftmost part of the visible content.]{: #EditSession.setScrollLeft}
         * @param scrollLeft The new scroll left value
         */
        setScrollLeft(scrollLeft: number): void;

        /**
         * [Returns the value of the distance between the left of the editor and the leftmost part of the visible content.]{: #EditSession.getScrollLeft}
         */
        getScrollLeft(): number;

        /**
         * Returns the width of the screen.
         */
        getScreenWidth(): number;

        /**
         * Returns a verbatim copy of the given line as it is in the document
         * @param row The row to retrieve from
         */
        getLine(row: number): string;

        /**
         * Returns an array of strings of the rows between `firstRow` and `lastRow`. This function is inclusive of `lastRow`.
         * @param firstRow The first row index to retrieve
         * @param lastRow The final row index to retrieve
         */
        getLines(firstRow: number, lastRow: number): string[];

        /**
         * Returns the number of rows in the document.
         */
        getLength(): number;

        /**
         * {:Document.getTextRange.desc}
         * @param range The range to work with
         */
        getTextRange(range: Range): string;

        /**
         * Inserts a block of `text` and the indicated `position`.
         * @param position The position {row, column} to start inserting at
         * @param text A chunk of text to insert
         */
        insert(position: Position, text: string): any;

        /**
         * Removes the `range` from the document.
         * @param range A specified Range to remove
         */
        remove(range: Range): any;

        /**
         * Reverts previous changes to your document.
         * @param deltas An array of previous changes
         * @param dontSelect [If `true`, doesn't select the range of where the change occured]{: #dontSelect}
         */
        undoChanges(deltas: any[], dontSelect: boolean): Range;

        /**
         * Re-implements a previously undone change to your document.
         * @param deltas An array of previous changes
         * @param dontSelect {:dontSelect}
         */
        redoChanges(deltas: any[], dontSelect: boolean): Range;

        /**
         * Enables or disables highlighting of the range where an undo occured.
         * @param enable If `true`, selects the range of the reinserted change
         */
        setUndoSelect(enable: boolean): void;

        /**
         * Replaces a range in the document with the new `text`.
         * @param range A specified Range to replace
         * @param text The new text to use as a replacement
         */
        replace(range: Range, text: string): any;

        /**
         * Moves a range of text from the given range to the given position. `toPosition` is an object that looks like this:
         * ```json
         * { row: newRowLocation, column: newColumnLocation }
         * ```
         * @param fromRange The range of text you want moved within the document
         * @param toPosition The location (row and column) where you want to move the text to
         */
        moveText(fromRange: Range, toPosition: any): Range;

        /**
         * Indents all the rows, from `startRow` to `endRow` (inclusive), by prefixing each row with the token in `indentString`.
         * If `indentString` contains the `'\t'` character, it's replaced by whatever is defined by [[EditSession.getTabString `getTabString()`]].
         * @param startRow Starting row
         * @param endRow Ending row
         * @param indentString The indent token
         */
        indentRows(startRow: number, endRow: number, indentString: string): void;

        /**
         * Outdents all the rows defined by the `start` and `end` properties of `range`.
         * @param range A range of rows
         */
        outdentRows(range: Range): void;

        /**
         * Shifts all the lines in the document up one, starting from `firstRow` and ending at `lastRow`.
         * @param firstRow The starting row to move up
         * @param lastRow The final row to move up
         */
        moveLinesUp(firstRow: number, lastRow: number): number;

        /**
         * Shifts all the lines in the document down one, starting from `firstRow` and ending at `lastRow`.
         * @param firstRow The starting row to move down
         * @param lastRow The final row to move down
         */
        moveLinesDown(firstRow: number, lastRow: number): number;

        /**
         * Duplicates all the text between `firstRow` and `lastRow`.
         * @param firstRow The starting row to duplicate
         * @param lastRow The final row to duplicate
         */
        duplicateLines(firstRow: number, lastRow: number): number;

        /**
         * Sets whether or not line wrapping is enabled. If `useWrapMode` is different than the current value, the `'changeWrapMode'` event is emitted.
         * @param useWrapMode Enable (or disable) wrap mode
         */
        setUseWrapMode(useWrapMode: boolean): void;

        /**
         * Returns `true` if wrap mode is being used; `false` otherwise.
         */
        getUseWrapMode(): boolean;

        /**
         * 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 min The minimum wrap value (the left side wrap)
         * @param max The maximum wrap value (the right side wrap)
         */
        setWrapLimitRange(min: number, max: number): void;

        /**
         * This should generally only be called by the renderer when a resize is detected.
         * @param desiredLimit The new wrap limit
         */
        adjustWrapLimit(desiredLimit: number): boolean;

        /**
         * Returns the value of wrap limit.
         */
        getWrapLimit(): number;

        /**
         * Returns an object that defines the minimum and maximum of the wrap limit; it looks something like this:
         * { min: wrapLimitRange_min, max: wrapLimitRange_max }
         */
        getWrapLimitRange(): any;

        /**
         * Given a string, returns an array of the display characters, including tabs and spaces.
         * @param str The string to check
         * @param offset The value to start at
         */
        $getDisplayTokens(str: string, offset: number): void;

        /**
         * Calculates the width of the string `str` on the screen while assuming that the string starts at the first column on the screen.
         * @param str The string to calculate the screen width of
         * @param maxScreenColumn
         * @param screenColumn
         */
        $getStringScreenWidth(str: string, maxScreenColumn: number, screenColumn: number): number[];

        /**
         * Returns number of screenrows in a wrapped line.
         * @param row The row number to check
         */
        getRowLength(row: number): number;

        /**
         * Returns the position (on screen) for the last character in the provided screen row.
         * @param screenRow The screen row to check
         */
        getScreenLastRowColumn(screenRow: number): number;

        /**
         * For the given document row and column, this returns the column position of the last screen row.
         * @param docRow
         * @param docColumn
         */
        getDocumentLastRowColumn(docRow: number, docColumn: number): number;

        /**
         * For the given document row and column, this returns the document position of the last row.
         * @param docRow
         * @param docColumn
         */
        getDocumentLastRowColumnPosition(docRow: number, docColumn: number): number;

        /**
         * For the given row, this returns the split data.
         */
        getRowSplitData(): string;

        /**
         * The distance to the next tab stop at the specified screen column.
         * @param screenColumn The screen column to check
         */
        getScreenTabSize(screenColumn: number): number;

        /**
         * 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.]{: #conversionConsiderations}
         * @param screenRow The screen row to check
         * @param screenColumn The screen column to check
         */
        screenToDocumentPosition(screenRow: number, screenColumn: number): any;

        /**
         * Converts document coordinates to screen coordinates. {:conversionConsiderations}
         * @param docRow The document row to check
         * @param docColumn The document column to check
         */
        documentToScreenPosition(docRow: number, docColumn: number): any;

        /**
         * For the given document row and column, returns the screen column.
         * @param row
         * @param docColumn
         */
        documentToScreenColumn(row: number, docColumn: number): number;

        /**
         * For the given document row and column, returns the screen row.
         * @param docRow
         * @param docColumn
         */
        documentToScreenRow(docRow: number, docColumn: number): void;

        /**
         * Returns the length of the screen.
         */
        getScreenLength(): number;
    }
    var EditSession: {
        /**
         * Sets up a new `EditSession` and associates it with the given `Document` and `TextMode`.
         * @param text [If `text` is a `Document`, it associates the `EditSession` with it. Otherwise, a new `Document` is created, with the initial text]{: #textParam}
         * @param mode [The inital language mode to use for the document]{: #modeParam}
         */
        new(text: string, mode?: TextMode): IEditSession;

        new(content: string, mode?: string): IEditSession;

        new(text: string[], mode?: string): IEditSession;
    };

    ////////////////////////////////
    /// Editor
    ////////////////////////////////

    /**
     * The main entry point into the Ace functionality.
     * The `Editor` manages the [[EditSession]] (which manages [[Document]]s), as well as the [[VirtualRenderer]], which draws everything to the screen.
     * Event sessions dealing with the mouse and keyboard are bubbled up from `Document` to the `Editor`, which decides what to do with them.
     */
    export interface Editor extends OptionProvider {
        on(ev: string, callback: (e: any) => any): void;

        addEventListener(ev: "change", callback: (ev: EditorChangeEvent) => any): void;
        addEventListener(ev: string, callback: Function): void;

        off(ev: string, callback: Function): void;

        removeListener(ev: string, callback: Function): void;

        removeEventListener(ev: string, callback: Function): void;

        inMultiSelectMode: boolean;

        selectMoreLines(n: number): void;

        onTextInput(text: string): void;

        onCommandKey(e: any, hashId: number, keyCode: number): void;

        commands: CommandManager;

        session: IEditSession;

        selection: Selection;

        renderer: VirtualRenderer;

        keyBinding: KeyBinding;

        container: HTMLElement;

        onSelectionChange(e: any): void;

        onChangeMode(e?: any): void;

        execCommand(command: string, args?: any): void;

        /**
         * Get rid of console warning by setting this to Infinity
         */
        $blockScrolling: number;

        /**
         * Sets a new key handler, such as "vim" or "windows".
         * @param keyboardHandler The new key handler
         */
        setKeyboardHandler(keyboardHandler: string): void;

        /**
         * Returns the keyboard handler, such as "vim" or "windows".
         */
        getKeyboardHandler(): string;

        /**
         * Sets a new editsession to use. This method also emits the `'changeSession'` event.
         * @param session The new session to use
         */
        setSession(session: IEditSession): void;

        /**
         * Returns the current session being used.
         */
        getSession(): IEditSession;

        /**
         * Sets the current document to `val`.
         * @param val The new value to set for the document
         * @param cursorPos Where to set the new value. `undefined` or 0 is selectAll, -1 is at the document start, and 1 is at the end
         */
        setValue(val: string, cursorPos?: number): string;

        /**
         * Returns the current session's content.
         */
        getValue(): string;

        /**
         * Returns the currently highlighted selection.
         */
        getSelection(): Selection;

        /**
         * {:VirtualRenderer.onResize}
         * @param force If `true`, recomputes the size, even if the height and width haven't changed
         */
        resize(force?: boolean): void;

        /**
         * {:VirtualRenderer.setTheme}
         * @param theme The path to a theme
         */
        setTheme(theme: string): void;

        /**
         * {:VirtualRenderer.getTheme}
         */
        getTheme(): string;

        /**
         * {:VirtualRenderer.setStyle}
         * @param style A class name
         */
        setStyle(style: string): void;

        /**
         * {:VirtualRenderer.unsetStyle}
         */
        unsetStyle(): void;

        /**
         * Set a new font size (in pixels) for the editor text.
         * @param size A font size ( _e.g._ "12px")
         */
        setFontSize(size: string): void;

        /**
         * Brings the current `textInput` into focus.
         */
        focus(): void;

        /**
         * Returns `true` if the current `textInput` is in focus.
         */
        isFocused(): boolean;

        /**
         * Blurs the current `textInput`.
         */
        blur(): void;

        /**
         * Emitted once the editor comes into focus.
         */
        onFocus(): void;

        /**
         * Emitted once the editor has been blurred.
         */
        onBlur(): void;

        /**
         * Emitted whenever the document is changed.
         * @param e Contains a single property, `data`, which has the delta of changes
         */
        onDocumentChange(e: any): void;

        /**
         * Emitted when the selection changes.
         */
        onCursorChange(): void;

        /**
         * Returns the string of text currently highlighted.
         */
        getCopyText(): string;

        /**
         * Called whenever a text "copy" happens.
         */
        onCopy(): void;

        /**
         * Called whenever a text "cut" happens.
         */
        onCut(): void;

        /**
         * Called whenever a text "paste" happens.
         * @param text The pasted text
         */
        onPaste(text: string): void;

        /**
         * Inserts `text` into wherever the cursor is pointing.
         * @param text The new text to add
         */
        insert(text: string): void;

        /**
         * 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 emites the `changeOverwrite` event.
         * @param overwrite Defines wheter or not to set overwrites
         */
        setOverwrite(overwrite: boolean): void;

        /**
         * Returns `true` if overwrites are enabled; `false` otherwise.
         */
        getOverwrite(): boolean;

        /**
         * Sets the value of overwrite to the opposite of whatever it currently is.
         */
        toggleOverwrite(): void;

        /**
         * Sets how fast the mouse scrolling should do.
         * @param speed A value indicating the new speed (in milliseconds)
         */
        setScrollSpeed(speed: number): void;

        /**
         * Returns the value indicating how fast the mouse scroll speed is (in milliseconds).
         */
        getScrollSpeed(): number;

        /**
         * Sets the delay (in milliseconds) of the mouse drag.
         * @param dragDelay A value indicating the new delay
         */
        setDragDelay(dragDelay: number): void;

        /**
         * Returns the current mouse drag delay.
         */
        getDragDelay(): number;

        /**
         * Indicates how selections should occur.
         * By default, selections are set to "line". There are no other styles at the moment,
         * although this code change in the future.
         * This function also emits the `'changeSelectionStyle'` event.
         * @param style The new selection style
         */
        setSelectionStyle(style: string): void;

        /**
         * Returns the current selection style.
         */
        getSelectionStyle(): string;

        /**
         * Determines whether or not the current line should be highlighted.
         * @param shouldHighlight Set to `true` to highlight the current line
         */
        setHighlightActiveLine(shouldHighlight: boolean): void;

        /**
         * Returns `true` if current lines are always highlighted.
         */
        getHighlightActiveLine(): boolean;

        /**
         * Determines if the currently selected word should be highlighted.
         * @param shouldHighlight Set to `true` to highlight the currently selected word
         */
        setHighlightSelectedWord(shouldHighlight: boolean): void;

        /**
         * Returns `true` if currently highlighted words are to be highlighted.
         */
        getHighlightSelectedWord(): boolean;

        /**
         * If `showInvisibiles` is set to `true`, invisible characters&mdash;like spaces or new lines&mdash;are show in the editor.
         * @param showInvisibles Specifies whether or not to show invisible characters
         */
        setShowInvisibles(showInvisibles: boolean): void;

        /**
         * Returns `true` if invisible characters are being shown.
         */
        getShowInvisibles(): boolean;

        /**
         * If `showPrintMargin` is set to `true`, the print margin is shown in the editor.
         * @param showPrintMargin Specifies whether or not to show the print margin
         */
        setShowPrintMargin(showPrintMargin: boolean): void;

        /**