/**
 * Type representing the JSON structure returned by xml2js
 */
type XmlJson = {
    [key: string]: XmlJsonValue;
};
type XmlJsonValue = string | number | boolean | null | XmlJsonElement | XmlJsonValue[];
type XmlJsonElement = {
    $?: Record<string, string | number | boolean>;
    _?: string;
    [key: string]: XmlJsonValue | Record<string, string | number | boolean> | string | undefined;
};

declare class LightBurnBaseElement {
    token: string;
    static token: string;
    getChildren(): LightBurnBaseElement[];
    /**
     * Get XML attributes for this element
     * Subclasses should override this to provide their specific attributes
     */
    getXmlAttributes(): Record<string, string | number | boolean | undefined>;
    /**
     * Get the XML tag name for this element
     * By default, uses the token, but can be overridden
     */
    getXmlTag(): string;
    /**
     * Convert this element to XML string
     */
    toXml(indent?: number): string;
    getStringIndented(): string;
    getString(): string;
    get [Symbol.toStringTag](): string;
    private static elementRegistry;
    private static shapeRegistry;
    /**
     * Should be called after class definition to register the class for parsing
     */
    static register(token: string, klass: any): void;
    /**
     * Parse an XML string into registered LightBurnBaseElement instances
     */
    static parse(xml: string): LightBurnBaseElement | LightBurnBaseElement[];
    static fromXmlJson(node: XmlJsonElement): LightBurnBaseElement;
    static parseXmlJson(xmlJson: XmlJsonValue): any;
    static instantiateElement(tag: string, node: XmlJsonElement): LightBurnBaseElement;
}

interface LightBurnProjectInit {
    appVersion?: string;
    formatVersion?: string;
    materialHeight?: number;
    mirrorX?: boolean;
    mirrorY?: boolean;
    children?: LightBurnBaseElement[];
}
declare class LightBurnProject extends LightBurnBaseElement {
    appVersion?: string;
    formatVersion?: string;
    materialHeight?: number;
    mirrorX?: boolean;
    mirrorY?: boolean;
    children: LightBurnBaseElement[];
    constructor(init?: LightBurnProjectInit);
    static fromXmlJson(node: XmlJsonElement): LightBurnProject;
    getChildren(): LightBurnBaseElement[];
    getXmlAttributes(): Record<string, string | number | boolean | undefined>;
}

interface CutSettingInit {
    type?: string;
    index?: number;
    name?: string;
    priority?: number;
    minPower?: number;
    maxPower?: number;
    minPower2?: number;
    maxPower2?: number;
    speed?: number;
    kerf?: number;
    zOffset?: number;
    enablePowerRamp?: boolean;
    rampLength?: number;
    numPasses?: number;
    zPerPass?: number;
    perforate?: boolean;
    dotMode?: boolean;
    scanOpt?: string;
    interval?: number;
    angle?: number;
    overScanning?: number;
    lineAngle?: number;
    crossHatch?: boolean;
    frequency?: number;
    qPulseWidth?: number;
}
declare class CutSetting extends LightBurnBaseElement {
    private _type;
    private _index?;
    private _name?;
    private _priority?;
    private _minPower?;
    private _maxPower?;
    private _minPower2?;
    private _maxPower2?;
    private _speed?;
    private _kerf?;
    private _zOffset?;
    private _enablePowerRamp?;
    private _rampLength?;
    private _numPasses?;
    private _zPerPass?;
    private _perforate?;
    private _dotMode?;
    private _scanOpt?;
    private _interval?;
    private _angle?;
    private _overScanning?;
    private _lineAngle?;
    private _crossHatch?;
    private _frequency?;
    private _qPulseWidth?;
    constructor(init?: CutSettingInit);
    get type(): string;
    set type(value: string);
    get index(): number | undefined;
    set index(value: number | undefined);
    get name(): string | undefined;
    set name(value: string | undefined);
    get priority(): number | undefined;
    set priority(value: number | undefined);
    get minPower(): number | undefined;
    set minPower(value: number | undefined);
    get maxPower(): number | undefined;
    set maxPower(value: number | undefined);
    get minPower2(): number | undefined;
    set minPower2(value: number | undefined);
    get maxPower2(): number | undefined;
    set maxPower2(value: number | undefined);
    get speed(): number | undefined;
    set speed(value: number | undefined);
    get kerf(): number | undefined;
    set kerf(value: number | undefined);
    get zOffset(): number | undefined;
    set zOffset(value: number | undefined);
    get enablePowerRamp(): boolean | undefined;
    set enablePowerRamp(value: boolean | undefined);
    get rampLength(): number | undefined;
    set rampLength(value: number | undefined);
    get numPasses(): number | undefined;
    set numPasses(value: number | undefined);
    get zPerPass(): number | undefined;
    set zPerPass(value: number | undefined);
    get perforate(): boolean | undefined;
    set perforate(value: boolean | undefined);
    get dotMode(): boolean | undefined;
    set dotMode(value: boolean | undefined);
    get scanOpt(): string | undefined;
    set scanOpt(value: string | undefined);
    get interval(): number | undefined;
    set interval(value: number | undefined);
    get angle(): number | undefined;
    set angle(value: number | undefined);
    get overScanning(): number | undefined;
    set overScanning(value: number | undefined);
    get lineAngle(): number | undefined;
    set lineAngle(value: number | undefined);
    get crossHatch(): boolean | undefined;
    set crossHatch(value: boolean | undefined);
    get frequency(): number | undefined;
    set frequency(value: number | undefined);
    get qPulseWidth(): number | undefined;
    set qPulseWidth(value: number | undefined);
    getXmlAttributes(): Record<string, string | number | boolean | undefined>;
    getChildren(): LightBurnBaseElement[];
    static fromXmlJson(node: XmlJsonElement): CutSetting;
}

declare class Notes extends LightBurnBaseElement {
    showOnLoad?: boolean;
    text?: string;
    constructor();
    static fromXmlJson(node: XmlJsonElement): Notes;
}

declare class VariableText extends LightBurnBaseElement {
    start?: number;
    end?: number;
    current?: number;
    increment?: number;
    autoAdvance?: boolean;
    constructor();
    static fromXmlJson(node: XmlJsonElement): VariableText;
}

declare class UIPrefs extends LightBurnBaseElement {
    prefs: Record<string, string>;
    constructor();
    static fromXmlJson(node: XmlJsonElement): UIPrefs;
}

declare class Thumbnail extends LightBurnBaseElement {
    pngBase64?: string;
    constructor();
    static fromXmlJson(node: XmlJsonElement): Thumbnail;
}

type Mat = [
    a: number,
    b: number,
    c: number,
    d: number,
    tx: number,
    ty: number
];
declare abstract class ShapeBase extends LightBurnBaseElement {
    cutIndex?: number;
    locked?: boolean;
    xform: Mat;
    protected getShapeXmlAttributes(): Record<string, string | number | boolean | undefined>;
    getChildren(): LightBurnBaseElement[];
    static readCommon(node: XmlJsonElement): {
        cutIndex?: number;
        locked?: boolean;
        xform: Mat;
    };
}

declare class ShapeEllipse extends ShapeBase {
    rx?: number;
    ry?: number;
    constructor();
    static fromXmlJson(node: XmlJsonElement): ShapeEllipse;
}

declare class ShapeRect extends ShapeBase {
    w?: number;
    h?: number;
    cr?: number;
    constructor();
    getXmlAttributes(): Record<string, string | number | boolean | undefined>;
    static fromXmlJson(node: XmlJsonElement): ShapeRect;
}

interface Vert {
    x: number;
    y: number;
    c?: number;
    c0x?: number;
    c0y?: number;
    c1x?: number;
    c1y?: number;
}
interface Prim {
    type: number;
}
interface ShapePathInit {
    verts?: Vert[];
    prims?: Prim[];
    isClosed?: boolean;
    cutIndex?: number;
    locked?: boolean;
    xform?: Mat;
}
declare class ShapePath extends ShapeBase {
    verts: Vert[];
    prims: Prim[];
    isClosed: boolean;
    private static templateRegistry;
    constructor(init?: ShapePathInit);
    static clearTemplateRegistry(): void;
    getXmlAttributes(): Record<string, string | number | boolean | undefined>;
    getChildren(): LightBurnBaseElement[];
    static fromXmlJson(node: XmlJsonElement): ShapePath;
    /**
     * Parse encoded VertList string format
     * Format: V{x} {y}c{flag}c0x{value}c0y{value}c1x{value}c1y{value}
     * Example: V2.1156745 -12.3306c0x1c1x1.5871694c1y-12.3306
     *
     * Control points are encoded as:
     * - c0x{value}c0y{value} = control point 0 (outgoing handle when this vertex is START of Bezier)
     * - c1x{value}c1y{value} = control point 1 (incoming handle when this vertex is END of Bezier)
     * - c0x1 or c1x1 (value of exactly "1" without corresponding y) = "no handle" marker, not a coordinate
     */
    static parseEncodedVertList(encoded: string): Vert[];
    /**
     * Parse encoded PrimList string format
     * Format: {type}{fromIdx} {toIdx}{type}{fromIdx} {toIdx}...
     * Example: L0 1B1 2L2 3B3 4
     * where L = Line (type 0), B = Bezier (type 1)
     */
    static parseEncodedPrimList(encoded: string): Prim[];
    /**
     * Parse encoded PrimPolyline string format
     * This typically contains line-to commands, each prim is type 0 (LineTo)
     */
    static parseEncodedPrimPolyline(encoded: string): Prim[];
    /**
     * Generate primitives from vertices based on PrimID
     * PrimID meanings:
     * - 0: Simple polyline (all LineTo)
     * - 2: Rounded rectangle with bezier curves at corners
     * - 3: Other curve type
     */
    static generatePrimsFromVerts(verts: Vert[], primID?: number): Prim[];
}

declare class ShapeText extends ShapeBase {
    text?: string;
    font?: string;
    backupPath?: ShapePath;
    constructor();
    static fromXmlJson(node: XmlJsonElement): ShapeText;
}

declare class ShapeGroup extends ShapeBase {
    children: LightBurnBaseElement[];
    constructor();
    getXmlAttributes(): Record<string, string | number | boolean | undefined>;
    static fromXmlJson(node: XmlJsonElement): ShapeGroup;
    getChildren(): LightBurnBaseElement[];
    toXml(indent?: number): string;
}

declare class ShapeBitmap extends ShapeBase {
    private _w?;
    private _h?;
    private _dataBase64?;
    private _grayscale?;
    private _dpi?;
    private _ditherMode?;
    private _halftone?;
    private _negative?;
    private _brightnessAdjust?;
    private _contrastAdjust?;
    private _gammaAdjust?;
    constructor();
    get w(): number | undefined;
    set w(value: number | undefined);
    get h(): number | undefined;
    set h(value: number | undefined);
    get dataBase64(): string | undefined;
    set dataBase64(value: string | undefined);
    get grayscale(): boolean | undefined;
    set grayscale(value: boolean | undefined);
    get dpi(): number | undefined;
    set dpi(value: number | undefined);
    get ditherMode(): string | undefined;
    set ditherMode(value: string | undefined);
    get halftone(): boolean | undefined;
    set halftone(value: boolean | undefined);
    get negative(): boolean | undefined;
    set negative(value: boolean | undefined);
    get brightnessAdjust(): number | undefined;
    set brightnessAdjust(value: number | undefined);
    get contrastAdjust(): number | undefined;
    set contrastAdjust(value: number | undefined);
    get gammaAdjust(): number | undefined;
    set gammaAdjust(value: number | undefined);
    static fromXmlJson(node: XmlJsonElement): ShapeBitmap;
}

interface GenerateSvgOptions {
    margin?: number;
    /** Target width for the SVG. When provided with height, scales the output. */
    width?: number;
    /** Target height for the SVG. When provided with width, scales the output. */
    height?: number;
    /** Default stroke width for shapes in mm. */
    defaultStrokeWidth?: number;
}

declare function generateLightBurnSvg(root: LightBurnBaseElement | LightBurnBaseElement[], options?: GenerateSvgOptions): string;

interface SplitLightBurnProjectFile {
    fileName: string;
    content: string;
    cutIndex: number;
    cutSettingName: string;
    shapeCount: number;
}
declare function splitLightBurnProjectByCutSetting(input: string | LightBurnProject, originalFileName?: string): SplitLightBurnProjectFile[];

declare const parseXml: (xml: string) => XmlJson;

export { LightBurnBaseElement as BaseLightBurnElement, CutSetting, type CutSettingInit, type GenerateSvgOptions, LightBurnBaseElement, LightBurnProject, type LightBurnProjectInit, type Mat, Notes, type Prim, ShapeBase, ShapeBitmap, ShapeEllipse, ShapeGroup, ShapePath, type ShapePathInit, ShapeRect, ShapeText, type SplitLightBurnProjectFile, Thumbnail, UIPrefs, VariableText, type Vert, generateLightBurnSvg, parseXml, splitLightBurnProjectByCutSetting };