/**
 * A dxf tag type represetation
 */
type token_t = {
    code: number;
    value: string;
    line: number;
};
type tokens_t = token_t[];
type matcher_t = (token: token_t) => boolean;
type spec_t = Map<number, string>;
type point_t = {
    x: number;
    y: number;
    z: number;
};
type obj_t = {
    [key: string]: any;
    unknowns?: tokens_t;
};

interface UnknownTokens {
    unknowns?: tokens_t;
}
interface Commons {
    handle: string;
    ownerObjectHandle: string;
    subclassMarker: string[];
}
interface RecordCommons extends UnknownTokens, Commons {
}
interface TableCommons<T, Multi> extends UnknownTokens {
    handle: string;
    ownerObjectHandle: string;
    subclassMarker: Multi extends true ? string[] : string;
    numberOfRecords: number;
    [key: string]: any | {
        ownerDictionariesHandle?: string[];
    };
    records: T[];
}
interface AppIdRecord extends RecordCommons {
    name: string;
    flags: number;
}
interface BlockRecord extends RecordCommons {
    name: string;
    layoutObject: string;
    insertionUnits: number;
    explodability: number;
    scalability: number;
}
interface DimStyleRecord extends RecordCommons {
    name: string;
    flags: number;
    DIMPOST: string;
    DIMAPOST: string;
    DIMSCALE: number;
    DIMASZ: number;
    DIMEXO: number;
    DIMDLI: number;
    DIMEXE: number;
    DIMRND: number;
    DIMDLE: number;
    DIMTP: number;
    DIMTM: number;
    DIMTXT: number;
    DIMCEN: number;
    DIMTSZ: number;
    DIMALTF: number;
    DIMLFAC: number;
    DIMTVP: number;
    DIMTFAC: number;
    DIMGAP: number;
    DIMALTRND: number;
    DIMTOL: number;
    DIMLIM: number;
    DIMTIH: number;
    DIMTOH: number;
    DIMSE1: number;
    DIMSE2: number;
    DIMTAD: number;
    DIMZIN: number;
    DIMAZIN: number;
    DIMALT: number;
    DIMALTD: number;
    DIMTOFL: number;
    DIMSAH: number;
    DIMTIX: number;
    DIMSOXD: number;
    DIMCLRD: number;
    DIMCLRE: number;
    DIMCLRT: number;
    DIMADEC: number;
    DIMDEC: number;
    DIMTDEC: number;
    DIMALTU: number;
    DIMALTTD: number;
    DIMAUNIT: number;
    DIMFRAC: number;
    DIMLUNIT: number;
    DIMDSEP: number;
    DIMTMOVE: number;
    DIMJUST: number;
    DIMSD1: number;
    DIMSD2: number;
    DIMTOLJ: number;
    DIMTZIN: number;
    DIMALTZ: number;
    DIMALTTZ: number;
    DIMFIT: number;
    DIMUPT: number;
    DIMATFIT: number;
    DIMTXSTY: string;
    DIMLDRBLK: string;
    DIMBLK: string;
    DIMBLK1: string;
    DIMBLK2: string;
    DIMLWD: number;
    DIMLWE: number;
}
interface LayerRecord extends RecordCommons {
    name: string;
    flags: number;
    color: number;
    lineType: string;
    plottingFlag: number;
    lineweight: number;
    plotStyleNameObject: string;
    materialObject: string;
}
interface LTypeElement {
    length: number;
    complexType: number;
    shapeNumber: number;
    styleObject: string;
    scale: number;
    rotation: number;
    offsetX: number;
    offsetY: number;
    text: string;
}
interface LTypeRecord extends RecordCommons {
    name: string;
    flags: number;
    descriptive: string;
    alignmentCode: number;
    numberOfElements: number;
    patternLength: number;
    elements: LTypeElement[];
}
interface StyleRecord extends RecordCommons {
    name: string;
    flags: number;
    textHeight: number;
    widthFactor: number;
    obliqueAngle: number;
    textGenerationFlags: number;
    lastHeight: number;
    primaryFontFile: string;
    bigFontFile: string;
    trueTypeFont: string;
}
interface ClassRecord {
    recordName: string;
    className: string;
    applicationName: string;
    proxyFlag: number;
    instanceCount: number;
    wasProxyFlag: number;
    isEntityFlag: number;
}
interface EntityCommons {
    handle: string;
    ownerBlockRecordHandle: string;
    subclassMarker: string[];
    inPaperSpace?: number;
    layoutTabName?: string;
    layerName?: string;
    linetypeName?: string;
    materialObjectHandle?: string;
    colorNumber?: number;
    lineweightEnumValue?: number;
    linetypeScale?: number;
    visibilty?: boolean;
    trueColor?: number;
    colorName?: string;
    transparency?: number;
    plotstyleObjectHandle?: string;
    shadowMode?: number;
}
interface PointEntity extends EntityCommons {
    x: number;
    y: number;
    z: number;
    thickness?: number;
    xAxisAngle?: number;
}
interface ArcEntity extends EntityCommons {
    thickness?: number;
    centerX: number;
    centerY: number;
    centerZ: number;
    radius: number;
    startAngle: number;
    endAngle: number;
}
interface Face3DEntity extends EntityCommons {
    firstX: number;
    firstY: number;
    firstZ: number;
    secondX: number;
    secondY: number;
    secondZ: number;
    thirdX: number;
    thirdY: number;
    thirdZ: number;
    fourthX: number;
    fourthY: number;
    fourthZ: number;
    invisibleEdgeFlag?: number;
}
interface Solid3DEntity extends EntityCommons {
    modelerFormatVersion: number;
    proprietaryData: string[];
    lastProprietrayData: string;
    historyObjectHandle: string;
}
interface SolidEntity extends EntityCommons {
    firstX: number;
    firstY: number;
    firstZ: number;
    secondX: number;
    secondY: number;
    secondZ: number;
    thirdX: number;
    thirdY: number;
    thirdZ: number;
    fourthX: number;
    fourthY: number;
    fourthZ: number;
    thickness?: number;
}
interface CircleEntity extends EntityCommons {
    thickness?: number;
    centerX: number;
    centerY: number;
    centerZ: number;
    radius: number;
}
interface EllipseEntity extends EntityCommons {
    centerX: number;
    centerY: number;
    centerZ: number;
    majorAxisX: number;
    majorAxisY: number;
    majorAxisZ: number;
    ratioOfMinorAxisToMajorAxis: number;
    startParameter: number;
    endParameter: number;
}
interface LWPolylineVertex {
    x: number;
    y: number;
    startingWidth: number;
    endWidth: number;
    bulge: number;
}
interface LWPolylineEntity extends EntityCommons {
    numberOfVertices: number;
    flag: number;
    constantWidth: number;
    elevation: number;
    thickness: number;
    vertices: LWPolylineVertex[];
}
interface PolylineEntity extends EntityCommons {
    entitiesFollowFlag: number;
    x: number;
    y: number;
    z: number;
    thickness: number;
    flag: number;
    startingWidth: number;
    endWidth: number;
    mVertexCount: number;
    nVertexCount: number;
    mDensity: number;
    nDensity: number;
    curvesAndSmoothSurface: number;
    vertices: VertexEntity[];
}
interface InsertEntity extends EntityCommons {
    attributesFollowFlag: number;
    blockName: string;
    x: number;
    y: number;
    z: number;
    xScale: number;
    yScale: number;
    zScale: number;
    rotation: number;
    columnCount: number;
    rowCount: number;
    columnSpacing: number;
    rowSpacing: number;
    attribs: AttribEntity[];
}
interface VertexEntity extends EntityCommons {
    x: number;
    y: number;
    z: number;
    startingWidth: number;
    endWidth: number;
    bulge: number;
    flag: number;
    tangentDirection: number;
    meshVertexIndex1: number;
    meshVertexIndex2: number;
    meshVertexIndex3: number;
    meshVertexIndex4: number;
    identifier: number;
}
interface LineEntity extends EntityCommons {
    thickness: number;
    startX: number;
    startY: number;
    startZ: number;
    endX: number;
    endY: number;
    endZ: number;
}
interface TextEntity extends EntityCommons {
    thickness: number;
    firstAlignmentX: number;
    firstAlignmentY: number;
    firstAlignmentZ: number;
    textHeight: number;
    text: string;
    rotation: number;
    factorWidth: number;
    obliqueAngle: number;
    styleName: string;
    generationFlags: number;
    horizontalJustification: number;
    secondAlignmentendX: number;
    secondAlignmentendY: number;
    secondAlignmentendZ: number;
    verticalJustification: number;
}
interface SplineEntity extends EntityCommons {
    normalVectorX: number;
    normalVectory: number;
    normalVectorZ: number;
    flags: number;
    degree: number;
    numberOfKnots: number;
    numberOfControlPoints: number;
    numberOfFitPoints: number;
    knotTolerance: number;
    controlPointTolerance: number;
    fitTolerance: number;
    startTangentX: number;
    startTangentY: number;
    startTangentZ: number;
    endTangentX: number;
    endTangentY: number;
    endTangentZ: number;
    knots: number[];
    weights: number[];
    controlPoints: point_t[];
    fitPoints: point_t[];
}
interface AttdefEntity extends EntityCommons {
    thickness?: number;
    firstAlignmentPointX: number;
    firstAlignmentPointY: number;
    firstAlignmentPointZ: number;
    height: number;
    value: string;
    rotation?: number;
    relativeXScaleFactor?: number;
    obliqueAngle?: number;
    styleName?: string;
    generationFlags?: number;
    horizontalJustification?: number;
    secondAlignmentPointX?: number;
    secondAlignmentPointY?: number;
    secondAlignmentPointZ?: number;
    verticalJustification?: number;
    prompt?: string;
    tag: string;
    flags?: number;
}
interface AttribEntity extends EntityCommons {
    thickness?: number;
    startPointX: number;
    startPointY: number;
    startPointZ: number;
    height: number;
    value: string;
    tag: string;
    flags?: number;
    rotation?: number;
    relativeXScaleFactor?: number;
    obliqueAngle?: number;
    styleName?: string;
    generationFlags?: number;
    horizontalJustification?: number;
    verticalJustification?: number;
    alignmentPointX?: number;
    alignmentPointY?: number;
    alignmentPointZ?: number;
}
interface Entities {
    face3ds: Face3DEntity[];
    points: PointEntity[];
    arcs: ArcEntity[];
    attdefs: AttdefEntity[];
    attribs: AttribEntity[];
    solid3ds: Solid3DEntity[];
    solids: SolidEntity[];
    circles: CircleEntity[];
    ellipses: EllipseEntity[];
    lwPolylines: LWPolylineEntity[];
    polylines: PolylineEntity[];
    lines: LineEntity[];
    texts: TextEntity[];
    splines: SplineEntity[];
    inserts: InsertEntity[];
}
interface Block extends Commons {
    layerName: string;
    name: string;
    typeFlags: number;
    basePointX: number;
    basePointY: number;
    basePointZ: number;
    name2: string;
    xRefPathName: string;
    description: string;
    entities: Entities;
}
interface DxfGlobalObject {
    header: obj_t;
    tables: {
        appId: TableCommons<Partial<AppIdRecord>, false>;
        blockRecord: TableCommons<Partial<BlockRecord>, false>;
        dimStyle: TableCommons<Partial<DimStyleRecord>, true>;
        layer: TableCommons<Partial<LayerRecord>, false>;
        lType: TableCommons<Partial<LTypeRecord>, false>;
        style: TableCommons<Partial<StyleRecord>, false>;
    };
    classes: ClassRecord[];
    blocks: Block[];
    entities: Entities;
}

declare class Tokenizer {
    readonly tokens: tokens_t;
    error?: string;
    private index;
    get cline(): number;
    get vline(): number;
    constructor(content: string);
    hasNext(): boolean;
    next(): token_t;
    peek(): token_t;
    advance(step?: number): void;
    is(matcher: matcher_t, advance?: boolean): boolean;
    isNot(matcher: matcher_t, advance?: boolean): boolean;
    isNotSectionOrEof(): boolean;
    isNotTable(): boolean;
    existInSpec(spec: spec_t): boolean;
    hasError(): boolean;
    expected(value: string, line: number): void;
    unexpected(value: string, line: number): void;
    endsec(): void;
    endtab(): void;
}

declare abstract class ParserBase {
    name: string;
    constructor(name: string);
    abstract parse(tk: Tokenizer): void;
    abstract match(tk: Tokenizer): boolean;
}

declare class BlocksParser extends ParserBase {
    blocks: Block[];
    constructor();
    parse(tk: Tokenizer): void;
    match(tk: Tokenizer): boolean;
    objectify(): {
        blocks: Block[];
    };
}

declare class ClassesParser extends ParserBase {
    records: ClassRecord[];
    constructor();
    parse(tk: Tokenizer): void;
    parseClass(tk: Tokenizer): void;
    match(tk: Tokenizer): boolean;
    objectify(): {
        classes: ClassRecord[];
    };
}

declare class Vertex extends ParserBase {
    vertices: VertexEntity[];
    constructor();
    parse(tk: Tokenizer): void;
    match(tk: Tokenizer): boolean;
    objectify(): {
        vertices: VertexEntity[];
    };
}

declare class Text extends ParserBase {
    texts: TextEntity[];
    constructor();
    parse(tk: Tokenizer): void;
    match(tk: Tokenizer): boolean;
    objectify(): {
        texts: TextEntity[];
    };
}

declare class Spline extends ParserBase {
    splines: SplineEntity[];
    constructor();
    parse(tk: Tokenizer): void;
    private parseControlPoints;
    private parseFitPoints;
    match(tk: Tokenizer): boolean;
    objectify(): {
        splines: SplineEntity[];
    };
}

declare class Solid extends ParserBase {
    solids: SolidEntity[];
    constructor();
    parse(tk: Tokenizer): void;
    match(tk: Tokenizer): boolean;
    objectify(): {
        solids: SolidEntity[];
    };
}

declare class Seqend extends ParserBase {
    constructor();
    parse(tk: Tokenizer): void;
    match(tk: Tokenizer): boolean;
}

declare class Polyline extends ParserBase {
    polylines: PolylineEntity[];
    constructor();
    parse(tk: Tokenizer): void;
    match(tk: Tokenizer): boolean;
    objectify(): {
        polylines: PolylineEntity[];
    };
}

declare class Point extends ParserBase {
    points: PointEntity[];
    constructor();
    parse(tk: Tokenizer): void;
    match(tk: Tokenizer): boolean;
    objectify(): {
        points: PointEntity[];
    };
}

declare class LWPolyline extends ParserBase {
    lwPolylines: LWPolylineEntity[];
    constructor();
    parse(tk: Tokenizer): void;
    private parseVertex;
    match(tk: Tokenizer): boolean;
    objectify(): {
        lwPolylines: LWPolylineEntity[];
    };
}

declare class Line extends ParserBase {
    lines: LineEntity[];
    constructor();
    parse(tk: Tokenizer): void;
    match(tk: Tokenizer): boolean;
    objectify(): {
        lines: LineEntity[];
    };
}

declare class Attrib extends ParserBase {
    attribs: AttribEntity[];
    constructor();
    parse(tk: Tokenizer): void;
    match(tk: Tokenizer): boolean;
    objectify(): {
        attribs: AttribEntity[];
    };
}

declare class Insert extends ParserBase {
    inserts: InsertEntity[];
    attrib: Attrib;
    seqend: Seqend;
    constructor();
    parse(tk: Tokenizer): void;
    match(tk: Tokenizer): boolean;
    objectify(): {
        inserts: InsertEntity[];
    };
}

declare class Hatch extends ParserBase {
    constructor();
    parse(tk: Tokenizer): void;
    match(tk: Tokenizer): boolean;
}

declare class Ellipse extends ParserBase {
    ellipses: EllipseEntity[];
    constructor();
    parse(tk: Tokenizer): void;
    match(tk: Tokenizer): boolean;
    objectify(): {
        ellipses: EllipseEntity[];
    };
}

declare class Circle extends ParserBase {
    circles: CircleEntity[];
    constructor();
    parse(tk: Tokenizer): void;
    match(tk: Tokenizer): boolean;
    objectify(): {
        circles: CircleEntity[];
    };
}

declare class Arc extends ParserBase {
    arcs: ArcEntity[];
    constructor();
    parse(tk: Tokenizer): void;
    match(tk: Tokenizer): boolean;
    objectify(): {
        arcs: ArcEntity[];
    };
}

declare class Solid3D extends ParserBase {
    solid3ds: Solid3DEntity[];
    constructor();
    parse(tk: Tokenizer): void;
    match(tk: Tokenizer): boolean;
    objectify(): {
        solid3ds: Solid3DEntity[];
    };
}

declare class Face3D extends ParserBase {
    face3ds: Face3DEntity[];
    constructor();
    parse(tk: Tokenizer): void;
    match(tk: Tokenizer): boolean;
    objectify(): {
        face3ds: Face3DEntity[];
    };
}

declare class Attdef extends ParserBase {
    attdefs: AttdefEntity[];
    constructor();
    parse(tk: Tokenizer): void;
    match(tk: Tokenizer): boolean;
    objectify(): {
        attdefs: AttdefEntity[];
    };
}

declare class EntitiesParser extends ParserBase {
    face3D: Face3D;
    solid3D: Solid3D;
    arc: Arc;
    attdef: Attdef;
    attrib: Attrib;
    circle: Circle;
    ellipse: Ellipse;
    hatch: Hatch;
    insert: Insert;
    line: Line;
    lwPolyline: LWPolyline;
    point: Point;
    polyline: Polyline;
    seqend: Seqend;
    solid: Solid;
    spline: Spline;
    text: Text;
    vertex: Vertex;
    constructor();
    parse(tk: Tokenizer): void;
    match(tk: Tokenizer): boolean;
    objectify(): {
        entities: {
            splines: SplineEntity[];
            texts: TextEntity[];
            lines: LineEntity[];
            polylines: PolylineEntity[];
            lwPolylines: LWPolylineEntity[];
            inserts: InsertEntity[];
            ellipses: EllipseEntity[];
            circles: CircleEntity[];
            solids: SolidEntity[];
            solid3ds: Solid3DEntity[];
            face3ds: Face3DEntity[];
            attribs: AttribEntity[];
            attdefs: AttdefEntity[];
            arcs: ArcEntity[];
            points: PointEntity[];
        };
    };
}

declare class HeaderParser extends ParserBase {
    variables: obj_t;
    private currentVariable;
    constructor();
    parse(tk: Tokenizer): void;
    private parsePoint;
    match(tk: Tokenizer): boolean;
    objectify(): {
        header: obj_t;
    };
}

declare class ObjectsParser extends ParserBase {
    constructor();
    parse(tk: Tokenizer): void;
    match(tk: Tokenizer): boolean;
}

declare class TableParser<Record extends RecordCommons, Multi = false> extends ParserBase {
    protected commonsParsed: boolean;
    readonly table: TableCommons<Partial<Record>, Multi>;
    readonly spec: spec_t;
    constructor(name: string, spec: spec_t, multipleSubclassMarkers?: boolean);
    match(tk: Tokenizer): boolean;
    parse(tk: Tokenizer): void;
    protected parseCommons(tk: Tokenizer): void;
    private parse102;
    protected parseRecords(tk: Tokenizer): void;
}

declare class AppIdParser extends TableParser<AppIdRecord> {
    constructor();
}

declare class BlockRecordParser extends TableParser<BlockRecord> {
    constructor();
}

declare class DimStyleParser extends TableParser<DimStyleRecord, true> {
    constructor();
}

declare class LayerParser extends TableParser<LayerRecord> {
    constructor();
}

declare class LTypeParser extends TableParser<LTypeRecord> {
    constructor();
    parse(tk: Tokenizer): void;
    private parselTypeElements;
}

declare class StyleParser extends TableParser<StyleRecord> {
    constructor();
}

declare class UcsParser extends ParserBase {
    constructor();
    parse(tk: Tokenizer): void;
    match(tk: Tokenizer): boolean;
}

declare class ViewParser extends ParserBase {
    constructor();
    parse(tk: Tokenizer): void;
    match(tk: Tokenizer): boolean;
}

declare class VPortParser extends ParserBase {
    constructor();
    parse(tk: Tokenizer): void;
    match(tk: Tokenizer): boolean;
}

declare class TablesParser extends ParserBase {
    appId: AppIdParser;
    blockRecord: BlockRecordParser;
    dimStyle: DimStyleParser;
    layer: LayerParser;
    lType: LTypeParser;
    style: StyleParser;
    ucs: UcsParser;
    view: ViewParser;
    vPort: VPortParser;
    constructor();
    parse(tk: Tokenizer): void;
    match(tk: Tokenizer): boolean;
    objectify(): {
        tables: {
            appId: TableCommons<Partial<AppIdRecord>, false>;
            blockRecord: TableCommons<Partial<BlockRecord>, false>;
            dimStyle: TableCommons<Partial<DimStyleRecord>, true>;
            layer: TableCommons<Partial<LayerRecord>, false>;
            lType: TableCommons<Partial<LTypeRecord>, false>;
            style: TableCommons<Partial<StyleRecord>, false>;
        };
    };
}

declare class Parser {
    readonly header: HeaderParser;
    readonly classes: ClassesParser;
    readonly tables: TablesParser;
    readonly blocks: BlocksParser;
    readonly entities: EntitiesParser;
    readonly objects: ObjectsParser;
    constructor();
    parse(content: string): Promise<DxfGlobalObject>;
}

export { AppIdRecord, ArcEntity, AttdefEntity, AttribEntity, Block, BlockRecord, CircleEntity, ClassRecord, Commons, DimStyleRecord, DxfGlobalObject, EllipseEntity, Entities, EntityCommons, Face3DEntity, InsertEntity, LTypeElement, LTypeRecord, LWPolylineEntity, LWPolylineVertex, LayerRecord, LineEntity, Parser, PointEntity, PolylineEntity, RecordCommons, Solid3DEntity, SolidEntity, SplineEntity, StyleRecord, TableCommons, TextEntity, UnknownTokens, VertexEntity };