@igorivaniuk/tlb-parser/dist/ast/nodes.d.ts

Parse TLB syntax into TypeScript objects

export declare abstract class ASTRootBase {
    readonly parent: ASTBase | null;
    readonly locations: {
        readonly line: number;
        readonly column: number;
    };
    static readonly _attributes: string[];
}
export declare abstract class ASTBase extends ASTRootBase {
    readonly parent: ASTBase;
}
export declare class Program extends ASTRootBase {
    readonly declarations: Declaration[];
    static readonly _attributes: string[];
    readonly parent: null;
    constructor(declarations: Declaration[]);
}
export declare class Declaration extends ASTBase {
    readonly constructorDef: Constructor;
    readonly fields: FieldDefinition[];
    readonly combinator: Combinator;
    static readonly _attributes: string[];
    constructor(constructorDef: Constructor, fields: FieldDefinition[], combinator: Combinator);
}
export declare class Constructor extends ASTBase {
    readonly name: string;
    readonly tag: string | null;
    constructor(name: string, tag: string | null);
    getTagType(): 'binary' | 'hex' | null;
}
export type FieldDefinition = FieldBuiltinDef | FieldCurlyExprDef | FieldAnonymousDef | FieldNamedDef | FieldExprDef;
export declare abstract class Field extends ASTBase {
}
export declare const FieldBuiltinType: readonly ["+", "Type"];
export declare class FieldBuiltinDef extends Field {
    readonly name: string;
    readonly type: typeof FieldBuiltinType[number];
    constructor(name: string, type: typeof FieldBuiltinType[number]);
}
export declare class FieldCurlyExprDef extends Field {
    readonly expr: Expression;
    static readonly _attributes: string[];
    constructor(expr: Expression);
}
export declare class FieldAnonymousDef extends Field {
    readonly name: string | null;
    readonly isRef: boolean;
    readonly fields: FieldDefinition[];
    static readonly _attributes: string[];
    constructor(name: string | null, isRef: boolean, fields: FieldDefinition[]);
}
export declare class FieldNamedDef extends Field {
    readonly name: string;
    readonly expr: CondExpr | TypeExpr;
    static readonly _attributes: string[];
    constructor(name: string, expr: CondExpr | TypeExpr);
}
export declare class FieldExprDef extends Field {
    readonly expr: CondExpr;
    static readonly _attributes: string[];
    constructor(expr: CondExpr);
}
export declare class Combinator extends ASTBase {
    readonly name: string;
    readonly args: TypeExpr[];
    static readonly _attributes: string[];
    constructor(name: string, args: TypeExpr[]);
}
export declare abstract class Expression extends ASTBase {
}
export declare class CondExpr extends Expression {
    readonly left: TypeExpr;
    readonly dotExpr: number | null;
    readonly condExpr: TypeExpr;
    static readonly _attributes: string[];
    constructor(left: TypeExpr, dotExpr: number | null, condExpr: TypeExpr);
}
export declare const CompareOperator: readonly ["<=", ">=", "!=", "=", "<", ">"];
export declare class CompareExpr extends Expression {
    readonly left: SimpleExpr;
    readonly op: typeof CompareOperator[number];
    readonly right: SimpleExpr;
    static readonly _attributes: string[];
    constructor(left: SimpleExpr, op: typeof CompareOperator[number], right: SimpleExpr);
}
export type TypeExpr = CellRefExpr | BuiltinExpr | CombinatorExpr | SimpleExpr;
export declare class CellRefExpr extends Expression {
    readonly expr: Expression;
    static readonly _attributes: string[];
    constructor(expr: Expression);
}
export declare class BuiltinExpr extends Expression {
}
export declare const BuiltinOneArgOperators: readonly ["#<=", "#<", "##"];
export declare class BuiltinOneArgExpr extends BuiltinExpr {
    readonly name: typeof BuiltinOneArgOperators[number];
    readonly arg: Reference;
    static readonly _attributes: string[];
    constructor(name: typeof BuiltinOneArgOperators[number], arg: Reference);
}
export declare const BuiltinZeroArgsOperators: readonly ["#"];
export declare class BuiltinZeroArgs extends BuiltinExpr {
    readonly name: typeof BuiltinZeroArgsOperators[number];
    constructor(name: typeof BuiltinZeroArgsOperators[number]);
}
export declare class CombinatorExpr extends Expression {
    readonly name: string;
    readonly args: TypeExpr[];
    static readonly _attributes: string[];
    constructor(name: string, args: TypeExpr[]);
}
export type SimpleExpr = NegateExpr | MathExpr | Reference;
export declare const MathOperator: readonly ["*", "+"];
export declare class MathExpr extends Expression {
    readonly left: SimpleExpr;
    readonly op: typeof MathOperator[number];
    readonly right: SimpleExpr;
    static readonly _attributes: string[];
    constructor(left: SimpleExpr, op: typeof MathOperator[number], right: SimpleExpr);
}
export declare class NegateExpr extends Expression {
    readonly expr: Expression;
    static readonly _attributes: string[];
    constructor(expr: Expression);
}
export declare class RefExpr extends Expression {
}
export type Reference = NameExpr | NumberExpr;
export declare class NameExpr extends RefExpr {
    readonly name: string;
    constructor(name: string);
}
export declare class NumberExpr extends RefExpr {
    readonly num: number;
    constructor(num: number);
}