@jorgsowa/php-parser 3.2.5-1

package/types.d.ts

@@ -0,0 +1,1457 @@
+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[];
+  }
+  /**
+   * Defines a class property hook getter & setter
+   */
+  class PropertyHook extends Node {
+    name: string;
+    isFinal: boolean;
+    byref: boolean;
+    parameter: Parameter | null;
+    body: Block | Statement;
+  }
+  /**
+   * 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;
+  };
+}