types.d.ts

declare module "php-parser" {
  /**
   * Defines an array structure
   * @example
   * // PHP code :
   * [1, 'foo' => 'bar', 3]
   *
   * // AST structure :
   * {
   *  "kind": "array",
   *  "shortForm": true
   *  "items": [
   *    {"kind": "number", "value": "1"},
   *    {
   *      "kind": "entry",
   *      "key": {"kind": "string", "value": "foo", "isDoubleQuote": false},
   *      "value": {"kind": "string", "value": "bar", "isDoubleQuote": false}
   *    },
   *    {"kind": "number", "value": "3"}
   *  ]
   * }
   * @property items - List of array items
   * @property shortForm - Indicate if the short array syntax is used, ex `[]` instead `array()`
   */
  class Array extends Expression {
    /**
     * List of array items
     */
    items: (Entry | Expression | Variable)[];
    /**
     * Indicate if the short array syntax is used, ex `[]` instead `array()`
     */
    shortForm: boolean;
  }
  /**
   * Defines an arrow function (it's like a closure)
   */
  class ArrowFunc extends Expression {
    arguments: Parameter[];
    type: Identifier;
    body: Expression;
    byref: boolean;
    nullable: boolean;
    isStatic: boolean;
  }
  /**
   * Assigns a value to the specified target
   */
  class Assign extends Expression {
    left: Expression;
    right: Expression;
    operator: string;
  }
  /**
   * Assigns a value to the specified target
   */
  class AssignRef extends Expression {
    left: Expression;
    right: Expression;
    operator: string;
  }
  /**
   * Attribute group
   */
  class AttrGroup extends Node {
    attrs: Attribute[];
  }
  /**
   * Attribute Value
   */
  class Attribute extends Node {
    name: string;
    args: Parameter[];
  }
  /**
   * Binary operations
   */
  class Bin extends Operation {
    type: string;
    left: Expression;
    right: Expression;
  }
  /**
   * A block statement, i.e., a sequence of statements surrounded by braces.
   */
  class Block extends Statement {
    children: Node[];
  }
  /**
   * Defines a boolean value (true/false)
   */
  class Boolean extends Literal {
    value: boolean;
  }
  /**
   * A break statement
   */
  class Break extends Statement {
    level: number | null;
  }
  /**
   * Passing by Reference - so the function can modify the variable
   */
  class ByRef extends Expression {
    what: ExpressionStatement;
  }
  /**
   * Executes a call statement
   */
  class Call extends Expression {
    what: Identifier | Variable;
    arguments: Expression[];
  }
  /**
   * A switch case statement
   * @property test - if null, means that the default case
   */
  class Case extends Statement {
    /**
     * if null, means that the default case
     */
    test: Expression | null;
    body: Block | null;
  }
  /**
   * Binary operations
   */
  class Cast extends Operation {
    type: string;
    raw: string;
    expr: Expression;
  }
  /**
   * Defines a catch statement
   */
  class Catch extends Statement {
    what: Name[];
    variable: Variable;
    body: Block;
  }
  /**
   * A class definition
   */
  class Class extends Declaration {
    extends: Identifier | null;
    implements: Identifier[] | null;
    body: Declaration[];
    isAnonymous: boolean;
    isAbstract: boolean;
    isFinal: boolean;
    isReadonly: boolean;
    attrGroups: AttrGroup[];
  }
  /**
   * Defines a class/interface/trait constant
   */
  class ClassConstant extends ConstantStatement {
    /**
     * Generic flags parser
     */
    parseFlags(flags: (number | null)[]): void;
    visibility: string;
    final: boolean;
    nullable: boolean;
    type: TypeReference | IntersectionType | UnionType | null;
    attrGroups: AttrGroup[];
  }
  /**
   * Defines a clone call
   */
  class Clone extends Expression {
    what: Expression;
  }
  /**
   * Defines a closure
   */
  class Closure extends Expression {
    arguments: Parameter[];
    uses: Variable[];
    type: Identifier;
    byref: boolean;
    nullable: boolean;
    body: Block | null;
    isStatic: boolean;
    attrGroups: AttrGroup[];
  }
  /**
   * Abstract documentation node (ComentLine or CommentBlock)
   */
  class Comment extends Node {
    value: string;
  }
  /**
   * A comment block (multiline)
   */
  class CommentBlock extends Comment {}
  /**
   * A single line comment
   */
  class CommentLine extends Comment {}
  /**
   * Defines a constant
   */
  class Constant extends Node {
    name: string;
    value: Node | string | number | boolean | null;
  }
  /**
   * Declares a constants into the current scope
   */
  class ConstantStatement extends Statement {
    constants: Constant[];
  }
  /**
   * A continue statement
   */
  class Continue extends Statement {
    level: number | null;
  }
  /**
   * A declaration statement (function, class, interface...)
   */
  class Declaration extends Statement {
    /**
     * Generic flags parser
     */
    parseFlags(flags: (number | null)[]): void;
    name: Identifier | string;
  }
  /**
   * The declare construct is used to set execution directives for a block of code
   */
  class Declare extends Block {
    /**
     * The node is declared as a short tag syntax :
     * ```php
     * <?php
     * declare(ticks=1):
     * // some statements
     * enddeclare;
     * ```
     */
    readonly MODE_SHORT: string;
    /**
     * The node is declared bracket enclosed code :
     * ```php
     * <?php
     * declare(ticks=1) {
     * // some statements
     * }
     * ```
     */
    readonly MODE_BLOCK: string;
    /**
     * The node is declared as a simple statement. In order to make things simpler
     * children of the node are automatically collected until the next
     * declare statement.
     * ```php
     * <?php
     * declare(ticks=1);
     * // some statements
     * declare(ticks=2);
     * // some statements
     * ```
     */
    readonly MODE_NONE: string;
    directives: DeclareDirective[];
    mode: string;
  }
  /**
   * Defines a constant
   */
  class DeclareDirective extends Node {
    key: Identifier;
    value: Node | string | number | boolean | null;
  }
  /**
   * Defines a do/while statement
   */
  class Do extends Statement {
    test: Expression;
    body: Block | null;
  }
  /**
   * Defines system based call
   */
  class Echo extends Statement {
    shortForm: boolean;
    expressions: Expression[];
  }
  /**
   * Defines an empty check call
   */
  class Empty extends Expression {}
  /**
   * Defines an encapsed string (contains expressions)
   * @property type - Defines the type of encapsed string (shell, heredoc, string)
   * @property label - The heredoc label, defined only when the type is heredoc
   */
  class Encapsed extends Literal {
    /**
     * The node is a double quote string :
     * ```php
     * <?php
     * echo "hello $world";
     * ```
     */
    readonly TYPE_STRING: string;
    /**
     * The node is a shell execute string :
     * ```php
     * <?php
     * echo `ls -larth $path`;
     * ```
     */
    readonly TYPE_SHELL: string;
    /**
     * The node is a shell execute string :
     * ```php
     * <?php
     * echo <<<STR
     *  Hello $world
     * STR
     * ;
     * ```
     */
    readonly TYPE_HEREDOC: string;
    /**
     * The node contains a list of constref / variables / expr :
     * ```php
     * <?php
     * echo $foo->bar_$baz;
     * ```
     */
    readonly TYPE_OFFSET: string;
    /**
     * Defines the type of encapsed string (shell, heredoc, string)
     */
    type: string;
    /**
     * The heredoc label, defined only when the type is heredoc
     */
    label: string | null;
    value: EncapsedPart[];
  }
  /**
   * Part of `Encapsed` node
   */
  class EncapsedPart extends Expression {
    expression: Expression;
    syntax: string;
    curly: boolean;
  }
  /**
   * An array entry - see [Array](#array)
   * @property key - The entry key/offset
   * @property value - The entry value
   * @property byRef - By reference
   * @property unpack - Argument unpacking
   */
  class Entry extends Expression {
    /**
     * The entry key/offset
     */
    key: Node | null;
    /**
     * The entry value
     */
    value: Node;
    /**
     * By reference
     */
    byRef: boolean;
    /**
     * Argument unpacking
     */
    unpack: boolean;
  }
  /**
   * A enum definition
   */
  class Enum extends Declaration {
    valueType: Identifier | null;
    implements: Identifier[];
    body: Declaration[];
    attrGroups: AttrGroup[];
  }
  /**
   * Declares a cases into the current scope
   */
  class EnumCase extends Node {
    name: string;
    value: string | number | null;
  }
  /**
   * Defines an error node (used only on silentMode)
   */
  class Error extends Node {
    message: string;
    line: number;
    token: number | string;
    expected: string | any[];
  }
  /**
   * Defines an eval statement
   */
  class Eval extends Expression {
    source: Node;
  }
  /**
   * Defines an exit / die call
   */
  class Exit extends Expression {
    expression: Node | null;
    useDie: boolean;
  }
  /**
   * Any expression node. Since the left-hand side of an assignment may
   * be any expression in general, an expression can also be a pattern.
   */
  class Expression extends Node {}
  /**
   * Defines an expression based statement
   */
  class ExpressionStatement extends Statement {
    expression: Expression;
  }
  /**
   * Defines a for iterator
   */
  class For extends Statement {
    init: Expression[];
    test: Expression[];
    increment: Expression[];
    body: Block | null;
    shortForm: boolean;
  }
  /**
   * Defines a foreach iterator
   */
  class Foreach extends Statement {
    source: Expression;
    key: Expression | null;
    value: Expression;
    body: Block | null;
    shortForm: boolean;
  }
  /**
   * Defines a classic function
   */
  class Function extends Declaration {
    arguments: Parameter[];
    type: Identifier;
    byref: boolean;
    nullable: boolean;
    body: Block | null;
    attrGroups: AttrGroup[];
  }
  /**
   * Imports a variable from the global scope
   */
  class Global extends Statement {
    items: Variable[];
  }
  /**
   * Defines goto statement
   */
  class Goto extends Statement {
    label: string;
  }
  /**
   * Halts the compiler execution
   * @property after - String after the halt statement
   */
  class Halt extends Statement {
    /**
     * String after the halt statement
     */
    after: string;
  }
  /**
   * Defines an identifier node
   */
  class Identifier extends Node {
    name: string;
  }
  /**
   * Defines a if statement
   */
  class If extends Statement {
    test: Expression;
    body: Block;
    alternate: Block | If | null;
    shortForm: boolean;
  }
  /**
   * Defines system include call
   */
  class Include extends Expression {
    target: Node;
    once: boolean;
    require: boolean;
  }
  /**
   * Defines inline html output (treated as echo output)
   */
  class Inline extends Literal {
    value: string;
  }
  /**
   * An interface definition
   */
  class Interface extends Declaration {
    extends: Identifier[];
    body: Declaration[];
    attrGroups: AttrGroup[];
  }
  /**
   * A union of types
   */
  class IntersectionType extends Declaration {
    types: TypeReference[];
  }
  /**
   * Defines an isset call
   */
  class Isset extends Expression {}
  /**
   * A label statement (referenced by goto)
   */
  class Label extends Statement {
    name: string;
  }
  /**
   * Defines list assignment
   */
  class List extends Expression {
    shortForm: boolean;
    items: Entry[];
  }
  /**
   * Defines an array structure
   */
  class Literal extends Expression {
    raw: string;
    value: EncapsedPart[] | Node | string | number | boolean | null;
  }
  /**
   * Defines the location of the node (with it's source contents as string)
   */
  class Location {
    source: string | null;
    start: Position;
    end: Position;
  }
  /**
   * Lookup on an offset in the specified object
   */
  class Lookup extends Expression {
    what: Expression;
    offset: Expression;
  }
  /**
   * Defines magic constant
   */
  class Magic extends Literal {}
  /**
   * Defines a match expression
   * @property cond - Condition expression to match against
   * @property arms - Arms for comparison
   */
  class Match extends Expression {
    /**
     * Condition expression to match against
     */
    cond: Expression;
    /**
     * Arms for comparison
     */
    arms: MatchArm[];
  }
  /**
   * An array entry - see [Array](#array)
   * @property conds - The match condition expression list - null indicates default arm
   * @property body - The return value expression
   */
  class MatchArm extends Expression {
    /**
     * The match condition expression list - null indicates default arm
     */
    conds: Expression[] | null;
    /**
     * The return value expression
     */
    body: Expression;
  }
  /**
   * Defines a class/interface/trait method
   */
  class Method extends Function {
    isAbstract: boolean;
    isFinal: boolean;
    isStatic: boolean;
    visibility: string;
  }
  /**
   * Defines a class reference node
   */
  class Name extends Reference {
    /**
     * This is an identifier without a namespace separator, such as Foo
     */
    readonly UNQUALIFIED_NAME: string;
    /**
     * This is an identifier with a namespace separator, such as Foo\Bar
     */
    readonly QUALIFIED_NAME: string;
    /**
     * This is an identifier with a namespace separator that begins with
     * a namespace separator, such as \Foo\Bar. The namespace \Foo is also
     * a fully qualified name.
     */
    readonly FULL_QUALIFIED_NAME: string;
    /**
     * This is an identifier starting with namespace, such as namespace\Foo\Bar.
     */
    readonly RELATIVE_NAME: string;
    name: string;
    resolution: string;
  }
  /**
   * Named arguments.
   */
  class namedargument extends Expression {
    name: string;
    value: Expression;
  }
  /**
   * The main program node
   */
  class Namespace extends Block {
    name: string;
    withBrackets: boolean;
  }
  /**
   * Creates a new instance of the specified class
   */
  class New extends Expression {
    what: Identifier | Variable | Class;
    arguments: Variable[];
  }
  /**
   * A generic AST node
   */
  class Node {
    /**
     * Attach comments to current node
     */
    setTrailingComments(docs: any): void;
    /**
     * Destroying an unused node
     */
    destroy(): void;
    /**
     * Includes current token position of the parser
     */
    includeToken(parser: any): void;
    /**
     * Helper for extending the Node class
     */
    static extends(
      type: string,
      constructor: (...params: any[]) => any,
    ): (...params: any[]) => any;
    loc: Location | null;
    leadingComments: CommentBlock[] | Comment[] | null;
    trailingComments: CommentBlock[] | Comment[] | null;
    kind: string;
  }
  /**
   * Ignore this node, it implies a no operation block, for example :
   * [$foo, $bar, /* here a noop node * /]
   */
  class Noop extends Node {}
  /**
   * Defines a nowdoc string
   */
  class NowDoc extends Literal {
    label: string;
    raw: string;
    value: string;
  }
  /**
   * Represents the null keyword
   */
  class NullKeyword extends Node {}
  /**
   * Lookup to an object property
   */
  class NullSafePropertyLookup extends Lookup {}
  /**
   * Defines a numeric value
   */
  class Number extends Literal {
    value: number;
  }
  /**
   * Lookup on an offset in an array
   */
  class OffsetLookup extends Lookup {}
  /**
   * Defines binary operations
   */
  class Operation extends Expression {}
  type MODIFIER_PUBLIC = 1;
  type MODIFIER_PROTECTED = 2;
  type MODIFIER_PRIVATE = 4;
  /**
   * Defines a function parameter
   */
  class Parameter extends Declaration {
    type: Identifier | null;
    value: Node | null;
    byref: boolean;
    variadic: boolean;
    readonly: boolean;
    nullable: boolean;
    attrGroups: AttrGroup[];
    flags: MODIFIER_PUBLIC | MODIFIER_PROTECTED | MODIFIER_PRIVATE;
  }
  /**
   * Defines a class reference node
   */
  class ParentReference extends Reference {}
  /**
   * Each Position object consists of a line number (1-indexed) and a column number (0-indexed):
   */
  class Position {
    line: number;
    column: number;
    offset: number;
  }
  /**
   * Defines a post operation `$i++` or `$i--`
   */
  class Post extends Operation {
    type: string;
    what: Variable;
  }
  /**
   * Defines a pre operation `++$i` or `--$i`
   */
  class Pre extends Operation {
    type: string;
    what: Variable;
  }
  /**
   * Outputs
   */
  class Print extends Expression {}
  /**
   * The main program node
   */
  class Program extends Block {
    errors: Error[];
    comments: Comment[] | null;
    tokens: String[] | null;
  }
  /**
   * Defines a class property
   */
  class Property extends Statement {
    name: string;
    value: Node | null;
    readonly: boolean;
    nullable: boolean;
    type: Identifier | Identifier[] | null;
    attrGroups: AttrGroup[];
  }
  /**
   * Lookup to an object property
   */
  class PropertyLookup extends Lookup {}
  /**
   * Declares a properties into the current scope
   */
  class PropertyStatement extends Statement {
    /**
     * Generic flags parser
     */
    parseFlags(flags: (number | null)[]): void;
    properties: Property[];
    visibility: string | null;
    isStatic: boolean;
  }
  /**
   * Defines a reference node
   */
  class Reference extends Node {}
  /**
   * Defines a short if statement that returns a value
   */
  class RetIf extends Expression {
    test: Expression;
    trueExpr: Expression;
    falseExpr: Expression;
  }
  /**
   * A continue statement
   */
  class Return extends Statement {
    expr: Expression | null;
  }
  /**
   * Defines a class reference node
   */
  class SelfReference extends Reference {}
  /**
   * Avoids to show/log warnings & notices from the inner expression
   */
  class Silent extends Expression {
    expr: Expression;
  }
  /**
   * Any statement.
   */
  class Statement extends Node {}
  /**
   * Declares a static variable into the current scope
   */
  class Static extends Statement {
    variables: StaticVariable[];
  }
  /**
   * Lookup to a static property
   */
  class StaticLookup extends Lookup {}
  /**
   * Defines a class reference node
   */
  class StaticReference extends Reference {}
  /**
   * Defines a constant
   */
  class StaticVariable extends Node {
    variable: Variable;
    defaultValue: Node | string | number | boolean | null;
  }
  /**
   * Defines a string (simple or double quoted) - chars are already escaped
   */
  class String extends Literal {
    unicode: boolean;
    isDoubleQuote: boolean;
    value: string;
  }
  /**
   * Defines a switch statement
   */
  class Switch extends Statement {
    test: Expression;
    body: Block;
    shortForm: boolean;
  }
  /**
   * Defines a throw statement
   */
  class Throw extends Statement {
    what: Expression;
  }
  /**
   * A trait definition
   */
  class Trait extends Declaration {
    body: Declaration[];
  }
  /**
   * Defines a trait alias
   */
  class TraitAlias extends Node {
    trait: Identifier | null;
    method: Identifier;
    as: Identifier | null;
    visibility: string | null;
  }
  /**
   * Defines a trait alias
   */
  class TraitPrecedence extends Node {
    trait: Identifier | null;
    method: Identifier;
    instead: Identifier[];
  }
  /**
   * Defines a trait usage
   */
  class TraitUse extends Node {
    traits: Identifier[];
    adaptations: Node[] | null;
  }
  /**
   * Defines a try statement
   */
  class Try extends Statement {
    body: Block;
    catches: Catch[];
    always: Block;
  }
  /**
   * Defines a class reference node
   */
  class TypeReference extends Reference {
    name: string;
  }
  /**
   * Unary operations
   */
  class Unary extends Operation {
    type: string;
    what: Expression;
  }
  /**
   * A union of types
   */
  class UnionType extends Declaration {
    types: TypeReference[];
  }
  /**
   * Deletes references to a list of variables
   */
  class Unset extends Statement {}
  /**
   * Defines a use statement (with a list of use items)
   * @property type - Possible value : function, const
   */
  class UseGroup extends Statement {
    name: string | null;
    /**
     * Possible value : function, const
     */
    type: string | null;
    item: UseItem[];
  }
  /**
   * Defines a use statement (from namespace)
   * @property type - Possible value : function, const
   */
  class UseItem extends Statement {
    /**
     * Importing a constant
     */
    readonly TYPE_CONST: string;
    /**
     * Importing a function
     */
    readonly TYPE_FUNC: string;
    name: string;
    /**
     * Possible value : function, const
     */
    type: string | null;
    alias: Identifier | null;
  }
  /**
   * Any expression node. Since the left-hand side of an assignment may
   * be any expression in general, an expression can also be a pattern.
   * @example
   * // PHP code :
   * $foo
   * // AST output
   * {
   *  "kind": "variable",
   *  "name": "foo",
   *  "curly": false
   * }
   * @property name - The variable name (can be a complex expression when the name is resolved dynamically)
   * @property curly - Indicate if the name is defined between curlies, ex `${foo}`
   */
  class Variable extends Expression {
    /**
     * The variable name (can be a complex expression when the name is resolved dynamically)
     */
    name: string | Node;
    /**
     * Indicate if the name is defined between curlies, ex `${foo}`
     */
    curly: boolean;
  }
  /**
   * Introduce a list of items into the arguments of the call
   */
  class Variadic extends Expression {
    what: any[] | Expression;
  }
  /**
   * Defines a variadic placeholder (the ellipsis in PHP 8.1+'s first-class callable syntax)
   */
  class VariadicPlaceholder extends Node {}
  /**
   * Defines a while statement
   */
  class While extends Statement {
    test: Expression;
    body: Block | null;
    shortForm: boolean;
  }
  /**
   * Defines a yield generator statement
   */
  class Yield extends Expression {
    value: Expression | null;
    key: Expression | null;
  }
  /**
   * Defines a yield from generator statement
   */
  class YieldFrom extends Expression {
    value: Expression;
  }
  /**
   * The AST builder class
   * @property withPositions - Should locate any node (by default false)
   * @property withSource - Should extract the node original code (by default false)
   */
  class AST {
    /**
     * Should locate any node (by default false)
     */
    withPositions: boolean;
    /**
     * Should extract the node original code (by default false)
     */
    withSource: boolean;
  }
  /**
   * Initialise a new parser instance with the specified options
   * @example
   * var parser = require('php-parser');
   * var instance = new parser({
   *   parser: {
   *     extractDoc: true,
   *     suppressErrors: true,
   *     version: 704 // or '7.4'
   *   },
   *   ast: {
   *     withPositions: true
   *   },
   *   lexer: {
   *     short_tags: true,
   *     asp_tags: true
   *   }
   * });
   *
   * var evalAST = instance.parseEval('some php code');
   * var codeAST = instance.parseCode('<?php some php code', 'foo.php');
   * var tokens = instance.tokenGetAll('<?php some php code');
   * @param options - List of options
   */
  class Engine {
    constructor(options: any);
    /**
     * Parse an evaluating mode string (no need to open php tags)
     */
    parseEval(buffer: string): Program;
    /**
     * Function that parse a php code with open/close tags
     *
     * Sample code :
     * ```php
     * <?php $x = 1;
     * ```
     *
     * Usage :
     * ```js
     * var parser = require('php-parser');
     * var phpParser = new parser({
     *   // some options
     * });
     * var ast = phpParser.parseCode('...php code...', 'foo.php');
     * ```
     * @param buffer - The code to be parsed
     * @param filename - Filename
     */
    parseCode(buffer: string, filename: string): Program;
    /**
     * Extract tokens from the specified buffer.
     * > Note that the output tokens are *STRICLY* similar to PHP function `token_get_all`
     * @returns - Each item can be a string or an array with following informations [token_name, text, line_number]
     */
    tokenGetAll(buffer: string): (string | string[])[];
    lexer: Lexer;
    parser: Parser;
    ast: AST;
    tokens: any;
  }
  /**
   * This is the php lexer. It will tokenize the string for helping the
   * parser to build the AST from its grammar.
   * @property all_tokens - defines if all tokens must be retrieved (used by token_get_all only)
   * @property comment_tokens - extracts comments tokens
   * @property mode_eval - enables the evald mode (ignore opening tags)
   * @property asp_tags - disables by default asp tags mode
   * @property short_tags - enables by default short tags mode
   * @property keywords - List of php keyword
   * @property castKeywords - List of php keywords for type casting
   */
  class Lexer {
    /**
     * Initialize the lexer with the specified input
     */
    setInput(): void;
    /**
     * consumes and returns one char from the input
     */
    input(): void;
    /**
     * revert eating specified size
     */
    unput(): void;
    /**
     * check if the text matches
     */
    tryMatch(text: string): boolean;
    /**
     * check if the text matches
     */
    tryMatchCaseless(text: string): boolean;
    /**
     * look ahead
     */
    ahead(size: number): string;
    /**
     * consume the specified size
     */
    consume(size: number): Lexer;
    /**
     * Gets the current state
     */
    getState(): void;
    /**
     * Sets the current lexer state
     */
    setState(): void;
    /**
     * prepend next token
     */
    appendToken(value: any, ahead: any): Lexer;
    /**
     * return next match that has a token
     */
    lex(): number | string;
    /**
     * activates a new lexer condition state (pushes the new lexer condition state onto the condition stack)
     */
    begin(condition: any): Lexer;
    /**
     * pop the previously active lexer condition state off the condition stack
     */
    popState(): string | any;
    /**
     * return next match in input
     */
    next(): number | any;
    EOF: number;
    /**
     * defines if all tokens must be retrieved (used by token_get_all only)
     */
    all_tokens: boolean;
    /**
     * extracts comments tokens
     */
    comment_tokens: boolean;
    /**
     * enables the evald mode (ignore opening tags)
     */
    mode_eval: boolean;
    /**
     * disables by default asp tags mode
     */
    asp_tags: boolean;
    /**
     * enables by default short tags mode
     */
    short_tags: boolean;
    /**
     * List of php keyword
     */
    keywords: any;
    /**
     * List of php keywords for type casting
     */
    castKeywords: any;
  }
  /**
   * The PHP Parser class that build the AST tree from the lexer
   * @property lexer - current lexer instance
   * @property ast - the AST factory instance
   * @property token - current token
   * @property extractDoc - should extract documentation as AST node
   * @property extractTokens - should extract each token
   * @property suppressErrors - should ignore parsing errors and continue
   * @property debug - should output debug informations
   */
  class Parser {
    /**
     * helper : gets a token name
     */
    getTokenName(): void;
    /**
     * main entry point : converts a source code to AST
     */
    parse(): void;
    /**
     * Raise an error
     */
    raiseError(): void;
    /**
     * handling errors
     */
    error(): void;
    /**
     * Create a position node from the lexers position
     */
    position(): Position;
    /**
     * Creates a new AST node
     */
    node(): void;
    /**
     * expects an end of statement or end of file
     */
    expectEndOfStatement(): boolean;
    /**
     * Force the parser to check the current token.
     *
     * If the current token does not match to expected token,
     * the an error will be raised.
     *
     * If the suppressError mode is activated, then the error will
     * be added to the program error stack and this function will return `false`.
     */
    expect(token: string | number): boolean;
    /**
     * Returns the current token contents
     */
    text(): string;
    /**
     * consume the next token
     */
    next(): void;
    /**
     * Peek at the next token.
     * @returns Next Token
     */
    peek(): string | number;
    /**
     * Eating a token
     */
    lex(): void;
    /**
     * Check if token is of specified type
     */
    is(): void;
    /**
     * current lexer instance
     */
    lexer: Lexer;
    /**
     * the AST factory instance
     */
    ast: AST;
    /**
     * current token
     */
    token: number | string;
    /**
     * should extract documentation as AST node
     */
    extractDoc: boolean;
    /**
     * should extract each token
     */
    extractTokens: boolean;
    /**
     * should ignore parsing errors and continue
     */
    suppressErrors: boolean;
    /**
     * should output debug informations
     */
    debug: boolean;
  }
  const enum TokenNames {
    T_HALT_COMPILER = 101,
    T_USE = 102,
    T_ENCAPSED_AND_WHITESPACE = 103,
    T_OBJECT_OPERATOR = 104,
    T_STRING = 105,
    T_DOLLAR_OPEN_CURLY_BRACES = 106,
    T_STRING_VARNAME = 107,
    T_CURLY_OPEN = 108,
    T_NUM_STRING = 109,
    T_ISSET = 110,
    T_EMPTY = 111,
    T_INCLUDE = 112,
    T_INCLUDE_ONCE = 113,
    T_EVAL = 114,
    T_REQUIRE = 115,
    T_REQUIRE_ONCE = 116,
    T_NAMESPACE = 117,
    T_NS_SEPARATOR = 118,
    T_AS = 119,
    T_IF = 120,
    T_ENDIF = 121,
    T_WHILE = 122,
    T_DO = 123,
    T_FOR = 124,
    T_SWITCH = 125,
    T_BREAK = 126,
    T_CONTINUE = 127,
    T_RETURN = 128,
    T_GLOBAL = 129,
    T_STATIC = 130,
    T_ECHO = 131,
    T_INLINE_HTML = 132,
    T_UNSET = 133,
    T_FOREACH = 134,
    T_DECLARE = 135,
    T_TRY = 136,
    T_THROW = 137,
    T_GOTO = 138,
    T_FINALLY = 139,
    T_CATCH = 140,
    T_ENDDECLARE = 141,
    T_LIST = 142,
    T_CLONE = 143,
    T_PLUS_EQUAL = 144,
    T_MINUS_EQUAL = 145,
    T_MUL_EQUAL = 146,
    T_DIV_EQUAL = 147,
    T_CONCAT_EQUAL = 148,
    T_MOD_EQUAL = 149,
    T_AND_EQUAL = 150,
    T_OR_EQUAL = 151,
    T_XOR_EQUAL = 152,
    T_SL_EQUAL = 153,
    T_SR_EQUAL = 154,
    T_INC = 155,
    T_DEC = 156,
    T_BOOLEAN_OR = 157,
    T_BOOLEAN_AND = 158,
    T_LOGICAL_OR = 159,
    T_LOGICAL_AND = 160,
    T_LOGICAL_XOR = 161,
    T_SL = 162,
    T_SR = 163,
    T_IS_IDENTICAL = 164,
    T_IS_NOT_IDENTICAL = 165,
    T_IS_EQUAL = 166,
    T_IS_NOT_EQUAL = 167,
    T_IS_SMALLER_OR_EQUAL = 168,
    T_IS_GREATER_OR_EQUAL = 169,
    T_INSTANCEOF = 170,
    T_INT_CAST = 171,
    T_DOUBLE_CAST = 172,
    T_STRING_CAST = 173,
    T_ARRAY_CAST = 174,
    T_OBJECT_CAST = 175,
    T_BOOL_CAST = 176,
    T_UNSET_CAST = 177,
    T_EXIT = 178,
    T_PRINT = 179,
    T_YIELD = 180,
    T_YIELD_FROM = 181,
    T_FUNCTION = 182,
    T_DOUBLE_ARROW = 183,
    T_DOUBLE_COLON = 184,
    T_ARRAY = 185,
    T_CALLABLE = 186,
    T_CLASS = 187,
    T_ABSTRACT = 188,
    T_TRAIT = 189,
    T_FINAL = 190,
    T_EXTENDS = 191,
    T_INTERFACE = 192,
    T_IMPLEMENTS = 193,
    T_VAR = 194,
    T_PUBLIC = 195,
    T_PROTECTED = 196,
    T_PRIVATE = 197,
    T_CONST = 198,
    T_NEW = 199,
    T_INSTEADOF = 200,
    T_ELSEIF = 201,
    T_ELSE = 202,
    T_ENDSWITCH = 203,
    T_CASE = 204,
    T_DEFAULT = 205,
    T_ENDFOR = 206,
    T_ENDFOREACH = 207,
    T_ENDWHILE = 208,
    T_CONSTANT_ENCAPSED_STRING = 209,
    T_LNUMBER = 210,
    T_DNUMBER = 211,
    T_LINE = 212,
    T_FILE = 213,
    T_DIR = 214,
    T_TRAIT_C = 215,
    T_METHOD_C = 216,
    T_FUNC_C = 217,
    T_NS_C = 218,
    T_START_HEREDOC = 219,
    T_END_HEREDOC = 220,
    T_CLASS_C = 221,
    T_VARIABLE = 222,
    T_OPEN_TAG = 223,
    T_OPEN_TAG_WITH_ECHO = 224,
    T_CLOSE_TAG = 225,
    T_WHITESPACE = 226,
    T_COMMENT = 227,
    T_DOC_COMMENT = 228,
    T_ELLIPSIS = 229,
    T_COALESCE = 230,
    T_POW = 231,
    T_POW_EQUAL = 232,
    T_SPACESHIP = 233,
    T_COALESCE_EQUAL = 234,
    T_FN = 235,
    T_NULLSAFE_OBJECT_OPERATOR = 236,
    T_MATCH = 237,
    T_ATTRIBUTE = 238,
    T_ENUM = 239,
    T_READ_ONLY = 240,
    T_NAME_RELATIVE = 241,
    T_NAME_QUALIFIED = 242,
    T_NAME_FULLY_QUALIFIED = 243,
  }
  /**
   * PHP AST Tokens
   */
  const tokens: {
    values: {
      [key: number]: string;
    };
    names: TokenNames;
  };
}