import { u32 } from "../types/ir_types";
import { init_table, Lexer } from "./kernel_lexer_next.js";
export { init_table };
export declare const fail_state_mask: number;
export declare const normal_state_mask: number;
export declare const goto_state_mask: number;
export declare const alpha_increment_stack_pointer_mask: number;
export declare const alpha_have_default_action_mask: number;
export declare const production_scope_pop_pointer = 2;
export declare const instruction_pointer_mask = 16777215;
export interface KernelStateType {
    stack_pointer: u32;
    state_stack: Uint32Array;
    readonly instructions: Uint32Array;
}
export declare function assign_peek(fn: any): void;
export declare class KernelState implements KernelStateType {
    readonly instructions: Uint32Array;
    lexer: Lexer;
    peek_lexer: Lexer;
    stack_pointer: u32;
    state_stack: Uint32Array;
    meta_stack: Uint32Array;
    rules: number[];
    origin: KernelState;
    symbol_accumulator: number;
    prod: number;
    next: KernelState[];
    state: number;
    origin_fork: number;
    last_byte_offset: number;
    last_token_offset: number;
    last_token_type: number;
    VALID: boolean;
    COMPLETED: boolean;
    FORKED: boolean;
    refs: number;
    constructor(state_buffer: Uint32Array, input_buffer: Uint8Array, input_len_in: number);
    get_rules_len(): number;
    push_state(kernel_state: number): void;
    swap_state(kernel_state: number): void;
    pop_state(): number;
    read_state(): number;
    copy_state_stack(dest: KernelState): void;
    copy_production_stack(dest: KernelState, cutoff: number): void;
    transfer_state_stack(dest: KernelState): void;
    fork(process_buffer: KernelStateBuffer, cutoff: number): 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;
    reset(): void;
}
export declare class KernelStateBuffer {
    data: KernelState[];
    constructor();
    len(): number;
    create_state(instructions: Uint32Array, input_buffer: Uint8Array, input_len_in: number): KernelState;
    remove_state_at_index(index: number): KernelState;
    add_state(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 kernel_executor(kernel_state: KernelState, kernel_states_repo: KernelStateBuffer): boolean;
export declare function run(state_buffer: Uint32Array, input_buffer: Uint8Array, input_byte_length: number, state_pointer: number): {
    invalid: KernelStateBuffer;
    valid: KernelStateBuffer;
};