import { StringReader } from '../utils/StringReader';
import { ClientCache } from './ClientCache';
import { ParserSuggestion } from './ParserSuggestion';
import { ParsingError } from './ParsingError';
import { Token } from './Token';
/**
 * Represent an argument parser.
 * @template T Type of the parsed data. Can be string, Selector, NBT, etc.
 */
export interface Parser<T> {
    /**
     * Parse.
     * @param reader Input reader.
     */
    parse(reader: StringReader, ...params: any[]): ParserResult<T>;
}
/**
 * Represent a parsed result.
 * @template T Type of the parsed data. Can be a FunctionInfo, Line, etc.
 */
export interface ParserResult<T> {
    /**
     * Parsed data.
     */
    data: T;
}
export declare namespace ParserResult {
    function create<T>(data: T): ParserResult<T>;
}
export interface ValidateResult {
    /**
     * All errors occurred while the process of parsing.
     */
    errors: ParsingError[];
    /**
     * Local cache.
     */
    cache: ClientCache;
    /**
     * Semantic tokens.
     */
    tokens: Token[];
    /**
     * Signature hints.
     * @example
     * {
     *   fix: ['advancement'],
     *   options: [
     *     ['grant', ['<target: entity>']],
     *     ['revoke', ['<target: entity>']]
     *   ]
     * }
     * @example
     * {
     *   fix: ['setblock', '<pos: 3D vector>'],
     *   options: [
     *     ['<block: block>', ['[destroy|keep|replace]']]
     *   ]
     * }
     */
    hint: {
        /**
         * Hints for previous nodes.
         */
        fix: string[];
        /**
         * Hints for the current node and the following nodes.
         */
        options: [string, string[]][];
    };
}
export declare namespace ValidateResult {
    function create(partial?: Partial<ValidateResult>): ValidateResult;
}
/**
 * ValidateResult with completions.
 */
export interface LegacyValidateResult extends ValidateResult {
    /**
     * Completions.
     */
    completions: ParserSuggestion[];
}
export declare namespace LegacyValidateResult {
    function create(partial?: Partial<LegacyValidateResult>): LegacyValidateResult;
}
/**
 * Represent a result parsed by argument parser.
 * @template T Type of the parsed data. Can be a string, Selector, NBT, etc.
 */
export interface ArgumentParserResult<T> extends ParserResult<T>, LegacyValidateResult {
}
export declare namespace ArgumentParserResult {
    function create<T>(data: T, partial?: Partial<ArgumentParserResult<T>>): ArgumentParserResult<T>;
}
export declare function combineArgumentParserResult(base: ArgumentParserResult<any>, override: Partial<LegacyValidateResult>): void;