import SortedQueue from '../common/queue';
type LocusDeltaDto = {
    url: string;
    baseSequence: {
        rangeStart: number;
        rangeEnd: number;
        entries: number[];
    };
    sequence: {
        rangeStart: number;
        rangeEnd: number;
        entries: number[];
    };
    syncUrl: string;
};
/**
 * Locus Delta Parser
 * @private
 * https://sqbu-github.cisco.com/WebExSquared/cloud-apps/wiki/Locus-Delta-Events
 */
export default class Parser {
    status: 'IDLE' | 'PAUSED' | 'WORKING' | 'BLOCKED';
    static loci: {
        EQ: string;
        GT: string;
        LT: string;
        DESYNC: string;
        USE_INCOMING: string;
        USE_CURRENT: string;
        WAIT: string;
        ERROR: string;
        LOCUS_URL_CHANGED: string;
    };
    queue: SortedQueue<LocusDeltaDto>;
    workingCopy: any;
    syncTimer?: ReturnType<typeof setTimeout>;
    /**
     * @constructs Parser
     */
    constructor();
    /**
     * Returns a debug string representing a locus delta - useful for logging
     *
     * @param {LocusDeltaDto} locus Locus delta
     * @returns {string}
     */
    static locus2string(locus: LocusDeltaDto): string;
    /**
     * Checks if two sequences overlap in time,
     * the sequence with the higher minimum value is greater.
     * Chooses sequence with most recent data.
     * @param {Types~Locus} current
     * @param {Types~Locus} incoming
     * @returns {string} loci comparison state
     */
    static checkSequenceOverlap(current: any, incoming: any): any;
    /**
     * Checks if two sequences have unequal ranges.
     * Chooses sequence with most larger range.
     * @param {Types~Locus} current
     * @param {Types~Locus} incoming
     * @returns {object} loci comparison
     */
    static checkUnequalRanges(current: any, incoming: any): any;
    /**
     * Checks if either sequences has unique entries.
     * Entries are considered unique if they do not overlap
     * with other Loci sequences or range values.
     * Chooses sequence with the unique entries.
     * @param {Types~Locus} current
     * @param {Types~Locus} incoming
     * @returns {string} loci comparison state
     */
    static checkForUniqueEntries(current: any, incoming: any): any;
    /**
     * Checks both Locus Delta objects to see if they are
     * out of sync with one another. If so sends a DESYNC
     * request to the server.
     * @param {Types~Locus} current
     * @param {Types~Locus} incoming
     * @returns {string} loci comparison state
     */
    static checkIfOutOfSync(current: any, incoming: any): any;
    /**
     * Compares two loci to determine which one contains the most recent state
     * @instance
     * @memberof Locus
     * @param {Types~Locus} current
     * @param {Types~Locus} incoming
     * @returns {string} loci comparison state
     */
    static compare(current: any, incoming: any): string;
    /**
     * Compares two loci sequences (with delta params) and indicates what action
     * to take.
     * @instance
     * @memberof Locus
     * @param {Types~Locus} current
     * @param {Types~Locus} incoming
     * @private
     * @returns {string} loci comparison state
     */
    private static compareDelta;
    /**
     * Compares Locus sequences - it should be called only for full Locus DTOs, not deltas
     *
     * @param {Types~Locus} current Current working copy
     * @param {Types~Locus} incomingFullDto New Full Locus DTO
     * @returns {string} either Parser.loci.USE_INCOMING or Parser.loci.USE_CURRENT
     */
    static compareFullDtoSequence(current: any, incomingFullDto: any): string;
    /**
     * Returns true if the incoming full locus DTO is newer than the current working copy
     *
     * @param {Types~Locus} incomingFullDto New Full Locus DTO
     * @returns {string} either Parser.loci.USE_INCOMING or Parser.loci.USE_CURRENT
     */
    isNewFullLocus(incomingFullDto: any): boolean;
    /**
     * Compares Locus sequences
     * @param {Types~Locus} current Current working copy
     * @param {Types~Locus} incoming New Locus delta
     * @returns {string}
     */
    static compareSequence(current: any, incoming: any): any;
    /**
     * Transates the result of a sequence comparison into an intended behavior
     * @param {string} result
     * @returns {string} Locus comparison action
     */
    static compareToAction(result: string): string;
    /**
     * Extracts a loci comparison from a string of data.
     * @param {string} lociComparisonResult Comparison result with extra data
     * @returns {string} Comparison of EQ, LT, GT, or DESYNC.
     */
    static extractComparisonState(lociComparisonResult: string): string;
    /**
     * @typedef {object} LociMetadata
     * @property {number} start - Starting sequence number
     * @property {number} end - Ending sequence number
     * @property {number} first - First sequence number
     * @property {number} last - Last sequence number
     * @property {number} min - Minimum sequence number
     * @property {number} max - Maximum sequence number
     * @property {number} entries - Loci sequence entries
     */
    /**
     * Metadata for Locus delta
     * @param {Array.<number>} sequence Locus delta sequence
     * @returns {LociMetadata} Locus Delta Metadata
     */
    static getMetaData(sequence: any): {
        start: any;
        end: any;
        first: any;
        last: any;
        min: any;
        max: any;
        entries: any;
    };
    /**
     * Compares two Locus delta objects and notes unique
     * values contained within baseLoci.
     * @param {LociMetadata} baseLoci
     * @param {LociMetadata} otherLoci
     * @returns {Array.<number>} List of unique sequences
     */
    static getUniqueSequences(baseLoci: any, otherLoci: any): number[];
    /**
     * Returns an array of numbers outside of a given range.
     * @param {Array.<number>} list Array to filter
     * @param {number} rangeStart Start of range
     * @param {number} rangeEnd End of range
     * @returns {Array.<number>} Array of numbers sorted ASC
     */
    static getNumbersOutOfRange(list: Array<number>, rangeStart: number, rangeEnd: number): number[];
    /**
     * Checks if newLoci or workingCopy is invalid.
     * @param {Types~Locus} newLoci
     * @returns {boolean}
     */
    isValidLocus(newLoci: any): boolean;
    /**
     * Determines if a paricular locus's sequence is empty
     * @param {Types~Locus} locus
     * @returns {bool}
     */
    static isSequenceEmpty(locus: any): boolean;
    /**
     * Determines if an object has basic
     * structure of a locus object.
     * @param {Types~Locus} loci
     * @returns {boolean}
     */
    static isLoci(loci: any): boolean;
    /**
     * Processes next event in queue,
     * if queue is empty sets status to idle.
     * @returns {undefined}
     */
    nextEvent(): void;
    /**
     * Function handler for delta actions,
     * is set by instance callee.
     * @param {string} action Locus delta action
     * @param {Types~Locus} locus Locus delta
     * @returns {undefined}
     */
    onDeltaAction(action: string, locus: any): void;
    /**
     * Event handler for locus delta events
     * @param {Types~Locus} loci Locus Delta
     * @returns {undefined}
     */
    onDeltaEvent(loci: any): void;
    /**
     * Appends new data onto a string of existing data.
     * @param {string} newData
     * @param {string} oldData
     * @returns {string}
     */
    static packComparisonResult(newData: string, oldData: string): string;
    /**
     * Pause locus processing
     * @returns {undefined}
     */
    pause(): void;
    /**
     * Triggers a sync with Locus
     *
     * @param {string} reason used just for logging
     * @returns {undefined}
     */
    private triggerSync;
    /**
     * Starts a timer with a random delay. When that timer expires we will do a sync.
     *
     * The main purpose of this timer is to handle a case when we get some out-of-order deltas,
     * so we start waiting to receive the missing delta. If that delta never arrives, this timer
     * will trigger a sync with Locus.
     *
     * @returns {undefined}
     */
    private startSyncTimer;
    /**
     * Stops the timer for triggering a sync
     *
     * @returns {undefined}
     */
    private stopSyncTimer;
    /**
     * Processes next locus delta in the queue,
     * continues until the queue is empty
     * or cleared.
     * @returns {undefined}
     */
    processDeltaEvent(): void;
    /**
     * Resume from a paused state
     * @returns {undefined}
     */
    resume(): void;
    /**
     * Gets related debug info for given error code
     * @param {string} debugCode Debug code
     * @param {string} comparison Locus comparison string
     * @returns {object} Debug message
     */
    static getDebugMessage(debugCode: string, comparison: string): any;
}
export {};