import { Lexer, init_table, compare } from "./kernel_lexer.js";
import { u32 } from "../types/ir_types";
export { init_table, compare };
export declare const fail_state_mask: number;
export declare const normal_state_mask: number;
export declare const alpha_increment_stack_pointer_mask: number;
export declare const alpha_have_default_action_mask: number;
export declare const alpha_auto_accept_with_peek_mask: number;
export declare const alpha_auto_consume_with_peek_mask: number;
export declare const production_scope_pop_pointer = 2;
export declare const instruction_pointer_mask = 16777215;
declare type ScannerFunction = (l: Lexer, i: u32, j: u32) => void;
export interface KernelStateType {
    stack_pointer: u32;
    state_stack: Uint32Array;
    tk_scan: ScannerFunction;
    readonly instruction_buffer: Uint32Array;
}
declare type state_pointer = number;
declare type lexer_type = number;
declare type lexer_token_offset = number;
declare type lexer_token_length = number;
declare type production_id = number;
export declare class KernelState implements KernelStateType {
    lexer: Lexer;
    peek_lexer: Lexer;
    stack_pointer: u32;
    state_stack: Uint32Array;
    meta_stack: Uint32Array;
    tk_scan: ScannerFunction;
    readonly instruction_buffer: Uint32Array;
    rules: number[];
    origin: KernelState;
    symbol_accumulator: number;
    prod: number;
    next: KernelState[];
    state: number;
    origin_fork: number;
    input_len: number;
    VALID: boolean;
    COMPLETED: boolean;
    FORKED: boolean;
    refs: number;
    state_history: [state_pointer, lexer_type, lexer_token_offset, lexer_token_length, production_id][];
    constructor(state_buffer: Uint32Array, input_buffer: Uint8Array, input_len_in: number, tk_scan: ScannerFunction);
    get_rules_len(): number;
    /**
     * JS Only
     */
    add_state_to_history(kernel_state: number, enable_history?: boolean): void;
    push_state(kernel_state: number): void;
    replace_top_state(kernel_state: number): void;
    pop_state(): number;
    get_state(): number;
    copy_state_stack(destination_state: KernelState): void;
    copy_production_stack(destination_state: KernelState): void;
    transfer_state_stack(new_state: KernelState): void;
    fork(process_buffer: KernelStateBuffer): KernelState;
    add_rule(val: number): void;
    add_reduce(sym_len: number, fn_id: number): void;
    add_shift(tok_len: number): void;
    add_skip(skip_delta: number): void;
    consume(): boolean;
    /**
     * Return a reference to the main parsing lexer.
     * ( the zero indexed lexer )
     */
    get_root_lexer(): Lexer;
}
export declare class KernelStateBuffer {
    data: KernelState[];
    constructor();
    remove_state_at_index(index: number): KernelState;
    len(): number;
    create_state(state_buffer: Uint32Array, input_buffer: Uint8Array, input_len_in: number, tk_scan: ScannerFunction): KernelState;
    add_state_pointer(state: KernelState): void;
    add_state_pointer_and_sort(state: KernelState): number;
    have_valid(): boolean;
    remove_valid_parser_state(): KernelState;
    get_mut_state(index: number): KernelState;
    get_ref_state(index: number): KernelState;
    get_recycled_KernelState(state: KernelState): KernelState;
}
export declare class KernelStateIterator {
    private current;
    private refs;
    private index;
    private final_index;
    private valid;
    constructor(state: KernelState);
    is_valid(): boolean;
    next(): number;
}
export declare function token_production(lexer: Lexer, production_state_pointer: u32, pid: number, _type: number, tk_flag: number, state_buffer: Uint32Array, tk_scan: ScannerFunction, enable_history?: boolean): boolean;
export declare function kernel_executor(kernel_state: KernelState, kernel_states_repo: KernelStateBuffer, enable_history: boolean): boolean;
export declare function run(state_buffer: Uint32Array, input_buffer: Uint8Array, input_byte_length: number, state_pointer: number, scanner_function: ScannerFunction, enable_history?: boolean): {
    invalid: KernelStateBuffer;
    valid: KernelStateBuffer;
};