type PrimitiveSExpr = string | number | boolean | null | PrimitiveSExpr[];

declare abstract class SxClass {
    abstract token: string;
    static token: string;
    /**
     * Token strings are sometimes re-used (e.g. a "type" token) but the class
     * varies based on the parent token
     */
    static parentToken?: string;
    isSxClass: boolean;
    getChildren(): SxClass[];
    getStringIndented(): string;
    getString(): string;
    get [Symbol.toStringTag](): string;
    static classes: Record<string, Record<string, any>>;
    /**
     * Should be called after class definition to register the class for parsing
     */
    static register(newClass: any): void;
    /**
     * Parse an S-expression string into registered SxClass instances
     */
    static parse(sexpr: string): SxClass[];
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): SxClass;
    static parsePrimitiveSexpr(primitiveSexpr: PrimitiveSExpr, options?: {
        parentToken?: string;
    }): SxClass | SxClass[] | number | string | boolean | null;
    static parsePrimitivesToClassProperties(primitiveSexprs: PrimitiveSExpr[], parentToken?: string): {
        propertyMap: Record<string, SxClass>;
        arrayPropertyMap: Record<string, SxClass[]>;
    };
}

declare abstract class SxPrimitiveNumber extends SxClass {
    value: number;
    constructor(v: number);
    set(value: number): void;
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): SxPrimitiveNumber;
    getString(): string;
}

declare class Width extends SxPrimitiveNumber {
    static token: string;
    token: string;
}

type StrokeTypeString = "dash" | "dash_dot" | "dash_dot_dot" | "dot" | "default" | "solid";
declare class StrokeType extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    type: StrokeTypeString;
    constructor(type: StrokeTypeString);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): StrokeType;
    getString(): string;
}

type RGBAColor = {
    r: number;
    g: number;
    b: number;
    a: number;
};
declare class Color extends SxClass {
    static token: string;
    token: string;
    color: RGBAColor;
    constructor(args: [r: number, g: number, b: number, a: number]);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): Color;
    getString(): string;
}

type StrokeProperty = Width | StrokeType | Color;
declare class Stroke extends SxClass {
    static token: string;
    token: string;
    _sxWidth?: Width;
    _sxType?: StrokeType;
    _sxColor?: Color;
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): Stroke;
    get width(): number | undefined;
    get type(): StrokeTypeString | undefined;
    get color(): RGBAColor | undefined;
    set width(width: number);
    set type(type: StrokeTypeString);
    set color(color: RGBAColor);
}

type UnitString = "inches" | "mils" | "millimeters" | "automatic";
declare class Unit extends SxClass {
    static token: string;
    token: string;
    value: UnitString;
    constructor(value: UnitString | number);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): Unit;
}

declare abstract class SxPrimitiveBoolean extends SxClass {
    value: boolean;
    constructor(v: boolean);
    set(value: boolean): void;
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): SxPrimitiveBoolean;
    getString(): string;
}

declare class InBom extends SxPrimitiveBoolean {
    static token: string;
    token: string;
}

declare class InPosFiles extends SxPrimitiveBoolean {
    static token: string;
    token: string;
}

declare class OnBoard extends SxPrimitiveBoolean {
    static token: string;
    token: string;
}

declare class Xy extends SxClass {
    static token: string;
    token: string;
    x: number;
    y: number;
    constructor(x: number, y: number);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): Xy;
    getChildren(): SxClass[];
    getString(): string;
}

declare class Pts extends SxClass {
    static token: string;
    token: string;
    points: Array<Xy | PtsArc>;
    constructor(points?: Array<Xy | PtsArc>);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): Pts;
    getChildren(): SxClass[];
    getString(): string;
}
declare class PtsArc extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _sxStart?;
    private _sxMid?;
    private _sxEnd?;
    constructor(params?: {
        start?: PtsArcStart | {
            x: number;
            y: number;
        };
        mid?: PtsArcMid | {
            x: number;
            y: number;
        };
        end?: PtsArcEnd | {
            x: number;
            y: number;
        };
    });
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): PtsArc;
    get start(): PtsArcStart | undefined;
    set start(value: PtsArcStart | {
        x: number;
        y: number;
    } | undefined);
    get mid(): PtsArcMid | undefined;
    set mid(value: PtsArcMid | {
        x: number;
        y: number;
    } | undefined);
    get end(): PtsArcEnd | undefined;
    set end(value: PtsArcEnd | {
        x: number;
        y: number;
    } | undefined);
    getChildren(): SxClass[];
    getString(): string;
}
declare class PtsArcStart extends SxClass {
    x: number;
    y: number;
    static token: string;
    static parentToken: string;
    token: string;
    constructor(x: number, y: number);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): PtsArcStart;
    getString(): string;
}
declare class PtsArcMid extends SxClass {
    x: number;
    y: number;
    static token: string;
    static parentToken: string;
    token: string;
    constructor(x: number, y: number);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): PtsArcMid;
    getString(): string;
}
declare class PtsArcEnd extends SxClass {
    x: number;
    y: number;
    static token: string;
    static parentToken: string;
    token: string;
    constructor(x: number, y: number);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): PtsArcEnd;
    getString(): string;
}

type AtInput = At | [x: number, y: number, angle?: number] | {
    x: number;
    y: number;
    angle?: number;
};
declare class At extends SxClass {
    static token: string;
    token: string;
    constructor(args: [x: number, y: number, angle?: number], opts?: {
        isTextSymbol?: boolean;
    });
    x: number;
    y: number;
    angle?: number;
    static from(input: AtInput, opts?: {
        isTextSymbol?: boolean;
    }): At;
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): At;
    getString(): string;
}

declare abstract class SxPrimitiveString extends SxClass {
    value: string;
    constructor(v: string);
    set(value: string): void;
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): SxPrimitiveString;
    getString(): string;
}

type TextEffectsProperty = TextEffectsFont | TextEffectsJustify;
interface TextEffectsConstructorParams {
    font?: TextEffectsFont;
    justify?: TextEffectsJustify;
    hiddenText?: boolean;
}
declare class TextEffects extends SxClass {
    static token: string;
    token: string;
    _sxFont?: TextEffectsFont;
    _sxJustify?: TextEffectsJustify;
    private _hiddenText;
    constructor(params?: TextEffectsConstructorParams);
    get font(): TextEffectsFont;
    set font(value: TextEffectsFont | undefined);
    get justify(): TextEffectsJustify | undefined;
    set justify(value: TextEffectsJustify | undefined);
    get hiddenText(): boolean;
    set hiddenText(value: boolean);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): TextEffects;
    getChildren(): SxClass[];
    getString(): string;
}
type TextEffectsFontProperty = TextEffectsFontFace | TextEffectsFontSize | Color | TextEffectsFontThickness | TextEffectsFontLineSpacing | TextEffectsFontBold | TextEffectsFontItalic;
declare class TextEffectsFont extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    _sxFace?: TextEffectsFontFace;
    _sxSize?: TextEffectsFontSize;
    _sxColor?: Color;
    _sxThickness?: TextEffectsFontThickness;
    _sxLineSpacing?: TextEffectsFontLineSpacing;
    _sxBold?: TextEffectsFontBold;
    _sxItalic?: TextEffectsFontItalic;
    get face(): string | undefined;
    set face(value: string | undefined);
    get size(): {
        height: number;
        width: number;
    } | undefined;
    set size(value: TextEffectsFontSize | {
        height: number;
        width: number;
    } | undefined);
    get color(): RGBAColor | undefined;
    set color(value: RGBAColor | undefined);
    get thickness(): number | undefined;
    set thickness(value: number | undefined);
    get lineSpacing(): number | undefined;
    set lineSpacing(value: number | undefined);
    get bold(): boolean;
    set bold(value: boolean);
    get italic(): boolean;
    set italic(value: boolean);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): TextEffectsFont;
    getChildren(): SxClass[];
    getString(): string;
}
declare class TextEffectsFontFace extends SxPrimitiveString {
    static token: string;
    static parentToken: string;
    token: string;
    getString(): string;
}
declare class TextEffectsFontSize extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _height;
    private _width;
    constructor(height?: number, width?: number);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): TextEffectsFontSize;
    get height(): number;
    set height(value: number);
    get width(): number;
    set width(value: number);
    getString(): string;
}
declare class TextEffectsFontThickness extends SxPrimitiveNumber {
    static token: string;
    static parentToken: string;
    token: string;
}
declare class TextEffectsFontBold extends SxPrimitiveBoolean {
    static token: string;
    static parentToken: string;
    token: string;
    constructor(value?: boolean);
    getString(): string;
}
declare class TextEffectsFontItalic extends SxPrimitiveBoolean {
    static token: string;
    static parentToken: string;
    token: string;
    constructor(value?: boolean);
    getString(): string;
}
declare class TextEffectsFontLineSpacing extends SxPrimitiveNumber {
    static token: string;
    static parentToken: string;
    token: string;
}
declare class TextEffectsJustify extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _horizontal?;
    private _vertical?;
    private _mirror;
    constructor(options?: {
        horizontal?: "left" | "right";
        vertical?: "top" | "bottom";
        mirror?: boolean;
    });
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): TextEffectsJustify;
    get horizontal(): "left" | "right" | undefined;
    set horizontal(value: "left" | "right" | undefined);
    get vertical(): "top" | "bottom" | undefined;
    set vertical(value: "top" | "bottom" | undefined);
    get mirror(): boolean;
    set mirror(value: boolean);
    getString(): string;
}

declare class Uuid extends SxPrimitiveString {
    static token: string;
    token: string;
}

interface TitleBlockConstructorParams {
    title?: string;
    date?: string;
    rev?: string;
    company?: string;
    comments?: TitleBlockComment[];
}
declare class TitleBlock extends SxClass {
    static token: string;
    token: string;
    private _sxTitle?;
    private _sxDate?;
    private _sxRev?;
    private _sxCompany?;
    comments: TitleBlockComment[];
    constructor(params?: TitleBlockConstructorParams);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): TitleBlock;
    get title(): string | undefined;
    set title(value: string | undefined);
    get date(): string | undefined;
    set date(value: string | undefined);
    get rev(): string | undefined;
    set rev(value: string | undefined);
    get company(): string | undefined;
    set company(value: string | undefined);
    getComment(index: number): string | undefined;
    setComment(index: number, value: string): void;
    removeComment(index: number): void;
    getChildren(): SxClass[];
    getString(): string;
}
declare abstract class TitleBlockStringValue extends SxClass {
    value: string;
    constructor(value: string);
    getChildren(): SxClass[];
}
declare class TitleBlockTitle extends TitleBlockStringValue {
    static token: string;
    static parentToken: string;
    token: string;
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): TitleBlockTitle;
    getString(): string;
}
declare class TitleBlockDate extends TitleBlockStringValue {
    static token: string;
    static parentToken: string;
    token: string;
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): TitleBlockDate;
    getString(): string;
}
declare class TitleBlockRevision extends TitleBlockStringValue {
    static token: string;
    static parentToken: string;
    token: string;
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): TitleBlockRevision;
    getString(): string;
}
declare class TitleBlockCompany extends TitleBlockStringValue {
    static token: string;
    static parentToken: string;
    token: string;
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): TitleBlockCompany;
    getString(): string;
}
declare class TitleBlockComment extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    index: number;
    value: string;
    private _sxAt?;
    private _sxEffects?;
    private _sxUuid?;
    constructor(index: number, value: string);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): TitleBlockComment;
    get at(): At | undefined;
    set at(value: At | undefined);
    get effects(): TextEffects | undefined;
    set effects(value: TextEffects | undefined);
    get uuid(): Uuid | undefined;
    set uuid(value: Uuid | undefined);
    getChildren(): SxClass[];
    getString(): string;
}

type StandardPaperSize = "A0" | "A1" | "A2" | "A3" | "A4" | "A5" | "A" | "B" | "C" | "D" | "E";
declare class Paper extends SxClass {
    static token: string;
    token: string;
    private _size?;
    private _width?;
    private _height?;
    private _portrait;
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): Paper;
    get size(): string | undefined;
    set size(value: string | undefined);
    get customSize(): {
        width: number;
        height: number;
    } | undefined;
    set customSize(size: {
        width: number;
        height: number;
    } | undefined);
    get isPortrait(): boolean;
    set isPortrait(value: boolean);
    getString(): string;
}

declare class Layer extends SxClass {
    static token: string;
    token: string;
    private _names;
    constructor(names?: Array<string | number>);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): Layer;
    get names(): string[];
    set names(values: Array<string | number>);
    addName(name: string | number): void;
    getString(): string;
}

interface ImageConstructorParams {
    position?: AtInput | Xy;
    scale?: ImageScale | number;
    layer?: Layer | string | string[];
    uuid?: Uuid | string;
    data?: ImageData | string | string[];
}
declare class Image extends SxClass {
    static token: string;
    token: string;
    private _sxPosition?;
    private _sxScale?;
    private _sxLayer?;
    private _sxUuid?;
    private _sxData?;
    constructor(params?: ImageConstructorParams);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): Image;
    get position(): At | Xy | undefined;
    set position(value: AtInput | Xy | undefined);
    get scale(): ImageScale | undefined;
    set scale(value: ImageScale | number | undefined);
    get layer(): Layer | undefined;
    set layer(value: Layer | string | string[] | undefined);
    get uuid(): Uuid | undefined;
    set uuid(value: Uuid | string | undefined);
    get data(): ImageData | undefined;
    set data(value: ImageData | string | string[] | undefined);
    getChildren(): SxClass[];
}
declare class ImageScale extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    value: number;
    constructor(value: number);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): ImageScale;
    getChildren(): SxClass[];
    getString(): string;
}
declare class ImageData extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _chunks;
    constructor(chunks?: string[]);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): ImageData;
    static fromStrings(values: string[]): ImageData;
    get chunks(): string[];
    set chunks(values: string[]);
    get value(): string;
    set value(data: string);
    getChildren(): SxClass[];
    getString(): string;
}

type RenderCacheElement = RenderCachePolygon;
declare class RenderCache extends SxClass {
    static token: string;
    token: string;
    private _text;
    private _angle?;
    private _offsetX?;
    private _offsetY?;
    private _elements;
    constructor(text?: string);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): RenderCache;
    get text(): string;
    set text(value: string);
    get angle(): number | undefined;
    set angle(value: number | undefined);
    get offsetX(): number | undefined;
    set offsetX(value: number | undefined);
    get offsetY(): number | undefined;
    set offsetY(value: number | undefined);
    get elements(): RenderCacheElement[];
    set elements(elements: RenderCacheElement[]);
    addElement(element: RenderCacheElement): void;
    getChildren(): SxClass[];
    getString(): string;
}
declare class RenderCachePolygon extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _contours;
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): RenderCachePolygon;
    get contours(): Pts[];
    set contours(value: Pts[]);
    getChildren(): SxClass[];
}

declare class Tstamp extends SxPrimitiveString {
    static token: string;
    token: string;
}

declare class KicadSchGenerator extends SxPrimitiveString {
    static token: string;
    static parentToken: string;
    token: string;
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): KicadSchGenerator;
    getString(): string;
}

declare class KicadSchVersion extends SxPrimitiveNumber {
    static token: string;
    static parentToken: string;
    token: string;
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): KicadSchVersion;
}

declare class KicadSchGeneratorVersion extends SxPrimitiveString {
    static token: string;
    static parentToken: string;
    token: string;
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): KicadSchGeneratorVersion;
    getString(): string;
}

declare class KicadSymbolLibGenerator extends SxPrimitiveString {
    static token: string;
    static parentToken: string;
    token: string;
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): KicadSymbolLibGenerator;
    getString(): string;
}

declare class KicadSymbolLibGeneratorVersion extends SxPrimitiveString {
    static token: string;
    static parentToken: string;
    token: string;
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): KicadSymbolLibGeneratorVersion;
    getString(): string;
}

declare class KicadSymbolLibVersion extends SxPrimitiveNumber {
    static token: string;
    static parentToken: string;
    token: string;
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): KicadSymbolLibVersion;
}

declare class Dnp extends SxPrimitiveBoolean {
    static token: string;
    token: string;
}

declare class EmbeddedFonts extends SxClass {
    static token: string;
    token: string;
    private _enabled;
    constructor(enabled?: boolean);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): EmbeddedFonts;
    get enabled(): boolean;
    set enabled(value: boolean);
    getChildren(): SxClass[];
    getString(): string;
}

declare class ExcludeFromSim extends SxPrimitiveBoolean {
    static token: string;
    token: string;
}

declare class FieldsAutoplaced extends SxPrimitiveBoolean {
    static token: string;
    token: string;
}

declare class PropertyDoNotAutoplace extends SxPrimitiveBoolean {
    static token: string;
    static parentToken: string;
    token: string;
}

declare class PropertyHide extends SxPrimitiveBoolean {
    static token: string;
    static parentToken: string;
    token: string;
}

declare class PropertyShowName extends SxPrimitiveBoolean {
    static token: string;
    static parentToken: string;
    token: string;
}

declare class SymbolBodyStyle extends SxPrimitiveNumber {
    static token: string;
    static parentToken: string;
    token: string;
}

declare class SymbolBodyStyles extends SxPrimitiveString {
    static token: string;
    static parentToken: string;
    token: string;
}

declare class SymbolLibName extends SxPrimitiveString {
    static token: string;
    static parentToken: string;
    token: string;
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): SymbolLibName;
    getString(): string;
}

declare class SymbolTextBox extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _text;
    private _sxExcludeFromSim?;
    private _sxAt?;
    private _sxSize?;
    private _sxStroke?;
    private _sxFill?;
    private _sxEffects?;
    private _sxUuid?;
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): SymbolTextBox;
    get text(): string;
    set text(value: string);
    getChildren(): SxClass[];
    getString(): string;
}

interface SymbolPolylineFillLike extends SxClass {
    type?: string;
}
interface PolylineConstructorParams {
    points?: Pts;
    stroke?: Stroke;
    uuid?: string | Uuid;
    fill?: SymbolPolylineFillLike;
}
/**
 * Base Polyline class that can be used in both kicad_sch and symbol contexts.
 * - When parent is "kicad_sch": supports pts, stroke, uuid
 * - When parent is "symbol": supports pts, stroke, fill
 */
declare class Polyline extends SxClass {
    static token: string;
    token: string;
    private _sxPts?;
    private _sxStroke?;
    private _sxUuid?;
    private _sxFill?;
    constructor(params?: PolylineConstructorParams);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): Polyline;
    get points(): Pts | undefined;
    set points(value: Pts | undefined);
    get stroke(): Stroke | undefined;
    set stroke(value: Stroke | undefined);
    get uuid(): Uuid | undefined;
    set uuid(value: Uuid | string | undefined);
    get fill(): SymbolPolylineFillLike | undefined;
    set fill(value: SymbolPolylineFillLike | undefined);
    getChildren(): SxClass[];
}
declare class SchematicPolyline extends Polyline {
    static parentToken: string;
}
declare class SymbolPolyline extends Polyline {
    static parentToken: string;
}

declare class SymbolUnit extends SxPrimitiveNumber {
    static token: string;
    static parentToken: string;
    token: string;
    static from(value: number | SymbolUnit): SymbolUnit;
}
declare class SymbolLibId extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    value: string;
    constructor(value: string);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): SymbolLibId;
    getChildren(): SxClass[];
    getString(): string;
}
declare class SymbolDuplicatePinNumbersAreJumpers extends SxPrimitiveBoolean {
    static token: string;
    static parentToken: string;
    token: string;
}
declare class Mirror extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    value: string;
    constructor(value: string);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): Mirror;
    getChildren(): SxClass[];
    getString(): string;
}
declare class SymbolPinNumbers extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _sxHide?;
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): SymbolPinNumbers;
    get hide(): boolean;
    set hide(value: boolean);
    getChildren(): SxClass[];
}
declare class SymbolPinNumbersHide extends SxPrimitiveBoolean {
    static token: string;
    static parentToken: string;
    token: string;
    private inline;
    constructor(value?: boolean, options?: {
        inline?: boolean;
    });
    getString(): string;
}
declare class SymbolPinNames extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _sxOffset?;
    private _sxHide?;
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): SymbolPinNames;
    get offset(): number | undefined;
    set offset(value: number | undefined);
    get hide(): boolean;
    set hide(value: boolean);
    getChildren(): SxClass[];
}
declare class SymbolPinNamesOffset extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    value: number;
    constructor(value: number);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): SymbolPinNamesOffset;
    getChildren(): SxClass[];
    getString(): string;
}
declare class SymbolPinNamesHide extends SxPrimitiveBoolean {
    static token: string;
    static parentToken: string;
    token: string;
}
declare abstract class SymbolPointBase extends SxClass {
    protected _x: number;
    protected _y: number;
    constructor(x: number, y: number);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): SymbolPointBase;
    get x(): number;
    set x(value: number);
    get y(): number;
    set y(value: number);
    toObject(): {
        x: number;
        y: number;
    };
    getChildren(): SxClass[];
    getString(): string;
}
declare class SymbolRectangleStart extends SymbolPointBase {
    static token: string;
    static parentToken: string;
    token: string;
}
declare class SymbolRectangleEnd extends SymbolPointBase {
    static token: string;
    static parentToken: string;
    token: string;
}
declare class SymbolArcStart extends SymbolPointBase {
    static token: string;
    static parentToken: string;
    token: string;
}
declare class SymbolArcMid extends SymbolPointBase {
    static token: string;
    static parentToken: string;
    token: string;
}
declare class SymbolArcEnd extends SymbolPointBase {
    static token: string;
    static parentToken: string;
    token: string;
}
declare class SymbolCircleCenter extends SymbolPointBase {
    static token: string;
    static parentToken: string;
    token: string;
}
declare class SymbolCircleRadius extends SxPrimitiveNumber {
    static token: string;
    static parentToken: string;
    token: string;
}
declare abstract class SymbolFillBase extends SxClass {
    protected _sxType?: SymbolFillType;
    protected _sxColor?: Color;
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): SymbolFillBase;
    get type(): string | undefined;
    set type(value: string | undefined);
    getChildren(): SxClass[];
}
declare class SymbolPolylineFill extends SymbolFillBase {
    static token: string;
    static parentToken: string;
    token: string;
}
declare class SymbolRectangleFill extends SymbolFillBase {
    static token: string;
    static parentToken: string;
    token: string;
}
declare class SymbolCircleFill extends SymbolFillBase {
    static token: string;
    static parentToken: string;
    token: string;
}
declare class SymbolArcFill extends SymbolFillBase {
    static token: string;
    static parentToken: string;
    token: string;
}
declare class SymbolFillType extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    value: string;
    constructor(value: string);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): SymbolFillType;
    getChildren(): SxClass[];
    getString(): string;
}
declare class SymbolRectangle extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _sxStart?;
    private _sxEnd?;
    private _sxStroke?;
    private _sxFill?;
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): SymbolRectangle;
    getChildren(): SxClass[];
}
declare class SymbolCircle extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _sxCenter?;
    private _sxRadius?;
    private _sxStroke?;
    private _sxFill?;
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): SymbolCircle;
    getChildren(): SxClass[];
}
declare class SymbolArc extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _sxStart?;
    private _sxMid?;
    private _sxEnd?;
    private _sxStroke?;
    private _sxFill?;
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): SymbolArc;
    getChildren(): SxClass[];
}
declare class SymbolText extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _value;
    private _sxAt?;
    private _sxEffects?;
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): SymbolText;
    get value(): string;
    set value(newValue: string);
    get at(): At | undefined;
    set at(value: AtInput | undefined);
    get effects(): TextEffects | undefined;
    set effects(value: TextEffects | undefined);
    getChildren(): SxClass[];
    getString(): string;
}
declare class SymbolPower extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    value?: string;
    constructor(value?: string);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): SymbolPower;
    getChildren(): SxClass[];
    getString(): string;
}
interface SchematicSymbolConstructorParams {
    libraryId?: string;
    libraryName?: string | SymbolLibName;
    at?: AtInput;
    mirror?: string | Mirror;
    unit?: number | SymbolUnit;
    bodyStyle?: number | SymbolBodyStyle;
    bodyStyles?: string | SymbolBodyStyles;
    pinNumbers?: SymbolPinNumbers;
    pinNames?: SymbolPinNames;
    excludeFromSim?: boolean;
    inBom?: boolean;
    onBoard?: boolean;
    inPosFiles?: boolean;
    dnp?: boolean;
    uuid?: string;
    duplicatePinNumbersAreJumpers?: boolean;
    fieldsAutoplaced?: boolean;
    properties?: SymbolProperty[];
    pins?: SymbolPin[];
    subSymbols?: SchematicSymbol[];
    polylines?: SymbolPolyline[];
    rectangles?: SymbolRectangle[];
    circles?: SymbolCircle[];
    arcs?: SymbolArc[];
    texts?: SymbolText[];
    textBoxes?: SymbolTextBox[];
    embeddedFonts?: EmbeddedFonts;
    instances?: SymbolInstances;
}
declare class SchematicSymbol extends SxClass {
    static token: string;
    token: string;
    private _sxLibName?;
    private _sxLibId?;
    _sxAt?: At;
    _sxMirror?: Mirror;
    _sxUnit?: SymbolUnit;
    _sxBodyStyle?: SymbolBodyStyle;
    _sxBodyStyles?: SymbolBodyStyles;
    _sxPinNumbers?: SymbolPinNumbers;
    _sxPinNames?: SymbolPinNames;
    _sxExcludeFromSim?: ExcludeFromSim;
    _sxInBom?: InBom;
    _sxOnBoard?: OnBoard;
    _sxInPosFiles?: InPosFiles;
    _sxDnp?: Dnp;
    _sxUuid?: Uuid;
    _sxDuplicatePinNumbersAreJumpers?: SymbolDuplicatePinNumbersAreJumpers;
    _sxFieldsAutoplaced?: FieldsAutoplaced;
    properties: SymbolProperty[];
    pins: SymbolPin[];
    subSymbols: SchematicSymbol[];
    polylines: SymbolPolyline[];
    rectangles: SymbolRectangle[];
    circles: SymbolCircle[];
    arcs: SymbolArc[];
    texts: SymbolText[];
    textBoxes: SymbolTextBox[];
    _sxPower?: SymbolPower;
    _sxEmbeddedFonts?: EmbeddedFonts;
    _sxInstances?: SymbolInstances;
    private _inlineLibId?;
    constructor(params?: SchematicSymbolConstructorParams);
    get libraryId(): string | undefined;
    set libraryId(value: string | SymbolLibId | undefined);
    get libraryName(): string | undefined;
    set libraryName(value: string | SymbolLibName | undefined);
    get at(): At | undefined;
    set at(value: AtInput | undefined);
    get mirror(): string | undefined;
    set mirror(value: string | Mirror | undefined);
    get unit(): number | undefined;
    set unit(value: number | undefined);
    get bodyStyle(): number | undefined;
    set bodyStyle(value: number | SymbolBodyStyle | undefined);
    get bodyStyles(): string | undefined;
    set bodyStyles(value: string | SymbolBodyStyles | undefined);
    get pinNumbers(): SymbolPinNumbers | undefined;
    set pinNumbers(value: SymbolPinNumbers | undefined);
    get pinNames(): SymbolPinNames | undefined;
    set pinNames(value: SymbolPinNames | undefined);
    get inBom(): boolean | undefined;
    set inBom(value: boolean | undefined);
    get excludeFromSim(): boolean;
    set excludeFromSim(value: boolean);
    get onBoard(): boolean | undefined;
    set onBoard(value: boolean | undefined);
    get inPosFiles(): boolean | undefined;
    set inPosFiles(value: boolean | undefined);
    get dnp(): boolean;
    set dnp(value: boolean);
    get fieldsAutoplaced(): boolean;
    set fieldsAutoplaced(value: boolean);
    get uuid(): string | undefined;
    set uuid(value: string | undefined);
    get duplicatePinNumbersAreJumpers(): boolean;
    set duplicatePinNumbersAreJumpers(value: boolean | undefined);
    get instances(): SymbolInstances | undefined;
    set instances(value: SymbolInstances | undefined);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): SchematicSymbol;
    getChildren(): SxClass[];
    getString(): string;
}
declare class SymbolPropertyId extends SxPrimitiveNumber {
    static token: string;
    static parentToken: string;
    token: string;
    static from(value: number | SymbolPropertyId): SymbolPropertyId;
}
declare class SymbolProperty extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    key: string;
    value: string;
    _sxId?: SymbolPropertyId;
    _sxAt?: At;
    _sxShowName?: PropertyShowName;
    _sxDoNotAutoplace?: PropertyDoNotAutoplace;
    _sxHide?: PropertyHide;
    _sxEffects?: TextEffects;
    constructor(params: {
        key: string;
        value: string;
        id?: number | SymbolPropertyId;
        at?: AtInput;
        showName?: boolean | PropertyShowName;
        doNotAutoplace?: boolean | PropertyDoNotAutoplace;
        hidden?: boolean | PropertyHide;
        effects?: TextEffects;
    });
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): SymbolProperty;
    get id(): number | undefined;
    set id(value: number | undefined);
    get at(): At | undefined;
    set at(value: AtInput | undefined);
    get showName(): boolean | undefined;
    set showName(value: boolean | undefined);
    get doNotAutoplace(): boolean | undefined;
    set doNotAutoplace(value: boolean | undefined);
    get hidden(): boolean;
    set hidden(value: boolean);
    get effects(): TextEffects | undefined;
    set effects(value: TextEffects | undefined);
    getChildren(): SxClass[];
    getString(): string;
}
type PinElectricalType = "input" | "output" | "bidirectional" | "tri_state" | "passive" | "free" | "unspecified" | "power_in" | "power_out" | "open_collector" | "open_emitter" | "no_connect";
type PinGraphicStyle = "line" | "inverted" | "clock" | "inverted_clock" | "input_low" | "clock_low" | "output_low" | "edge_clock_high" | "non_logic";
declare class SymbolPinLength extends SxPrimitiveNumber {
    static token: string;
    static parentToken: string;
    token: string;
}
declare class SymbolPinName extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    value: string;
    _sxEffects?: TextEffects;
    constructor(params: {
        value: string;
        effects?: TextEffects;
    });
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): SymbolPinName;
    get effects(): TextEffects | undefined;
    set effects(value: TextEffects | undefined);
    getChildren(): SxClass[];
    getString(): string;
}
declare class SymbolPinNumber extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    value: string;
    _sxEffects?: TextEffects;
    constructor(params: {
        value: string;
        effects?: TextEffects;
    });
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): SymbolPinNumber;
    get effects(): TextEffects | undefined;
    set effects(value: TextEffects | undefined);
    getChildren(): SxClass[];
    getString(): string;
}
interface SymbolPinAlternateConstructorParams {
    alternateName: string;
    pinElectricalType: PinElectricalType;
    pinGraphicStyle: PinGraphicStyle;
}
declare class SymbolPinAlternate extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    alternateName: string;
    pinElectricalType: PinElectricalType;
    pinGraphicStyle: PinGraphicStyle;
    constructor(params: SymbolPinAlternateConstructorParams);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): SymbolPinAlternate;
    getChildren(): SxClass[];
    getString(): string;
}
declare class SymbolPin extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    pinElectricalType?: PinElectricalType;
    pinGraphicStyle?: PinGraphicStyle;
    _sxAt?: At;
    _sxLength?: SymbolPinLength;
    _sxName?: SymbolPinName;
    _sxNumber?: SymbolPinNumber;
    _sxUuid?: Uuid;
    private inlineNumber?;
    private _sxHide?;
    private _alternates;
    static fromSexprPrimitives(args: PrimitiveSExpr[]): SymbolPin;
    get at(): At | undefined;
    set at(value: AtInput | undefined);
    get length(): number | undefined;
    set length(value: number | undefined);
    get name(): string | undefined;
    set name(value: string | undefined);
    get numberString(): string | undefined;
    set numberString(value: string | undefined);
    get uuid(): string | undefined;
    set uuid(value: string | undefined);
    get hidden(): boolean;
    set hidden(value: boolean);
    get alternates(): SymbolPinAlternate[];
    set alternates(value: SymbolPinAlternate[]);
    getChildren(): SxClass[];
    getString(): string;
}
declare class SymbolInstances extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    projects: SymbolInstancesProject[];
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): SymbolInstances;
    getChildren(): SxClass[];
    getString(): string;
}
declare class SymbolInstancesProject extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    name: string;
    paths: SymbolInstancePath[];
    constructor(name: string);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): SymbolInstancesProject;
    getChildren(): SxClass[];
    getString(): string;
}
declare class SymbolInstancePath extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    value: string;
    _sxReference?: SymbolInstanceReference;
    _sxUnit?: SymbolInstanceUnit;
    constructor(value: string);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): SymbolInstancePath;
    get reference(): string | undefined;
    set reference(value: string | undefined);
    get unit(): number | undefined;
    set unit(value: number | undefined);
    getChildren(): SxClass[];
    getString(): string;
}
declare class SymbolInstanceReference extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    value: string;
    constructor(value: string);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): SymbolInstanceReference;
    getString(): string;
}
declare class SymbolInstanceUnit extends SxPrimitiveNumber {
    static token: string;
    static parentToken: string;
    token: string;
}

interface KicadSymbolLibConstructorParams {
    version?: number | KicadSymbolLibVersion;
    generator?: string | KicadSymbolLibGenerator;
    generatorVersion?: string | KicadSymbolLibGeneratorVersion;
    symbols?: SchematicSymbol[];
}
declare class KicadSymbolLib extends SxClass {
    static token: string;
    token: string;
    private _sxVersion?;
    private _sxGenerator?;
    private _sxGeneratorVersion?;
    private _symbols;
    constructor(params?: KicadSymbolLibConstructorParams);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): KicadSymbolLib;
    get version(): number | undefined;
    set version(value: number | undefined);
    get generator(): string | undefined;
    set generator(value: string | undefined);
    get generatorVersion(): string | undefined;
    set generatorVersion(value: string | undefined);
    get symbols(): SchematicSymbol[];
    set symbols(value: SchematicSymbol[]);
    getChildren(): SxClass[];
}
declare const KicadSym: typeof KicadSymbolLib;
type KicadSym = KicadSymbolLib;

declare class LibSymbols extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _symbols;
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): LibSymbols;
    get symbols(): SchematicSymbol[];
    set symbols(value: SchematicSymbol[]);
    getChildren(): SxClass[];
}

interface WireConstructorParams {
    points?: Pts;
    stroke?: Stroke;
    uuid?: string | Uuid;
}
declare class Wire extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _sxPts?;
    private _sxStroke?;
    private _sxUuid?;
    constructor(params?: WireConstructorParams);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): Wire;
    get points(): Pts | undefined;
    set points(value: Pts | undefined);
    get stroke(): Stroke | undefined;
    set stroke(value: Stroke | undefined);
    get uuid(): Uuid | undefined;
    set uuid(value: Uuid | string | undefined);
    getChildren(): SxClass[];
}

interface BusConstructorParams {
    points?: Pts;
    stroke?: Stroke;
    uuid?: string | Uuid;
}
declare class Bus extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _sxPts?;
    private _sxStroke?;
    private _sxUuid?;
    constructor(params?: BusConstructorParams);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): Bus;
    get points(): Pts | undefined;
    set points(value: Pts | undefined);
    get stroke(): Stroke | undefined;
    set stroke(value: Stroke | undefined);
    get uuid(): Uuid | undefined;
    set uuid(value: Uuid | string | undefined);
    getChildren(): SxClass[];
}

interface JunctionConstructorParams {
    at?: AtInput;
    diameter?: number | JunctionDiameter;
    color?: Color;
    uuid?: string | Uuid;
}
declare class Junction extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _sxAt?;
    private _sxDiameter?;
    private _sxColor?;
    private _sxUuid?;
    constructor(params?: JunctionConstructorParams);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): Junction;
    get at(): At | undefined;
    set at(value: AtInput | undefined);
    get diameter(): number | undefined;
    set diameter(value: number | undefined);
    get color(): Color | undefined;
    set color(value: Color | undefined);
    get uuid(): Uuid | undefined;
    set uuid(value: Uuid | string | undefined);
    getChildren(): SxClass[];
}
declare class JunctionDiameter extends SxPrimitiveNumber {
    static token: string;
    static parentToken: string;
    token: string;
}

interface NoConnectConstructorParams {
    at?: AtInput;
    uuid?: string | Uuid;
}
declare class NoConnect extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _sxAt?;
    private _sxUuid?;
    constructor(params?: NoConnectConstructorParams);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): NoConnect;
    get at(): At | undefined;
    set at(value: AtInput | undefined);
    get uuid(): Uuid | undefined;
    set uuid(value: Uuid | string | undefined);
    getChildren(): SxClass[];
}

interface SchematicArcPoint {
    x: number;
    y: number;
}
interface SchematicArcConstructorParams {
    start?: SymbolArcStart | SchematicArcPoint;
    mid?: SymbolArcMid | SchematicArcPoint;
    end?: SymbolArcEnd | SchematicArcPoint;
    stroke?: Stroke;
    fill?: SymbolArcFill;
    uuid?: string | Uuid;
    locked?: boolean;
}
declare class SchematicArcLocked extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    value: boolean;
    constructor(value: boolean);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): SchematicArcLocked;
    getChildren(): SxClass[];
    getString(): string;
}
declare class SchematicArc extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _sxStart?;
    private _sxMid?;
    private _sxEnd?;
    private _sxStroke?;
    private _sxFill?;
    private _sxUuid?;
    private _sxLocked?;
    constructor(params?: SchematicArcConstructorParams);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): SchematicArc;
    get start(): SymbolArcStart | undefined;
    set start(value: SymbolArcStart | SchematicArcPoint | undefined);
    get mid(): SymbolArcMid | undefined;
    set mid(value: SymbolArcMid | SchematicArcPoint | undefined);
    get end(): SymbolArcEnd | undefined;
    set end(value: SymbolArcEnd | SchematicArcPoint | undefined);
    get stroke(): Stroke | undefined;
    set stroke(value: Stroke | undefined);
    get fill(): SymbolArcFill | undefined;
    set fill(value: SymbolArcFill | undefined);
    get uuid(): Uuid | undefined;
    set uuid(value: Uuid | string | undefined);
    get locked(): boolean;
    set locked(value: boolean);
    getChildren(): SxClass[];
}

interface BusEntryConstructorParams {
    at?: AtInput;
    size?: BusEntrySize | {
        x: number;
        y: number;
    };
    stroke?: Stroke;
    uuid?: string | Uuid;
}
declare class BusEntry extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _sxAt?;
    private _sxSize?;
    private _sxStroke?;
    private _sxUuid?;
    constructor(params?: BusEntryConstructorParams);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): BusEntry;
    get at(): At | undefined;
    set at(value: AtInput | undefined);
    get size(): {
        x: number;
        y: number;
    } | undefined;
    set size(value: BusEntrySize | {
        x: number;
        y: number;
    } | undefined);
    get stroke(): Stroke | undefined;
    set stroke(value: Stroke | undefined);
    get uuid(): Uuid | undefined;
    set uuid(value: Uuid | string | undefined);
    getChildren(): SxClass[];
}
declare class BusEntrySize extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _x;
    private _y;
    constructor(x: number, y: number);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): BusEntrySize;
    toObject(): {
        x: number;
        y: number;
    };
    getChildren(): SxClass[];
    getString(): string;
}

interface LabelConstructorParams {
    value?: string;
    at?: AtInput;
    effects?: TextEffects;
    uuid?: string | Uuid;
    fieldsAutoplaced?: boolean | FieldsAutoplaced;
}
declare class Label extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _value;
    private _sxAt?;
    private _sxEffects?;
    private _sxUuid?;
    private _sxFieldsAutoplaced?;
    constructor(params?: LabelConstructorParams);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): Label;
    get value(): string;
    set value(newValue: string);
    get at(): At | undefined;
    set at(value: AtInput | undefined);
    get effects(): TextEffects | undefined;
    set effects(value: TextEffects | undefined);
    get uuid(): Uuid | undefined;
    set uuid(value: Uuid | string | undefined);
    get fieldsAutoplaced(): boolean;
    set fieldsAutoplaced(value: boolean);
    getChildren(): SxClass[];
    getString(): string;
}

declare class PropertyUnlocked extends SxPrimitiveBoolean {
    static token: string;
    static parentToken: string;
    token: string;
}

interface PropertyConstructorParams {
    key?: string;
    value?: string;
    position?: AtInput | Xy;
    layer?: Layer | Array<string | number> | string;
    uuid?: string | Uuid;
    effects?: TextEffects;
    unlocked?: boolean | PropertyUnlocked;
    hidden?: boolean | PropertyHide;
}
declare class Property extends SxClass {
    static token: string;
    token: string;
    private _key;
    private _value;
    private _sxAt?;
    private _sxXy?;
    private _sxLayer?;
    private _sxUuid?;
    private _sxEffects?;
    private _sxUnlocked?;
    private _sxHide?;
    constructor(keyOrParams?: string | PropertyConstructorParams, value?: string);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): Property;
    get key(): string;
    set key(value: string);
    get value(): string;
    set value(value: string);
    get position(): At | Xy | undefined;
    set position(value: AtInput | Xy | undefined);
    get layer(): Layer | undefined;
    set layer(value: Layer | Array<string | number> | string | undefined);
    get uuid(): Uuid | undefined;
    set uuid(value: Uuid | string | undefined);
    get effects(): TextEffects | undefined;
    set effects(value: TextEffects | undefined);
    get unlocked(): boolean;
    set unlocked(value: boolean);
    get hidden(): boolean;
    set hidden(value: boolean);
    getChildren(): SxClass[];
    getString(): string;
}

type GlobalLabelShape = "input" | "output" | "bidirectional" | "tri_state" | "passive";
interface GlobalLabelConstructorParams {
    value?: string;
    shape?: GlobalLabelShape;
    at?: AtInput;
    effects?: TextEffects;
    uuid?: string | Uuid;
    fieldsAutoplaced?: boolean | FieldsAutoplaced;
    properties?: Property[];
}
declare class GlobalLabel extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _value;
    private _shape;
    private _sxAt?;
    private _sxEffects?;
    private _sxUuid?;
    private _sxFieldsAutoplaced?;
    private _properties;
    constructor(params?: GlobalLabelConstructorParams);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): GlobalLabel;
    get value(): string;
    set value(newValue: string);
    get shape(): GlobalLabelShape;
    set shape(value: GlobalLabelShape);
    get at(): At | undefined;
    set at(value: AtInput | undefined);
    get effects(): TextEffects | undefined;
    set effects(value: TextEffects | undefined);
    get uuid(): Uuid | undefined;
    set uuid(value: Uuid | string | undefined);
    get fieldsAutoplaced(): boolean;
    set fieldsAutoplaced(value: boolean);
    get properties(): Property[];
    set properties(value: Property[]);
    getChildren(): SxClass[];
    getString(): string;
}

interface SchematicTextConstructorParams {
    value?: string;
    excludeFromSim?: boolean | ExcludeFromSim;
    at?: AtInput;
    effects?: TextEffects;
    uuid?: string | Uuid;
}
declare class SchematicText extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _value;
    private _sxExcludeFromSim?;
    private _sxAt?;
    private _sxEffects?;
    private _sxUuid?;
    constructor(params?: SchematicTextConstructorParams);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): SchematicText;
    get value(): string;
    set value(newValue: string);
    get excludeFromSim(): boolean;
    set excludeFromSim(value: boolean);
    get at(): At | undefined;
    set at(value: AtInput | undefined);
    get effects(): TextEffects | undefined;
    set effects(value: TextEffects | undefined);
    get uuid(): Uuid | undefined;
    set uuid(value: Uuid | string | undefined);
    getChildren(): SxClass[];
    getString(): string;
}

declare class SchematicTextBox extends SymbolTextBox {
    static token: string;
    static parentToken: string;
    token: string;
}

interface SchematicRectanglePoint {
    x: number;
    y: number;
}
interface SchematicRectangleConstructorParams {
    start?: SymbolRectangleStart | SchematicRectanglePoint;
    end?: SymbolRectangleEnd | SchematicRectanglePoint;
    stroke?: Stroke;
    fill?: SymbolRectangleFill;
    uuid?: string | Uuid;
}
declare class SchematicRectangle extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _sxStart?;
    private _sxEnd?;
    private _sxStroke?;
    private _sxFill?;
    private _sxUuid?;
    constructor(params?: SchematicRectangleConstructorParams);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): SchematicRectangle;
    get start(): SymbolRectangleStart | undefined;
    set start(value: SymbolRectangleStart | SchematicRectanglePoint | undefined);
    get end(): SymbolRectangleEnd | undefined;
    set end(value: SymbolRectangleEnd | SchematicRectanglePoint | undefined);
    get stroke(): Stroke | undefined;
    set stroke(value: Stroke | undefined);
    get fill(): SymbolRectangleFill | undefined;
    set fill(value: SymbolRectangleFill | undefined);
    get uuid(): Uuid | undefined;
    set uuid(value: Uuid | string | undefined);
    getChildren(): SxClass[];
}

declare class SheetInstancesRoot extends SxClass {
    static token: string;
    token: string;
    private _paths;
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): SheetInstancesRoot;
    get paths(): SheetInstancesRootPath[];
    set paths(value: SheetInstancesRootPath[]);
    getChildren(): SxClass[];
}
declare class SheetInstancesRootPath extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _value;
    private _pages;
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): SheetInstancesRootPath;
    get value(): string;
    set value(newValue: string);
    get pages(): SheetInstancesRootPage[];
    set pages(value: SheetInstancesRootPage[]);
    getChildren(): SxClass[];
    getString(): string;
}
declare class SheetInstancesRootPage extends SxPrimitiveString {
    static token: string;
    static parentToken: string;
    token: string;
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): SheetInstancesRootPage;
    getString(): string;
}

declare class SheetInstances extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _projects;
    private _paths;
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): SheetInstances;
    get projects(): SheetInstancesProject[];
    set projects(value: SheetInstancesProject[]);
    get paths(): SheetInstancesRootPath[];
    set paths(value: SheetInstancesRootPath[]);
    getChildren(): SxClass[];
    getString(): string;
}
declare class SheetInstancesForSheet extends SheetInstances {
    static token: string;
    static parentToken: string;
    token: string;
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): SheetInstancesForSheet;
}
declare class SheetInstancesProject extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    name: string;
    paths: SheetInstancePath[];
    constructor(name: string);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): SheetInstancesProject;
    getChildren(): SxClass[];
    getString(): string;
}
declare class SheetInstancePath extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    value: string;
    pages: SheetInstancePage[];
    constructor(value: string);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): SheetInstancePath;
    getChildren(): SxClass[];
    getString(): string;
}
declare class SheetInstancePage extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    value: string;
    constructor(value: string);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): SheetInstancePage;
    getString(): string;
}

type SheetPinElectricalType = "input" | "output" | "bidirectional" | "tri_state" | "passive";
declare class SheetPin extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    name: string;
    electricalType: SheetPinElectricalType;
    private _sxAt?;
    private _sxEffects?;
    private _sxUuid?;
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): SheetPin;
    get position(): At | undefined;
    set position(value: At | undefined);
    get effects(): TextEffects | undefined;
    set effects(value: TextEffects | undefined);
    get uuid(): Uuid | undefined;
    set uuid(value: Uuid | string | undefined);
    getChildren(): SxClass[];
    getString(): string;
}

declare class SheetFill extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _sxColor?;
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): SheetFill;
    get color(): Color | undefined;
    set color(value: Color | undefined);
    getChildren(): SxClass[];
}

declare class SheetSize extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    width: number;
    height: number;
    constructor(width: number, height: number);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): SheetSize;
    toObject(): {
        width: number;
        height: number;
    };
    getString(): string;
}

declare class SheetProperty extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    key: string;
    value: string;
    private _sxId?;
    private _sxAt?;
    private _sxShowName?;
    private _sxDoNotAutoplace?;
    private _sxEffects?;
    constructor(params: {
        key: string;
        value: string;
        id?: number | SymbolPropertyId;
        at?: At;
        showName?: boolean | PropertyShowName;
        doNotAutoplace?: boolean | PropertyDoNotAutoplace;
        effects?: TextEffects;
    });
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): SheetProperty;
    get id(): number | undefined;
    set id(value: number | SymbolPropertyId | undefined);
    get idClass(): SymbolPropertyId | undefined;
    get at(): At | undefined;
    set at(value: At | undefined);
    get showName(): boolean | undefined;
    set showName(value: boolean | PropertyShowName | undefined);
    get doNotAutoplace(): boolean | undefined;
    set doNotAutoplace(value: boolean | PropertyDoNotAutoplace | undefined);
    get effects(): TextEffects | undefined;
    set effects(value: TextEffects | undefined);
    getChildren(): SxClass[];
    getString(): string;
}

interface SheetConstructorParams {
    position?: AtInput;
    size?: SheetSize | {
        width: number;
        height: number;
    };
    excludeFromSim?: boolean | ExcludeFromSim;
    inBom?: boolean | InBom;
    onBoard?: boolean | OnBoard;
    dnp?: boolean | Dnp;
    fieldsAutoplaced?: boolean | FieldsAutoplaced;
    stroke?: Stroke;
    fill?: SheetFill;
    uuid?: string | Uuid;
    properties?: SheetProperty[];
    pins?: SheetPin[];
    instances?: SheetInstances;
}
declare class Sheet extends SxClass {
    static token: string;
    token: string;
    private _sxAt?;
    private _sxSize?;
    private _sxExcludeFromSim?;
    private _sxInBom?;
    private _sxOnBoard?;
    private _sxDnp?;
    private _sxFieldsAutoplaced?;
    private _sxStroke?;
    private _sxFill?;
    private _sxUuid?;
    private _properties;
    private _pins;
    private _sxInstances?;
    constructor(params?: SheetConstructorParams);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): Sheet;
    get position(): At | undefined;
    set position(value: AtInput | undefined);
    get size(): {
        width: number;
        height: number;
    } | undefined;
    set size(value: SheetSize | {
        width: number;
        height: number;
    } | undefined);
    get excludeFromSim(): boolean;
    set excludeFromSim(value: boolean);
    get inBom(): boolean;
    set inBom(value: boolean);
    get onBoard(): boolean;
    set onBoard(value: boolean);
    get dnp(): boolean;
    set dnp(value: boolean);
    get fieldsAutoplaced(): boolean;
    set fieldsAutoplaced(value: boolean);
    get stroke(): Stroke | undefined;
    set stroke(value: Stroke | undefined);
    get fill(): SheetFill | undefined;
    set fill(value: SheetFill | undefined);
    get uuid(): Uuid | undefined;
    set uuid(value: Uuid | string | undefined);
    get properties(): SheetProperty[];
    set properties(value: SheetProperty[]);
    get pins(): SheetPin[];
    set pins(value: SheetPin[]);
    get instances(): SheetInstances | undefined;
    set instances(value: SheetInstances | undefined);
    getChildren(): SxClass[];
}

interface KicadSchConstructorParams {
    version?: number | KicadSchVersion;
    generator?: string | KicadSchGenerator;
    generatorVersion?: string | KicadSchGeneratorVersion;
    uuid?: string | Uuid;
    paper?: Paper;
    titleBlock?: TitleBlock;
    libSymbols?: LibSymbols;
    sheetInstances?: SheetInstances | SheetInstances[];
    embeddedFonts?: EmbeddedFonts;
    properties?: Property[];
    images?: Image[];
    sheets?: Sheet[];
    symbols?: SchematicSymbol[];
    texts?: SchematicText[];
    labels?: Label[];
    globalLabels?: GlobalLabel[];
    wires?: Wire[];
    junctions?: Junction[];
    noConnects?: NoConnect[];
    arcs?: SchematicArc[];
    polylines?: Polyline[];
    rectangles?: SchematicRectangle[];
    textBoxes?: SchematicTextBox[];
}
declare class KicadSch extends SxClass {
    static token: string;
    token: string;
    private _sxVersion?;
    private _sxGenerator?;
    private _sxGeneratorVersion?;
    private _sxUuid?;
    private _sxPaper?;
    private _sxTitleBlock?;
    private _sxLibSymbols?;
    private _sheetInstances;
    private _sxEmbeddedFonts?;
    private _properties;
    private _images;
    private _sheets;
    private _symbols;
    private _texts;
    private _labels;
    private _globalLabels;
    private _wires;
    private _junctions;
    private _noConnects;
    private _arcs;
    private _polylines;
    private _rectangles;
    private _textBoxes;
    constructor(params?: KicadSchConstructorParams);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): KicadSch;
    get version(): number | undefined;
    set version(value: number | undefined);
    get generator(): string | undefined;
    set generator(value: string | undefined);
    get generatorVersion(): string | undefined;
    set generatorVersion(value: string | undefined);
    get uuid(): Uuid | undefined;
    set uuid(value: Uuid | string | undefined);
    get paper(): Paper | undefined;
    set paper(value: Paper | undefined);
    get titleBlock(): TitleBlock | undefined;
    set titleBlock(value: TitleBlock | undefined);
    get libSymbols(): LibSymbols | undefined;
    set libSymbols(value: LibSymbols | undefined);
    get sheetInstances(): SheetInstances[];
    set sheetInstances(value: SheetInstances | SheetInstances[] | undefined);
    get embeddedFonts(): EmbeddedFonts | undefined;
    set embeddedFonts(value: EmbeddedFonts | undefined);
    get properties(): Property[];
    set properties(value: Property[]);
    get images(): Image[];
    set images(value: Image[]);
    get sheets(): Sheet[];
    set sheets(value: Sheet[]);
    get symbols(): SchematicSymbol[];
    set symbols(value: SchematicSymbol[]);
    get texts(): SchematicText[];
    set texts(value: SchematicText[]);
    get labels(): Label[];
    set labels(value: Label[]);
    get globalLabels(): GlobalLabel[];
    set globalLabels(value: GlobalLabel[]);
    get junctions(): Junction[];
    set junctions(value: Junction[]);
    get wires(): Wire[];
    set wires(value: Wire[]);
    get noConnects(): NoConnect[];
    set noConnects(value: NoConnect[]);
    get arcs(): SchematicArc[];
    set arcs(value: SchematicArc[]);
    get polylines(): Polyline[];
    set polylines(value: Polyline[]);
    get rectangles(): SchematicRectangle[];
    set rectangles(value: SchematicRectangle[]);
    get textBoxes(): SchematicTextBox[];
    set textBoxes(value: SchematicTextBox[]);
    getChildren(): SxClass[];
}

declare class FootprintAttr extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _type?;
    private _boardOnly;
    private _excludeFromPosFiles;
    private _excludeFromBom;
    private _allowMissingCourtyard;
    private _allowSoldermaskBridges;
    private _dnp;
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): FootprintAttr;
    private applyFlag;
    get type(): string | undefined;
    set type(value: string | undefined);
    get boardOnly(): boolean;
    set boardOnly(value: boolean);
    get excludeFromPosFiles(): boolean;
    set excludeFromPosFiles(value: boolean);
    get excludeFromBom(): boolean;
    set excludeFromBom(value: boolean);
    get allowSoldermaskBridges(): boolean;
    set allowSoldermaskBridges(value: boolean);
    get allowMissingCourtyard(): boolean;
    set allowMissingCourtyard(value: boolean);
    get dnp(): boolean;
    set dnp(value: boolean);
    getChildren(): SxClass[];
    getString(): string;
}

declare class FootprintVersion extends SxPrimitiveNumber {
    static token: string;
    static parentToken: string;
    token: string;
}

declare class FootprintGenerator extends SxPrimitiveString {
    static token: string;
    static parentToken: string;
    token: string;
    getString(): string;
}

declare class FootprintGeneratorVersion extends SxPrimitiveString {
    static token: string;
    static parentToken: string;
    token: string;
    getString(): string;
}

declare class FootprintAutoplaceCost180 extends SxPrimitiveNumber {
    static token: string;
    static parentToken: string;
    token: string;
}

declare class FootprintAutoplaceCost90 extends SxPrimitiveNumber {
    static token: string;
    static parentToken: string;
    token: string;
}

declare class FootprintClearance extends SxPrimitiveNumber {
    static token: string;
    static parentToken: string;
    token: string;
}

declare class FootprintDescr extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _value;
    constructor(value: string);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): FootprintDescr;
    get value(): string;
    set value(value: string);
    getChildren(): SxClass[];
    getString(): string;
}

declare class FootprintNetTiePadGroups extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _groups;
    constructor(groups: string[]);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): FootprintNetTiePadGroups;
    get groups(): string[];
    set groups(values: string[]);
    getChildren(): SxClass[];
    getString(): string;
}

declare class FootprintPath extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _value;
    constructor(value: string);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): FootprintPath;
    get value(): string;
    set value(value: string);
    getChildren(): SxClass[];
    getString(): string;
}

declare class FootprintPrivateLayers extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _layers;
    constructor(layers: string[]);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): FootprintPrivateLayers;
    get layers(): string[];
    set layers(values: string[]);
    getChildren(): SxClass[];
    getString(): string;
}

declare class FootprintSolderMaskMargin extends SxPrimitiveNumber {
    static token: string;
    static parentToken: string;
    token: string;
}

declare class FootprintSolderPasteMargin extends SxPrimitiveNumber {
    static token: string;
    static parentToken: string;
    token: string;
}

declare class FootprintSolderPasteRatio extends SxPrimitiveNumber {
    static token: string;
    static parentToken: string;
    token: string;
}

declare class FootprintSolderPasteMarginRatio extends FootprintSolderPasteRatio {
    static token: string;
    static parentToken: string;
    token: string;
}

declare class FootprintTags extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _value;
    constructor(value: string);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): FootprintTags;
    get value(): string;
    set value(value: string);
    getChildren(): SxClass[];
    getString(): string;
}

declare class FootprintTedit extends SxPrimitiveString {
    static token: string;
    static parentToken: string;
    token: string;
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): FootprintTedit;
}

declare class FootprintThermalGap extends SxPrimitiveNumber {
    static token: string;
    static parentToken: string;
    token: string;
}

declare class FootprintThermalWidth extends SxPrimitiveNumber {
    static token: string;
    static parentToken: string;
    token: string;
}

declare class FootprintZoneConnect extends SxPrimitiveNumber {
    static token: string;
    static parentToken: string;
    token: string;
}

declare class PadChamfer extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _corners;
    constructor(corners: string[]);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): PadChamfer;
    get corners(): string[];
    set corners(values: string[]);
    getChildren(): SxClass[];
    getString(): string;
}

declare class PadChamferRatio extends SxPrimitiveNumber {
    static token: string;
    static parentToken: string;
    token: string;
}

declare class PadClearance extends SxPrimitiveNumber {
    static token: string;
    static parentToken: string;
    token: string;
}

declare class PadDieLength extends SxPrimitiveNumber {
    static token: string;
    static parentToken: string;
    token: string;
}

declare class PadDrillOffset extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _x;
    private _y;
    constructor(x: number, y: number);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): PadDrillOffset;
    get x(): number;
    set x(value: number);
    get y(): number;
    set y(value: number);
    getChildren(): SxClass[];
    getString(): string;
}

declare class PadDrill extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _oval;
    private _diameter;
    private _width?;
    private _sxOffset?;
    constructor({ oval, diameter, width, offset, }: {
        oval?: boolean;
        diameter: number;
        width?: number;
        offset?: PadDrillOffset | {
            x: number;
            y: number;
        };
    });
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): PadDrill;
    get oval(): boolean;
    set oval(value: boolean);
    get diameter(): number;
    set diameter(value: number);
    get width(): number | undefined;
    set width(value: number | undefined);
    get offset(): PadDrillOffset | undefined;
    set offset(value: PadDrillOffset | {
        x: number;
        y: number;
    } | undefined);
    getChildren(): SxClass[];
    getString(): string;
}

type PadLayersInput = PadLayers | string[];
declare class PadLayers extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _layers;
    constructor(layers: string[]);
    static from(input: PadLayersInput): PadLayers;
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): PadLayers;
    get layers(): string[];
    set layers(values: string[]);
    getChildren(): SxClass[];
    getString(): string;
}

declare class PadNet extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _id?;
    private _name?;
    constructor(idOrName: number | string, name?: string);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): PadNet;
    get id(): number | undefined;
    set id(value: number | undefined);
    get name(): string | undefined;
    set name(value: string | undefined);
    getChildren(): SxClass[];
    getString(): string;
}

type PadOptionsClearanceType = "outline" | "convexhull";
type PadOptionsAnchorShape = "rect" | "circle";
declare class PadOptions extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _sxClearance?;
    private _sxAnchor?;
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): PadOptions;
    get clearance(): PadOptionsClearanceType | undefined;
    set clearance(value: PadOptionsClearanceType | undefined);
    get anchor(): PadOptionsAnchorShape | undefined;
    set anchor(value: PadOptionsAnchorShape | undefined);
    getChildren(): SxClass[];
}

declare class PadPinFunction extends SxPrimitiveString {
    static token: string;
    static parentToken: string;
    token: string;
}

declare class PadPinType extends SxPrimitiveString {
    static token: string;
    static parentToken: string;
    token: string;
}

declare class GrLineEnd extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _x;
    private _y;
    constructor(x: number, y: number);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): GrLineEnd;
    get x(): number;
    set x(value: number);
    get y(): number;
    set y(value: number);
    toObject(): {
        x: number;
        y: number;
    };
    getChildren(): SxClass[];
    getString(): string;
}

declare class GrLineStart extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _x;
    private _y;
    constructor(x: number, y: number);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): GrLineStart;
    get x(): number;
    set x(value: number);
    get y(): number;
    set y(value: number);
    toObject(): {
        x: number;
        y: number;
    };
    getChildren(): SxClass[];
    getString(): string;
}

declare class PadPrimitiveGrLine extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _sxStart?;
    private _sxEnd?;
    private _sxWidth?;
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): PadPrimitiveGrLine;
    get start(): GrLineStart | undefined;
    set start(value: GrLineStart | {
        x: number;
        y: number;
    } | undefined);
    get end(): GrLineEnd | undefined;
    set end(value: GrLineEnd | {
        x: number;
        y: number;
    } | undefined);
    get width(): number | undefined;
    set width(value: Width | number | undefined);
    get widthClass(): Width | undefined;
    getChildren(): SxClass[];
    getString(): string;
}

interface PadPrimitiveGrArcConstructorParams {
    start?: PadPrimitiveGrArcStart | {
        x: number;
        y: number;
    };
    mid?: PadPrimitiveGrArcMid | {
        x: number;
        y: number;
    };
    end?: PadPrimitiveGrArcEnd | {
        x: number;
        y: number;
    };
    width?: Width | number;
}
declare class PadPrimitiveGrArc extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _sxStart?;
    private _sxMid?;
    private _sxEnd?;
    private _sxWidth?;
    constructor(params?: PadPrimitiveGrArcConstructorParams);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): PadPrimitiveGrArc;
    get start(): PadPrimitiveGrArcStart | undefined;
    set start(value: PadPrimitiveGrArcStart | {
        x: number;
        y: number;
    } | undefined);
    get mid(): PadPrimitiveGrArcMid | undefined;
    set mid(value: PadPrimitiveGrArcMid | {
        x: number;
        y: number;
    } | undefined);
    get end(): PadPrimitiveGrArcEnd | undefined;
    set end(value: PadPrimitiveGrArcEnd | {
        x: number;
        y: number;
    } | undefined);
    get width(): number | undefined;
    set width(value: Width | number | undefined);
    get widthClass(): Width | undefined;
    getChildren(): SxClass[];
    getString(): string;
}
declare abstract class PadPrimitiveGrArcPoint extends SxClass {
    protected _x: number;
    protected _y: number;
    protected constructor(x: number, y: number);
    get x(): number;
    set x(value: number);
    get y(): number;
    set y(value: number);
    getChildren(): SxClass[];
    getString(): string;
}
declare class PadPrimitiveGrArcStart extends PadPrimitiveGrArcPoint {
    static token: string;
    static parentToken: string;
    token: string;
    constructor(x: number, y: number);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): PadPrimitiveGrArcStart;
}
declare class PadPrimitiveGrArcMid extends PadPrimitiveGrArcPoint {
    static token: string;
    static parentToken: string;
    token: string;
    constructor(x: number, y: number);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): PadPrimitiveGrArcMid;
}
declare class PadPrimitiveGrArcEnd extends PadPrimitiveGrArcPoint {
    static token: string;
    static parentToken: string;
    token: string;
    constructor(x: number, y: number);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): PadPrimitiveGrArcEnd;
}

interface PadPrimitiveGrCircleConstructorParams {
    center?: PadPrimitiveGrCircleCenter | {
        x: number;
        y: number;
    };
    end?: PadPrimitiveGrCircleEnd | {
        x: number;
        y: number;
    };
    width?: Width | number;
    fill?: PadPrimitiveGrCircleFill | boolean;
}
declare class PadPrimitiveGrCircle extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _sxCenter?;
    private _sxEnd?;
    private _sxWidth?;
    private _sxFill?;
    constructor(params?: PadPrimitiveGrCircleConstructorParams);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): PadPrimitiveGrCircle;
    get center(): PadPrimitiveGrCircleCenter | undefined;
    set center(value: PadPrimitiveGrCircleCenter | {
        x: number;
        y: number;
    } | undefined);
    get end(): PadPrimitiveGrCircleEnd | undefined;
    set end(value: PadPrimitiveGrCircleEnd | {
        x: number;
        y: number;
    } | undefined);
    get width(): number | undefined;
    set width(value: Width | number | undefined);
    get widthClass(): Width | undefined;
    get fill(): boolean | undefined;
    set fill(value: PadPrimitiveGrCircleFill | boolean | undefined);
    get fillClass(): PadPrimitiveGrCircleFill | undefined;
    getChildren(): SxClass[];
    getString(): string;
}
declare abstract class PadPrimitiveGrCirclePoint extends SxClass {
    protected _x: number;
    protected _y: number;
    protected constructor(x: number, y: number);
    get x(): number;
    set x(value: number);
    get y(): number;
    set y(value: number);
    getChildren(): SxClass[];
    getString(): string;
}
declare class PadPrimitiveGrCircleCenter extends PadPrimitiveGrCirclePoint {
    static token: string;
    static parentToken: string;
    token: string;
    constructor(x: number, y: number);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): PadPrimitiveGrCircleCenter;
}
declare class PadPrimitiveGrCircleEnd extends PadPrimitiveGrCirclePoint {
    static token: string;
    static parentToken: string;
    token: string;
    constructor(x: number, y: number);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): PadPrimitiveGrCircleEnd;
}
declare class PadPrimitiveGrCircleFill extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    value: string;
    constructor(value?: boolean | string);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): PadPrimitiveGrCircleFill;
    get filled(): boolean;
    set filled(value: boolean);
    getString(): string;
}

type PadPrimitiveGraphic = PadPrimitiveGrPoly | PadPrimitiveGrLine | PadPrimitiveGrArc | PadPrimitiveGrCircle;
declare class PadPrimitives extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _graphics;
    private _sxWidth?;
    private _sxFill?;
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): PadPrimitives;
    get graphics(): PadPrimitiveGraphic[];
    set graphics(value: PadPrimitiveGraphic[]);
    addGraphic(graphic: PadPrimitiveGraphic): void;
    get width(): number | undefined;
    set width(value: number | undefined);
    get fill(): boolean | undefined;
    set fill(value: boolean | undefined);
    getChildren(): SxClass[];
}
declare class PadPrimitiveGrPoly extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _contours;
    private _sxWidth?;
    private _sxFill?;
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): PadPrimitiveGrPoly;
    get contours(): Pts[];
    set contours(value: Pts[]);
    get width(): number | undefined;
    set width(value: number | undefined);
    get filled(): boolean | undefined;
    set filled(value: boolean | undefined);
    getChildren(): SxClass[];
}

declare class PadRoundrectRratio extends SxPrimitiveNumber {
    static token: string;
    static parentToken: string;
    token: string;
}

type PadSizeInput = PadSize | [width: number, height: number] | {
    width: number;
    height: number;
};
declare class PadSize extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _width;
    private _height;
    constructor(width: number, height: number);
    static from(input: PadSizeInput): PadSize;
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): PadSize;
    get width(): number;
    set width(value: number);
    get height(): number;
    set height(value: number);
    getChildren(): SxClass[];
    getString(): string;
}

declare class PadSolderMaskMargin extends SxPrimitiveNumber {
    static token: string;
    static parentToken: string;
    token: string;
}

declare class PadSolderPasteMargin extends SxPrimitiveNumber {
    static token: string;
    static parentToken: string;
    token: string;
}

declare class PadSolderPasteMarginRatio extends SxPrimitiveNumber {
    static token: string;
    static parentToken: string;
    token: string;
}

declare class PadThermalGap extends SxPrimitiveNumber {
    static token: string;
    static parentToken: string;
    token: string;
}

declare class PadThermalWidth extends SxPrimitiveNumber {
    static token: string;
    static parentToken: string;
    token: string;
}

declare class PadThermalBridgeAngle extends SxPrimitiveNumber {
    static token: string;
    static parentToken: string;
    token: string;
}

declare class PadZoneConnect extends SxPrimitiveNumber {
    static token: string;
    static parentToken: string;
    token: string;
}

declare class PadZoneLayerConnections extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    static fromSexprPrimitives(): PadZoneLayerConnections;
    getChildren(): SxClass[];
}

declare class PadProperty extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _value;
    constructor(value: string);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): PadProperty;
    get value(): string;
    set value(value: string);
    getChildren(): SxClass[];
    getString(): string;
}

declare class PadTeardrops extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _bestLengthRatio?;
    private _maxLength?;
    private _bestWidthRatio?;
    private _maxWidth?;
    private _filterRatio?;
    private _curvePoints?;
    private _curvedEdges?;
    private _enabled?;
    private _allowTwoSegments?;
    private _preferZoneConnections?;
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): PadTeardrops;
    get bestLengthRatio(): number | undefined;
    set bestLengthRatio(value: number | undefined);
    get maxLength(): number | undefined;
    set maxLength(value: number | undefined);
    get bestWidthRatio(): number | undefined;
    set bestWidthRatio(value: number | undefined);
    get maxWidth(): number | undefined;
    set maxWidth(value: number | undefined);
    get filterRatio(): number | undefined;
    set filterRatio(value: number | undefined);
    get curvePoints(): number | undefined;
    set curvePoints(value: number | undefined);
    get curvedEdges(): boolean | undefined;
    set curvedEdges(value: boolean | undefined);
    get enabled(): boolean | undefined;
    set enabled(value: boolean | undefined);
    get allowTwoSegments(): boolean | undefined;
    set allowTwoSegments(value: boolean | undefined);
    get preferZoneConnections(): boolean | undefined;
    set preferZoneConnections(value: boolean | undefined);
    getChildren(): SxClass[];
    getString(): string;
}

declare class PadRectDelta extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _x;
    private _y;
    constructor(x?: number, y?: number);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): PadRectDelta;
    get x(): number;
    set x(value: number);
    get y(): number;
    set y(value: number);
    getChildren(): SxClass[];
    getString(): string;
}

interface FootprintPadConstructorParams {
    number?: string;
    padType?: string;
    shape?: string;
    locked?: boolean;
    removeUnusedLayers?: boolean;
    keepEndLayers?: boolean;
    at?: AtInput;
    size?: PadSizeInput;
    drill?: PadDrill;
    layers?: PadLayersInput;
    width?: Width | number;
    stroke?: Stroke;
    properties?: PadProperty[];
    roundrectRatio?: number | PadRoundrectRratio;
    chamferRatio?: number | PadChamferRatio;
    chamfer?: PadChamfer;
    rectDelta?: PadRectDelta;
    net?: PadNet;
    tstamp?: Tstamp | string;
    uuid?: Uuid | string;
    pinFunction?: string | PadPinFunction;
    pinType?: string | PadPinType;
    dieLength?: number | PadDieLength;
    solderMaskMargin?: number | PadSolderMaskMargin;
    solderPasteMargin?: number | PadSolderPasteMargin;
    solderPasteMarginRatio?: number | PadSolderPasteMarginRatio;
    clearance?: number | PadClearance;
    zoneConnect?: number | PadZoneConnect;
    zoneLayerConnections?: PadZoneLayerConnections;
    thermalWidth?: number | PadThermalWidth;
    thermalGap?: number | PadThermalGap;
    thermalBridgeAngle?: number | PadThermalBridgeAngle;
    options?: PadOptions;
    primitives?: PadPrimitives;
    teardrops?: PadTeardrops;
}
declare class FootprintPad extends SxClass {
    static token: string;
    token: string;
    private _number;
    private _padType;
    private _shape;
    private _locked;
    private _sxRemoveUnusedLayers?;
    private _sxKeepEndLayers?;
    private _sxAt?;
    private _sxSize?;
    private _sxDrill?;
    private _sxLayers?;
    private _sxWidth?;
    private _sxStroke?;
    private _properties;
    private _sxRoundrectRatio?;
    private _sxChamferRatio?;
    private _sxChamfer?;
    private _sxRectDelta?;
    private _sxNet?;
    private _sxTstamp?;
    private _sxUuid?;
    private _sxPinFunction?;
    private _sxPinType?;
    private _sxDieLength?;
    private _sxSolderMaskMargin?;
    private _sxSolderPasteMargin?;
    private _sxSolderPasteMarginRatio?;
    private _sxClearance?;
    private _sxZoneConnect?;
    private _sxZoneLayerConnections?;
    private _sxThermalWidth?;
    private _sxThermalGap?;
    private _sxThermalBridgeAngle?;
    private _sxOptions?;
    private _sxPrimitives?;
    private _sxTeardrops?;
    constructor(params?: FootprintPadConstructorParams | string, padType?: string, shape?: string);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): FootprintPad;
    get number(): string;
    set number(value: string);
    get padType(): string;
    set padType(value: string);
    get shape(): string;
    set shape(value: string);
    get locked(): boolean;
    set locked(value: boolean);
    get removeUnusedLayer(): boolean;
    set removeUnusedLayer(value: boolean);
    get keepEndLayers(): boolean;
    set keepEndLayers(value: boolean);
    get at(): At | undefined;
    set at(value: AtInput | undefined);
    get size(): PadSize | undefined;
    set size(value: PadSizeInput | undefined);
    get drill(): PadDrill | undefined;
    set drill(value: PadDrill | undefined);
    get layers(): PadLayers | undefined;
    set layers(value: PadLayersInput | undefined);
    get width(): Width | undefined;
    set width(value: number | Width | undefined);
    get stroke(): Stroke | undefined;
    set stroke(value: Stroke | undefined);
    get properties(): PadProperty[];
    set properties(value: PadProperty[]);
    get roundrectRatio(): number | undefined;
    set roundrectRatio(value: number | PadRoundrectRratio | undefined);
    get chamferRatio(): number | undefined;
    set chamferRatio(value: number | PadChamferRatio | undefined);
    get chamfer(): PadChamfer | undefined;
    set chamfer(value: PadChamfer | undefined);
    get chamferCorners(): string[] | undefined;
    get rectDelta(): PadRectDelta | undefined;
    set rectDelta(value: PadRectDelta | {
        x: number;
        y: number;
    } | undefined);
    get net(): PadNet | undefined;
    set net(value: PadNet | undefined);
    get tstamp(): Tstamp | undefined;
    set tstamp(value: Tstamp | string | undefined);
    get uuid(): Uuid | undefined;
    set uuid(value: Uuid | string | undefined);
    get pinfunction(): string | undefined;
    set pinfunction(value: string | PadPinFunction | undefined);
    get pintype(): string | undefined;
    set pintype(value: string | PadPinType | undefined);
    get dieLength(): number | undefined;
    set dieLength(value: number | PadDieLength | undefined);
    get solderMaskMargin(): number | undefined;
    set solderMaskMargin(value: number | PadSolderMaskMargin | undefined);
    get solderPasteMargin(): number | undefined;
    set solderPasteMargin(value: number | PadSolderPasteMargin | undefined);
    get solderPasteMarginRatio(): number | undefined;
    set solderPasteMarginRatio(value: number | PadSolderPasteMarginRatio | undefined);
    get clearance(): number | undefined;
    set clearance(value: number | PadClearance | undefined);
    get zoneConnect(): number | undefined;
    set zoneConnect(value: number | PadZoneConnect | undefined);
    get thermalWidth(): number | undefined;
    set thermalWidth(value: number | PadThermalWidth | undefined);
    get thermalGap(): number | undefined;
    set thermalGap(value: number | PadThermalGap | undefined);
    get thermalBridgeAngle(): number | undefined;
    set thermalBridgeAngle(value: number | PadThermalBridgeAngle | undefined);
    get options(): PadOptions | undefined;
    set options(value: PadOptions | undefined);
    get primitives(): PadPrimitives | undefined;
    set primitives(value: PadPrimitives | undefined);
    get teardrops(): PadTeardrops | undefined;
    set teardrops(value: PadTeardrops | undefined);
    get zoneLayerConnections(): PadZoneLayerConnections | undefined;
    set zoneLayerConnections(value: PadZoneLayerConnections | undefined);
    getChildren(): SxClass[];
    getString(): string;
}

type FpTextType = "reference" | "value" | "user" | string;
interface FpTextConstructorParams {
    type?: FpTextType;
    text?: string;
    position?: AtInput | Xy;
    locked?: boolean;
    unlocked?: boolean;
    hidden?: boolean;
    layer?: Layer | string | string[];
    effects?: TextEffects;
    tstamp?: Tstamp | string;
    uuid?: Uuid | string;
}
declare class FpText extends SxClass {
    static token: string;
    token: string;
    private _type?;
    private _text;
    private _sxPosition?;
    private _sxLocked?;
    private _sxUnlocked?;
    private _sxHide?;
    private _sxLayer?;
    private _sxEffects?;
    private _sxTstamp?;
    private _sxUuid?;
    constructor(params?: FpTextConstructorParams);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): FpText;
    get type(): FpTextType | undefined;
    set type(value: FpTextType | undefined);
    get text(): string;
    set text(value: string);
    get position(): At | Xy | undefined;
    set position(value: AtInput | Xy | undefined);
    get locked(): boolean;
    set locked(value: boolean);
    get unlocked(): boolean;
    set unlocked(value: boolean);
    get hidden(): boolean;
    set hidden(value: boolean);
    get layer(): Layer | undefined;
    set layer(value: Layer | string | string[] | undefined);
    get effects(): TextEffects | undefined;
    set effects(value: TextEffects | undefined);
    get tstamp(): Tstamp | undefined;
    set tstamp(value: Tstamp | string | undefined);
    get uuid(): Uuid | undefined;
    set uuid(value: Uuid | string | undefined);
    getChildren(): SxClass[];
    getString(): string;
}

interface FpTextBoxConstructorParams {
    locked?: boolean;
    text?: string;
    start?: FpTextBoxStart | {
        x: number;
        y: number;
    };
    end?: FpTextBoxEnd | {
        x: number;
        y: number;
    };
    pts?: Pts;
    angle?: FpTextBoxAngle | number;
    layer?: Layer | string | string[];
    uuid?: Uuid | string;
    effects?: TextEffects;
    stroke?: Stroke;
    renderCache?: RenderCache;
}
declare class FpTextBox extends SxClass {
    static token: string;
    token: string;
    private _sxLocked?;
    private _text;
    private _sxStart?;
    private _sxEnd?;
    private _sxPts?;
    private _sxAngle?;
    private _sxLayer?;
    private _sxUuid?;
    private _sxEffects?;
    private _sxStroke?;
    private _sxRenderCache?;
    constructor(params?: FpTextBoxConstructorParams);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): FpTextBox;
    get locked(): boolean;
    set locked(value: boolean);
    get text(): string;
    set text(value: string);
    get start(): FpTextBoxStart | undefined;
    set start(value: FpTextBoxStart | {
        x: number;
        y: number;
    } | undefined);
    get end(): FpTextBoxEnd | undefined;
    set end(value: FpTextBoxEnd | {
        x: number;
        y: number;
    } | undefined);
    get pts(): Pts | undefined;
    set pts(value: Pts | undefined);
    get angle(): FpTextBoxAngle | undefined;
    set angle(value: FpTextBoxAngle | number | undefined);
    get layer(): Layer | undefined;
    set layer(value: Layer | string | string[] | undefined);
    get effects(): TextEffects | undefined;
    set effects(value: TextEffects | undefined);
    get stroke(): Stroke | undefined;
    set stroke(value: Stroke | undefined);
    get uuid(): Uuid | undefined;
    set uuid(value: Uuid | string | undefined);
    get renderCache(): RenderCache | undefined;
    set renderCache(value: RenderCache | undefined);
    getChildren(): SxClass[];
    getString(): string;
}
declare class FpTextBoxStart extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    x: number;
    y: number;
    constructor(args: [number, number]);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): FpTextBoxStart;
    getChildren(): SxClass[];
    getString(): string;
}
declare class FpTextBoxEnd extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    x: number;
    y: number;
    constructor(args: [number, number]);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): FpTextBoxEnd;
    getChildren(): SxClass[];
    getString(): string;
}
declare class FpTextBoxAngle extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    value: number;
    constructor(args: [number]);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): FpTextBoxAngle;
    getChildren(): SxClass[];
    getString(): string;
}

declare class FpRectNet extends SxClass {
    id: number;
    static token: string;
    static parentToken: string;
    token: string;
    constructor(id: number);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): FpRectNet;
    getChildren(): SxClass[];
    getString(): string;
}

interface FpRectConstructorParams {
    start?: FpRectStart | {
        x: number;
        y: number;
    };
    end?: FpRectEnd | {
        x: number;
        y: number;
    };
    layer?: Layer | string | string[];
    width?: number | Width;
    stroke?: Stroke;
    fill?: boolean | FpRectFill;
    net?: FpRectNet | number;
    uuid?: string | Uuid;
    locked?: boolean;
}
declare class FpRect extends SxClass {
    static token: string;
    token: string;
    private _sxStart?;
    private _sxEnd?;
    private _sxLayer?;
    private _sxWidth?;
    private _sxStroke?;
    private _sxFill?;
    private _sxNet?;
    private _sxUuid?;
    private _locked;
    constructor(params?: FpRectConstructorParams);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): FpRect;
    get start(): FpRectStart | undefined;
    set start(value: FpRectStart | {
        x: number;
        y: number;
    } | undefined);
    get end(): FpRectEnd | undefined;
    set end(value: FpRectEnd | {
        x: number;
        y: number;
    } | undefined);
    get layer(): Layer | undefined;
    set layer(value: Layer | string | string[] | undefined);
    get stroke(): Stroke | undefined;
    set stroke(value: Stroke | undefined);
    get width(): number | undefined;
    set width(value: number | Width | undefined);
    get widthClass(): Width | undefined;
    get fill(): boolean | undefined;
    set fill(value: boolean | FpRectFill | undefined);
    get fillClass(): FpRectFill | undefined;
    get net(): FpRectNet | undefined;
    set net(value: FpRectNet | number | undefined);
    get uuid(): string | undefined;
    set uuid(value: string | Uuid | undefined);
    get uuidClass(): Uuid | undefined;
    get locked(): boolean;
    set locked(value: boolean);
    getChildren(): SxClass[];
    getString(): string;
}
declare class FpRectStart extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    x: number;
    y: number;
    constructor(x: number, y: number);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): FpRectStart;
    getString(): string;
}
declare class FpRectEnd extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    x: number;
    y: number;
    constructor(x: number, y: number);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): FpRectEnd;
    getString(): string;
}
declare class FpRectFill extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    filled: boolean;
    constructor(filled: boolean);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): FpRectFill;
    getString(): string;
}

declare class FpCircleNet extends SxClass {
    id: number;
    static token: string;
    static parentToken: string;
    token: string;
    constructor(id: number);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): FpCircleNet;
    getChildren(): SxClass[];
    getString(): string;
}

interface FpCircleConstructorParams {
    center?: FpCircleCenter | {
        x: number;
        y: number;
    };
    end?: FpCircleEnd | {
        x: number;
        y: number;
    };
    layer?: Layer | string | string[];
    width?: number | Width;
    stroke?: Stroke;
    fill?: boolean | FpCircleFill;
    net?: FpCircleNet | number;
    uuid?: string | Uuid;
    locked?: boolean;
}
declare class FpCircle extends SxClass {
    static token: string;
    token: string;
    private _sxCenter?;
    private _sxEnd?;
    private _sxLayer?;
    private _sxWidth?;
    private _sxStroke?;
    private _sxFill?;
    private _sxNet?;
    private _sxUuid?;
    private _locked;
    constructor(params?: FpCircleConstructorParams);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): FpCircle;
    get center(): FpCircleCenter | undefined;
    set center(value: FpCircleCenter | {
        x: number;
        y: number;
    } | undefined);
    get end(): FpCircleEnd | undefined;
    set end(value: FpCircleEnd | {
        x: number;
        y: number;
    } | undefined);
    get layer(): Layer | undefined;
    set layer(value: Layer | string | string[] | undefined);
    get width(): number | undefined;
    set width(value: number | Width | undefined);
    get widthClass(): Width | undefined;
    get stroke(): Stroke | undefined;
    set stroke(value: Stroke | undefined);
    get fill(): boolean | undefined;
    set fill(value: boolean | FpCircleFill | undefined);
    get fillClass(): FpCircleFill | undefined;
    get net(): FpCircleNet | undefined;
    set net(value: FpCircleNet | number | undefined);
    get uuid(): string | undefined;
    set uuid(value: string | Uuid | undefined);
    get uuidClass(): Uuid | undefined;
    get locked(): boolean;
    set locked(value: boolean);
    getChildren(): SxClass[];
    getString(): string;
}
declare class FpCircleCenter extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    x: number;
    y: number;
    constructor(x: number, y: number);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): FpCircleCenter;
    getString(): string;
}
declare class FpCircleEnd extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    x: number;
    y: number;
    constructor(x: number, y: number);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): FpCircleEnd;
    getString(): string;
}
declare class FpCircleFill extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    filled: boolean;
    constructor(filled: boolean);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): FpCircleFill;
    getString(): string;
}

interface FpArcConstructorParams {
    start?: FpArcStart | {
        x: number;
        y: number;
    };
    mid?: FpArcMid | {
        x: number;
        y: number;
    };
    end?: FpArcEnd | {
        x: number;
        y: number;
    };
    layer?: Layer | string | string[];
    width?: number | Width;
    stroke?: Stroke;
    tstamp?: Tstamp | string;
    uuid?: string | Uuid;
    locked?: boolean;
}
declare class FpArc extends SxClass {
    static token: string;
    token: string;
    private _sxStart?;
    private _sxMid?;
    private _sxEnd?;
    private _sxLayer?;
    private _sxWidth?;
    private _sxStroke?;
    private _sxTstamp?;
    private _sxUuid?;
    private _locked;
    constructor(params?: FpArcConstructorParams);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): FpArc;
    get start(): FpArcStart | undefined;
    set start(value: FpArcStart | {
        x: number;
        y: number;
    } | undefined);
    get mid(): FpArcMid | undefined;
    set mid(value: FpArcMid | {
        x: number;
        y: number;
    } | undefined);
    get end(): FpArcEnd | undefined;
    set end(value: FpArcEnd | {
        x: number;
        y: number;
    } | undefined);
    get layer(): Layer | undefined;
    set layer(value: Layer | string | string[] | undefined);
    get width(): number | undefined;
    set width(value: number | Width | undefined);
    get widthClass(): Width | undefined;
    get stroke(): Stroke | undefined;
    set stroke(value: Stroke | undefined);
    get tstamp(): Tstamp | undefined;
    set tstamp(value: Tstamp | string | undefined);
    get uuid(): string | undefined;
    set uuid(value: string | Uuid | undefined);
    get uuidClass(): Uuid | undefined;
    get locked(): boolean;
    set locked(value: boolean);
    getChildren(): SxClass[];
    getString(): string;
}
declare class FpArcStart extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    x: number;
    y: number;
    constructor(x: number, y: number);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): FpArcStart;
    getString(): string;
}
declare class FpArcMid extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    x: number;
    y: number;
    constructor(x: number, y: number);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): FpArcMid;
    getString(): string;
}
declare class FpArcEnd extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    x: number;
    y: number;
    constructor(x: number, y: number);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): FpArcEnd;
    getString(): string;
}

interface FpCurveConstructorParams {
    points?: Pts | Xy[] | Array<{
        x: number;
        y: number;
    }>;
    layer?: Layer | string | Array<string | number>;
    width?: Width | number;
    stroke?: Stroke;
    tstamp?: Tstamp | string;
    uuid?: Uuid | string;
    locked?: boolean;
}
declare class FpCurve extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _sxPts?;
    private _sxLayer?;
    private _sxWidth?;
    private _sxStroke?;
    private _sxTstamp?;
    private _sxUuid?;
    private _locked;
    constructor(params?: FpCurveConstructorParams);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): FpCurve;
    get points(): Pts | undefined;
    set points(value: Pts | Xy[] | Array<{
        x: number;
        y: number;
    }> | undefined);
    get layer(): Layer | undefined;
    set layer(value: Layer | string | Array<string | number> | undefined);
    get width(): number | undefined;
    set width(value: Width | number | undefined);
    get stroke(): Stroke | undefined;
    set stroke(value: Stroke | undefined);
    get tstamp(): Tstamp | undefined;
    set tstamp(value: Tstamp | string | undefined);
    get uuid(): Uuid | undefined;
    set uuid(value: Uuid | string | undefined);
    get locked(): boolean;
    set locked(value: boolean);
    getChildren(): SxClass[];
}
declare class FpCurveLocked extends SxClass {
    value: boolean;
    static token: string;
    static parentToken: string;
    token: string;
    constructor(value?: boolean);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): FpCurveLocked;
    getString(): string;
}

declare class FpPolyFill extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    value: string;
    constructor(value: string | boolean);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): FpPolyFill;
    get filled(): boolean;
    set filled(filled: boolean);
    getString(): string;
}

interface FpPolyConstructorParams {
    points?: Pts | Xy[] | Array<{
        x: number;
        y: number;
    }>;
    layer?: Layer | string | Array<string | number>;
    width?: Width | number;
    stroke?: Stroke;
    fill?: FpPolyFill | boolean;
    locked?: boolean;
    tstamp?: Tstamp | string;
    uuid?: Uuid | string;
}
declare class FpPoly extends SxClass {
    static token: string;
    token: string;
    private _sxPts?;
    private _sxLayer?;
    private _sxWidth?;
    private _sxStroke?;
    private _sxFill?;
    private _sxLocked?;
    private _sxTstamp?;
    private _sxUuid?;
    constructor(params?: FpPolyConstructorParams);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): FpPoly;
    get points(): Pts | undefined;
    set points(value: Pts | Xy[] | Array<{
        x: number;
        y: number;
    }> | undefined);
    get layer(): Layer | undefined;
    set layer(value: Layer | string | Array<string | number> | undefined);
    get width(): number | undefined;
    set width(value: Width | number | undefined);
    get widthClass(): Width | undefined;
    set widthClass(value: Width | undefined);
    get stroke(): Stroke | undefined;
    set stroke(value: Stroke | undefined);
    get fill(): FpPolyFill | undefined;
    set fill(value: FpPolyFill | boolean | undefined);
    get locked(): boolean;
    set locked(value: boolean);
    get tstamp(): Tstamp | undefined;
    set tstamp(value: Tstamp | string | undefined);
    get uuid(): Uuid | undefined;
    set uuid(value: Uuid | string | undefined);
    getChildren(): SxClass[];
}

interface GroupConstructorParams {
    name?: string;
    uuid?: string | Uuid;
    locked?: boolean;
    members?: string[];
}
declare class Group extends SxClass {
    static token: string;
    token: string;
    private _name;
    private _sxUuid?;
    private _sxLocked?;
    private _sxMembers?;
    constructor(params?: GroupConstructorParams);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): Group;
    get name(): string;
    set name(value: string);
    get uuid(): string | undefined;
    set uuid(value: string | Uuid | undefined);
    get uuidClass(): Uuid | undefined;
    get locked(): boolean;
    set locked(value: boolean);
    get members(): string[];
    set members(value: string[]);
    get membersClass(): GroupMembers | undefined;
    getChildren(): SxClass[];
    getString(): string;
}
declare class GroupLocked extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    value: boolean;
    constructor(value: boolean);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): GroupLocked;
    getString(): string;
}
declare class GroupMembers extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    members: string[];
    constructor(members: string[]);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): GroupMembers;
    getString(): string;
}

declare class FootprintSheetname extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _value;
    constructor(value: string);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): FootprintSheetname;
    get value(): string;
    set value(value: string);
    getChildren(): SxClass[];
    getString(): string;
}

declare class FootprintSheetfile extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _value;
    constructor(value: string);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): FootprintSheetfile;
    get value(): string;
    set value(value: string);
    getChildren(): SxClass[];
    getString(): string;
}

declare class FpLineNet extends SxClass {
    id: number;
    static token: string;
    static parentToken: string;
    token: string;
    constructor(id: number);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): FpLineNet;
    getChildren(): SxClass[];
    getString(): string;
}

interface FpLineConstructorParams {
    start?: FpLineStart | {
        x: number;
        y: number;
    };
    end?: FpLineEnd | {
        x: number;
        y: number;
    };
    layer?: Layer | string | string[];
    width?: number;
    stroke?: Stroke;
    net?: FpLineNet | number;
    tstamp?: Tstamp | string;
    uuid?: Uuid | string;
    locked?: boolean;
}
declare class FpLine extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _sxStart?;
    private _sxEnd?;
    private _sxLayer?;
    private _sxWidth?;
    private _sxStroke?;
    private _sxNet?;
    private _sxTstamp?;
    private _sxUuid?;
    private _locked;
    constructor(params?: FpLineConstructorParams);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): FpLine;
    get start(): FpLineStart | undefined;
    set start(value: FpLineStart | {
        x: number;
        y: number;
    } | undefined);
    get end(): FpLineEnd | undefined;
    set end(value: FpLineEnd | {
        x: number;
        y: number;
    } | undefined);
    get layer(): Layer | undefined;
    set layer(value: Layer | string | Array<string | number> | undefined);
    get width(): number | undefined;
    set width(value: number | undefined);
    get stroke(): Stroke | undefined;
    set stroke(value: Stroke | undefined);
    get net(): FpLineNet | undefined;
    set net(value: FpLineNet | number | undefined);
    get tstamp(): Tstamp | undefined;
    set tstamp(value: Tstamp | string | undefined);
    get uuid(): Uuid | undefined;
    set uuid(value: Uuid | string | undefined);
    get locked(): boolean;
    set locked(value: boolean);
    getChildren(): SxClass[];
}
declare class FpLineStart extends SxClass {
    x: number;
    y: number;
    static token: string;
    static parentToken: string;
    token: string;
    constructor(x: number, y: number);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): FpLineStart;
    getChildren(): SxClass[];
    getString(): string;
}
declare class FpLineEnd extends SxClass {
    x: number;
    y: number;
    static token: string;
    static parentToken: string;
    token: string;
    constructor(x: number, y: number);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): FpLineEnd;
    getChildren(): SxClass[];
    getString(): string;
}

interface ModelVector {
    x: number;
    y: number;
    z: number;
}
declare class FootprintModel extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _path;
    private _offset?;
    private _scale?;
    private _rotate?;
    private _opacity?;
    private _hide;
    constructor(path: string);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): FootprintModel;
    get path(): string;
    set path(value: string);
    get offset(): ModelVector | undefined;
    set offset(value: ModelVector | undefined);
    get scale(): ModelVector | undefined;
    set scale(value: ModelVector | undefined);
    get rotate(): ModelVector | undefined;
    set rotate(value: ModelVector | undefined);
    get opacity(): number | undefined;
    set opacity(value: number | undefined);
    get hide(): boolean;
    set hide(value: boolean);
    getChildren(): SxClass[];
    getString(): string;
}

declare class EmbeddedFileChecksum extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _value;
    constructor(value: string);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): EmbeddedFileChecksum;
    get value(): string;
    set value(value: string);
    getChildren(): SxClass[];
    getString(): string;
}

declare class EmbeddedFileData extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _chunks;
    constructor(chunks?: string[]);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): EmbeddedFileData;
    static fromStrings(values: string[]): EmbeddedFileData;
    get chunks(): string[];
    set chunks(values: string[]);
    get value(): string;
    set value(data: string);
    getChildren(): SxClass[];
    getString(): string;
}

declare class EmbeddedFileName extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _value;
    constructor(value: string);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): EmbeddedFileName;
    get value(): string;
    set value(value: string);
    getChildren(): SxClass[];
    getString(): string;
}

declare class EmbeddedFileType extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _value;
    constructor(value: string);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): EmbeddedFileType;
    get value(): string;
    set value(value: string);
    getChildren(): SxClass[];
    getString(): string;
}

interface EmbeddedFileConstructorParams {
    name?: string | EmbeddedFileName;
    type?: string | EmbeddedFileType;
    checksum?: string | EmbeddedFileChecksum;
    data?: EmbeddedFileData | string | string[];
}
declare class EmbeddedFile extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _sxName?;
    private _sxType?;
    private _sxChecksum?;
    private _sxData?;
    constructor(params?: EmbeddedFileConstructorParams);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): EmbeddedFile;
    get name(): string | undefined;
    set name(value: string | EmbeddedFileName | undefined);
    get type(): string | undefined;
    set type(value: string | EmbeddedFileType | undefined);
    get checksum(): string | undefined;
    set checksum(value: string | EmbeddedFileChecksum | undefined);
    get data(): EmbeddedFileData | undefined;
    set data(value: EmbeddedFileData | string | string[] | undefined);
    getChildren(): SxClass[];
}

interface EmbeddedFilesConstructorParams {
    files?: EmbeddedFile[];
}
declare class EmbeddedFiles extends SxClass {
    static token: string;
    token: string;
    private _files;
    constructor(params?: EmbeddedFilesConstructorParams);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): EmbeddedFiles;
    get files(): EmbeddedFile[];
    set files(value: EmbeddedFile[]);
    getChildren(): SxClass[];
}

declare class FootprintLocked extends SxPrimitiveBoolean {
    static token: string;
    static parentToken: string;
    token: string;
    constructor(value?: boolean);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): FootprintLocked;
}

declare class FootprintPlaced extends SxPrimitiveBoolean {
    static token: string;
    static parentToken: string;
    token: string;
    constructor(value?: boolean);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): FootprintPlaced;
}

declare class FootprintDuplicatePadNumbersAreJumpers extends SxPrimitiveString {
    static token: string;
    static parentToken: string;
    token: string;
}

declare class FootprintPoint extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _sxAt?;
    private _sxSize?;
    private _sxLayer?;
    private _sxUuid?;
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): FootprintPoint;
    getChildren(): SxClass[];
}

declare class FootprintUnit extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _sxName?;
    private _sxPins?;
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): FootprintUnit;
    getChildren(): SxClass[];
}

declare class FootprintUnits extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _units;
    constructor(units?: FootprintUnit[]);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): FootprintUnits;
    getChildren(): SxClass[];
}

declare class Layers extends SxClass {
    static token: string;
    token: string;
    private _names;
    constructor(names?: Array<string | number>);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): Layers;
    get names(): string[];
    set names(values: Array<string | number>);
    getString(): string;
}

declare class ZoneAttrTeardropType extends SxPrimitiveString {
    static token: string;
    static parentToken: string;
    token: string;
}

declare class ZoneAttrTeardrop extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _sxType?;
    constructor(type?: ZoneAttrTeardropType | string);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): ZoneAttrTeardrop;
    get type(): string | undefined;
    set type(value: ZoneAttrTeardropType | string | undefined);
    getChildren(): SxClass[];
}

declare class ZoneAttr extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _sxTeardrop?;
    constructor(params?: {
        teardrop?: ZoneAttrTeardrop;
    });
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): ZoneAttr;
    get teardrop(): ZoneAttrTeardrop | undefined;
    set teardrop(value: ZoneAttrTeardrop | undefined);
    getChildren(): SxClass[];
}

declare class ZoneConnectPadsClearance extends SxPrimitiveNumber {
    static token: string;
    static parentToken: string;
    token: string;
}

type ZoneConnectPadsMode = "yes" | "no" | "thru_hole_only";
declare class ZoneConnectPads extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _mode?;
    private _sxClearance?;
    constructor(params?: {
        enabled?: boolean;
        mode?: ZoneConnectPadsMode;
        clearance?: number;
    });
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): ZoneConnectPads;
    get enabled(): boolean | undefined;
    set enabled(value: boolean | undefined);
    get mode(): ZoneConnectPadsMode | undefined;
    set mode(value: ZoneConnectPadsMode | undefined);
    get clearance(): number | undefined;
    set clearance(value: ZoneConnectPadsClearance | number | undefined);
    getChildren(): SxClass[];
    getString(): string;
}

declare class ZoneFillIslandAreaMin extends SxPrimitiveNumber {
    static token: string;
    static parentToken: string;
    token: string;
}

declare class ZoneFillIslandRemovalMode extends SxPrimitiveNumber {
    static token: string;
    static parentToken: string;
    token: string;
}

declare class ZoneFillRadius extends SxPrimitiveNumber {
    static token: string;
    static parentToken: string;
    token: string;
}

declare class ZoneFillSmoothing extends SxPrimitiveString {
    static token: string;
    static parentToken: string;
    token: string;
}

declare class ZoneFillThermalBridgeWidth extends SxPrimitiveNumber {
    static token: string;
    static parentToken: string;
    token: string;
}

declare class ZoneFillThermalGap extends SxPrimitiveNumber {
    static token: string;
    static parentToken: string;
    token: string;
}

declare class ZoneFill extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _filled?;
    private _sxThermalGap?;
    private _sxThermalBridgeWidth?;
    private _sxSmoothing?;
    private _sxRadius?;
    private _sxIslandRemovalMode?;
    private _sxIslandAreaMin?;
    constructor(params?: {
        filled?: boolean;
        thermalGap?: number;
        thermalBridgeWidth?: number;
        smoothing?: string;
        radius?: number;
        islandRemovalMode?: number;
        islandAreaMin?: number;
    });
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): ZoneFill;
    get filled(): boolean | undefined;
    set filled(value: boolean | undefined);
    get thermalGap(): number | undefined;
    set thermalGap(value: ZoneFillThermalGap | number | undefined);
    get thermalBridgeWidth(): number | undefined;
    set thermalBridgeWidth(value: ZoneFillThermalBridgeWidth | number | undefined);
    get smoothing(): string | undefined;
    set smoothing(value: ZoneFillSmoothing | string | undefined);
    get radius(): number | undefined;
    set radius(value: ZoneFillRadius | number | undefined);
    get islandRemovalMode(): number | undefined;
    set islandRemovalMode(value: ZoneFillIslandRemovalMode | number | undefined);
    get islandAreaMin(): number | undefined;
    set islandAreaMin(value: ZoneFillIslandAreaMin | number | undefined);
    getChildren(): SxClass[];
    getString(): string;
}

declare class ZoneFilledAreasThickness extends SxPrimitiveBoolean {
    static token: string;
    static parentToken: string;
    token: string;
}

declare class ZoneFilledPolygon extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _sxLayer?;
    private _sxPts?;
    constructor(params?: {
        layer?: Layer;
        pts?: Pts;
        island?: boolean;
    });
    private _island;
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): ZoneFilledPolygon;
    get layer(): Layer | undefined;
    set layer(value: Layer | undefined);
    get pts(): Pts | undefined;
    set pts(value: Pts | undefined);
    get island(): boolean;
    set island(value: boolean);
    getChildren(): SxClass[];
}
declare class ZoneFilledPolygonIsland extends SxClass {
    value: boolean;
    static token: string;
    static parentToken: string;
    token: string;
    constructor(value?: boolean);
    static fromSexprPrimitives(): ZoneFilledPolygonIsland;
    getString(): string;
}

declare class ZoneHatch extends SxClass {
    style: string;
    pitch: number;
    static token: string;
    static parentToken: string;
    token: string;
    constructor(style: string, pitch: number);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): ZoneHatch;
    getString(): string;
}

declare class ZoneKeepoutCopperpour extends SxPrimitiveString {
    static token: string;
    static parentToken: string;
    token: string;
}

declare class ZoneKeepoutFootprints extends SxPrimitiveString {
    static token: string;
    static parentToken: string;
    token: string;
}

declare class ZoneKeepoutPads extends SxPrimitiveString {
    static token: string;
    static parentToken: string;
    token: string;
}

declare class ZoneKeepoutTracks extends SxPrimitiveString {
    static token: string;
    static parentToken: string;
    token: string;
}

declare class ZoneKeepoutVias extends SxPrimitiveString {
    static token: string;
    static parentToken: string;
    token: string;
}

type ZoneKeepoutRule = "allowed" | "not_allowed";
interface ZoneKeepoutConstructorParams {
    tracks?: ZoneKeepoutTracks | ZoneKeepoutRule;
    vias?: ZoneKeepoutVias | ZoneKeepoutRule;
    pads?: ZoneKeepoutPads | ZoneKeepoutRule;
    copperpour?: ZoneKeepoutCopperpour | ZoneKeepoutRule;
    footprints?: ZoneKeepoutFootprints | ZoneKeepoutRule;
}
declare class ZoneKeepout extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _sxTracks?;
    private _sxVias?;
    private _sxPads?;
    private _sxCopperpour?;
    private _sxFootprints?;
    constructor(params?: ZoneKeepoutConstructorParams);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): ZoneKeepout;
    get tracks(): string | undefined;
    set tracks(value: ZoneKeepoutTracks | string | undefined);
    get vias(): string | undefined;
    set vias(value: ZoneKeepoutVias | string | undefined);
    get pads(): string | undefined;
    set pads(value: ZoneKeepoutPads | string | undefined);
    get copperpour(): string | undefined;
    set copperpour(value: ZoneKeepoutCopperpour | string | undefined);
    get footprints(): string | undefined;
    set footprints(value: ZoneKeepoutFootprints | string | undefined);
    getChildren(): SxClass[];
}

declare class ZoneLocked extends SxPrimitiveBoolean {
    static token: string;
    static parentToken: string;
    token: string;
    constructor(value: boolean);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): ZoneLocked;
    getString(): string;
}

declare class ZoneMinThickness extends SxPrimitiveNumber {
    static token: string;
    static parentToken: string;
    token: string;
}

declare class ZoneName extends SxPrimitiveString {
    static token: string;
    static parentToken: string;
    token: string;
}

declare class ZoneNet extends SxClass {
    value: number | string;
    static token: string;
    static parentToken: string;
    token: string;
    constructor(value: number | string);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): ZoneNet;
    getString(): string;
}

declare class ZoneNetName extends SxPrimitiveString {
    static token: string;
    static parentToken: string;
    token: string;
}

declare class ZonePlacementEnabled extends SxPrimitiveBoolean {
    static token: string;
    static parentToken: string;
    token: string;
}

declare class ZonePlacementSheetname extends SxPrimitiveString {
    static token: string;
    static parentToken: string;
    token: string;
}

declare class ZonePlacement extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _sxEnabled?;
    private _sxSheetname?;
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): ZonePlacement;
    get enabled(): boolean | undefined;
    set enabled(value: ZonePlacementEnabled | boolean | undefined);
    get sheetname(): string | undefined;
    set sheetname(value: ZonePlacementSheetname | string | undefined);
    getChildren(): SxClass[];
}

declare class ZonePolygon extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _sxPts?;
    constructor(pts?: Pts);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): ZonePolygon;
    get pts(): Pts | undefined;
    set pts(value: Pts | undefined);
    getChildren(): SxClass[];
}

declare class ZonePriority extends SxPrimitiveNumber {
    static token: string;
    static parentToken: string;
    token: string;
}

interface ZoneConstructorParams {
    net?: ZoneNet | number | string;
    netName?: ZoneNetName | string;
    layer?: Layer | string | string[];
    layers?: Layers | string[];
    tstamp?: Tstamp | string;
    uuid?: Uuid | string;
    locked?: ZoneLocked | boolean;
    name?: ZoneName | string;
    hatch?: ZoneHatch;
    priority?: ZonePriority | number;
    attr?: ZoneAttr;
    connectPads?: ZoneConnectPads;
    minThickness?: ZoneMinThickness | number;
    filledAreasThickness?: ZoneFilledAreasThickness | boolean;
    keepout?: ZoneKeepout;
    placement?: ZonePlacement;
    fill?: ZoneFill;
    polygons?: ZonePolygon[];
    filledPolygons?: ZoneFilledPolygon[];
}
declare class Zone extends SxClass {
    static token: string;
    token: string;
    private _sxNet?;
    private _sxNetName?;
    private _sxLayer?;
    private _sxLayers?;
    private _sxTstamp?;
    private _sxUuid?;
    private _sxLocked?;
    private _sxName?;
    private _sxHatch?;
    private _sxPriority?;
    private _sxAttr?;
    private _sxConnectPads?;
    private _sxMinThickness?;
    private _sxFilledAreasThickness?;
    private _sxKeepout?;
    private _sxPlacement?;
    private _sxFill?;
    private _polygons;
    private _filledPolygons;
    constructor(params?: ZoneConstructorParams);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): Zone;
    get net(): number | string | undefined;
    set net(value: ZoneNet | number | string | undefined);
    get netClass(): ZoneNet | undefined;
    get netName(): string | undefined;
    set netName(value: ZoneNetName | string | undefined);
    get layer(): Layer | undefined;
    set layer(value: Layer | string | string[] | undefined);
    get layers(): Layers | undefined;
    set layers(value: Layers | string[] | undefined);
    get tstamp(): Tstamp | undefined;
    set tstamp(value: Tstamp | string | undefined);
    get uuid(): Uuid | undefined;
    set uuid(value: Uuid | string | undefined);
    get locked(): boolean;
    set locked(value: ZoneLocked | boolean | undefined);
    get name(): string | undefined;
    set name(value: ZoneName | string | undefined);
    get hatch(): ZoneHatch | undefined;
    set hatch(value: ZoneHatch | undefined);
    get priority(): number | undefined;
    set priority(value: ZonePriority | number | undefined);
    get attr(): ZoneAttr | undefined;
    set attr(value: ZoneAttr | undefined);
    get connectPads(): ZoneConnectPads | undefined;
    set connectPads(value: ZoneConnectPads | undefined);
    get minThickness(): number | undefined;
    set minThickness(value: ZoneMinThickness | number | undefined);
    get filledAreasThickness(): boolean | undefined;
    set filledAreasThickness(value: ZoneFilledAreasThickness | boolean | undefined);
    get keepout(): ZoneKeepout | undefined;
    set keepout(value: ZoneKeepout | undefined);
    get placement(): ZonePlacement | undefined;
    set placement(value: ZonePlacement | undefined);
    get fill(): ZoneFill | undefined;
    set fill(value: ZoneFill | undefined);
    get polygons(): ZonePolygon[];
    set polygons(value: ZonePolygon[]);
    get filledPolygons(): ZoneFilledPolygon[];
    set filledPolygons(value: ZoneFilledPolygon[]);
    getChildren(): SxClass[];
}

interface FootprintConstructorParams {
    libraryLink?: string;
    version?: number | FootprintVersion;
    generator?: string | FootprintGenerator;
    generatorVersion?: string | FootprintGeneratorVersion;
    locked?: boolean;
    placed?: boolean;
    layer?: Layer | string | string[];
    tstamp?: Tstamp | string;
    uuid?: Uuid | string;
    at?: AtInput | Xy;
    descr?: string | FootprintDescr;
    tags?: string | string[] | FootprintTags;
    path?: string | FootprintPath;
    autoplaceCost90?: number | FootprintAutoplaceCost90;
    autoplaceCost180?: number | FootprintAutoplaceCost180;
    solderMaskMargin?: number | FootprintSolderMaskMargin;
    solderPasteMargin?: number | FootprintSolderPasteMargin;
    solderPasteRatio?: number | FootprintSolderPasteRatio;
    solderPasteMarginRatio?: number | FootprintSolderPasteMarginRatio;
    clearance?: number | FootprintClearance;
    zoneConnect?: number | FootprintZoneConnect;
    thermalWidth?: number | FootprintThermalWidth;
    thermalGap?: number | FootprintThermalGap;
    attr?: FootprintAttr;
    privateLayers?: FootprintPrivateLayers;
    netTiePadGroups?: FootprintNetTiePadGroups;
    sheetname?: string | FootprintSheetname;
    sheetfile?: string | FootprintSheetfile;
    units?: FootprintUnits;
    duplicatePadNumbersAreJumpers?: string | FootprintDuplicatePadNumbersAreJumpers;
    embeddedFonts?: EmbeddedFonts;
    embeddedFiles?: EmbeddedFiles;
    properties?: Property[];
    fpTexts?: FpText[];
    fpTextBoxes?: FpTextBox[];
    fpLines?: FpLine[];
    fpRects?: FpRect[];
    fpCircles?: FpCircle[];
    fpArcs?: FpArc[];
    fpCurves?: FpCurve[];
    fpPolys?: FpPoly[];
    points?: FootprintPoint[];
    pads?: FootprintPad[];
    models?: FootprintModel[];
    zones?: Zone[];
    groups?: Group[];
}
declare class Footprint extends SxClass {
    static token: string;
    token: string;
    private _libraryLink?;
    private _sxVersion?;
    private _sxGenerator?;
    private _sxGeneratorVersion?;
    private _sxLocked?;
    private _sxPlaced?;
    private _sxLayer?;
    private _sxTedit?;
    private _sxTstamp?;
    private _sxUuid?;
    private _sxAt?;
    private _sxXy?;
    private _sxDescr?;
    private _sxTags?;
    private _sxPath?;
    private _sxAutoplaceCost90?;
    private _sxAutoplaceCost180?;
    private _sxSolderMaskMargin?;
    private _sxSolderPasteMargin?;
    private _sxSolderPasteRatio?;
    private _sxClearance?;
    private _sxZoneConnect?;
    private _sxThermalWidth?;
    private _sxThermalGap?;
    private _sxAttr?;
    private _sxPrivateLayers?;
    private _sxNetTiePadGroups?;
    private _sxSheetname?;
    private _sxSheetfile?;
    private _sxUnits?;
    private _sxDuplicatePadNumbersAreJumpers?;
    private _sxEmbeddedFonts?;
    private _sxEmbeddedFiles?;
    private _properties;
    private _fpTexts;
    private _fpTextBoxes;
    private _fpLines;
    private _fpRects;
    private _fpCircles;
    private _fpArcs;
    private _fpCurves;
    private _fpPolys;
    private _points;
    private _fpPads;
    private _models;
    private _zones;
    private _groups;
    constructor(params?: FootprintConstructorParams);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): Footprint;
    get libraryLink(): string | undefined;
    set libraryLink(value: string | undefined);
    get version(): number | undefined;
    set version(value: number | FootprintVersion | undefined);
    get generator(): string | undefined;
    set generator(value: string | FootprintGenerator | undefined);
    get generatorVersion(): string | undefined;
    set generatorVersion(value: string | FootprintGeneratorVersion | undefined);
    get locked(): boolean;
    set locked(value: FootprintLocked | boolean | undefined);
    get placed(): boolean;
    set placed(value: FootprintPlaced | boolean | undefined);
    get layer(): Layer | undefined;
    set layer(value: Layer | string | string[] | undefined);
    get tedit(): FootprintTedit | undefined;
    set tedit(value: FootprintTedit | string | undefined);
    get tstamp(): Tstamp | undefined;
    set tstamp(value: Tstamp | string | undefined);
    get uuid(): Uuid | undefined;
    set uuid(value: Uuid | string | undefined);
    get position(): At | Xy | undefined;
    set position(value: AtInput | Xy | undefined);
    get descr(): FootprintDescr | undefined;
    set descr(value: FootprintDescr | string | undefined);
    get tags(): FootprintTags | undefined;
    set tags(value: string | string[] | FootprintTags | undefined);
    get path(): FootprintPath | undefined;
    set path(value: FootprintPath | string | undefined);
    get autoplaceCost90(): FootprintAutoplaceCost90 | undefined;
    set autoplaceCost90(value: FootprintAutoplaceCost90 | number | undefined);
    get autoplaceCost180(): FootprintAutoplaceCost180 | undefined;
    set autoplaceCost180(value: FootprintAutoplaceCost180 | number | undefined);
    get solderMaskMargin(): FootprintSolderMaskMargin | undefined;
    set solderMaskMargin(value: FootprintSolderMaskMargin | number | undefined);
    get solderPasteMargin(): FootprintSolderPasteMargin | undefined;
    set solderPasteMargin(value: FootprintSolderPasteMargin | number | undefined);
    get solderPasteRatio(): FootprintSolderPasteRatio | undefined;
    set solderPasteRatio(value: FootprintSolderPasteRatio | number | undefined);
    get solderPasteMarginRatio(): FootprintSolderPasteMarginRatio | undefined;
    set solderPasteMarginRatio(value: FootprintSolderPasteMarginRatio | number | undefined);
    get clearance(): FootprintClearance | undefined;
    set clearance(value: FootprintClearance | number | undefined);
    get zoneConnect(): FootprintZoneConnect | undefined;
    set zoneConnect(value: FootprintZoneConnect | number | undefined);
    get thermalWidth(): FootprintThermalWidth | undefined;
    set thermalWidth(value: FootprintThermalWidth | number | undefined);
    get thermalGap(): FootprintThermalGap | undefined;
    set thermalGap(value: FootprintThermalGap | number | undefined);
    get attr(): FootprintAttr | undefined;
    set attr(value: FootprintAttr | undefined);
    get privateLayers(): FootprintPrivateLayers | undefined;
    set privateLayers(value: FootprintPrivateLayers | string[] | undefined);
    get netTiePadGroups(): FootprintNetTiePadGroups | undefined;
    set netTiePadGroups(value: FootprintNetTiePadGroups | string[] | undefined);
    get sheetname(): string | undefined;
    set sheetname(value: string | FootprintSheetname | undefined);
    get sheetfile(): string | undefined;
    set sheetfile(value: string | FootprintSheetfile | undefined);
    get units(): FootprintUnits | undefined;
    set units(value: FootprintUnits | undefined);
    get duplicatePadNumbersAreJumpers(): string | undefined;
    set duplicatePadNumbersAreJumpers(value: string | FootprintDuplicatePadNumbersAreJumpers | undefined);
    get embeddedFonts(): EmbeddedFonts | undefined;
    set embeddedFonts(value: EmbeddedFonts | undefined);
    get embeddedFiles(): EmbeddedFiles | undefined;
    set embeddedFiles(value: EmbeddedFiles | undefined);
    get properties(): Property[];
    set properties(value: Property[]);
    get fpTexts(): FpText[];
    set fpTexts(value: FpText[]);
    get fpTextBoxes(): FpTextBox[];
    set fpTextBoxes(value: FpTextBox[]);
    get fpLines(): FpLine[];
    set fpLines(value: FpLine[]);
    get fpRects(): FpRect[];
    set fpRects(value: FpRect[]);
    get fpCircles(): FpCircle[];
    set fpCircles(value: FpCircle[]);
    get fpArcs(): FpArc[];
    set fpArcs(value: FpArc[]);
    get fpCurves(): FpCurve[];
    set fpCurves(value: FpCurve[]);
    get fpPolys(): FpPoly[];
    set fpPolys(value: FpPoly[]);
    get points(): FootprintPoint[];
    set points(value: FootprintPoint[]);
    get fpPads(): FootprintPad[];
    set fpPads(value: FootprintPad[]);
    get models(): FootprintModel[];
    set models(value: FootprintModel[]);
    get zones(): Zone[];
    set zones(value: Zone[]);
    get groups(): Group[];
    set groups(value: Group[]);
    getChildren(): SxClass[];
    getString(): string;
}

declare class FootprintPointSize extends SxPrimitiveNumber {
    static token: string;
    static parentToken: string;
    token: string;
}

declare class FootprintUnitName extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    value: string;
    constructor(value: string);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): FootprintUnitName;
    getChildren(): SxClass[];
    getString(): string;
}

declare class FootprintUnitPins extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    values: string[];
    constructor(values?: string[]);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): FootprintUnitPins;
    getChildren(): SxClass[];
    getString(): string;
}

interface GrArcPoint {
    x: number;
    y: number;
}
interface GrArcConstructorParams {
    start?: GrArcStart | GrArcPoint;
    mid?: GrArcMid | GrArcPoint;
    end?: GrArcEnd | GrArcPoint;
    layer?: Layer | string | Array<string | number>;
    width?: Width | number;
    stroke?: Stroke;
    tstamp?: Tstamp | string;
    uuid?: Uuid | string;
    locked?: boolean;
}
declare class GrArc extends SxClass {
    static token: string;
    token: string;
    private _sxStart?;
    private _sxMid?;
    private _sxEnd?;
    private _sxLayer?;
    private _sxWidth?;
    private _sxStroke?;
    private _sxTstamp?;
    private _sxUuid?;
    private _sxLocked?;
    constructor(params?: GrArcConstructorParams);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): GrArc;
    get start(): GrArcStart | undefined;
    set start(value: GrArcStart | GrArcPoint | undefined);
    get mid(): GrArcMid | undefined;
    set mid(value: GrArcMid | GrArcPoint | undefined);
    get end(): GrArcEnd | undefined;
    set end(value: GrArcEnd | GrArcPoint | undefined);
    get startPoint(): GrArcPoint | undefined;
    get midPoint(): GrArcPoint | undefined;
    get endPoint(): GrArcPoint | undefined;
    get layer(): Layer | undefined;
    set layer(value: Layer | string | Array<string | number> | undefined);
    get width(): number | undefined;
    set width(value: Width | number | undefined);
    get widthClass(): Width | undefined;
    set widthClass(value: Width | undefined);
    get stroke(): Stroke | undefined;
    set stroke(value: Stroke | undefined);
    get tstamp(): Tstamp | undefined;
    set tstamp(value: Tstamp | string | undefined);
    get uuid(): Uuid | undefined;
    set uuid(value: Uuid | string | undefined);
    get locked(): boolean;
    set locked(value: boolean);
    getChildren(): SxClass[];
    private normalizeStart;
    private normalizeMid;
    private normalizeEnd;
}
declare class GrArcStart extends SxClass {
    x: number;
    y: number;
    static token: string;
    static parentToken: string;
    token: string;
    constructor(x: number, y: number);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): GrArcStart;
    toObject(): GrArcPoint;
    getChildren(): SxClass[];
    getString(): string;
}
declare class GrArcMid extends SxClass {
    x: number;
    y: number;
    static token: string;
    static parentToken: string;
    token: string;
    constructor(x: number, y: number);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): GrArcMid;
    toObject(): GrArcPoint;
    getChildren(): SxClass[];
    getString(): string;
}
declare class GrArcEnd extends SxClass {
    x: number;
    y: number;
    static token: string;
    static parentToken: string;
    token: string;
    constructor(x: number, y: number);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): GrArcEnd;
    toObject(): GrArcPoint;
    getChildren(): SxClass[];
    getString(): string;
}

interface GrCirclePoint {
    x: number;
    y: number;
}
interface GrCircleConstructorParams {
    center?: GrCircleCenter | GrCirclePoint;
    end?: GrCircleEnd | GrCirclePoint;
    layer?: Layer | string | Array<string | number>;
    width?: Width | number;
    stroke?: Stroke;
    fill?: PadPrimitiveGrCircleFill | string;
    locked?: boolean;
    tstamp?: Tstamp | string;
    uuid?: Uuid | string;
}
declare class GrCircle extends SxClass {
    static token: string;
    token: string;
    private _sxCenter?;
    private _sxEnd?;
    private _sxLayer?;
    private _sxWidth?;
    private _sxStroke?;
    private _sxFill?;
    private _sxLocked?;
    private _sxTstamp?;
    private _sxUuid?;
    constructor(params?: GrCircleConstructorParams);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): GrCircle;
    get center(): GrCircleCenter | undefined;
    set center(value: GrCircleCenter | GrCirclePoint | undefined);
    get end(): GrCircleEnd | undefined;
    set end(value: GrCircleEnd | GrCirclePoint | undefined);
    get centerPoint(): GrCirclePoint | undefined;
    get endPoint(): GrCirclePoint | undefined;
    get layer(): Layer | undefined;
    set layer(value: Layer | string | Array<string | number> | undefined);
    get width(): number | undefined;
    set width(value: Width | number | undefined);
    get widthClass(): Width | undefined;
    set widthClass(value: Width | undefined);
    get stroke(): Stroke | undefined;
    set stroke(value: Stroke | undefined);
    get fill(): PadPrimitiveGrCircleFill | undefined;
    set fill(value: PadPrimitiveGrCircleFill | string | undefined);
    get tstamp(): Tstamp | undefined;
    set tstamp(value: Tstamp | string | undefined);
    get uuid(): string | undefined;
    get uuidClass(): Uuid | undefined;
    set uuid(value: Uuid | string | undefined);
    get locked(): boolean;
    set locked(value: boolean);
    getChildren(): SxClass[];
    private normalizeCenter;
    private normalizeEnd;
}
declare class GrCircleCenter extends SxClass {
    x: number;
    y: number;
    static token: string;
    static parentToken: string;
    token: string;
    constructor(x: number, y: number);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): GrCircleCenter;
    toObject(): GrCirclePoint;
    getChildren(): SxClass[];
    getString(): string;
}
declare class GrCircleEnd extends SxClass {
    x: number;
    y: number;
    static token: string;
    static parentToken: string;
    token: string;
    constructor(x: number, y: number);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): GrCircleEnd;
    toObject(): GrCirclePoint;
    getChildren(): SxClass[];
    getString(): string;
}
declare class GrCircleLocked extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    value: boolean;
    constructor(value: boolean);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): GrCircleLocked;
    getString(): string;
}

interface GrCurveConstructorParams {
    points?: Pts | Xy[] | Array<{
        x: number;
        y: number;
    }>;
    layer?: Layer | string | Array<string | number>;
    width?: Width | number;
    stroke?: Stroke;
    tstamp?: Tstamp | string;
    uuid?: Uuid | string;
}
declare class GrCurve extends SxClass {
    static token: string;
    token: string;
    private _sxPts?;
    private _sxLayer?;
    private _sxWidth?;
    private _sxStroke?;
    private _sxTstamp?;
    private _sxUuid?;
    constructor(params?: GrCurveConstructorParams);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): GrCurve;
    get points(): Pts | undefined;
    set points(value: Pts | Xy[] | Array<{
        x: number;
        y: number;
    }> | undefined);
    get layer(): Layer | undefined;
    set layer(value: Layer | string | Array<string | number> | undefined);
    get width(): number | undefined;
    set width(value: Width | number | undefined);
    get widthClass(): Width | undefined;
    set widthClass(value: Width | undefined);
    get stroke(): Stroke | undefined;
    set stroke(value: Stroke | undefined);
    get tstamp(): Tstamp | undefined;
    set tstamp(value: Tstamp | string | undefined);
    get uuid(): Uuid | undefined;
    set uuid(value: Uuid | string | undefined);
    getChildren(): SxClass[];
}

interface GrLinePoint {
    x: number;
    y: number;
}
interface GrLineConstructorParams {
    start?: GrLineStart | GrLinePoint;
    end?: GrLineEnd | GrLinePoint;
    angle?: number;
    layer?: Layer | string | Array<string | number>;
    width?: Width | number;
    stroke?: Stroke;
    tstamp?: Tstamp | string;
    uuid?: Uuid | string;
    locked?: boolean;
}
declare class GrLine extends SxClass {
    static token: string;
    token: string;
    private _sxStart?;
    private _sxEnd?;
    private _sxAngle?;
    private _sxLayer?;
    private _sxWidth?;
    private _sxStroke?;
    private _sxTstamp?;
    private _sxUuid?;
    private _sxLocked?;
    constructor(params?: GrLineConstructorParams);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): GrLine;
    get start(): GrLineStart | undefined;
    set start(value: GrLineStart | GrLinePoint | undefined);
    get end(): GrLineEnd | undefined;
    set end(value: GrLineEnd | GrLinePoint | undefined);
    get startPoint(): GrLinePoint | undefined;
    get endPoint(): GrLinePoint | undefined;
    get angle(): number | undefined;
    set angle(value: number | undefined);
    get layer(): Layer | undefined;
    set layer(value: Layer | string | Array<string | number> | undefined);
    get width(): number | undefined;
    set width(value: Width | number | undefined);
    get widthClass(): Width | undefined;
    set widthClass(value: Width | undefined);
    get stroke(): Stroke | undefined;
    set stroke(value: Stroke | undefined);
    get tstamp(): Tstamp | undefined;
    set tstamp(value: Tstamp | string | undefined);
    get uuid(): Uuid | undefined;
    set uuid(value: Uuid | string | undefined);
    get locked(): boolean;
    set locked(value: boolean);
    getChildren(): SxClass[];
    private normalizeStart;
    private normalizeEnd;
}

declare class GrLineAngle extends SxPrimitiveNumber {
    static token: string;
    static parentToken: string;
    token: string;
    constructor(value: number);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): GrLineAngle;
    getString(): string;
}

declare class GrLineLocked extends SxPrimitiveBoolean {
    static token: string;
    static parentToken: string;
    token: string;
    constructor(value: boolean);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): GrLineLocked;
    getString(): string;
}

declare class GrArcLocked extends SxPrimitiveBoolean {
    static token: string;
    static parentToken: string;
    token: string;
    constructor(value: boolean);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): GrArcLocked;
    getString(): string;
}

interface GrRectConstructorParams {
    start?: GrRectStart | {
        x: number;
        y: number;
    };
    end?: GrRectEnd | {
        x: number;
        y: number;
    };
    layer?: Layer | string | string[];
    width?: number | Width;
    stroke?: Stroke;
    fill?: boolean | GrRectFill;
    tstamp?: string | Tstamp;
    uuid?: string | Uuid;
    locked?: boolean;
}
declare class GrRect extends SxClass {
    static token: string;
    token: string;
    private _sxStart?;
    private _sxEnd?;
    private _sxLayer?;
    private _sxWidth?;
    private _sxStroke?;
    private _sxFill?;
    private _sxTstamp?;
    private _sxUuid?;
    private _sxLocked?;
    constructor(params?: GrRectConstructorParams);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): GrRect;
    get start(): GrRectStart | undefined;
    set start(value: GrRectStart | {
        x: number;
        y: number;
    } | undefined);
    get end(): GrRectEnd | undefined;
    set end(value: GrRectEnd | {
        x: number;
        y: number;
    } | undefined);
    get startPoint(): {
        x: number;
        y: number;
    } | undefined;
    get endPoint(): {
        x: number;
        y: number;
    } | undefined;
    get layer(): Layer | undefined;
    set layer(value: Layer | string | string[] | undefined);
    get stroke(): Stroke | undefined;
    set stroke(value: Stroke | undefined);
    get width(): number | undefined;
    set width(value: number | Width | undefined);
    get widthClass(): Width | undefined;
    set widthClass(value: Width | undefined);
    get fill(): boolean | undefined;
    set fill(value: boolean | GrRectFill | undefined);
    get fillClass(): GrRectFill | undefined;
    get uuid(): string | undefined;
    set uuid(value: string | Uuid | undefined);
    get uuidClass(): Uuid | undefined;
    get tstamp(): Tstamp | undefined;
    set tstamp(value: string | Tstamp | undefined);
    get locked(): boolean;
    set locked(value: boolean);
    getChildren(): SxClass[];
}
declare class GrRectStart extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _x;
    private _y;
    constructor(x: number, y: number);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): GrRectStart;
    get x(): number;
    set x(value: number);
    get y(): number;
    set y(value: number);
    toObject(): {
        x: number;
        y: number;
    };
    getChildren(): SxClass[];
    getString(): string;
}
declare class GrRectEnd extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _x;
    private _y;
    constructor(x: number, y: number);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): GrRectEnd;
    get x(): number;
    set x(value: number);
    get y(): number;
    set y(value: number);
    toObject(): {
        x: number;
        y: number;
    };
    getChildren(): SxClass[];
    getString(): string;
}
declare class GrRectFill extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    filled: boolean;
    constructor(filled: boolean);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): GrRectFill;
    getString(): string;
}
declare class GrRectLocked extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    value: boolean;
    constructor(value: boolean);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): GrRectLocked;
    getString(): string;
}

interface GrTextPosition {
    x: number;
    y: number;
    angle?: number;
}
interface GrTextConstructorParams {
    text?: string;
    position?: AtInput | Xy | GrTextPosition;
    layer?: Layer | string | Array<string | number>;
    tstamp?: Tstamp | string;
    uuid?: Uuid | string;
    effects?: TextEffects;
    renderCaches?: GrTextRenderCache[];
    locked?: boolean;
}
declare class GrText extends SxClass {
    static token: string;
    token: string;
    private _text;
    private _sxPosition?;
    private _sxLayer?;
    private _sxTstamp?;
    private _sxUuid?;
    private _sxEffects?;
    private _renderCaches;
    private _locked;
    constructor(params?: GrTextConstructorParams | string);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): GrText;
    get text(): string;
    set text(value: string);
    get position(): At | Xy | undefined;
    set position(value: AtInput | Xy | GrTextPosition | undefined);
    get layer(): Layer | undefined;
    set layer(value: Layer | string | Array<string | number> | undefined);
    get tstamp(): Tstamp | undefined;
    set tstamp(value: Tstamp | string | undefined);
    get uuid(): Uuid | undefined;
    set uuid(value: Uuid | string | undefined);
    get effects(): TextEffects | undefined;
    set effects(value: TextEffects | undefined);
    get renderCaches(): GrTextRenderCache[];
    set renderCaches(value: GrTextRenderCache[]);
    get locked(): boolean;
    set locked(value: boolean);
    getChildren(): SxClass[];
    getString(): string;
}
declare class GrTextLocked extends SxClass {
    value: boolean;
    static token: string;
    static parentToken: string;
    token: string;
    constructor(value?: boolean);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): GrTextLocked;
    getString(): string;
}
declare class GrTextRenderCache extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _text;
    private _angle;
    private _polygons;
    constructor(params?: {
        text?: string;
        angle?: number;
        polygons?: GrTextRenderCachePolygon[];
    });
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): GrTextRenderCache;
    get text(): string;
    set text(value: string);
    get angle(): number;
    set angle(value: number);
    get polygons(): GrTextRenderCachePolygon[];
    set polygons(value: GrTextRenderCachePolygon[]);
    getChildren(): SxClass[];
    getString(): string;
}
declare class GrTextRenderCachePolygon extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _pts?;
    constructor(params?: {
        pts?: Pts;
    });
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): GrTextRenderCachePolygon;
    get pts(): Pts | undefined;
    set pts(value: Pts | undefined);
    getChildren(): SxClass[];
    getString(): string;
}

declare class GrPolyNet extends SxClass {
    id: number;
    static token: string;
    static parentToken: string;
    token: string;
    constructor(id: number);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): GrPolyNet;
    getString(): string;
}

declare class GrPolyFill extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    filled: boolean;
    constructor(filled: boolean);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): GrPolyFill;
    getString(): string;
}
interface GrPolyConstructorParams {
    points?: Pts | Xy[] | Array<{
        x: number;
        y: number;
    }>;
    layer?: Layer | string | Array<string | number>;
    width?: Width | number;
    stroke?: Stroke;
    fill?: GrPolyFill | boolean;
    net?: GrPolyNet | number;
    uuid?: Uuid | string;
}
declare class GrPoly extends SxClass {
    static token: string;
    token: string;
    private _sxPts?;
    private _sxLayer?;
    private _sxWidth?;
    private _sxStroke?;
    private _sxFill?;
    private _sxNet?;
    private _sxUuid?;
    constructor(params?: GrPolyConstructorParams);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): GrPoly;
    get points(): Pts | undefined;
    set points(value: Pts | Xy[] | Array<{
        x: number;
        y: number;
    }> | undefined);
    get layer(): Layer | undefined;
    set layer(value: Layer | string | Array<string | number> | undefined);
    get width(): number | undefined;
    set width(value: Width | number | undefined);
    get widthClass(): Width | undefined;
    set widthClass(value: Width | undefined);
    get stroke(): Stroke | undefined;
    set stroke(value: Stroke | undefined);
    get fill(): boolean | undefined;
    set fill(value: GrPolyFill | boolean | undefined);
    get fillClass(): GrPolyFill | undefined;
    get uuid(): string | undefined;
    set uuid(value: Uuid | string | undefined);
    get uuidClass(): Uuid | undefined;
    get net(): number | undefined;
    set net(value: GrPolyNet | number | undefined);
    getChildren(): SxClass[];
}

declare class DimensionFormat extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _sxPrefix?;
    private _sxSuffix?;
    private _sxUnits?;
    private _sxUnitsFormat?;
    private _sxPrecision?;
    private _sxOverrideValue?;
    private _sxSuppressZeros?;
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): DimensionFormat;
    getChildren(): SxClass[];
}

declare class DimensionStyle extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _sxThickness?;
    private _sxArrowLength?;
    private _sxTextPositionMode?;
    private _sxArrowDirection?;
    private _sxExtensionHeight?;
    private _sxTextFrame?;
    private _sxExtensionOffset?;
    private _sxKeepTextAligned?;
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): DimensionStyle;
    getChildren(): SxClass[];
}

declare class Dimension extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _sxLocked?;
    private _sxType?;
    private _sxLayer?;
    private _sxTstamp?;
    private _sxUuid?;
    private _sxPts?;
    private _sxHeight?;
    private _sxOrientation?;
    private _sxLeaderLength?;
    private _sxFormat?;
    private _sxStyle?;
    private _sxGrText?;
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): Dimension;
    getChildren(): SxClass[];
    get tstamp(): Tstamp | undefined;
    get uuid(): Uuid | undefined;
}

declare class Target extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _shape;
    private _sxAt?;
    private _sxSize?;
    private _sxWidth?;
    private _sxLayer?;
    private _sxUuid?;
    constructor(shape: string);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): Target;
    getChildren(): SxClass[];
    getString(): string;
}

declare class Generated extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _rawChildren;
    constructor();
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): Generated;
    get rawChildren(): PrimitiveSExpr[];
    set rawChildren(value: PrimitiveSExpr[]);
    getChildren(): SxClass[];
    getString(): string;
}

interface PcbArcPoint {
    x: number;
    y: number;
}
interface PcbArcConstructorParams {
    start?: PcbArcPoint;
    mid?: PcbArcPoint;
    end?: PcbArcPoint;
    width?: number | Width;
    layer?: string | Layer;
    net?: number | string;
    locked?: boolean;
    tstamp?: string | Tstamp;
    uuid?: string | Uuid;
}
declare class PcbArc extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _start?;
    private _mid?;
    private _end?;
    private _sxWidth?;
    private _sxLayer?;
    private _net?;
    private _locked;
    private _sxTstamp?;
    private _sxUuid?;
    constructor(params?: PcbArcConstructorParams);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): PcbArc;
    get start(): PcbArcPoint | undefined;
    set start(value: PcbArcPoint | undefined);
    get mid(): PcbArcPoint | undefined;
    set mid(value: PcbArcPoint | undefined);
    get end(): PcbArcPoint | undefined;
    set end(value: PcbArcPoint | undefined);
    get width(): number | undefined;
    set width(value: number | Width | undefined);
    get layer(): Layer | undefined;
    set layer(value: string | Layer | undefined);
    get net(): number | string | undefined;
    set net(value: number | string | undefined);
    get locked(): boolean;
    set locked(value: boolean);
    get uuid(): Uuid | undefined;
    set uuid(value: string | Uuid | undefined);
    get tstamp(): Tstamp | undefined;
    set tstamp(value: string | Tstamp | undefined);
    getChildren(): SxClass[];
    getString(): string;
}

declare class SegmentEnd extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _x;
    private _y;
    constructor(x: number, y: number);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): SegmentEnd;
    get x(): number;
    set x(value: number);
    get y(): number;
    set y(value: number);
    toObject(): {
        x: number;
        y: number;
    };
    getChildren(): SxClass[];
    getString(): string;
}

declare class SegmentNet extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _id?;
    private _name?;
    constructor(idOrName: number | string, name?: string);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): SegmentNet;
    get id(): number | undefined;
    set id(value: number | undefined);
    get name(): string | undefined;
    set name(value: string | undefined);
    toObject(): {
        id?: number;
        name?: string;
    };
    getChildren(): SxClass[];
    getString(): string;
}

declare class SegmentStart extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _x;
    private _y;
    constructor(x: number, y: number);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): SegmentStart;
    get x(): number;
    set x(value: number);
    get y(): number;
    set y(value: number);
    toObject(): {
        x: number;
        y: number;
    };
    getChildren(): SxClass[];
    getString(): string;
}

interface SegmentConstructorParams {
    start?: SegmentStart | {
        x: number;
        y: number;
    };
    end?: SegmentEnd | {
        x: number;
        y: number;
    };
    width?: Width | number;
    layer?: Layer | string | Array<string | number>;
    net?: SegmentNet | {
        id: number;
        name?: string;
    };
    tstamp?: Tstamp | string;
    uuid?: Uuid | string;
    locked?: boolean;
}
declare class Segment extends SxClass {
    static token: string;
    token: string;
    private _sxStart?;
    private _sxEnd?;
    private _sxWidth?;
    private _sxLayer?;
    private _sxNet?;
    private _sxTstamp?;
    private _sxUuid?;
    private _sxLocked?;
    constructor(params?: SegmentConstructorParams);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): Segment;
    get start(): SegmentStart | undefined;
    set start(value: SegmentStart | {
        x: number;
        y: number;
    } | undefined);
    get end(): SegmentEnd | undefined;
    set end(value: SegmentEnd | {
        x: number;
        y: number;
    } | undefined);
    get startPoint(): {
        x: number;
        y: number;
    } | undefined;
    get endPoint(): {
        x: number;
        y: number;
    } | undefined;
    get width(): number | undefined;
    set width(value: Width | number | undefined);
    get widthClass(): Width | undefined;
    set widthClass(value: Width | undefined);
    get layer(): Layer | undefined;
    set layer(value: Layer | string | Array<string | number> | undefined);
    get net(): SegmentNet | undefined;
    set net(value: SegmentNet | {
        id: number;
        name?: string;
    } | undefined);
    get tstamp(): Tstamp | undefined;
    set tstamp(value: Tstamp | string | undefined);
    get uuid(): Uuid | undefined;
    set uuid(value: Uuid | string | undefined);
    get locked(): boolean;
    set locked(value: boolean);
    getChildren(): SxClass[];
    private normalizeStart;
    private normalizeEnd;
}

declare class SegmentLocked extends SxPrimitiveBoolean {
    static token: string;
    static parentToken: string;
    token: string;
    constructor(value: boolean);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): SegmentLocked;
    getString(): string;
}

declare class FpPolyLocked extends SxPrimitiveBoolean {
    static token: string;
    static parentToken: string;
    token: string;
    constructor(value: boolean);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): FpPolyLocked;
    getString(): string;
}

declare class TextBoxSize extends SxClass {
    width: number;
    height: number;
    static token: string;
    static parentToken: string;
    token: string;
    constructor(width: number, height: number);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): TextBoxSize;
    getString(): string;
}

declare class TextBoxFill extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _sxType?;
    private _sxColor?;
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): TextBoxFill;
    getChildren(): SxClass[];
}

declare abstract class SingleValueProperty<T extends string | number> extends SxClass {
    protected _value: T;
    protected quoteStringValue: boolean;
    constructor(value: T);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): SingleValueProperty<string | number>;
    protected static parsePrimitiveValue(value: PrimitiveSExpr | undefined): string | number;
    get value(): T;
    set value(value: T);
    getChildren(): SxClass[];
    protected formatValue(): string;
    getString(): string;
}
declare abstract class NumericListProperty extends SxClass {
    protected _values: number[];
    constructor(values: number[]);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): NumericListProperty;
    get values(): number[];
    set values(values: number[]);
    getChildren(): SxClass[];
    getString(): string;
}
declare abstract class CoordinateProperty extends SxClass {
    protected _x: number;
    protected _y: number;
    constructor(x: number, y: number);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): CoordinateProperty;
    get x(): number;
    set x(value: number);
    get y(): number;
    set y(value: number);
    getChildren(): SxClass[];
    getString(): string;
}

declare class Back extends SingleValueProperty<string> {
    static token: string;
    token: string;
}

declare class Front extends SingleValueProperty<string> {
    static token: string;
    token: string;
}

declare class Covering extends SxClass {
    static token: string;
    token: string;
    private _sxFront?;
    private _sxBack?;
    constructor(params?: {
        front?: Front | string;
        back?: Back | string;
    });
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): Covering;
    get front(): string | undefined;
    set front(value: Front | string | undefined);
    get back(): string | undefined;
    set back(value: Back | string | undefined);
    getChildren(): SxClass[];
}

declare class PcbPlotParams extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _properties;
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): PcbPlotParams;
    getChildren(): SxClass[];
    private clearProperty;
    private setStringProperty;
    private setNumberProperty;
    private setStringOrNumberProperty;
    get layerselection(): string | number | undefined;
    set layerselection(value: string | number | undefined);
    get plot_on_all_layers_selection(): string | number | undefined;
    set plot_on_all_layers_selection(value: string | number | undefined);
    get disableapertmacros(): string | undefined;
    set disableapertmacros(value: string | undefined);
    get usegerberextensions(): string | undefined;
    set usegerberextensions(value: string | undefined);
    get usegerberattributes(): string | undefined;
    set usegerberattributes(value: string | undefined);
    get usegerberadvancedattributes(): string | undefined;
    set usegerberadvancedattributes(value: string | undefined);
    get creategerberjobfile(): string | undefined;
    set creategerberjobfile(value: string | undefined);
    get excludeedgelayer(): string | undefined;
    set excludeedgelayer(value: string | undefined);
    get dashed_line_dash_ratio(): number | undefined;
    set dashed_line_dash_ratio(value: number | undefined);
    get dashed_line_gap_ratio(): number | undefined;
    set dashed_line_gap_ratio(value: number | undefined);
    get svguseinch(): string | undefined;
    set svguseinch(value: string | undefined);
    get svgprecision(): number | undefined;
    set svgprecision(value: number | undefined);
    get linewidth(): number | undefined;
    set linewidth(value: number | undefined);
    get plotframeref(): string | undefined;
    set plotframeref(value: string | undefined);
    get plotreference(): string | undefined;
    set plotreference(value: string | undefined);
    get plotvalue(): string | undefined;
    set plotvalue(value: string | undefined);
    get plotfptext(): string | undefined;
    set plotfptext(value: string | undefined);
    get plotothertext(): string | undefined;
    set plotothertext(value: string | undefined);
    get plotinvisibletext(): string | undefined;
    set plotinvisibletext(value: string | undefined);
    get padsonsilk(): string | undefined;
    set padsonsilk(value: string | undefined);
    get plotpadnumbers(): string | undefined;
    set plotpadnumbers(value: string | undefined);
    get sketchpadsonfab(): string | undefined;
    set sketchpadsonfab(value: string | undefined);
    get hidednponfab(): string | undefined;
    set hidednponfab(value: string | undefined);
    get sketchdnponfab(): string | undefined;
    set sketchdnponfab(value: string | undefined);
    get crossoutdnponfab(): string | undefined;
    set crossoutdnponfab(value: string | undefined);
    get subtractmaskfromsilk(): string | undefined;
    set subtractmaskfromsilk(value: string | undefined);
    get plot_black_and_white(): string | undefined;
    set plot_black_and_white(value: string | undefined);
    get plot_on_all_layers(): string | undefined;
    set plot_on_all_layers(value: string | undefined);
    get plotinvisible(): string | undefined;
    set plotinvisible(value: string | undefined);
    get mode(): number | undefined;
    set mode(value: number | undefined);
    get useauxorigin(): string | undefined;
    set useauxorigin(value: string | undefined);
    get viasonmask(): string | undefined;
    set viasonmask(value: string | undefined);
    get hpglpennumber(): number | undefined;
    set hpglpennumber(value: number | undefined);
    get hpglpenspeed(): number | undefined;
    set hpglpenspeed(value: number | undefined);
    get hpglpendiameter(): number | undefined;
    set hpglpendiameter(value: number | undefined);
    get hpglpenoverlay(): number | undefined;
    set hpglpenoverlay(value: number | undefined);
    get pdf_front_fp_property_popups(): string | undefined;
    set pdf_front_fp_property_popups(value: string | undefined);
    get pdf_back_fp_property_popups(): string | undefined;
    set pdf_back_fp_property_popups(value: string | undefined);
    get pdf_metadata(): string | undefined;
    set pdf_metadata(value: string | undefined);
    get pdf_single_document(): string | undefined;
    set pdf_single_document(value: string | undefined);
    get dxfpolygonmode(): string | undefined;
    set dxfpolygonmode(value: string | undefined);
    get dxfimperialunits(): string | undefined;
    set dxfimperialunits(value: string | undefined);
    get dxfusepcbnewfont(): string | undefined;
    set dxfusepcbnewfont(value: string | undefined);
    get psnegative(): string | undefined;
    set psnegative(value: string | undefined);
    get psa4output(): string | undefined;
    set psa4output(value: string | undefined);
    get mirror(): string | undefined;
    set mirror(value: string | undefined);
    get outputformat(): number | undefined;
    set outputformat(value: number | undefined);
    get drillshape(): number | undefined;
    set drillshape(value: number | undefined);
    get scaleselection(): number | undefined;
    set scaleselection(value: number | undefined);
    get outputdirectory(): string | undefined;
    set outputdirectory(value: string | undefined);
}

declare class Plugging extends SxClass {
    static token: string;
    token: string;
    private _sxFront?;
    private _sxBack?;
    constructor(params?: {
        front?: Front | string;
        back?: Back | string;
    });
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): Plugging;
    get front(): string | undefined;
    set front(value: Front | string | undefined);
    get back(): string | undefined;
    set back(value: Back | string | undefined);
    getChildren(): SxClass[];
}

declare abstract class StackupSingleValueProperty<T extends string | number> extends SingleValueProperty<T> {
    static parentToken: string;
}
declare class StackupCopperFinish extends StackupSingleValueProperty<string> {
    static token: string;
    token: string;
    protected quoteStringValue: boolean;
}
declare class StackupDielectricConstraints extends StackupSingleValueProperty<string> {
    static token: string;
    token: string;
}
declare class StackupEdgeConnector extends StackupSingleValueProperty<string> {
    static token: string;
    token: string;
}
declare class StackupCastellatedPads extends StackupSingleValueProperty<string> {
    static token: string;
    token: string;
}
declare class StackupEdgePlating extends StackupSingleValueProperty<string> {
    static token: string;
    token: string;
}

declare abstract class StackupLayerProperty<T extends string | number> extends SingleValueProperty<T> {
    static parentToken: string;
}
declare class StackupLayerType extends StackupLayerProperty<string> {
    static token: string;
    token: string;
    protected quoteStringValue: boolean;
}
declare class StackupLayerColor extends StackupLayerProperty<string> {
    static token: string;
    token: string;
    protected quoteStringValue: boolean;
}
declare class StackupLayerThickness extends StackupLayerProperty<number> {
    static token: string;
    token: string;
    protected static parsePrimitiveValue(value: PrimitiveSExpr | undefined): number;
}
declare class StackupLayerMaterial extends StackupLayerProperty<string> {
    static token: string;
    token: string;
    protected quoteStringValue: boolean;
}
declare class StackupLayerEpsilonR extends StackupLayerProperty<number> {
    static token: string;
    token: string;
    protected static parsePrimitiveValue(value: PrimitiveSExpr | undefined): number;
}
declare class StackupLayerLossTangent extends StackupLayerProperty<number> {
    static token: string;
    token: string;
    protected static parsePrimitiveValue(value: PrimitiveSExpr | undefined): number;
}

declare class StackupLayer extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _name;
    private _number?;
    private _sxType?;
    private _sxColor?;
    private _sxThickness?;
    private _sxMaterial?;
    private _sxEpsilonR?;
    private _sxLossTangent?;
    constructor(name: string, opts?: {
        number?: number;
        type?: StackupLayerType;
        color?: StackupLayerColor;
        thickness?: StackupLayerThickness;
        material?: StackupLayerMaterial;
        epsilonR?: StackupLayerEpsilonR;
        lossTangent?: StackupLayerLossTangent;
    });
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): StackupLayer;
    get name(): string;
    set name(value: string);
    get number(): number | undefined;
    set number(value: number | undefined);
    get type(): string | undefined;
    set type(value: string | StackupLayerType | undefined);
    get color(): string | undefined;
    set color(value: string | StackupLayerColor | undefined);
    get thickness(): number | undefined;
    set thickness(value: number | StackupLayerThickness | undefined);
    get material(): string | undefined;
    set material(value: string | StackupLayerMaterial | undefined);
    get epsilonR(): number | undefined;
    set epsilonR(value: number | StackupLayerEpsilonR | undefined);
    get lossTangent(): number | undefined;
    set lossTangent(value: number | StackupLayerLossTangent | undefined);
    getChildren(): SxClass[];
    getString(): string;
}

declare class Stackup extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _layers;
    private _sxCopperFinish?;
    private _sxDielectricConstraints?;
    private _sxEdgeConnector?;
    private _sxCastellatedPads?;
    private _sxEdgePlating?;
    constructor(opts?: {
        layers?: StackupLayer[];
        copperFinish?: StackupCopperFinish;
        dielectricConstraints?: StackupDielectricConstraints;
        edgeConnector?: StackupEdgeConnector;
        castellatedPads?: StackupCastellatedPads;
        edgePlating?: StackupEdgePlating;
    });
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): Stackup;
    get layers(): StackupLayer[];
    set layers(layers: StackupLayer[]);
    get copperFinish(): string | undefined;
    set copperFinish(value: string | undefined);
    get dielectricConstraints(): string | undefined;
    set dielectricConstraints(value: string | undefined);
    get edgeConnector(): string | undefined;
    set edgeConnector(value: string | undefined);
    get castellatedPads(): string | undefined;
    set castellatedPads(value: string | undefined);
    get edgePlating(): string | undefined;
    set edgePlating(value: string | undefined);
    getChildren(): SxClass[];
}

type Coordinate = {
    x: number;
    y: number;
};
declare class Setup extends SxClass {
    static token: string;
    token: string;
    private _properties;
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): Setup;
    getChildren(): SxClass[];
    private setProperty;
    private setNumberProperty;
    private getPropertyInstance;
    get stackup(): Stackup | undefined;
    set stackup(value: Stackup | undefined);
    get pcbPlotParams(): PcbPlotParams | undefined;
    set pcbPlotParams(value: PcbPlotParams | undefined);
    get padToMaskClearance(): number | undefined;
    set padToMaskClearance(value: number | undefined);
    get solderMaskMinWidth(): number | undefined;
    set solderMaskMinWidth(value: number | undefined);
    get padToPasteClearance(): number | undefined;
    set padToPasteClearance(value: number | undefined);
    get padToPasteClearanceRatio(): number | undefined;
    set padToPasteClearanceRatio(value: number | undefined);
    get lastTraceWidth(): number | undefined;
    set lastTraceWidth(value: number | undefined);
    get traceClearance(): number | undefined;
    set traceClearance(value: number | undefined);
    get zoneClearance(): number | undefined;
    set zoneClearance(value: number | undefined);
    get zone45Only(): string | undefined;
    set zone45Only(value: string | undefined);
    get traceMin(): number | undefined;
    set traceMin(value: number | undefined);
    get segmentWidth(): number | undefined;
    set segmentWidth(value: number | undefined);
    get edgeWidth(): number | undefined;
    set edgeWidth(value: number | undefined);
    get viaSize(): number | undefined;
    set viaSize(value: number | undefined);
    get viaDrill(): number | undefined;
    set viaDrill(value: number | undefined);
    get viaMinSize(): number | undefined;
    set viaMinSize(value: number | undefined);
    get viaMinDrill(): number | undefined;
    set viaMinDrill(value: number | undefined);
    get uviasAllowed(): string | undefined;
    set uviasAllowed(value: string | undefined);
    get uviaSize(): number | undefined;
    set uviaSize(value: number | undefined);
    get uviaDrill(): number | undefined;
    set uviaDrill(value: number | undefined);
    get uviaMinSize(): number | undefined;
    set uviaMinSize(value: number | undefined);
    get uviaMinDrill(): number | undefined;
    set uviaMinDrill(value: number | undefined);
    get pcbTextWidth(): number | undefined;
    set pcbTextWidth(value: number | undefined);
    get pcbTextSize(): number[] | undefined;
    set pcbTextSize(values: number[] | undefined);
    get modEdgeWidth(): number | undefined;
    set modEdgeWidth(value: number | undefined);
    get modTextSize(): number[] | undefined;
    set modTextSize(values: number[] | undefined);
    get modTextWidth(): number | undefined;
    set modTextWidth(value: number | undefined);
    get padSize(): number[] | undefined;
    set padSize(values: number[] | undefined);
    get padDrill(): number | undefined;
    set padDrill(value: number | undefined);
    get allowSoldermaskBridgesInFootprints(): string | undefined;
    set allowSoldermaskBridgesInFootprints(value: string | undefined);
    get tenting(): string[] | undefined;
    set tenting(sides: string[] | undefined);
    get covering(): Covering | undefined;
    set covering(value: Covering | undefined);
    get plugging(): Plugging | undefined;
    set plugging(value: Plugging | undefined);
    get capping(): string | undefined;
    set capping(value: string | undefined);
    get filling(): string | undefined;
    set filling(value: string | undefined);
    get auxAxisOrigin(): Coordinate | undefined;
    set auxAxisOrigin(origin: Coordinate | undefined);
    get gridOrigin(): Coordinate | undefined;
    set gridOrigin(origin: Coordinate | undefined);
    get visibleElements(): string | undefined;
    set visibleElements(value: string | undefined);
    get padToPasteClearanceValues(): number[] | undefined;
    set padToPasteClearanceValues(values: number[] | undefined);
    get traceWidth(): number[] | undefined;
    set traceWidth(values: number[] | undefined);
}

declare class Capping extends SingleValueProperty<string> {
    static token: string;
    token: string;
}

declare class Filling extends SingleValueProperty<string> {
    static token: string;
    token: string;
}

declare abstract class PlotParamProperty<T extends string | number> extends SingleValueProperty<T> {
    static parentToken: string;
}

declare class PlotParamPlotFpText extends PlotParamProperty<string> {
    static token: string;
    token: string;
}

declare abstract class PlotParamNumberProperty extends PlotParamProperty<number> {
    protected static parsePrimitiveValue(value: PrimitiveSExpr | undefined): number;
}
declare class PlotParamLayerSelection extends PlotParamProperty<string | number> {
    static token: string;
    token: string;
}
declare class PlotParamPlotOnAllLayersSelection extends PlotParamProperty<string | number> {
    static token: string;
    token: string;
}
declare class PlotParamDashedLineDashRatio extends PlotParamNumberProperty {
    static token: string;
    token: string;
}
declare class PlotParamDashedLineGapRatio extends PlotParamNumberProperty {
    static token: string;
    token: string;
}
declare class PlotParamSvgPrecision extends PlotParamNumberProperty {
    static token: string;
    token: string;
}
declare class PlotParamLineWidth extends PlotParamNumberProperty {
    static token: string;
    token: string;
}
declare class PlotParamMode extends PlotParamNumberProperty {
    static token: string;
    token: string;
}
declare class PlotParamHpglPenNumber extends PlotParamNumberProperty {
    static token: string;
    token: string;
}
declare class PlotParamHpglPenSpeed extends PlotParamNumberProperty {
    static token: string;
    token: string;
}
declare class PlotParamHpglPenDiameter extends PlotParamNumberProperty {
    static token: string;
    token: string;
}
declare class PlotParamHpglPenOverlay extends PlotParamNumberProperty {
    static token: string;
    token: string;
}
declare class PlotParamOutputFormat extends PlotParamNumberProperty {
    static token: string;
    token: string;
}
declare class PlotParamDrillShape extends PlotParamNumberProperty {
    static token: string;
    token: string;
}
declare class PlotParamScaleSelection extends PlotParamNumberProperty {
    static token: string;
    token: string;
}

declare class PlotParamDisableApertMacros extends PlotParamProperty<string> {
    static token: string;
    token: string;
}
declare class PlotParamUseGerberExtensions extends PlotParamProperty<string> {
    static token: string;
    token: string;
}
declare class PlotParamUseGerberAttributes extends PlotParamProperty<string> {
    static token: string;
    token: string;
}
declare class PlotParamUseGerberAdvancedAttributes extends PlotParamProperty<string> {
    static token: string;
    token: string;
}
declare class PlotParamCreateGerberJobFile extends PlotParamProperty<string> {
    static token: string;
    token: string;
}
declare class PlotParamSvgUseInch extends PlotParamProperty<string> {
    static token: string;
    token: string;
}
declare class PlotParamExcludeEdgeLayer extends PlotParamProperty<string> {
    static token: string;
    token: string;
}
declare class PlotParamPlotFrameRef extends PlotParamProperty<string> {
    static token: string;
    token: string;
}
declare class PlotParamViaOnMask extends PlotParamProperty<string> {
    static token: string;
    token: string;
}
declare class PlotParamUseAuxOrigin extends PlotParamProperty<string> {
    static token: string;
    token: string;
}
declare class PlotParamPdfFrontFpPropertyPopups extends PlotParamProperty<string> {
    static token: string;
    token: string;
}
declare class PlotParamPdfBackFpPropertyPopups extends PlotParamProperty<string> {
    static token: string;
    token: string;
}
declare class PlotParamPdfMetadata extends PlotParamProperty<string> {
    static token: string;
    token: string;
}
declare class PlotParamPdfSingleDocument extends PlotParamProperty<string> {
    static token: string;
    token: string;
}
declare class PlotParamDxfPolygonMode extends PlotParamProperty<string> {
    static token: string;
    token: string;
}
declare class PlotParamDxfImperialUnits extends PlotParamProperty<string> {
    static token: string;
    token: string;
}
declare class PlotParamDxfUsePcbnewFont extends PlotParamProperty<string> {
    static token: string;
    token: string;
}
declare class PlotParamPsNegative extends PlotParamProperty<string> {
    static token: string;
    token: string;
}

declare class PlotParamPsA4Output extends PlotParamProperty<string> {
    static token: string;
    token: string;
}
declare class PlotParamPlotReference extends PlotParamProperty<string> {
    static token: string;
    token: string;
}
declare class PlotParamPlotValue extends PlotParamProperty<string> {
    static token: string;
    token: string;
}
declare class PlotParamPlotOtherText extends PlotParamProperty<string> {
    static token: string;
    token: string;
}
declare class PlotParamPlotInvisibleText extends PlotParamProperty<string> {
    static token: string;
    token: string;
}
declare class PlotParamPadOnSilk extends PlotParamProperty<string> {
    static token: string;
    token: string;
}
declare class PlotParamSketchPadsOnFab extends PlotParamProperty<string> {
    static token: string;
    token: string;
}
declare class PlotParamPlotPadNumbers extends PlotParamProperty<string> {
    static token: string;
    token: string;
}
declare class PlotParamHideDnpOnFab extends PlotParamProperty<string> {
    static token: string;
    token: string;
}
declare class PlotParamSketchDnpOnFab extends PlotParamProperty<string> {
    static token: string;
    token: string;
}
declare class PlotParamCrossoutDnpOnFab extends PlotParamProperty<string> {
    static token: string;
    token: string;
}
declare class PlotParamSubtractMaskFromSilk extends PlotParamProperty<string> {
    static token: string;
    token: string;
}
declare class PlotParamPlotBlackAndWhite extends PlotParamProperty<string> {
    static token: string;
    token: string;
}
declare class PlotParamMirror extends PlotParamProperty<string> {
    static token: string;
    token: string;
}
declare class PlotParamOutputDirectory extends PlotParamProperty<string> {
    static token: string;
    token: string;
    protected quoteStringValue: boolean;
}
declare class PlotParamPlotOnAllLayers extends PlotParamProperty<string> {
    static token: string;
    token: string;
}
declare class PlotParamPlotInvisible extends PlotParamProperty<string> {
    static token: string;
    token: string;
}

declare abstract class SetupNumberProperty extends SingleValueProperty<number> {
    static parentToken: string;
    protected static parsePrimitiveValue(value: PrimitiveSExpr | undefined): number;
}
declare class SetupPadToMaskClearance extends SetupNumberProperty {
    static token: string;
    token: string;
}
declare class SetupSolderMaskMinWidth extends SetupNumberProperty {
    static token: string;
    token: string;
}
declare class SetupPadToPasteClearance extends SetupNumberProperty {
    static token: string;
    token: string;
}
declare class SetupPadToPasteClearanceRatio extends SetupNumberProperty {
    static token: string;
    token: string;
}
declare class SetupLastTraceWidth extends SetupNumberProperty {
    static token: string;
    token: string;
}
declare class SetupTraceClearance extends SetupNumberProperty {
    static token: string;
    token: string;
}
declare class SetupZoneClearance extends SetupNumberProperty {
    static token: string;
    token: string;
}
declare class SetupTraceMin extends SetupNumberProperty {
    static token: string;
    token: string;
}
declare class SetupSegmentWidth extends SetupNumberProperty {
    static token: string;
    token: string;
}
declare class SetupEdgeWidth extends SetupNumberProperty {
    static token: string;
    token: string;
}
declare class SetupViaSize extends SetupNumberProperty {
    static token: string;
    token: string;
}
declare class SetupViaDrill extends SetupNumberProperty {
    static token: string;
    token: string;
}
declare class SetupViaMinSize extends SetupNumberProperty {
    static token: string;
    token: string;
}
declare class SetupViaMinDrill extends SetupNumberProperty {
    static token: string;
    token: string;
}
declare class SetupUviaSize extends SetupNumberProperty {
    static token: string;
    token: string;
}
declare class SetupUviaDrill extends SetupNumberProperty {
    static token: string;
    token: string;
}
declare class SetupUviaMinSize extends SetupNumberProperty {
    static token: string;
    token: string;
}
declare class SetupUviaMinDrill extends SetupNumberProperty {
    static token: string;
    token: string;
}
declare class SetupPcbTextWidth extends SetupNumberProperty {
    static token: string;
    token: string;
}
declare class SetupModEdgeWidth extends SetupNumberProperty {
    static token: string;
    token: string;
}
declare class SetupModTextWidth extends SetupNumberProperty {
    static token: string;
    token: string;
}
declare class SetupPadDrill extends SetupNumberProperty {
    static token: string;
    token: string;
}

declare abstract class SetupNumericListProperty extends NumericListProperty {
    static parentToken: string;
}
declare abstract class SetupCoordinateProperty extends CoordinateProperty {
    static parentToken: string;
}
declare class SetupPcbTextSize extends SetupNumericListProperty {
    static token: string;
    token: string;
}
declare class SetupModTextSize extends SetupNumericListProperty {
    static token: string;
    token: string;
}
declare class SetupPadSize extends SetupNumericListProperty {
    static token: string;
    token: string;
}
declare class SetupPadToPasteClearanceValues extends SetupNumericListProperty {
    static token: string;
    token: string;
}
declare class SetupTraceWidth extends SetupNumericListProperty {
    static token: string;
    token: string;
}
declare class SetupAuxAxisOrigin extends SetupCoordinateProperty {
    static token: string;
    token: string;
}
declare class SetupGridOrigin extends SetupCoordinateProperty {
    static token: string;
    token: string;
}

declare abstract class SetupStringProperty extends SingleValueProperty<string> {
    static parentToken: string;
}
declare class SetupZone45Only extends SetupStringProperty {
    static token: string;
    token: string;
}
declare class SetupAllowSoldermaskBridgesInFootprints extends SetupStringProperty {
    static token: string;
    token: string;
}
declare class SetupVisibleElements extends SetupStringProperty {
    static token: string;
    token: string;
}
declare class SetupUviasAllowed extends SetupStringProperty {
    static token: string;
    token: string;
}
declare class SetupTenting extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _sides;
    private _sxFront?;
    private _sxBack?;
    constructor(sides?: string[]);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): SetupTenting;
    get sides(): string[];
    set sides(sides: string[]);
    getChildren(): SxClass[];
    getString(): string;
}

interface SetupPropertyValues {
    stackup?: Stackup;
    pcbPlotParams?: PcbPlotParams;
    padToMaskClearance?: SetupPadToMaskClearance;
    solderMaskMinWidth?: SetupSolderMaskMinWidth;
    padToPasteClearance?: SetupPadToPasteClearance;
    padToPasteClearanceRatio?: SetupPadToPasteClearanceRatio;
    lastTraceWidth?: SetupLastTraceWidth;
    traceClearance?: SetupTraceClearance;
    zoneClearance?: SetupZoneClearance;
    zone45Only?: SetupZone45Only;
    traceMin?: SetupTraceMin;
    segmentWidth?: SetupSegmentWidth;
    edgeWidth?: SetupEdgeWidth;
    viaSize?: SetupViaSize;
    viaDrill?: SetupViaDrill;
    viaMinSize?: SetupViaMinSize;
    viaMinDrill?: SetupViaMinDrill;
    uviasAllowed?: SetupUviasAllowed;
    uviaSize?: SetupUviaSize;
    uviaDrill?: SetupUviaDrill;
    uviaMinSize?: SetupUviaMinSize;
    uviaMinDrill?: SetupUviaMinDrill;
    pcbTextWidth?: SetupPcbTextWidth;
    pcbTextSize?: SetupPcbTextSize;
    modEdgeWidth?: SetupModEdgeWidth;
    modTextSize?: SetupModTextSize;
    modTextWidth?: SetupModTextWidth;
    padSize?: SetupPadSize;
    padDrill?: SetupPadDrill;
    allowSoldermaskBridgesInFootprints?: SetupAllowSoldermaskBridgesInFootprints;
    tenting?: SetupTenting;
    covering?: Covering;
    plugging?: Plugging;
    capping?: Capping;
    filling?: Filling;
    auxAxisOrigin?: SetupAuxAxisOrigin;
    gridOrigin?: SetupGridOrigin;
    visibleElements?: SetupVisibleElements;
    padToPasteClearanceValues?: SetupPadToPasteClearanceValues;
    traceWidth?: SetupTraceWidth;
}
type SetupProperty = Stackup | PcbPlotParams | SetupPadToMaskClearance | SetupSolderMaskMinWidth | SetupPadToPasteClearance | SetupPadToPasteClearanceRatio | SetupLastTraceWidth | SetupTraceClearance | SetupZoneClearance | SetupZone45Only | SetupTraceMin | SetupSegmentWidth | SetupEdgeWidth | SetupViaSize | SetupViaDrill | SetupViaMinSize | SetupViaMinDrill | SetupUviasAllowed | SetupUviaSize | SetupUviaDrill | SetupUviaMinSize | SetupUviaMinDrill | SetupPcbTextWidth | SetupPcbTextSize | SetupModEdgeWidth | SetupModTextSize | SetupModTextWidth | SetupPadSize | SetupPadDrill | SetupAllowSoldermaskBridgesInFootprints | SetupTenting | Covering | Plugging | Capping | Filling | SetupAuxAxisOrigin | SetupGridOrigin | SetupVisibleElements | SetupPadToPasteClearanceValues | SetupTraceWidth;

declare class PcbGeneral extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _sxThickness?;
    private _sxLegacyTeardrops?;
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): PcbGeneral;
    get thickness(): number | undefined;
    set thickness(value: number | undefined);
    get legacyTeardrops(): boolean | undefined;
    set legacyTeardrops(value: boolean | undefined);
    getChildren(): SxClass[];
}

declare class PcbGeneralThickness extends SxPrimitiveNumber {
    static token: string;
    static parentToken: string;
    token: string;
}

declare class PcbGeneralLegacyTeardrops extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _enabled;
    constructor(enabled: boolean);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): PcbGeneralLegacyTeardrops;
    get enabled(): boolean;
    set enabled(value: boolean);
    getChildren(): SxClass[];
    getString(): string;
}

declare class PcbLayerDefinition extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _index?;
    private _name?;
    private _type?;
    private _userName?;
    constructor(options: {
        index?: number;
        name?: string;
        type?: string;
        userName?: string;
    });
    static fromPrimitive(primitive: PrimitiveSExpr): PcbLayerDefinition;
    get index(): number | undefined;
    set index(value: number | undefined);
    get name(): string | undefined;
    set name(value: string | undefined);
    get type(): string | undefined;
    set type(value: string | undefined);
    get userName(): string | undefined;
    set userName(value: string | undefined);
    getChildren(): SxClass[];
    getString(): string;
}

declare class PcbLayers extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _definitions;
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): PcbLayers;
    get definitions(): PcbLayerDefinition[];
    set definitions(value: PcbLayerDefinition[]);
    getChildren(): SxClass[];
}

declare class PcbNet extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _id;
    private _name;
    constructor(id: number, name: string);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): PcbNet;
    get id(): number;
    set id(value: number);
    get name(): string;
    set name(value: string);
    getChildren(): SxClass[];
    getString(): string;
}

declare class PcbVersion extends SxPrimitiveNumber {
    static token: string;
    static parentToken: string;
    token: string;
}

declare class PcbGenerator extends SxPrimitiveString {
    static token: string;
    static parentToken: string;
    token: string;
    getString(): string;
}

declare class PcbGeneratorVersion extends SxPrimitiveString {
    static token: string;
    static parentToken: string;
    token: string;
    getString(): string;
}

declare class ViaNet extends SxClass {
    static token: string;
    static parentToken: string;
    token: string;
    private _id?;
    private _name?;
    constructor(idOrName: number | string, name?: string);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): ViaNet;
    get id(): number | undefined;
    set id(value: number | undefined);
    get name(): string | undefined;
    set name(value: string | undefined);
    getChildren(): SxClass[];
    getString(): string;
}

interface ViaConstructorParams {
    type?: string;
    locked?: boolean;
    free?: boolean;
    removeUnusedLayers?: boolean;
    keepEndLayers?: boolean;
    at?: AtInput;
    size?: number;
    drill?: number;
    layers?: Layers | string[];
    net?: ViaNet;
    uuid?: Uuid | string;
    tstamp?: Tstamp | string;
    teardrops?: PadTeardrops;
    capping?: string | Capping;
    covering?: Covering;
    plugging?: Plugging;
    filling?: string | Filling;
}
declare class Via extends SxClass {
    static token: string;
    token: string;
    private _type?;
    private _locked;
    private _free;
    private _removeUnusedLayers;
    private _keepEndLayers;
    private _sxAt?;
    private _size?;
    private _drill?;
    private _sxLayers?;
    private _sxNet?;
    private _sxUuid?;
    private _sxTstamp?;
    private _sxTeardrops?;
    private _sxCapping?;
    private _sxCovering?;
    private _sxPlugging?;
    private _sxFilling?;
    constructor(params?: ViaConstructorParams);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): Via;
    private consumeBareToken;
    private consumeNode;
    private parseYesNo;
    get type(): string | undefined;
    set type(value: string | undefined);
    get locked(): boolean;
    set locked(value: boolean);
    get free(): boolean;
    set free(value: boolean);
    get removeUnusedLayers(): boolean;
    set removeUnusedLayers(value: boolean);
    get keepEndLayers(): boolean;
    set keepEndLayers(value: boolean);
    get at(): At | undefined;
    set at(value: AtInput | undefined);
    get size(): number | undefined;
    set size(value: number | undefined);
    get drill(): number | undefined;
    set drill(value: number | undefined);
    get layers(): Layers | undefined;
    set layers(value: Layers | string[] | undefined);
    get net(): ViaNet | undefined;
    set net(value: ViaNet | undefined);
    get uuid(): Uuid | undefined;
    set uuid(value: Uuid | string | undefined);
    get teardrops(): PadTeardrops | undefined;
    set teardrops(value: PadTeardrops | undefined);
    get capping(): string | undefined;
    set capping(value: string | Capping | undefined);
    get covering(): Covering | undefined;
    set covering(value: Covering | undefined);
    get plugging(): Plugging | undefined;
    set plugging(value: Plugging | undefined);
    get filling(): string | undefined;
    set filling(value: string | Filling | undefined);
    get tstamp(): Tstamp | undefined;
    set tstamp(value: Tstamp | string | undefined);
    getChildren(): SxClass[];
    getString(): string;
}

interface KicadPcbConstructorParams {
    version?: number;
    generator?: string;
    generatorVersion?: string;
    general?: PcbGeneral;
    paper?: Paper;
    titleBlock?: TitleBlock;
    layers?: PcbLayers;
    setup?: Setup;
    properties?: Property[];
    nets?: PcbNet[];
    footprints?: Footprint[];
    images?: Image[];
    segments?: Segment[];
    arcs?: PcbArc[];
    graphicArcs?: GrArc[];
    graphicCircles?: GrCircle[];
    graphicCurves?: GrCurve[];
    graphicLines?: GrLine[];
    graphicTexts?: GrText[];
    graphicPolys?: GrPoly[];
    graphicRects?: GrRect[];
    vias?: Via[];
    zones?: Zone[];
    embeddedFonts?: EmbeddedFonts;
    embeddedFiles?: EmbeddedFiles;
    otherChildren?: SxClass[];
}
declare class KicadPcb extends SxClass {
    static token: string;
    token: string;
    private _sxVersion?;
    private _sxGenerator?;
    private _sxGeneratorVersion?;
    private _sxGeneral?;
    private _sxPaper?;
    private _sxTitleBlock?;
    private _sxLayers?;
    private _sxSetup?;
    private _properties;
    private _nets;
    private _footprints;
    private _images;
    private _segments;
    private _arcs;
    private _grArcs;
    private _grCircles;
    private _grCurves;
    private _grLines;
    private _grTexts;
    private _grPolys;
    private _grRects;
    private _vias;
    private _zones;
    private _sxEmbeddedFonts?;
    private _sxEmbeddedFiles?;
    private _otherChildren;
    constructor(params?: KicadPcbConstructorParams);
    static fromSexprPrimitives(primitiveSexprs: PrimitiveSExpr[]): KicadPcb;
    private consumeChild;
    get version(): number | undefined;
    set version(value: number | undefined);
    get generator(): string | undefined;
    set generator(value: string | undefined);
    get generatorVersion(): string | undefined;
    set generatorVersion(value: string | undefined);
    get general(): PcbGeneral | undefined;
    set general(value: PcbGeneral | undefined);
    get paper(): Paper | undefined;
    set paper(value: Paper | undefined);
    get titleBlock(): TitleBlock | undefined;
    set titleBlock(value: TitleBlock | undefined);
    get layers(): PcbLayers | undefined;
    set layers(value: PcbLayers | undefined);
    get setup(): Setup | undefined;
    set setup(value: Setup | undefined);
    get properties(): Property[];
    set properties(value: Property[]);
    get nets(): PcbNet[];
    set nets(value: PcbNet[]);
    get footprints(): Footprint[];
    set footprints(value: Footprint[]);
    get images(): Image[];
    set images(value: Image[]);
    get segments(): Segment[];
    set segments(value: Segment[]);
    get arcs(): PcbArc[];
    set arcs(value: PcbArc[]);
    get graphicArcs(): GrArc[];
    set graphicArcs(value: GrArc[]);
    get graphicCircles(): GrCircle[];
    set graphicCircles(value: GrCircle[]);
    get graphicCurves(): GrCurve[];
    set graphicCurves(value: GrCurve[]);
    get graphicLines(): GrLine[];
    set graphicLines(value: GrLine[]);
    get graphicTexts(): GrText[];
    set graphicTexts(value: GrText[]);
    get graphicPolys(): GrPoly[];
    set graphicPolys(value: GrPoly[]);
    get graphicRects(): GrRect[];
    set graphicRects(value: GrRect[]);
    get vias(): Via[];
    set vias(value: Via[]);
    get zones(): Zone[];
    set zones(value: Zone[]);
    get embeddedFonts(): EmbeddedFonts | undefined;
    set embeddedFonts(value: EmbeddedFonts | undefined);
    get embeddedFiles(): EmbeddedFiles | undefined;
    set embeddedFiles(value: EmbeddedFiles | undefined);
    get otherChildren(): SxClass[];
    set otherChildren(value: SxClass[]);
    getChildren(): SxClass[];
}

declare const parseKicadSexpr: (sexpr: string) => SxClass[];
declare const parseKicadSch: (sexpr: string) => KicadSch;
declare const parseKicadPcb: (sexpr: string) => KicadPcb;
declare const parseKicadSym: (sexpr: string) => KicadSymbolLib;
declare const parseKicadMod: (sexpr: string) => Footprint;

export { At, type AtInput, Back, Bus, type BusConstructorParams, BusEntry, type BusEntryConstructorParams, BusEntrySize, Capping, Color, Covering, Dimension, DimensionFormat, DimensionStyle, Dnp, EmbeddedFile, EmbeddedFileChecksum, type EmbeddedFileConstructorParams, EmbeddedFileData, EmbeddedFileName, EmbeddedFileType, EmbeddedFiles, type EmbeddedFilesConstructorParams, EmbeddedFonts, ExcludeFromSim, FieldsAutoplaced, Filling, Footprint, FootprintAttr, FootprintAutoplaceCost180, FootprintAutoplaceCost90, FootprintClearance, type FootprintConstructorParams, FootprintDescr, FootprintDuplicatePadNumbersAreJumpers, FootprintGenerator, FootprintGeneratorVersion, FootprintLocked, FootprintModel, FootprintNetTiePadGroups, FootprintPad, type FootprintPadConstructorParams, FootprintPath, FootprintPlaced, FootprintPoint, FootprintPointSize, FootprintPrivateLayers, FootprintSheetfile, FootprintSheetname, FootprintSolderMaskMargin, FootprintSolderPasteMargin, FootprintSolderPasteMarginRatio, FootprintSolderPasteRatio, FootprintTags, FootprintTedit, FootprintThermalGap, FootprintThermalWidth, FootprintUnit, FootprintUnitName, FootprintUnitPins, FootprintUnits, FootprintVersion, FootprintZoneConnect, FpArc, type FpArcConstructorParams, FpArcEnd, FpArcMid, FpArcStart, FpCircle, FpCircleCenter, type FpCircleConstructorParams, FpCircleEnd, FpCircleFill, FpCircleNet, FpCurve, type FpCurveConstructorParams, FpCurveLocked, FpLine, type FpLineConstructorParams, FpLineEnd, FpLineNet, FpLineStart, FpPoly, type FpPolyConstructorParams, FpPolyFill, FpPolyLocked, FpRect, type FpRectConstructorParams, FpRectEnd, FpRectFill, FpRectNet, FpRectStart, FpText, FpTextBox, FpTextBoxAngle, type FpTextBoxConstructorParams, FpTextBoxEnd, FpTextBoxStart, type FpTextConstructorParams, type FpTextType, Front, Generated, GlobalLabel, type GlobalLabelConstructorParams, type GlobalLabelShape, GrArc, type GrArcConstructorParams, GrArcEnd, GrArcLocked, GrArcMid, type GrArcPoint, GrArcStart, GrCircle, GrCircleCenter, type GrCircleConstructorParams, GrCircleEnd, GrCircleLocked, type GrCirclePoint, GrCurve, type GrCurveConstructorParams, GrLine, GrLineAngle, type GrLineConstructorParams, GrLineEnd, GrLineLocked, type GrLinePoint, GrLineStart, GrPoly, type GrPolyConstructorParams, GrPolyFill, GrPolyNet, GrRect, type GrRectConstructorParams, GrRectEnd, GrRectFill, GrRectLocked, GrRectStart, GrText, type GrTextConstructorParams, GrTextLocked, type GrTextPosition, GrTextRenderCache, GrTextRenderCachePolygon, Group, type GroupConstructorParams, GroupLocked, GroupMembers, Image, type ImageConstructorParams, ImageData, ImageScale, InBom, InPosFiles, Junction, type JunctionConstructorParams, JunctionDiameter, KicadPcb, type KicadPcbConstructorParams, KicadSch, type KicadSchConstructorParams, KicadSchGenerator, KicadSchGeneratorVersion, KicadSchVersion, KicadSym, KicadSymbolLib, type KicadSymbolLibConstructorParams, KicadSymbolLibGenerator, KicadSymbolLibGeneratorVersion, KicadSymbolLibVersion, Label, type LabelConstructorParams, Layer, Layers, LibSymbols, Mirror, type ModelVector, NoConnect, type NoConnectConstructorParams, OnBoard, PadChamfer, PadChamferRatio, PadClearance, PadDieLength, PadDrill, PadDrillOffset, PadLayers, type PadLayersInput, PadNet, PadOptions, type PadOptionsAnchorShape, type PadOptionsClearanceType, PadPinFunction, PadPinType, PadPrimitiveGrArc, type PadPrimitiveGrArcConstructorParams, PadPrimitiveGrCircle, type PadPrimitiveGrCircleConstructorParams, PadPrimitiveGrCircleFill, PadPrimitiveGrLine, PadPrimitiveGrPoly, PadPrimitives, PadProperty, PadRectDelta, PadRoundrectRratio, PadSize, type PadSizeInput, PadSolderMaskMargin, PadSolderPasteMargin, PadSolderPasteMarginRatio, PadTeardrops, PadThermalBridgeAngle, PadThermalGap, PadThermalWidth, PadZoneConnect, PadZoneLayerConnections, Paper, PcbArc, type PcbArcConstructorParams, type PcbArcPoint, PcbGeneral, PcbGeneralLegacyTeardrops, PcbGeneralThickness, PcbGenerator, PcbGeneratorVersion, PcbLayerDefinition, PcbLayers, PcbNet, PcbPlotParams, PcbVersion, type PinElectricalType, type PinGraphicStyle, PlotParamCreateGerberJobFile, PlotParamCrossoutDnpOnFab, PlotParamDashedLineDashRatio, PlotParamDashedLineGapRatio, PlotParamDisableApertMacros, PlotParamDrillShape, PlotParamDxfImperialUnits, PlotParamDxfPolygonMode, PlotParamDxfUsePcbnewFont, PlotParamExcludeEdgeLayer, PlotParamHideDnpOnFab, PlotParamHpglPenDiameter, PlotParamHpglPenNumber, PlotParamHpglPenOverlay, PlotParamHpglPenSpeed, PlotParamLayerSelection, PlotParamLineWidth, PlotParamMirror, PlotParamMode, PlotParamOutputDirectory, PlotParamOutputFormat, PlotParamPadOnSilk, PlotParamPdfBackFpPropertyPopups, PlotParamPdfFrontFpPropertyPopups, PlotParamPdfMetadata, PlotParamPdfSingleDocument, PlotParamPlotBlackAndWhite, PlotParamPlotFpText, PlotParamPlotFrameRef, PlotParamPlotInvisible, PlotParamPlotInvisibleText, PlotParamPlotOnAllLayers, PlotParamPlotOnAllLayersSelection, PlotParamPlotOtherText, PlotParamPlotPadNumbers, PlotParamPlotReference, PlotParamPlotValue, PlotParamProperty, PlotParamPsA4Output, PlotParamPsNegative, PlotParamScaleSelection, PlotParamSketchDnpOnFab, PlotParamSketchPadsOnFab, PlotParamSubtractMaskFromSilk, PlotParamSvgPrecision, PlotParamSvgUseInch, PlotParamUseAuxOrigin, PlotParamUseGerberAdvancedAttributes, PlotParamUseGerberAttributes, PlotParamUseGerberExtensions, PlotParamViaOnMask, Plugging, Polyline, type PolylineConstructorParams, Property, type PropertyConstructorParams, PropertyDoNotAutoplace, PropertyHide, PropertyShowName, PropertyUnlocked, Pts, PtsArc, PtsArcEnd, PtsArcMid, PtsArcStart, type RGBAColor, RenderCache, SchematicArc, type SchematicArcConstructorParams, SchematicArcLocked, type SchematicArcPoint, SchematicPolyline, SchematicRectangle, type SchematicRectangleConstructorParams, type SchematicRectanglePoint, SchematicSymbol, type SchematicSymbolConstructorParams, SchematicText, SchematicTextBox, type SchematicTextConstructorParams, Segment, type SegmentConstructorParams, SegmentEnd, SegmentLocked, SegmentNet, SegmentStart, Setup, SetupAllowSoldermaskBridgesInFootprints, SetupAuxAxisOrigin, SetupEdgeWidth, SetupGridOrigin, SetupLastTraceWidth, SetupModEdgeWidth, SetupModTextSize, SetupModTextWidth, SetupPadDrill, SetupPadSize, SetupPadToMaskClearance, SetupPadToPasteClearance, SetupPadToPasteClearanceRatio, SetupPadToPasteClearanceValues, SetupPcbTextSize, SetupPcbTextWidth, type SetupProperty, type SetupPropertyValues, SetupSegmentWidth, SetupSolderMaskMinWidth, SetupTenting, SetupTraceClearance, SetupTraceMin, SetupTraceWidth, SetupUviaDrill, SetupUviaMinDrill, SetupUviaMinSize, SetupUviaSize, SetupUviasAllowed, SetupViaDrill, SetupViaMinDrill, SetupViaMinSize, SetupViaSize, SetupVisibleElements, SetupZone45Only, SetupZoneClearance, Sheet, type SheetConstructorParams, SheetFill, SheetInstancePage, SheetInstancePath, SheetInstances, SheetInstancesForSheet, SheetInstancesProject, SheetInstancesRoot, SheetInstancesRootPage, SheetInstancesRootPath, SheetPin, type SheetPinElectricalType, SheetProperty, SheetSize, Stackup, StackupCastellatedPads, StackupCopperFinish, StackupDielectricConstraints, StackupEdgeConnector, StackupEdgePlating, StackupLayer, StackupLayerColor, StackupLayerEpsilonR, StackupLayerLossTangent, StackupLayerMaterial, StackupLayerThickness, StackupLayerType, type StandardPaperSize, Stroke, type StrokeProperty, StrokeType, type StrokeTypeString, SxClass, SymbolArc, SymbolArcEnd, SymbolArcFill, SymbolArcMid, SymbolArcStart, SymbolBodyStyle, SymbolBodyStyles, SymbolCircle, SymbolCircleCenter, SymbolCircleFill, SymbolCircleRadius, SymbolDuplicatePinNumbersAreJumpers, SymbolFillType, SymbolInstancePath, SymbolInstanceReference, SymbolInstanceUnit, SymbolInstances, SymbolInstancesProject, SymbolLibId, SymbolLibName, SymbolPin, SymbolPinAlternate, type SymbolPinAlternateConstructorParams, SymbolPinLength, SymbolPinName, SymbolPinNames, SymbolPinNamesHide, SymbolPinNamesOffset, SymbolPinNumber, SymbolPinNumbers, SymbolPinNumbersHide, SymbolPolyline, SymbolPolylineFill, type SymbolPolylineFillLike, SymbolPower, SymbolProperty, SymbolPropertyId, SymbolRectangle, SymbolRectangleEnd, SymbolRectangleFill, SymbolRectangleStart, SymbolText, SymbolTextBox, SymbolUnit, Target, TextBoxFill, TextBoxSize, TextEffects, type TextEffectsConstructorParams, TextEffectsFont, TextEffectsFontBold, TextEffectsFontFace, TextEffectsFontItalic, TextEffectsFontLineSpacing, type TextEffectsFontProperty, TextEffectsFontSize, TextEffectsFontThickness, TextEffectsJustify, type TextEffectsProperty, TitleBlock, TitleBlockComment, TitleBlockCompany, type TitleBlockConstructorParams, TitleBlockDate, TitleBlockRevision, TitleBlockTitle, Tstamp, Unit, type UnitString, Uuid, Via, type ViaConstructorParams, ViaNet, Width, Wire, type WireConstructorParams, Xy, Zone, ZoneAttr, ZoneAttrTeardrop, ZoneAttrTeardropType, ZoneConnectPads, ZoneConnectPadsClearance, type ZoneConnectPadsMode, type ZoneConstructorParams, ZoneFill, ZoneFillIslandAreaMin, ZoneFillIslandRemovalMode, ZoneFillRadius, ZoneFillSmoothing, ZoneFillThermalBridgeWidth, ZoneFillThermalGap, ZoneFilledAreasThickness, ZoneFilledPolygon, ZoneFilledPolygonIsland, ZoneHatch, ZoneKeepout, type ZoneKeepoutConstructorParams, ZoneKeepoutCopperpour, ZoneKeepoutFootprints, ZoneKeepoutPads, type ZoneKeepoutRule, ZoneKeepoutTracks, ZoneKeepoutVias, ZoneLocked, ZoneMinThickness, ZoneName, ZoneNet, ZoneNetName, ZonePlacement, ZonePlacementEnabled, ZonePlacementSheetname, ZonePolygon, ZonePriority, parseKicadMod, parseKicadPcb, parseKicadSch, parseKicadSexpr, parseKicadSym };