@tscircuit/internal-dynamic-import 0.0.0

package/dist/index.d.ts

@@ -0,0 +1,3007 @@
+import { AnyCircuitElement, SourceComponentBase, PcbComponent, CircuitJson, SchematicNetLabel, PCBTrace, PCBPort, LayerRef as LayerRef$1, NinePointAnchor, PcbRenderLayer, PcbBoard, PcbCopperPour, PcbCopperText, PcbCourtyardCircle, PcbCutout, PcbFabricationNoteDimension, PcbFabricationNotePath, PcbFabricationNoteRect, PcbFabricationNoteText, PcbHole, PCBKeepout, PcbNoteDimension, PcbNotePath, PcbNoteRect, PcbNoteText, PcbPanel, PcbPlatedHole, PcbSilkscreenCircle, PcbSilkscreenLine, PcbSilkscreenOval, PcbSilkscreenPath, PcbSilkscreenPill, PcbSilkscreenRect, PcbSilkscreenText, PcbSmtPad, PcbTrace, PcbVia, PCBVia, SimulationExperiment, SimulationTransientVoltageGraph, SimulationVoltageProbe, PcbPort, SchematicComponent } from 'circuit-json';
+import { BpcGraph } from 'bpc-graph';
+import { z, AnyZodObject } from 'zod';
+import { CircuitJsonUtilObjects, cju } from '@tscircuit/circuit-json-util';
+import { KicadSch, KicadPcb, SchematicSymbol } from 'kicadts';
+import { Matrix } from 'transformation-matrix';
+import { LightBurnProject } from 'lbrnts';
+import { Box } from '@tscircuit/simple-3d-svg';
+import { INode } from 'svgson';
+
+type SupplierPartNumberColumn = "JLCPCB Part #";
+interface BomRow {
+    designator: string;
+    comment: string;
+    value: string;
+    footprint: string;
+    supplier_part_number_columns?: Partial<Record<SupplierPartNumberColumn, string>>;
+    manufacturer_mpn_pairs?: Array<{
+        manufacturer: string;
+        mpn: string;
+    }>;
+    extra_columns?: Record<string, string>;
+}
+interface ResolvedPart {
+    part_number?: string;
+    footprint?: string;
+    comment?: string;
+    supplier_part_number_columns?: Record<SupplierPartNumberColumn, string>;
+    manufacturer_mpn_pairs?: Array<{
+        manufacturer: string;
+        mpn: string;
+    }>;
+    extra_columns?: Record<string, string>;
+}
+declare const convertCircuitJsonToBomRows: ({ circuitJson, resolvePart, }: {
+    circuitJson: AnyCircuitElement[];
+    resolvePart?: (part_info: {
+        source_component: SourceComponentBase;
+        pcb_component: PcbComponent;
+    }) => Promise<ResolvedPart | null>;
+}) => Promise<BomRow[]>;
+declare const convertBomRowsToCsv: (bom_rows: BomRow[]) => string;
+
+declare const CircuitJsonToBomCsvModule_convertBomRowsToCsv: typeof convertBomRowsToCsv;
+declare const CircuitJsonToBomCsvModule_convertCircuitJsonToBomRows: typeof convertCircuitJsonToBomRows;
+declare namespace CircuitJsonToBomCsvModule {
+  export { CircuitJsonToBomCsvModule_convertBomRowsToCsv as convertBomRowsToCsv, CircuitJsonToBomCsvModule_convertCircuitJsonToBomRows as convertCircuitJsonToBomRows };
+}
+
+declare const convertCircuitJsonToBpc: (circuitJson: CircuitJson, opts?: {
+    inferNetLabels?: boolean;
+    useReadableIds?: boolean;
+}) => BpcGraph;
+
+/**
+ * Generate implicit net labels for schematic ports that belong to a net but
+ * are not connected via a trace. Existing labels are not duplicated.
+ */
+declare const generateImplicitNetLabels: (circuitJson: CircuitJson) => SchematicNetLabel[];
+
+declare const CircuitJsonToBpcModule_convertCircuitJsonToBpc: typeof convertCircuitJsonToBpc;
+declare const CircuitJsonToBpcModule_generateImplicitNetLabels: typeof generateImplicitNetLabels;
+declare namespace CircuitJsonToBpcModule {
+  export { CircuitJsonToBpcModule_convertCircuitJsonToBpc as convertCircuitJsonToBpc, CircuitJsonToBpcModule_generateImplicitNetLabels as generateImplicitNetLabels };
+}
+
+type NodeId = string;
+declare function findConnectedNetworks(connections: Array<NodeId[]>): Record<string, string[]>;
+
+declare class ConnectivityMap {
+    netMap: Record<string, string[]>;
+    idToNetMap: Record<string, string>;
+    constructor(netMap: Record<string, string[]>);
+    addConnections(connections: string[][]): void;
+    getIdsConnectedToNet(netId: string): string[];
+    getNetConnectedToId(id: string): string | undefined;
+    areIdsConnected(id1: string, id2: string): boolean;
+    areAllIdsConnected(ids: string[]): boolean;
+}
+
+declare const getSourcePortConnectivityMapFromCircuitJson: (circuitJson: AnyCircuitElement[]) => ConnectivityMap;
+
+declare const getFullConnectivityMapFromCircuitJson: (circuitJson: AnyCircuitElement[]) => ConnectivityMap;
+
+/**
+ * A PCB Connectivity Map is a connectivity map that has analyzed what traces and ports are actually connected on the
+ * PCB.
+ *
+ * This is useful for determining how to route a trace on the PCB. For example, you may want to determine where the
+ * nearest connected net point is to connect an unrouted pin.
+ */
+declare class PcbConnectivityMap {
+    circuitJson: AnyCircuitElement[];
+    traceIdToElm: Map<string, PCBTrace>;
+    portIdToElm: Map<string, PCBPort>;
+    connMap: ConnectivityMap;
+    constructor(circuitJson?: AnyCircuitElement[]);
+    private _buildPortMap;
+    private _buildTraceMap;
+    private _buildTraceConnectivityMap;
+    addTrace(trace: PCBTrace): void;
+    _arePcbTracesConnected(trace1: PCBTrace, trace2: PCBTrace): boolean;
+    areTracesConnected(traceId1: string, traceId2: string): boolean;
+    getAllTracesConnectedToTrace(traceId: string): PCBTrace[];
+    getAllTracesConnectedToPort(portId: string): PCBTrace[];
+}
+
+type CircuitJsonToConnectivityMapModule_ConnectivityMap = ConnectivityMap;
+declare const CircuitJsonToConnectivityMapModule_ConnectivityMap: typeof ConnectivityMap;
+type CircuitJsonToConnectivityMapModule_PcbConnectivityMap = PcbConnectivityMap;
+declare const CircuitJsonToConnectivityMapModule_PcbConnectivityMap: typeof PcbConnectivityMap;
+declare const CircuitJsonToConnectivityMapModule_findConnectedNetworks: typeof findConnectedNetworks;
+declare const CircuitJsonToConnectivityMapModule_getFullConnectivityMapFromCircuitJson: typeof getFullConnectivityMapFromCircuitJson;
+declare const CircuitJsonToConnectivityMapModule_getSourcePortConnectivityMapFromCircuitJson: typeof getSourcePortConnectivityMapFromCircuitJson;
+declare namespace CircuitJsonToConnectivityMapModule {
+  export { CircuitJsonToConnectivityMapModule_ConnectivityMap as ConnectivityMap, CircuitJsonToConnectivityMapModule_PcbConnectivityMap as PcbConnectivityMap, CircuitJsonToConnectivityMapModule_findConnectedNetworks as findConnectedNetworks, CircuitJsonToConnectivityMapModule_getFullConnectivityMapFromCircuitJson as getFullConnectivityMapFromCircuitJson, CircuitJsonToConnectivityMapModule_getSourcePortConnectivityMapFromCircuitJson as getSourcePortConnectivityMapFromCircuitJson };
+}
+
+interface ExcellonDrillCommandDef<K extends string, T extends AnyZodObject | z.ZodIntersection<any, any>> {
+    command_code: K;
+    schema: T;
+    stringify: (c: z.infer<T>) => string;
+}
+
+declare const excellon_drill_command_map: {
+    G00: ExcellonDrillCommandDef<"G00", z.ZodObject<{
+        command_code: z.ZodDefault<z.ZodLiteral<"G00">>;
+    }, "strip", z.ZodTypeAny, {
+        command_code: "G00";
+    }, {
+        command_code?: "G00" | undefined;
+    }>>;
+    G01: ExcellonDrillCommandDef<"G01", z.ZodObject<{
+        command_code: z.ZodDefault<z.ZodLiteral<"G01">>;
+    }, "strip", z.ZodTypeAny, {
+        command_code: "G01";
+    }, {
+        command_code?: "G01" | undefined;
+    }>>;
+    G85: ExcellonDrillCommandDef<"G85", z.ZodObject<{
+        command_code: z.ZodDefault<z.ZodLiteral<"G85">>;
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        width: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        command_code: "G85";
+        x: number;
+        y: number;
+        width: number;
+    }, {
+        x: number;
+        y: number;
+        width: number;
+        command_code?: "G85" | undefined;
+    }>>;
+    M48: ExcellonDrillCommandDef<"M48", z.ZodObject<{
+        command_code: z.ZodDefault<z.ZodLiteral<"M48">>;
+    }, "strip", z.ZodTypeAny, {
+        command_code: "M48";
+    }, {
+        command_code?: "M48" | undefined;
+    }>>;
+    M95: ExcellonDrillCommandDef<"M95", z.ZodObject<{
+        command_code: z.ZodDefault<z.ZodLiteral<"M95">>;
+    }, "strip", z.ZodTypeAny, {
+        command_code: "M95";
+    }, {
+        command_code?: "M95" | undefined;
+    }>>;
+    FMAT: ExcellonDrillCommandDef<"FMAT", z.ZodObject<{
+        command_code: z.ZodDefault<z.ZodLiteral<"FMAT">>;
+        format: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        command_code: "FMAT";
+        format: number;
+    }, {
+        format: number;
+        command_code?: "FMAT" | undefined;
+    }>>;
+    unit_format: ExcellonDrillCommandDef<"unit_format", z.ZodObject<{
+        command_code: z.ZodDefault<z.ZodLiteral<"unit_format">>;
+        unit: z.ZodUnion<[z.ZodLiteral<"INCH">, z.ZodLiteral<"METRIC">]>;
+        lz: z.ZodDefault<z.ZodNullable<z.ZodUnion<[z.ZodLiteral<"LZ">, z.ZodLiteral<"TZ">]>>>;
+    }, "strip", z.ZodTypeAny, {
+        command_code: "unit_format";
+        unit: "INCH" | "METRIC";
+        lz: "LZ" | "TZ" | null;
+    }, {
+        unit: "INCH" | "METRIC";
+        command_code?: "unit_format" | undefined;
+        lz?: "LZ" | "TZ" | null | undefined;
+    }>>;
+    aper_function_header: ExcellonDrillCommandDef<"aper_function_header", z.ZodObject<{
+        command_code: z.ZodDefault<z.ZodLiteral<"aper_function_header">>;
+        is_plated: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        is_plated: boolean;
+        command_code: "aper_function_header";
+    }, {
+        is_plated: boolean;
+        command_code?: "aper_function_header" | undefined;
+    }>>;
+    percent_sign: ExcellonDrillCommandDef<"percent_sign", z.ZodObject<{
+        command_code: z.ZodDefault<z.ZodLiteral<"percent_sign">>;
+    }, "strip", z.ZodTypeAny, {
+        command_code: "percent_sign";
+    }, {
+        command_code?: "percent_sign" | undefined;
+    }>>;
+    T: ExcellonDrillCommandDef<"define_tool", z.ZodObject<{
+        command_code: z.ZodDefault<z.ZodLiteral<"define_tool">>;
+        tool_number: z.ZodNumber;
+        diameter: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        command_code: "define_tool";
+        tool_number: number;
+        diameter: number;
+    }, {
+        tool_number: number;
+        diameter: number;
+        command_code?: "define_tool" | undefined;
+    }>>;
+    define_tool: ExcellonDrillCommandDef<"define_tool", z.ZodObject<{
+        command_code: z.ZodDefault<z.ZodLiteral<"define_tool">>;
+        tool_number: z.ZodNumber;
+        diameter: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        command_code: "define_tool";
+        tool_number: number;
+        diameter: number;
+    }, {
+        tool_number: number;
+        diameter: number;
+        command_code?: "define_tool" | undefined;
+    }>>;
+    use_tool: ExcellonDrillCommandDef<"use_tool", z.ZodObject<{
+        command_code: z.ZodDefault<z.ZodLiteral<"use_tool">>;
+        tool_number: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        command_code: "use_tool";
+        tool_number: number;
+    }, {
+        tool_number: number;
+        command_code?: "use_tool" | undefined;
+    }>>;
+    G90: ExcellonDrillCommandDef<"G90", z.ZodObject<{
+        command_code: z.ZodDefault<z.ZodLiteral<"G90">>;
+    }, "strip", z.ZodTypeAny, {
+        command_code: "G90";
+    }, {
+        command_code?: "G90" | undefined;
+    }>>;
+    G05: ExcellonDrillCommandDef<"G05", z.ZodObject<{
+        command_code: z.ZodDefault<z.ZodLiteral<"G05">>;
+    }, "strip", z.ZodTypeAny, {
+        command_code: "G05";
+    }, {
+        command_code?: "G05" | undefined;
+    }>>;
+    M15: ExcellonDrillCommandDef<"M15", z.ZodObject<{
+        command_code: z.ZodDefault<z.ZodLiteral<"M15">>;
+    }, "strip", z.ZodTypeAny, {
+        command_code: "M15";
+    }, {
+        command_code?: "M15" | undefined;
+    }>>;
+    M16: ExcellonDrillCommandDef<"M16", z.ZodObject<{
+        command_code: z.ZodDefault<z.ZodLiteral<"M16">>;
+    }, "strip", z.ZodTypeAny, {
+        command_code: "M16";
+    }, {
+        command_code?: "M16" | undefined;
+    }>>;
+    M30: ExcellonDrillCommandDef<"M30", z.ZodObject<{
+        command_code: z.ZodDefault<z.ZodLiteral<"M30">>;
+    }, "strip", z.ZodTypeAny, {
+        command_code: "M30";
+    }, {
+        command_code?: "M30" | undefined;
+    }>>;
+    drill_at: ExcellonDrillCommandDef<"drill_at", z.ZodObject<{
+        command_code: z.ZodDefault<z.ZodLiteral<"drill_at">>;
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        command_code: "drill_at";
+        x: number;
+        y: number;
+    }, {
+        x: number;
+        y: number;
+        command_code?: "drill_at" | undefined;
+    }>>;
+    header_comment: ExcellonDrillCommandDef<"header_comment", z.ZodObject<{
+        command_code: z.ZodDefault<z.ZodLiteral<"header_comment">>;
+        text: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        command_code: "header_comment";
+        text: string;
+    }, {
+        text: string;
+        command_code?: "header_comment" | undefined;
+    }>>;
+    header_attribute: ExcellonDrillCommandDef<"header_attribute", z.ZodObject<{
+        command_code: z.ZodDefault<z.ZodLiteral<"header_attribute">>;
+        attribute_name: z.ZodString;
+        attribute_value: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        command_code: "header_attribute";
+        attribute_name: string;
+        attribute_value: string;
+    }, {
+        attribute_name: string;
+        attribute_value: string;
+        command_code?: "header_attribute" | undefined;
+    }>>;
+    rewind: ExcellonDrillCommandDef<"rewind", z.ZodObject<{
+        command_code: z.ZodDefault<z.ZodLiteral<"rewind">>;
+    }, "strip", z.ZodTypeAny, {
+        command_code: "rewind";
+    }, {
+        command_code?: "rewind" | undefined;
+    }>>;
+};
+type AnyExcellonDrillCommand = z.infer<(typeof excellon_drill_command_map)[keyof typeof excellon_drill_command_map]["schema"]>;
+
+declare const stringifyExcellonDrill: (commands: Array<AnyExcellonDrillCommand>) => string;
+
+declare const convertSoupToExcellonDrillCommands: ({ circuitJson, is_plated, flip_y_axis, }: {
+    circuitJson: Array<AnyCircuitElement>;
+    is_plated: boolean;
+    flip_y_axis?: boolean;
+}) => Array<AnyExcellonDrillCommand>;
+
+declare class ExcellonDrillBuilder {
+    commands: Array<AnyExcellonDrillCommand>;
+    constructor();
+    add<T extends keyof typeof excellon_drill_command_map>(cmd: T, props: z.input<(typeof excellon_drill_command_map)[T]["schema"]>): ExcellonDrillBuilder;
+    build(): Array<AnyExcellonDrillCommand>;
+}
+declare const excellonDrill: () => ExcellonDrillBuilder;
+
+interface GerberCommandDef<K extends string, T extends AnyZodObject | z.ZodIntersection<any, any>> {
+    command_code: K;
+    schema: T;
+    stringify: (c: z.infer<T>) => string;
+}
+
+declare const gerber_command_map: {
+    readonly add_attribute_on_aperture: GerberCommandDef<"TA", z.ZodObject<{
+        command_code: z.ZodDefault<z.ZodLiteral<"TA">>;
+        attribute_name: z.ZodString;
+        attribute_value: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        command_code: "TA";
+        attribute_name: string;
+        attribute_value: string;
+    }, {
+        attribute_name: string;
+        attribute_value: string;
+        command_code?: "TA" | undefined;
+    }>>;
+    readonly add_attribute_on_file: GerberCommandDef<"TF", z.ZodObject<{
+        command_code: z.ZodDefault<z.ZodLiteral<"TF">>;
+        attribute_name: z.ZodString;
+        attribute_value: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        command_code: "TF";
+        attribute_name: string;
+        attribute_value: string;
+    }, {
+        attribute_name: string;
+        attribute_value: string;
+        command_code?: "TF" | undefined;
+    }>>;
+    readonly add_attribute_on_object: GerberCommandDef<"TO", z.ZodObject<{
+        command_code: z.ZodDefault<z.ZodLiteral<"TO">>;
+        attribute_name: z.ZodString;
+        attribute_value: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        command_code: "TO";
+        attribute_name: string;
+        attribute_value: string;
+    }, {
+        attribute_name: string;
+        attribute_value: string;
+        command_code?: "TO" | undefined;
+    }>>;
+    readonly aperture_block: GerberCommandDef<"AB", z.ZodObject<{
+        command_code: z.ZodDefault<z.ZodLiteral<"AB">>;
+        block: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        command_code: "AB";
+        block: string;
+    }, {
+        block: string;
+        command_code?: "AB" | undefined;
+    }>>;
+    readonly comment: GerberCommandDef<"G04", z.ZodObject<{
+        command_code: z.ZodDefault<z.ZodLiteral<"G04">>;
+        comment: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        command_code: "G04";
+        comment: string;
+    }, {
+        comment: string;
+        command_code?: "G04" | undefined;
+    }>>;
+    readonly create_arc: GerberCommandDef<"G75", z.ZodObject<{
+        command_code: z.ZodDefault<z.ZodLiteral<"G75">>;
+    }, "strip", z.ZodTypeAny, {
+        command_code: "G75";
+    }, {
+        command_code?: "G75" | undefined;
+    }>>;
+    readonly define_aperture: GerberCommandDef<"AD", z.ZodObject<{
+        command_code: z.ZodDefault<z.ZodLiteral<"AD">>;
+        aperture_code: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        command_code: "AD";
+        aperture_code: string;
+    }, {
+        aperture_code: string;
+        command_code?: "AD" | undefined;
+    }>>;
+    readonly define_macro_aperture_template: GerberCommandDef<"AM", z.ZodObject<{
+        command_code: z.ZodDefault<z.ZodLiteral<"AM">>;
+        macro_name: z.ZodString;
+        template_code: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        command_code: "AM";
+        macro_name: string;
+        template_code: string;
+    }, {
+        macro_name: string;
+        template_code: string;
+        command_code?: "AM" | undefined;
+    }>>;
+    readonly delete_attribute: GerberCommandDef<"TD", z.ZodObject<{
+        command_code: z.ZodDefault<z.ZodLiteral<"TD">>;
+        attribute: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        command_code: "TD";
+        attribute?: string | undefined;
+    }, {
+        command_code?: "TD" | undefined;
+        attribute?: string | undefined;
+    }>>;
+    readonly end_of_file: GerberCommandDef<"M02", z.ZodObject<{
+        command_code: z.ZodDefault<z.ZodLiteral<"M02">>;
+    }, "strip", z.ZodTypeAny, {
+        command_code: "M02";
+    }, {
+        command_code?: "M02" | undefined;
+    }>>;
+    readonly move_operation: GerberCommandDef<"D02", z.ZodObject<{
+        command_code: z.ZodDefault<z.ZodLiteral<"D02">>;
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        command_code: "D02";
+        x: number;
+        y: number;
+    }, {
+        x: number;
+        y: number;
+        command_code?: "D02" | undefined;
+    }>>;
+    readonly flash_operation: GerberCommandDef<"D03", z.ZodObject<{
+        command_code: z.ZodDefault<z.ZodLiteral<"D03">>;
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        command_code: "D03";
+        x: number;
+        y: number;
+    }, {
+        x: number;
+        y: number;
+        command_code?: "D03" | undefined;
+    }>>;
+    readonly end_region_statement: GerberCommandDef<"G37", z.ZodObject<{
+        command_code: z.ZodDefault<z.ZodLiteral<"G37">>;
+    }, "strip", z.ZodTypeAny, {
+        command_code: "G37";
+    }, {
+        command_code?: "G37" | undefined;
+    }>>;
+    readonly format_specification: GerberCommandDef<"FS", z.ZodObject<{
+        command_code: z.ZodDefault<z.ZodLiteral<"FS">>;
+        zero_omission_mode: z.ZodDefault<z.ZodNullable<z.ZodUnion<[z.ZodLiteral<"L">, z.ZodLiteral<"T">]>>>;
+        coordinate_notation: z.ZodDefault<z.ZodUnion<[z.ZodLiteral<"A">, z.ZodLiteral<"I">]>>;
+        x_integer_digits: z.ZodDefault<z.ZodNumber>;
+        x_decimal_digits: z.ZodDefault<z.ZodNumber>;
+        y_integer_digits: z.ZodDefault<z.ZodNumber>;
+        y_decimal_digits: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        command_code: "FS";
+        zero_omission_mode: "T" | "L" | null;
+        coordinate_notation: "A" | "I";
+        x_integer_digits: number;
+        x_decimal_digits: number;
+        y_integer_digits: number;
+        y_decimal_digits: number;
+    }, {
+        command_code?: "FS" | undefined;
+        zero_omission_mode?: "T" | "L" | null | undefined;
+        coordinate_notation?: "A" | "I" | undefined;
+        x_integer_digits?: number | undefined;
+        x_decimal_digits?: number | undefined;
+        y_integer_digits?: number | undefined;
+        y_decimal_digits?: number | undefined;
+    }>>;
+    readonly load_rotation: GerberCommandDef<"LR", z.ZodObject<{
+        command_code: z.ZodDefault<z.ZodLiteral<"LR">>;
+        rotation_degrees: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        command_code: "LR";
+        rotation_degrees: number;
+    }, {
+        rotation_degrees: number;
+        command_code?: "LR" | undefined;
+    }>>;
+    readonly plot_operation: GerberCommandDef<"D01", z.ZodObject<{
+        command_code: z.ZodDefault<z.ZodLiteral<"D01">>;
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        i: z.ZodOptional<z.ZodNumber>;
+        j: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        command_code: "D01";
+        x: number;
+        y: number;
+        i?: number | undefined;
+        j?: number | undefined;
+    }, {
+        x: number;
+        y: number;
+        command_code?: "D01" | undefined;
+        i?: number | undefined;
+        j?: number | undefined;
+    }>>;
+    readonly define_aperture_template: GerberCommandDef<"ADD", z.ZodIntersection<z.ZodUnion<[z.ZodDiscriminatedUnion<"standard_template_code", [z.ZodObject<{
+        standard_template_code: z.ZodLiteral<"C">;
+        diameter: z.ZodNumber;
+        hole_diameter: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        diameter: number;
+        standard_template_code: "C";
+        hole_diameter?: number | undefined;
+    }, {
+        diameter: number;
+        standard_template_code: "C";
+        hole_diameter?: number | undefined;
+    }>, z.ZodObject<{
+        standard_template_code: z.ZodLiteral<"R">;
+        x_size: z.ZodNumber;
+        y_size: z.ZodNumber;
+        hole_diameter: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        standard_template_code: "R";
+        x_size: number;
+        y_size: number;
+        hole_diameter?: number | undefined;
+    }, {
+        standard_template_code: "R";
+        x_size: number;
+        y_size: number;
+        hole_diameter?: number | undefined;
+    }>, z.ZodObject<{
+        standard_template_code: z.ZodLiteral<"O">;
+        x_size: z.ZodNumber;
+        y_size: z.ZodNumber;
+        hole_diameter: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        standard_template_code: "O";
+        x_size: number;
+        y_size: number;
+        hole_diameter?: number | undefined;
+    }, {
+        standard_template_code: "O";
+        x_size: number;
+        y_size: number;
+        hole_diameter?: number | undefined;
+    }>, z.ZodObject<{
+        standard_template_code: z.ZodLiteral<"P">;
+        outer_diameter: z.ZodNumber;
+        number_of_vertices: z.ZodNumber;
+        rotation: z.ZodOptional<z.ZodNumber>;
+        hole_diameter: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        standard_template_code: "P";
+        outer_diameter: number;
+        number_of_vertices: number;
+        hole_diameter?: number | undefined;
+        rotation?: number | undefined;
+    }, {
+        standard_template_code: "P";
+        outer_diameter: number;
+        number_of_vertices: number;
+        hole_diameter?: number | undefined;
+        rotation?: number | undefined;
+    }>]>, z.ZodDiscriminatedUnion<"macro_name", [z.ZodObject<{
+        macro_name: z.ZodLiteral<"HORZPILL">;
+        x_size: z.ZodNumber;
+        y_size: z.ZodNumber;
+        circle_diameter: z.ZodNumber;
+        circle_center_offset: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        macro_name: "HORZPILL";
+        x_size: number;
+        y_size: number;
+        circle_diameter: number;
+        circle_center_offset: number;
+    }, {
+        macro_name: "HORZPILL";
+        x_size: number;
+        y_size: number;
+        circle_diameter: number;
+        circle_center_offset: number;
+    }>, z.ZodObject<{
+        macro_name: z.ZodLiteral<"VERTPILL">;
+        x_size: z.ZodNumber;
+        y_size: z.ZodNumber;
+        circle_diameter: z.ZodNumber;
+        circle_center_offset: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        macro_name: "VERTPILL";
+        x_size: number;
+        y_size: number;
+        circle_diameter: number;
+        circle_center_offset: number;
+    }, {
+        macro_name: "VERTPILL";
+        x_size: number;
+        y_size: number;
+        circle_diameter: number;
+        circle_center_offset: number;
+    }>, z.ZodObject<{
+        macro_name: z.ZodLiteral<"ROUNDRECT">;
+        corner_radius: z.ZodNumber;
+        corner_1_x: z.ZodNumber;
+        corner_1_y: z.ZodNumber;
+        corner_2_x: z.ZodNumber;
+        corner_2_y: z.ZodNumber;
+        corner_3_x: z.ZodNumber;
+        corner_3_y: z.ZodNumber;
+        corner_4_x: z.ZodNumber;
+        corner_4_y: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        macro_name: "ROUNDRECT";
+        corner_radius: number;
+        corner_1_x: number;
+        corner_1_y: number;
+        corner_2_x: number;
+        corner_2_y: number;
+        corner_3_x: number;
+        corner_3_y: number;
+        corner_4_x: number;
+        corner_4_y: number;
+    }, {
+        macro_name: "ROUNDRECT";
+        corner_radius: number;
+        corner_1_x: number;
+        corner_1_y: number;
+        corner_2_x: number;
+        corner_2_y: number;
+        corner_3_x: number;
+        corner_3_y: number;
+        corner_4_x: number;
+        corner_4_y: number;
+    }>]>]>, z.ZodObject<{
+        command_code: z.ZodDefault<z.ZodLiteral<"ADD">>;
+        aperture_number: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        command_code: "ADD";
+        aperture_number: number;
+    }, {
+        aperture_number: number;
+        command_code?: "ADD" | undefined;
+    }>>>;
+    readonly set_movement_mode_to_clockwise_circular: GerberCommandDef<"G02", z.ZodObject<{
+        command_code: z.ZodDefault<z.ZodLiteral<"G02">>;
+    }, "strip", z.ZodTypeAny, {
+        command_code: "G02";
+    }, {
+        command_code?: "G02" | undefined;
+    }>>;
+    readonly set_movement_mode_to_counterclockwise_circular: GerberCommandDef<"G03", z.ZodObject<{
+        command_code: z.ZodDefault<z.ZodLiteral<"G03">>;
+    }, "strip", z.ZodTypeAny, {
+        command_code: "G03";
+    }, {
+        command_code?: "G03" | undefined;
+    }>>;
+    readonly set_movement_mode_to_linear: GerberCommandDef<"G01", z.ZodObject<{
+        command_code: z.ZodDefault<z.ZodLiteral<"G01">>;
+    }, "strip", z.ZodTypeAny, {
+        command_code: "G01";
+    }, {
+        command_code?: "G01" | undefined;
+    }>>;
+    readonly select_aperture: GerberCommandDef<"D", z.ZodObject<{
+        command_code: z.ZodDefault<z.ZodLiteral<"D">>;
+        aperture_number: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        command_code: "D";
+        aperture_number: number;
+    }, {
+        aperture_number: number;
+        command_code?: "D" | undefined;
+    }>>;
+    readonly set_unit: GerberCommandDef<"MO", z.ZodObject<{
+        command_code: z.ZodDefault<z.ZodLiteral<"MO">>;
+        unit: z.ZodEnum<["MM", "in"]>;
+    }, "strip", z.ZodTypeAny, {
+        command_code: "MO";
+        unit: "MM" | "in";
+    }, {
+        unit: "MM" | "in";
+        command_code?: "MO" | undefined;
+    }>>;
+    readonly set_layer_polarity: GerberCommandDef<"LP", z.ZodObject<{
+        command_code: z.ZodDefault<z.ZodLiteral<"LP">>;
+        polarity: z.ZodEnum<["D", "C"]>;
+    }, "strip", z.ZodTypeAny, {
+        command_code: "LP";
+        polarity: "C" | "D";
+    }, {
+        polarity: "C" | "D";
+        command_code?: "LP" | undefined;
+    }>>;
+    readonly start_region_statement: GerberCommandDef<"G36", z.ZodObject<{
+        command_code: z.ZodDefault<z.ZodLiteral<"G36">>;
+    }, "strip", z.ZodTypeAny, {
+        command_code: "G36";
+    }, {
+        command_code?: "G36" | undefined;
+    }>>;
+};
+type AnyGerberCommand = z.infer<(typeof gerber_command_map)[keyof typeof gerber_command_map]["schema"]>;
+
+declare const gerberBuilder: () => GerberBuilder;
+declare class GerberBuilder {
+    commands: Array<AnyGerberCommand>;
+    constructor();
+    $if(condition: boolean, fn: (gb: GerberBuilder) => GerberBuilder): GerberBuilder;
+    add<T extends keyof typeof gerber_command_map>(cmd: T, props: z.input<(typeof gerber_command_map)[T]["schema"]>): GerberBuilder;
+    build(): Array<AnyGerberCommand>;
+}
+
+type LayerToGerberCommandsMap = {
+    F_Cu: AnyGerberCommand[];
+    F_SilkScreen: AnyGerberCommand[];
+    F_Mask: AnyGerberCommand[];
+    F_Paste: AnyGerberCommand[];
+    B_Cu: AnyGerberCommand[];
+    B_SilkScreen: AnyGerberCommand[];
+    B_Mask: AnyGerberCommand[];
+    B_Paste: AnyGerberCommand[];
+    Edge_Cuts: AnyGerberCommand[];
+};
+type GerberLayerName = keyof LayerToGerberCommandsMap;
+
+declare const stringifyGerberCommandLayers: (commandLayers: Record<GerberLayerName, AnyGerberCommand[]>) => Record<GerberLayerName, string>;
+
+declare const stringifyGerberCommand: (command: AnyGerberCommand) => string;
+
+declare const stringifyGerberCommands: (commands: AnyGerberCommand[]) => string;
+
+/**
+ * Converts tscircuit soup to arrays of Gerber commands for each layer
+ */
+declare const convertSoupToGerberCommands: (soup: AnyCircuitElement[], opts?: {
+    flip_y_axis?: boolean;
+}) => LayerToGerberCommandsMap;
+
+declare const CircuitJsonToGerberModule_convertSoupToExcellonDrillCommands: typeof convertSoupToExcellonDrillCommands;
+declare const CircuitJsonToGerberModule_convertSoupToGerberCommands: typeof convertSoupToGerberCommands;
+declare const CircuitJsonToGerberModule_excellonDrill: typeof excellonDrill;
+declare const CircuitJsonToGerberModule_gerberBuilder: typeof gerberBuilder;
+declare const CircuitJsonToGerberModule_stringifyExcellonDrill: typeof stringifyExcellonDrill;
+declare const CircuitJsonToGerberModule_stringifyGerberCommand: typeof stringifyGerberCommand;
+declare const CircuitJsonToGerberModule_stringifyGerberCommandLayers: typeof stringifyGerberCommandLayers;
+declare const CircuitJsonToGerberModule_stringifyGerberCommands: typeof stringifyGerberCommands;
+declare namespace CircuitJsonToGerberModule {
+  export { CircuitJsonToGerberModule_convertSoupToExcellonDrillCommands as convertSoupToExcellonDrillCommands, CircuitJsonToGerberModule_convertSoupToGerberCommands as convertSoupToGerberCommands, CircuitJsonToGerberModule_excellonDrill as excellonDrill, CircuitJsonToGerberModule_gerberBuilder as gerberBuilder, CircuitJsonToGerberModule_stringifyExcellonDrill as stringifyExcellonDrill, CircuitJsonToGerberModule_stringifyGerberCommand as stringifyGerberCommand, CircuitJsonToGerberModule_stringifyGerberCommandLayers as stringifyGerberCommandLayers, CircuitJsonToGerberModule_stringifyGerberCommands as stringifyGerberCommands };
+}
+
+interface AuthHeaders extends Record<string, string> {
+    Authorization: string;
+}
+interface ConversionOptions {
+    format?: "gltf" | "glb";
+    boardTextureResolution?: number;
+    showPcbNotes?: boolean;
+    boardDrillQuality?: "high" | "fast";
+    drawFauxBoard?: boolean;
+    includeModels?: boolean;
+    modelCache?: Map<string, STLMesh | OBJMesh>;
+    backgroundColor?: string;
+    showBoundingBoxes?: boolean;
+    coordinateTransform?: CoordinateTransformConfig;
+    projectBaseUrl?: string;
+    authHeaders?: AuthHeaders;
+}
+interface CoordinateTransformConfig {
+    flipX?: number;
+    flipY?: number;
+    flipZ?: number;
+    axisMapping?: {
+        x?: "x" | "y" | "z" | "-x" | "-y" | "-z";
+        y?: "x" | "y" | "z" | "-x" | "-y" | "-z";
+        z?: "x" | "y" | "z" | "-x" | "-y" | "-z";
+    };
+    rotation?: {
+        x?: number;
+        y?: number;
+        z?: number;
+    };
+}
+interface Point3 {
+    x: number;
+    y: number;
+    z: number;
+}
+interface Size3 {
+    x: number;
+    y: number;
+    z: number;
+}
+interface Triangle {
+    vertices: [Point3, Point3, Point3];
+    normal: Point3;
+    color?: Color;
+    materialIndex?: number;
+}
+interface BoundingBox {
+    min: Point3;
+    max: Point3;
+}
+interface STLMesh {
+    triangles: Triangle[];
+    boundingBox: BoundingBox;
+}
+interface OBJMesh extends STLMesh {
+    materials?: Map<string, OBJMaterial>;
+    materialIndexMap?: Map<string, number>;
+}
+interface OBJMaterial {
+    name: string;
+    color?: Color;
+    ambient?: Color;
+    specular?: Color;
+    shininess?: number;
+    dissolve?: number;
+}
+type Color = string | [number, number, number, number];
+interface Box3D {
+    center: Point3;
+    size: Size3;
+    rotation?: Point3;
+    color?: Color;
+    texture?: {
+        top?: string;
+        bottom?: string;
+        front?: string;
+        back?: string;
+        left?: string;
+        right?: string;
+    };
+    mesh?: STLMesh | OBJMesh;
+    meshUrl?: string;
+    meshType?: "stl" | "obj" | "glb" | "step";
+    label?: string;
+    labelColor?: Color;
+    isTranslucent?: boolean;
+}
+interface Scene3D {
+    boxes: Box3D[];
+    camera?: Camera3D;
+    lights?: Light3D[];
+}
+interface Camera3D {
+    position: Point3;
+    target: Point3;
+    up?: Point3;
+    fov?: number;
+    near?: number;
+    far?: number;
+}
+interface Light3D {
+    type: "ambient" | "directional" | "point";
+    color?: Color;
+    intensity?: number;
+    position?: Point3;
+    direction?: Point3;
+}
+interface GLTFExportOptions {
+    binary?: boolean;
+    trs?: boolean;
+    onlyVisible?: boolean;
+    truncateDrawRange?: boolean;
+    embedImages?: boolean;
+    animations?: any[];
+    forceIndices?: boolean;
+    includeCustomExtensions?: boolean;
+}
+interface CircuitTo3DOptions {
+    pcbColor?: Color;
+    componentColor?: Color;
+    copperColor?: Color;
+    boardThickness?: number;
+    boardDrillQuality?: "high" | "fast";
+    drawFauxBoard?: boolean;
+    defaultComponentHeight?: number;
+    renderBoardTextures?: boolean;
+    textureResolution?: number;
+    showPcbNotes?: boolean;
+    coordinateTransform?: CoordinateTransformConfig;
+    showBoundingBoxes?: boolean;
+    projectBaseUrl?: string;
+    authHeaders?: AuthHeaders;
+}
+interface BoardRenderOptions {
+    layer: "top" | "bottom";
+    resolution?: number;
+    backgroundColor?: string;
+    copperColor?: string;
+    silkscreenColor?: string;
+    padColor?: string;
+    drillColor?: string;
+    showPcbNotes?: boolean;
+}
+
+declare function renderBoardLayer(circuitJson: CircuitJson, options: BoardRenderOptions): Promise<string>;
+declare function renderBoardTextures(circuitJson: CircuitJson, { resolution, showPcbNotes }: {
+    resolution?: number | undefined;
+    showPcbNotes?: boolean | undefined;
+}): Promise<{
+    top: string;
+    bottom: string;
+}>;
+
+declare function convertCircuitJsonTo3D(circuitJson: CircuitJson, options?: CircuitTo3DOptions): Promise<Scene3D>;
+
+declare function convertSceneToGLTF(scene: Scene3D, options?: GLTFExportOptions): Promise<ArrayBuffer | object>;
+
+declare function loadGLB({ url, transform, projectBaseUrl, authHeaders, }: {
+    url: string;
+    transform?: CoordinateTransformConfig;
+    projectBaseUrl?: string;
+    authHeaders?: AuthHeaders;
+}): Promise<STLMesh | OBJMesh>;
+declare function clearGLBCache(): void;
+
+declare function loadOBJ({ url, transform, projectBaseUrl, authHeaders, }: {
+    url: string;
+    transform?: CoordinateTransformConfig;
+    projectBaseUrl?: string;
+    authHeaders?: AuthHeaders;
+}): Promise<OBJMesh>;
+declare function clearOBJCache(): void;
+
+declare function loadSTL({ url, transform, projectBaseUrl, authHeaders, }: {
+    url: string;
+    transform?: CoordinateTransformConfig;
+    projectBaseUrl?: string;
+    authHeaders?: AuthHeaders;
+}): Promise<STLMesh>;
+declare function clearSTLCache(): void;
+
+interface CameraFitOptions {
+    /**
+     * Target-to-camera direction vector used for solved camera position.
+     */
+    direction?: readonly [number, number, number];
+    /**
+     * Vertical field of view in degrees.
+     */
+    fov?: number;
+    /**
+     * Aspect ratio (width / height) used for horizontal fit calculations.
+     */
+    aspectRatio?: number;
+    /**
+     * Focal length in millimeters. If provided with sensorHeight,
+     * it is used instead of fov.
+     */
+    focalLength?: number;
+    /**
+     * Sensor height in millimeters for focalLength->fov conversion.
+     */
+    sensorHeight?: number;
+}
+/**
+ * Calculate optimal camera position for PCB viewing based on circuit dimensions
+ */
+declare function getBestCameraPosition(circuitJson: CircuitJson): {
+    camPos: readonly [number, number, number];
+    lookAt: readonly [number, number, number];
+    fov: number;
+};
+
+declare function applyCoordinateTransform(point: Point3, config: CoordinateTransformConfig): Point3;
+declare function transformTriangles(triangles: Triangle[], config: CoordinateTransformConfig): Triangle[];
+declare const COORDINATE_TRANSFORMS: {
+    readonly Z_UP_TO_Y_UP: CoordinateTransformConfig;
+    readonly Z_OUT_OF_TOP: CoordinateTransformConfig;
+    readonly STEP_INVERTED: CoordinateTransformConfig;
+    readonly USB_PORT_FIX: CoordinateTransformConfig;
+    readonly Z_UP_TO_Y_UP_USB_FIX: CoordinateTransformConfig;
+    readonly IDENTITY: CoordinateTransformConfig;
+    readonly TEST_ROTATE_X_90: CoordinateTransformConfig;
+    readonly TEST_ROTATE_X_270: CoordinateTransformConfig;
+    readonly TEST_ROTATE_Y_90: CoordinateTransformConfig;
+    readonly TEST_ROTATE_Y_270: CoordinateTransformConfig;
+    readonly TEST_ROTATE_Z_90: CoordinateTransformConfig;
+    readonly TEST_ROTATE_Z_270: CoordinateTransformConfig;
+    readonly TEST_FLIP_X: CoordinateTransformConfig;
+    readonly TEST_FLIP_Z: CoordinateTransformConfig;
+    readonly FOOTPRINTER_MODEL_TRANSFORM: CoordinateTransformConfig;
+    readonly OBJ_Z_UP_TO_Y_UP: CoordinateTransformConfig;
+};
+
+declare function convertCircuitJsonToGltf(circuitJson: CircuitJson, options?: ConversionOptions): Promise<ArrayBuffer | object>;
+
+interface Point {
+    x: number;
+    y: number;
+}
+type LayerRef = string | number;
+interface BRepShape {
+    polygons: Point[][];
+    is_negative?: boolean;
+}
+
+type CircuitJsonToGltfModule_BRepShape = BRepShape;
+type CircuitJsonToGltfModule_BoardRenderOptions = BoardRenderOptions;
+type CircuitJsonToGltfModule_BoundingBox = BoundingBox;
+type CircuitJsonToGltfModule_Box3D = Box3D;
+declare const CircuitJsonToGltfModule_COORDINATE_TRANSFORMS: typeof COORDINATE_TRANSFORMS;
+type CircuitJsonToGltfModule_Camera3D = Camera3D;
+type CircuitJsonToGltfModule_CameraFitOptions = CameraFitOptions;
+type CircuitJsonToGltfModule_CircuitTo3DOptions = CircuitTo3DOptions;
+type CircuitJsonToGltfModule_Color = Color;
+type CircuitJsonToGltfModule_ConversionOptions = ConversionOptions;
+type CircuitJsonToGltfModule_CoordinateTransformConfig = CoordinateTransformConfig;
+type CircuitJsonToGltfModule_GLTFExportOptions = GLTFExportOptions;
+type CircuitJsonToGltfModule_LayerRef = LayerRef;
+type CircuitJsonToGltfModule_Light3D = Light3D;
+type CircuitJsonToGltfModule_OBJMaterial = OBJMaterial;
+type CircuitJsonToGltfModule_OBJMesh = OBJMesh;
+type CircuitJsonToGltfModule_Point = Point;
+type CircuitJsonToGltfModule_Point3 = Point3;
+type CircuitJsonToGltfModule_STLMesh = STLMesh;
+type CircuitJsonToGltfModule_Scene3D = Scene3D;
+type CircuitJsonToGltfModule_Size3 = Size3;
+type CircuitJsonToGltfModule_Triangle = Triangle;
+declare const CircuitJsonToGltfModule_applyCoordinateTransform: typeof applyCoordinateTransform;
+declare const CircuitJsonToGltfModule_clearGLBCache: typeof clearGLBCache;
+declare const CircuitJsonToGltfModule_clearOBJCache: typeof clearOBJCache;
+declare const CircuitJsonToGltfModule_clearSTLCache: typeof clearSTLCache;
+declare const CircuitJsonToGltfModule_convertCircuitJsonTo3D: typeof convertCircuitJsonTo3D;
+declare const CircuitJsonToGltfModule_convertCircuitJsonToGltf: typeof convertCircuitJsonToGltf;
+declare const CircuitJsonToGltfModule_convertSceneToGLTF: typeof convertSceneToGLTF;
+declare const CircuitJsonToGltfModule_getBestCameraPosition: typeof getBestCameraPosition;
+declare const CircuitJsonToGltfModule_loadGLB: typeof loadGLB;
+declare const CircuitJsonToGltfModule_loadOBJ: typeof loadOBJ;
+declare const CircuitJsonToGltfModule_loadSTL: typeof loadSTL;
+declare const CircuitJsonToGltfModule_renderBoardLayer: typeof renderBoardLayer;
+declare const CircuitJsonToGltfModule_renderBoardTextures: typeof renderBoardTextures;
+declare const CircuitJsonToGltfModule_transformTriangles: typeof transformTriangles;
+declare namespace CircuitJsonToGltfModule {
+  export { type CircuitJsonToGltfModule_BRepShape as BRepShape, type CircuitJsonToGltfModule_BoardRenderOptions as BoardRenderOptions, type CircuitJsonToGltfModule_BoundingBox as BoundingBox, type CircuitJsonToGltfModule_Box3D as Box3D, CircuitJsonToGltfModule_COORDINATE_TRANSFORMS as COORDINATE_TRANSFORMS, type CircuitJsonToGltfModule_Camera3D as Camera3D, type CircuitJsonToGltfModule_CameraFitOptions as CameraFitOptions, type CircuitJsonToGltfModule_CircuitTo3DOptions as CircuitTo3DOptions, type CircuitJsonToGltfModule_Color as Color, type CircuitJsonToGltfModule_ConversionOptions as ConversionOptions, type CircuitJsonToGltfModule_CoordinateTransformConfig as CoordinateTransformConfig, type CircuitJsonToGltfModule_GLTFExportOptions as GLTFExportOptions, type CircuitJsonToGltfModule_LayerRef as LayerRef, type CircuitJsonToGltfModule_Light3D as Light3D, type CircuitJsonToGltfModule_OBJMaterial as OBJMaterial, type CircuitJsonToGltfModule_OBJMesh as OBJMesh, type CircuitJsonToGltfModule_Point as Point, type CircuitJsonToGltfModule_Point3 as Point3, type CircuitJsonToGltfModule_STLMesh as STLMesh, type CircuitJsonToGltfModule_Scene3D as Scene3D, type CircuitJsonToGltfModule_Size3 as Size3, type CircuitJsonToGltfModule_Triangle as Triangle, CircuitJsonToGltfModule_applyCoordinateTransform as applyCoordinateTransform, CircuitJsonToGltfModule_clearGLBCache as clearGLBCache, CircuitJsonToGltfModule_clearOBJCache as clearOBJCache, CircuitJsonToGltfModule_clearSTLCache as clearSTLCache, CircuitJsonToGltfModule_convertCircuitJsonTo3D as convertCircuitJsonTo3D, CircuitJsonToGltfModule_convertCircuitJsonToGltf as convertCircuitJsonToGltf, CircuitJsonToGltfModule_convertSceneToGLTF as convertSceneToGLTF, CircuitJsonToGltfModule_getBestCameraPosition as getBestCameraPosition, CircuitJsonToGltfModule_loadGLB as loadGLB, CircuitJsonToGltfModule_loadOBJ as loadOBJ, CircuitJsonToGltfModule_loadSTL as loadSTL, CircuitJsonToGltfModule_renderBoardLayer as renderBoardLayer, CircuitJsonToGltfModule_renderBoardTextures as renderBoardTextures, CircuitJsonToGltfModule_transformTriangles as transformTriangles };
+}
+
+type PaperSize = "A0" | "A1" | "A2" | "A3" | "A4" | "A5";
+interface PaperDimensions {
+    width: number;
+    height: number;
+    name: PaperSize;
+}
+
+type SchematicPortId = string;
+type SchematicTraceId = string;
+type PcbPortId = string;
+interface PcbNetInfo {
+    id: number;
+    name: string;
+}
+interface SymbolEntry {
+    symbolName: string;
+    symbol: SchematicSymbol;
+    /**
+     * Whether this symbol is from a standard library footprint (has footprinter_string).
+     * If true, this is a builtin/standard symbol. If false, it's a custom/inline symbol.
+     */
+    isBuiltin?: boolean;
+}
+interface FootprintEntry {
+    footprintName: string;
+    kicadModString: string;
+    model3dSourcePaths: string[];
+    /**
+     * Whether this footprint is from a standard library footprint (has footprinter_string).
+     * If true, this is a builtin/standard footprint. If false, it's a custom/inline footprint.
+     */
+    isBuiltin?: boolean;
+}
+interface KicadLibraryOutput {
+    kicadSymString: string;
+    symbols: SymbolEntry[];
+    footprints: FootprintEntry[];
+    fpLibTableString: string;
+    symLibTableString: string;
+    model3dSourcePaths: string[];
+}
+interface ConverterContext {
+    db: CircuitJsonUtilObjects;
+    circuitJson: CircuitJson;
+    kicadSch?: KicadSch;
+    kicadPcb?: KicadPcb;
+    /** Circuit JSON to KiCad schematic transformation matrix */
+    c2kMatSch?: Matrix;
+    /** Circuit JSON to KiCad PCB transformation matrix */
+    c2kMatPcb?: Matrix;
+    /** Selected paper size for schematic */
+    schematicPaperSize?: PaperDimensions;
+    pinPositions?: Map<SchematicPortId, {
+        x: number;
+        y: number;
+    }>;
+    wireConnections?: Map<SchematicTraceId, SchematicPortId[]>;
+    pcbPadPositions?: Map<PcbPortId, {
+        x: number;
+        y: number;
+    }>;
+    pcbNetMap?: Map<string, PcbNetInfo>;
+    numLayers?: number;
+    /** Project name used as the .3dshapes folder for user-provided 3D models */
+    projectName?: string;
+    /** CDN URLs of 3D models needed for this PCB (collected during footprint stage) */
+    pcbModel3dSourcePaths?: string[];
+    libraryName?: string;
+    fpLibraryName?: string;
+    kicadSchString?: string;
+    kicadPcbString?: string;
+    symbolEntries?: SymbolEntry[];
+    footprintEntries?: FootprintEntry[];
+    libraryOutput?: KicadLibraryOutput;
+}
+declare abstract class ConverterStage<Input, Output> {
+    MAX_ITERATIONS: number;
+    iteration: number;
+    finished: boolean;
+    input: Input;
+    ctx: ConverterContext;
+    constructor(input: Input, ctx: ConverterContext);
+    step(): void;
+    _step(): void;
+    runUntilFinished(): void;
+    getOutput(): Output;
+}
+
+declare class CircuitJsonToKicadSchConverter {
+    ctx: ConverterContext;
+    pipeline: ConverterStage<CircuitJson, KicadSch>[];
+    currentStageIndex: number;
+    finished: boolean;
+    get currentStage(): ConverterStage<CircuitJson, KicadSch> | undefined;
+    constructor(circuitJson: CircuitJson);
+    step(): void;
+    runUntilFinished(): void;
+    getOutput(): KicadSch;
+    /**
+     * Get the output as a string
+     */
+    getOutputString(): string;
+}
+
+interface CircuitJsonToKicadPcbOptions {
+    /**
+     * Set to true to embed "${KIPRJMOD}/3dmodels" 3D model references for
+     * builtin footprints. Enable this in the CLI zip export.
+     * Defaults to false.
+     */
+    includeBuiltin3dModels?: boolean;
+    /**
+     * Project name used as the .3dshapes folder for user-provided models.
+     * e.g. "index" → "3dmodels/index.3dshapes/{filename}"
+     */
+    projectName?: string;
+}
+declare class CircuitJsonToKicadPcbConverter {
+    ctx: ConverterContext;
+    pipeline: ConverterStage<CircuitJson, KicadPcb>[];
+    currentStageIndex: number;
+    finished: boolean;
+    get currentStage(): ConverterStage<CircuitJson, KicadPcb> | undefined;
+    constructor(circuitJson: CircuitJson, options?: CircuitJsonToKicadPcbOptions);
+    step(): void;
+    runUntilFinished(): void;
+    getOutput(): KicadPcb;
+    /**
+     * Get the output as a string
+     */
+    getOutputString(): string;
+    /**
+     * Returns CDN URLs for 3D model files needed by builtin footprints in this PCB.
+     * The CLI can use these to download and include the models in the project zip.
+     */
+    getModel3dSourcePaths(): string[];
+}
+
+interface CircuitJsonToKicadProOptions {
+    projectName?: string;
+    schematicFilename?: string;
+    pcbFilename?: string;
+}
+interface KicadProProject {
+    version: number;
+    head: {
+        generator: string;
+        generator_version: string;
+        project_name: string;
+        created: string;
+        modified: string;
+    };
+    meta: {
+        version: number;
+    };
+    text_variables: Record<string, string>;
+    libraries: {
+        pinned_symbol_libs: string[];
+        pinned_footprint_libs: string[];
+    };
+    boards: string[];
+    cvpcb: {
+        meta: {
+            version: number;
+        };
+    };
+    erc: {
+        meta: {
+            version: number;
+        };
+        erc_exclusions: unknown[];
+    };
+    net_settings: {
+        meta: {
+            version: number;
+        };
+        last_net_id: number;
+        classes: unknown[];
+    };
+    pcbnew: {
+        page_layout_descr_file: string;
+        last_paths: Record<string, string>;
+    };
+    schematic: {
+        meta: {
+            version: number;
+        };
+        page_layout_descr_file: string;
+        last_opened_files: string[];
+    };
+    board: {
+        meta: {
+            version: number;
+        };
+        last_opened_board: string;
+    };
+    sheets: [string, string][];
+}
+declare class CircuitJsonToKicadProConverter {
+    ctx: {
+        db: ReturnType<typeof cju>;
+        circuitJson: CircuitJson;
+    };
+    private project;
+    constructor(circuitJson: CircuitJson, options?: CircuitJsonToKicadProOptions);
+    runUntilFinished(): void;
+    getOutput(): KicadProProject;
+    getOutputString(): string;
+}
+
+interface CircuitJsonToKicadLibraryOptions {
+    libraryName?: string;
+    footprintLibraryName?: string;
+}
+
+declare class CircuitJsonToKicadLibraryConverter {
+    ctx: ConverterContext;
+    pipeline: ConverterStage<CircuitJson, KicadLibraryOutput>[];
+    currentStageIndex: number;
+    finished: boolean;
+    get currentStage(): ConverterStage<CircuitJson, KicadLibraryOutput> | undefined;
+    constructor(circuitJson: CircuitJson, options?: CircuitJsonToKicadLibraryOptions);
+    step(): void;
+    runUntilFinished(): void;
+    getOutput(): KicadLibraryOutput;
+    getSymbolLibraryString(): string;
+    getFootprints(): FootprintEntry[];
+    getFpLibTableString(): string;
+    getSymLibTableString(): string;
+    getModel3dSourcePaths(): string[];
+}
+
+interface KicadLibraryConverterOptions {
+    /**
+     * Name for the generated KiCad library (e.g., "my-library").
+     * This will be used for the user library files.
+     */
+    kicadLibraryName?: string;
+    /**
+     * The main entry point file for the library (e.g., "lib/my-library.ts").
+     * This file's exports define the public API of the library.
+     */
+    entrypoint: string;
+    /**
+     * Callback to build circuit JSON from a file path and export name.
+     * Should handle both board components and symbol components:
+     * - For board components: render inside a <board> element
+     * - For symbol components: render inside a <chip> with the symbol prop
+     *   (Note: tscircuit symbols cannot render standalone - they must be
+     *   used as a prop on a <chip> component)
+     * Return null if the export cannot be rendered.
+     */
+    buildFileToCircuitJson: (filePath: string, componentName: string) => Promise<CircuitJson | null>;
+    /**
+     * Callback to get all exports from a TSX/TS file.
+     * Must evaluate the file (not just parse) to handle `export * from` patterns.
+     */
+    getExportsFromTsxFile: (filePath: string) => Promise<string[]>;
+    /**
+     * Callback to resolve an export name to its file path.
+     * Returns the file path where the component is defined, or null if not resolvable.
+     */
+    resolveExportPath?: (entrypoint: string, exportName: string) => Promise<string | null>;
+    /**
+     * Whether to include builtin footprints/symbols (like 0402, soic8).
+     * Default: true
+     */
+    includeBuiltins?: boolean;
+    /**
+     * Whether to generate files for KiCad PCM (Plugin and Content Manager).
+     * When true:
+     * - Footprint references in symbols will be prefixed with "PCM_"
+     * - 3D model paths will use ${KICAD_3RD_PARTY} variable instead of relative paths
+     * Default: false
+     */
+    isPcm?: boolean;
+    /**
+     * The KiCad PCM package identifier (e.g., "com_tscircuit_author_package-name").
+     * Required when useKicadPcmPaths is true.
+     * Used to construct 3D model paths like:
+     * ${KICAD9_3RD_PARTY}/3dmodels/<kicadPcmPackageId>/<library>.3dshapes/<model>.step
+     */
+    kicadPcmPackageId?: string;
+}
+interface KicadLibraryConverterOutput {
+    /**
+     * Map of file paths to file contents for the generated KiCad library.
+     */
+    kicadProjectFsMap: Record<string, string | Buffer>;
+    /**
+     * Source paths to 3D model files that need to be copied.
+     */
+    model3dSourcePaths: string[];
+}
+
+/**
+ * Converts tscircuit component files to a KiCad library.
+ */
+declare class KicadLibraryConverter {
+    private options;
+    private output;
+    private ctx;
+    constructor(options: KicadLibraryConverterOptions);
+    run(): Promise<void>;
+    /**
+     * Builds tscircuit components to circuit-json.
+     */
+    private buildTscircuitComponents;
+    /**
+     * Extracts KiCad footprints and symbols from built tscircuit components.
+     */
+    private extractKicadComponents;
+    getOutput(): KicadLibraryConverterOutput;
+}
+
+type CircuitJsonToKicadModule_CircuitJsonToKicadLibraryConverter = CircuitJsonToKicadLibraryConverter;
+declare const CircuitJsonToKicadModule_CircuitJsonToKicadLibraryConverter: typeof CircuitJsonToKicadLibraryConverter;
+type CircuitJsonToKicadModule_CircuitJsonToKicadPcbConverter = CircuitJsonToKicadPcbConverter;
+declare const CircuitJsonToKicadModule_CircuitJsonToKicadPcbConverter: typeof CircuitJsonToKicadPcbConverter;
+type CircuitJsonToKicadModule_CircuitJsonToKicadProConverter = CircuitJsonToKicadProConverter;
+declare const CircuitJsonToKicadModule_CircuitJsonToKicadProConverter: typeof CircuitJsonToKicadProConverter;
+type CircuitJsonToKicadModule_CircuitJsonToKicadSchConverter = CircuitJsonToKicadSchConverter;
+declare const CircuitJsonToKicadModule_CircuitJsonToKicadSchConverter: typeof CircuitJsonToKicadSchConverter;
+type CircuitJsonToKicadModule_FootprintEntry = FootprintEntry;
+type CircuitJsonToKicadModule_KicadLibraryConverter = KicadLibraryConverter;
+declare const CircuitJsonToKicadModule_KicadLibraryConverter: typeof KicadLibraryConverter;
+type CircuitJsonToKicadModule_KicadLibraryConverterOptions = KicadLibraryConverterOptions;
+type CircuitJsonToKicadModule_KicadLibraryConverterOutput = KicadLibraryConverterOutput;
+type CircuitJsonToKicadModule_KicadLibraryOutput = KicadLibraryOutput;
+type CircuitJsonToKicadModule_SymbolEntry = SymbolEntry;
+declare namespace CircuitJsonToKicadModule {
+  export { CircuitJsonToKicadModule_CircuitJsonToKicadLibraryConverter as CircuitJsonToKicadLibraryConverter, CircuitJsonToKicadModule_CircuitJsonToKicadPcbConverter as CircuitJsonToKicadPcbConverter, CircuitJsonToKicadModule_CircuitJsonToKicadProConverter as CircuitJsonToKicadProConverter, CircuitJsonToKicadModule_CircuitJsonToKicadSchConverter as CircuitJsonToKicadSchConverter, type CircuitJsonToKicadModule_FootprintEntry as FootprintEntry, CircuitJsonToKicadModule_KicadLibraryConverter as KicadLibraryConverter, type CircuitJsonToKicadModule_KicadLibraryConverterOptions as KicadLibraryConverterOptions, type CircuitJsonToKicadModule_KicadLibraryConverterOutput as KicadLibraryConverterOutput, type CircuitJsonToKicadModule_KicadLibraryOutput as KicadLibraryOutput, type CircuitJsonToKicadModule_SymbolEntry as SymbolEntry };
+}
+
+interface ConvertCircuitJsonToLbrnOptions {
+    includeSilkscreen?: boolean;
+    origin?: {
+        x: number;
+        y: number;
+    };
+    margin?: number;
+    includeCopper?: boolean;
+    includeSoldermask?: boolean;
+    includeSoldermaskCure?: boolean;
+    globalCopperSoldermaskMarginAdjustment?: number;
+    solderMaskMarginPercent?: number;
+    includeLayers?: Array<"top" | "bottom">;
+    traceMargin?: number;
+    laserSpotSize?: number;
+    mirrorBottomLayer?: boolean;
+    /**
+     * Whether to generate copper cut fill layers.
+     * Creates a ring/band around traces and pads that will be laser cut
+     * to remove copper, without cutting into the traces or pads themselves.
+     */
+    includeCopperCutFill?: boolean;
+    /**
+     * Margin to expand the copper outline for the cut fill band (in mm).
+     * This determines how wide the band of copper removal will be around traces/pads.
+     */
+    copperCutFillMargin?: number;
+    /**
+     * Whether to generate an oxidation cleaning layer.
+     * Creates a filled area covering the entire "inside" of the board outline
+     * for laser ablation to clean oxidation from the copper surface.
+     */
+    includeOxidationCleaningLayer?: boolean;
+    laserProfile?: {
+        copper?: {
+            speed?: number;
+            numPasses?: number;
+            frequency?: number;
+            pulseWidth?: number;
+        };
+        board?: {
+            speed?: number;
+            numPasses?: number;
+            frequency?: number;
+            pulseWidth?: number;
+        };
+    };
+}
+declare const convertCircuitJsonToLbrn: (circuitJson: CircuitJson, options?: ConvertCircuitJsonToLbrnOptions) => Promise<LightBurnProject>;
+
+type CircuitJsonToLbrnModule_ConvertCircuitJsonToLbrnOptions = ConvertCircuitJsonToLbrnOptions;
+declare const CircuitJsonToLbrnModule_convertCircuitJsonToLbrn: typeof convertCircuitJsonToLbrn;
+declare namespace CircuitJsonToLbrnModule {
+  export { type CircuitJsonToLbrnModule_ConvertCircuitJsonToLbrnOptions as ConvertCircuitJsonToLbrnOptions, CircuitJsonToLbrnModule_convertCircuitJsonToLbrn as convertCircuitJsonToLbrn };
+}
+
+interface PickAndPlaceRow {
+    designator: string;
+    mid_x: number;
+    mid_y: number;
+    layer: LayerRef$1;
+    rotation: number;
+}
+declare const convertCircuitJsonToPickAndPlaceRows: (circuitJson: AnyCircuitElement[], opts?: {
+    flip_y_axis?: boolean;
+}) => PickAndPlaceRow[];
+declare const convertCircuitJsonToPickAndPlaceCsv: (circuitJson: AnyCircuitElement[]) => string;
+
+declare const CircuitJsonToPnpCsvModule_convertCircuitJsonToPickAndPlaceCsv: typeof convertCircuitJsonToPickAndPlaceCsv;
+declare const CircuitJsonToPnpCsvModule_convertCircuitJsonToPickAndPlaceRows: typeof convertCircuitJsonToPickAndPlaceRows;
+declare namespace CircuitJsonToPnpCsvModule {
+  export { CircuitJsonToPnpCsvModule_convertCircuitJsonToPickAndPlaceCsv as convertCircuitJsonToPickAndPlaceCsv, CircuitJsonToPnpCsvModule_convertCircuitJsonToPickAndPlaceRows as convertCircuitJsonToPickAndPlaceRows };
+}
+
+declare const convertCircuitJsonToReadableNetlist: (circuitJson: AnyCircuitElement[]) => string;
+
+declare const CircuitJsonToReadableNetlistModule_convertCircuitJsonToReadableNetlist: typeof convertCircuitJsonToReadableNetlist;
+declare namespace CircuitJsonToReadableNetlistModule {
+  export { CircuitJsonToReadableNetlistModule_convertCircuitJsonToReadableNetlist as convertCircuitJsonToReadableNetlist };
+}
+
+type AnglePreset = "angle1" | "angle2" | "left" | "right" | "left-raised" | "right-raised";
+
+interface BackgroundOptions {
+    color?: string;
+    opacity?: number;
+}
+interface Simple3dSvgOptions {
+    camera?: {
+        position: {
+            x: number;
+            y: number;
+            z: number;
+        };
+        lookAt: {
+            x: number;
+            y: number;
+            z: number;
+        };
+        focalLength?: number;
+    };
+    anglePreset?: AnglePreset;
+    defaultZoomMultiplier?: number;
+    background?: BackgroundOptions;
+    width?: number;
+    height?: number;
+    showAxes?: boolean;
+    showOrigin?: boolean;
+    showGrid?: boolean;
+    showBoundingBoxes?: boolean;
+}
+
+declare function convertCircuitJsonToSimple3dScene(circuitJson: CircuitJson, opts?: Simple3dSvgOptions): Promise<{
+    boxes: Box[];
+    camera: any;
+}>;
+declare function convertCircuitJsonToSimple3dSvg(circuitJson: CircuitJson, opts?: Simple3dSvgOptions): Promise<string>;
+
+type CircuitJsonToSimple3dModule_AnglePreset = AnglePreset;
+type CircuitJsonToSimple3dModule_BackgroundOptions = BackgroundOptions;
+type CircuitJsonToSimple3dModule_Simple3dSvgOptions = Simple3dSvgOptions;
+declare const CircuitJsonToSimple3dModule_convertCircuitJsonToSimple3dScene: typeof convertCircuitJsonToSimple3dScene;
+declare const CircuitJsonToSimple3dModule_convertCircuitJsonToSimple3dSvg: typeof convertCircuitJsonToSimple3dSvg;
+declare namespace CircuitJsonToSimple3dModule {
+  export { type CircuitJsonToSimple3dModule_AnglePreset as AnglePreset, type CircuitJsonToSimple3dModule_BackgroundOptions as BackgroundOptions, type CircuitJsonToSimple3dModule_Simple3dSvgOptions as Simple3dSvgOptions, CircuitJsonToSimple3dModule_convertCircuitJsonToSimple3dScene as convertCircuitJsonToSimple3dScene, CircuitJsonToSimple3dModule_convertCircuitJsonToSimple3dSvg as convertCircuitJsonToSimple3dSvg };
+}
+
+interface BaseSpiceCommand {
+    commandName?: string;
+    statementName?: string;
+    toSpiceString(): string;
+}
+
+declare class SpiceComponent {
+    name: string;
+    command: BaseSpiceCommand;
+    nodes: string[];
+    constructor(name: string, command: BaseSpiceCommand, nodes: string[]);
+    toSpiceString(): string;
+}
+
+declare class SpiceSubcircuit {
+    name: string;
+    pins: string[];
+    constructor(name: string, pins: string[]);
+    toSpiceString(): string;
+}
+
+declare class SpiceNetlist {
+    title: string;
+    components: SpiceComponent[];
+    nodes: Set<string>;
+    controls: string[];
+    subcircuits: SpiceSubcircuit[];
+    models: Map<string, string>;
+    tranCommand: string | null;
+    printStatements: string[];
+    constructor(title?: string);
+    addComponent(component: SpiceComponent): void;
+    addSubcircuit(subcircuit: SpiceSubcircuit): void;
+    toSpiceString(): string;
+}
+
+declare function circuitJsonToSpice(circuitJson: AnyCircuitElement[]): SpiceNetlist;
+
+declare const convertSpiceNetlistToString: (netlist: SpiceNetlist) => string;
+
+interface BJTCommandProps {
+    name: string;
+    collector: string;
+    base: string;
+    emitter: string;
+    substrate?: string;
+    model: string;
+    area?: string;
+}
+declare class BJTCommand implements BaseSpiceCommand {
+    commandName: "bjt";
+    props: BJTCommandProps;
+    constructor(props: BJTCommandProps);
+    toSpiceString(): string;
+}
+
+interface CapacitorCommandProps {
+    name: string;
+    positiveNode: string;
+    negativeNode: string;
+    modelName?: string;
+    value: string;
+    initialCondition?: string;
+}
+declare class CapacitorCommand implements BaseSpiceCommand {
+    commandName: "capacitor";
+    props: CapacitorCommandProps;
+    constructor(props: CapacitorCommandProps);
+    toSpiceString(): string;
+}
+
+interface CurrentSourceCommandProps {
+    name: string;
+    positiveNode: string;
+    negativeNode: string;
+    value?: string;
+    acMagnitude?: string;
+    acPhase?: string;
+}
+declare class CurrentSourceCommand implements BaseSpiceCommand {
+    commandName: "current_source";
+    props: CurrentSourceCommandProps;
+    constructor(props: CurrentSourceCommandProps);
+    toSpiceString(): string;
+}
+
+interface DiodeCommandProps {
+    name: string;
+    positiveNode: string;
+    negativeNode: string;
+    model: string;
+    area?: string;
+}
+declare class DiodeCommand implements BaseSpiceCommand {
+    commandName: "diode";
+    props: DiodeCommandProps;
+    constructor(props: DiodeCommandProps);
+    toSpiceString(): string;
+}
+
+interface InductorCommandProps {
+    name: string;
+    positiveNode: string;
+    negativeNode: string;
+    model?: string;
+    value: string;
+    initialCondition?: string;
+}
+declare class InductorCommand implements BaseSpiceCommand {
+    commandName: "inductor";
+    props: InductorCommandProps;
+    constructor(props: InductorCommandProps);
+    toSpiceString(): string;
+}
+
+interface InductorCouplingCommandProps {
+    name: string;
+    inductors: string[];
+    coupling: string;
+}
+declare class InductorCouplingCommand implements BaseSpiceCommand {
+    commandName: "inductor_coupling";
+    props: InductorCouplingCommandProps;
+    constructor(props: InductorCouplingCommandProps);
+    toSpiceString(): string;
+}
+
+interface JFETCommandProps {
+    name: string;
+    drain: string;
+    gate: string;
+    source: string;
+    model: string;
+    area?: string;
+}
+declare class JFETCommand implements BaseSpiceCommand {
+    commandName: "jfet";
+    props: JFETCommandProps;
+    constructor(props: JFETCommandProps);
+    toSpiceString(): string;
+}
+
+interface MOSFETCommandProps {
+    name: string;
+    drain: string;
+    gate: string;
+    source: string;
+    substrate: string;
+    model: string;
+    length?: string;
+    width?: string;
+    drainArea?: string;
+    sourceArea?: string;
+    drainPerimeter?: string;
+    sourcePerimeter?: string;
+    drainResistance?: string;
+    sourceResistance?: string;
+}
+declare class MOSFETCommand implements BaseSpiceCommand {
+    commandName: "mosfet";
+    props: MOSFETCommandProps;
+    constructor(props: MOSFETCommandProps);
+    toSpiceString(): string;
+}
+
+interface ResistorCommandProps {
+    name: string;
+    positiveNode: string;
+    negativeNode: string;
+    model?: string;
+    value: string;
+}
+declare class ResistorCommand implements BaseSpiceCommand {
+    commandName: "resistor";
+    props: ResistorCommandProps;
+    constructor(props: ResistorCommandProps);
+    toSpiceString(): string;
+}
+
+interface SubcircuitCallCommandProps {
+    name: string;
+    nodes: string[];
+    subcircuitName: string;
+}
+declare class SubcircuitCallCommand implements BaseSpiceCommand {
+    commandName: "subcircuit_call";
+    props: SubcircuitCallCommandProps;
+    constructor(props: SubcircuitCallCommandProps);
+    toSpiceString(): string;
+}
+
+interface TransmissionLineCommandProps {
+    name: string;
+    aPositive: string;
+    aNegative: string;
+    bPositive: string;
+    bNegative: string;
+    impedance: string;
+    delay?: string;
+    frequency?: string;
+    normalizedLength?: string;
+}
+declare class TransmissionLineCommand implements BaseSpiceCommand {
+    commandName: "transmission_line";
+    props: TransmissionLineCommandProps;
+    constructor(props: TransmissionLineCommandProps);
+    toSpiceString(): string;
+}
+
+interface VoltageControlledSwitchCommandProps {
+    name: string;
+    positiveNode: string;
+    negativeNode: string;
+    positiveControl: string;
+    negativeControl: string;
+    model: string;
+}
+declare class VoltageControlledSwitchCommand implements BaseSpiceCommand {
+    commandName: "voltage_controlled_switch";
+    props: VoltageControlledSwitchCommandProps;
+    constructor(props: VoltageControlledSwitchCommandProps);
+    toSpiceString(): string;
+}
+
+interface VoltageSourceCommandProps {
+    name: string;
+    positiveNode: string;
+    negativeNode: string;
+    value?: string;
+    acMagnitude?: string;
+    acPhase?: string;
+}
+declare class VoltageSourceCommand implements BaseSpiceCommand {
+    commandName: "voltage_source";
+    props: VoltageSourceCommandProps;
+    constructor(props: VoltageSourceCommandProps);
+    toSpiceString(): string;
+}
+
+type CircuitJsonToSpiceModule_BJTCommand = BJTCommand;
+declare const CircuitJsonToSpiceModule_BJTCommand: typeof BJTCommand;
+type CircuitJsonToSpiceModule_BJTCommandProps = BJTCommandProps;
+type CircuitJsonToSpiceModule_BaseSpiceCommand = BaseSpiceCommand;
+type CircuitJsonToSpiceModule_CapacitorCommand = CapacitorCommand;
+declare const CircuitJsonToSpiceModule_CapacitorCommand: typeof CapacitorCommand;
+type CircuitJsonToSpiceModule_CapacitorCommandProps = CapacitorCommandProps;
+type CircuitJsonToSpiceModule_CurrentSourceCommand = CurrentSourceCommand;
+declare const CircuitJsonToSpiceModule_CurrentSourceCommand: typeof CurrentSourceCommand;
+type CircuitJsonToSpiceModule_CurrentSourceCommandProps = CurrentSourceCommandProps;
+type CircuitJsonToSpiceModule_DiodeCommand = DiodeCommand;
+declare const CircuitJsonToSpiceModule_DiodeCommand: typeof DiodeCommand;
+type CircuitJsonToSpiceModule_DiodeCommandProps = DiodeCommandProps;
+type CircuitJsonToSpiceModule_InductorCommand = InductorCommand;
+declare const CircuitJsonToSpiceModule_InductorCommand: typeof InductorCommand;
+type CircuitJsonToSpiceModule_InductorCommandProps = InductorCommandProps;
+type CircuitJsonToSpiceModule_InductorCouplingCommand = InductorCouplingCommand;
+declare const CircuitJsonToSpiceModule_InductorCouplingCommand: typeof InductorCouplingCommand;
+type CircuitJsonToSpiceModule_InductorCouplingCommandProps = InductorCouplingCommandProps;
+type CircuitJsonToSpiceModule_JFETCommand = JFETCommand;
+declare const CircuitJsonToSpiceModule_JFETCommand: typeof JFETCommand;
+type CircuitJsonToSpiceModule_JFETCommandProps = JFETCommandProps;
+type CircuitJsonToSpiceModule_MOSFETCommand = MOSFETCommand;
+declare const CircuitJsonToSpiceModule_MOSFETCommand: typeof MOSFETCommand;
+type CircuitJsonToSpiceModule_MOSFETCommandProps = MOSFETCommandProps;
+type CircuitJsonToSpiceModule_ResistorCommand = ResistorCommand;
+declare const CircuitJsonToSpiceModule_ResistorCommand: typeof ResistorCommand;
+type CircuitJsonToSpiceModule_ResistorCommandProps = ResistorCommandProps;
+type CircuitJsonToSpiceModule_SpiceComponent = SpiceComponent;
+declare const CircuitJsonToSpiceModule_SpiceComponent: typeof SpiceComponent;
+type CircuitJsonToSpiceModule_SpiceNetlist = SpiceNetlist;
+declare const CircuitJsonToSpiceModule_SpiceNetlist: typeof SpiceNetlist;
+type CircuitJsonToSpiceModule_SpiceSubcircuit = SpiceSubcircuit;
+declare const CircuitJsonToSpiceModule_SpiceSubcircuit: typeof SpiceSubcircuit;
+type CircuitJsonToSpiceModule_SubcircuitCallCommand = SubcircuitCallCommand;
+declare const CircuitJsonToSpiceModule_SubcircuitCallCommand: typeof SubcircuitCallCommand;
+type CircuitJsonToSpiceModule_SubcircuitCallCommandProps = SubcircuitCallCommandProps;
+type CircuitJsonToSpiceModule_TransmissionLineCommand = TransmissionLineCommand;
+declare const CircuitJsonToSpiceModule_TransmissionLineCommand: typeof TransmissionLineCommand;
+type CircuitJsonToSpiceModule_TransmissionLineCommandProps = TransmissionLineCommandProps;
+type CircuitJsonToSpiceModule_VoltageControlledSwitchCommand = VoltageControlledSwitchCommand;
+declare const CircuitJsonToSpiceModule_VoltageControlledSwitchCommand: typeof VoltageControlledSwitchCommand;
+type CircuitJsonToSpiceModule_VoltageControlledSwitchCommandProps = VoltageControlledSwitchCommandProps;
+type CircuitJsonToSpiceModule_VoltageSourceCommand = VoltageSourceCommand;
+declare const CircuitJsonToSpiceModule_VoltageSourceCommand: typeof VoltageSourceCommand;
+type CircuitJsonToSpiceModule_VoltageSourceCommandProps = VoltageSourceCommandProps;
+declare const CircuitJsonToSpiceModule_circuitJsonToSpice: typeof circuitJsonToSpice;
+declare const CircuitJsonToSpiceModule_convertSpiceNetlistToString: typeof convertSpiceNetlistToString;
+declare namespace CircuitJsonToSpiceModule {
+  export { CircuitJsonToSpiceModule_BJTCommand as BJTCommand, type CircuitJsonToSpiceModule_BJTCommandProps as BJTCommandProps, type CircuitJsonToSpiceModule_BaseSpiceCommand as BaseSpiceCommand, CircuitJsonToSpiceModule_CapacitorCommand as CapacitorCommand, type CircuitJsonToSpiceModule_CapacitorCommandProps as CapacitorCommandProps, CircuitJsonToSpiceModule_CurrentSourceCommand as CurrentSourceCommand, type CircuitJsonToSpiceModule_CurrentSourceCommandProps as CurrentSourceCommandProps, CircuitJsonToSpiceModule_DiodeCommand as DiodeCommand, type CircuitJsonToSpiceModule_DiodeCommandProps as DiodeCommandProps, CircuitJsonToSpiceModule_InductorCommand as InductorCommand, type CircuitJsonToSpiceModule_InductorCommandProps as InductorCommandProps, CircuitJsonToSpiceModule_InductorCouplingCommand as InductorCouplingCommand, type CircuitJsonToSpiceModule_InductorCouplingCommandProps as InductorCouplingCommandProps, CircuitJsonToSpiceModule_JFETCommand as JFETCommand, type CircuitJsonToSpiceModule_JFETCommandProps as JFETCommandProps, CircuitJsonToSpiceModule_MOSFETCommand as MOSFETCommand, type CircuitJsonToSpiceModule_MOSFETCommandProps as MOSFETCommandProps, CircuitJsonToSpiceModule_ResistorCommand as ResistorCommand, type CircuitJsonToSpiceModule_ResistorCommandProps as ResistorCommandProps, CircuitJsonToSpiceModule_SpiceComponent as SpiceComponent, CircuitJsonToSpiceModule_SpiceNetlist as SpiceNetlist, CircuitJsonToSpiceModule_SpiceSubcircuit as SpiceSubcircuit, CircuitJsonToSpiceModule_SubcircuitCallCommand as SubcircuitCallCommand, type CircuitJsonToSpiceModule_SubcircuitCallCommandProps as SubcircuitCallCommandProps, CircuitJsonToSpiceModule_TransmissionLineCommand as TransmissionLineCommand, type CircuitJsonToSpiceModule_TransmissionLineCommandProps as TransmissionLineCommandProps, CircuitJsonToSpiceModule_VoltageControlledSwitchCommand as VoltageControlledSwitchCommand, type CircuitJsonToSpiceModule_VoltageControlledSwitchCommandProps as VoltageControlledSwitchCommandProps, CircuitJsonToSpiceModule_VoltageSourceCommand as VoltageSourceCommand, type CircuitJsonToSpiceModule_VoltageSourceCommandProps as VoltageSourceCommandProps, CircuitJsonToSpiceModule_circuitJsonToSpice as circuitJsonToSpice, CircuitJsonToSpiceModule_convertSpiceNetlistToString as convertSpiceNetlistToString };
+}
+
+interface CircuitJsonToStepOptions {
+    /** Board width in mm (optional if pcb_board is present) */
+    boardWidth?: number;
+    /** Board height in mm (optional if pcb_board is present) */
+    boardHeight?: number;
+    /** Board thickness in mm (default: 1.6mm or from pcb_board) */
+    boardThickness?: number;
+    /** Product name (default: "PCB") */
+    productName?: string;
+    /** Include component meshes (default: false) */
+    includeComponents?: boolean;
+    /** Include external model meshes from model_*_url fields (default: false). Only applicable when includeComponents is true. */
+    includeExternalMeshes?: boolean;
+    /**
+     * Pre-loaded STEP file contents, keyed by URL/path.
+     * If a URL is found here, the content is used directly instead of fetching.
+     * Useful for tests that need to load local files.
+     */
+    fsMap?: Record<string, string>;
+}
+/**
+ * Converts circuit JSON to STEP format, creating holes in a PCB board
+ */
+declare function circuitJsonToStep(circuitJson: CircuitJson, options?: CircuitJsonToStepOptions): Promise<string>;
+
+type CircuitJsonToStepModule_CircuitJsonToStepOptions = CircuitJsonToStepOptions;
+declare const CircuitJsonToStepModule_circuitJsonToStep: typeof circuitJsonToStep;
+declare namespace CircuitJsonToStepModule {
+  export { type CircuitJsonToStepModule_CircuitJsonToStepOptions as CircuitJsonToStepOptions, CircuitJsonToStepModule_circuitJsonToStep as circuitJsonToStep };
+}
+
+interface ComponentTemplateParams {
+    pinLabels?: Record<string, string[]> | Record<string, string>;
+    componentName: string;
+    objUrl?: string;
+    circuitJson: AnyCircuitElement[];
+    supplierPartNumbers?: Record<string, string[]>;
+    manufacturerPartNumber?: string;
+}
+
+declare const convertCircuitJsonToTscircuit: (circuitJson: CircuitJson, opts: Omit<ComponentTemplateParams, "circuitJson">) => string;
+
+declare const CircuitJsonToTscircuitModule_convertCircuitJsonToTscircuit: typeof convertCircuitJsonToTscircuit;
+declare namespace CircuitJsonToTscircuitModule {
+  export { CircuitJsonToTscircuitModule_convertCircuitJsonToTscircuit as convertCircuitJsonToTscircuit };
+}
+
+/**
+ * Canvas context type that works with both browser and node-canvas.
+ * Uses a subset of CanvasRenderingContext2D methods that are common to both.
+ */
+interface CanvasContext {
+    beginPath(): void;
+    closePath(): void;
+    arc(x: number, y: number, radius: number, startAngle: number, endAngle: number, counterclockwise?: boolean): void;
+    arcTo(x1: number, y1: number, x2: number, y2: number, radius: number): void;
+    ellipse(x: number, y: number, radiusX: number, radiusY: number, rotation: number, startAngle: number, endAngle: number): void;
+    fill(fillRule?: "nonzero" | "evenodd"): void;
+    stroke(): void;
+    rect(x: number, y: number, w: number, h: number): void;
+    lineTo(x: number, y: number): void;
+    moveTo(x: number, y: number): void;
+    save(): void;
+    restore(): void;
+    clip(): void;
+    translate(x: number, y: number): void;
+    rotate(angle: number): void;
+    scale(x: number, y: number): void;
+    globalCompositeOperation?: string;
+    fillStyle: string | CanvasGradient | CanvasPattern;
+    strokeStyle: string | CanvasGradient | CanvasPattern;
+    globalAlpha: number;
+    lineWidth: number;
+    lineCap: "butt" | "round" | "square";
+    lineJoin: "bevel" | "round" | "miter";
+    setLineDash(segments: number[]): void;
+    canvas: {
+        width: number;
+        height: number;
+    };
+    fillText(text: string, x: number, y: number): void;
+    fillRect(x: number, y: number, width: number, height: number): void;
+    measureText?: (text: string) => {
+        width: number;
+        actualBoundingBoxAscent?: number;
+        actualBoundingBoxDescent?: number;
+    };
+    font: string;
+    textAlign: "start" | "end" | "left" | "right" | "center";
+}
+type CopperLayerName$1 = "top" | "bottom" | "inner1" | "inner2" | "inner3" | "inner4" | "inner5" | "inner6";
+type CopperColorMap$1 = Record<CopperLayerName$1, string> & {
+    [layer: string]: string;
+};
+interface PcbColorMap$1 {
+    copper: CopperColorMap$1;
+    copperPour: {
+        top: string;
+        bottom: string;
+    };
+    drill: string;
+    silkscreen: {
+        top: string;
+        bottom: string;
+    };
+    boardOutline: string;
+    soldermask: {
+        top: string;
+        bottom: string;
+    };
+    soldermaskWithCopperUnderneath: {
+        top: string;
+        bottom: string;
+    };
+    soldermaskOverCopper: {
+        top: string;
+        bottom: string;
+    };
+    substrate: string;
+    courtyard: {
+        top: string;
+        bottom: string;
+    };
+    keepout: string;
+    fabricationNote: string;
+}
+declare const DEFAULT_PCB_COLOR_MAP: PcbColorMap$1;
+interface DrawerConfig {
+    colorOverrides?: Partial<PcbColorMap$1>;
+}
+interface CameraBounds {
+    minX: number;
+    maxX: number;
+    minY: number;
+    maxY: number;
+}
+interface DrawContext {
+    ctx: CanvasRenderingContext2D;
+    realToCanvasMat: Matrix;
+    colorMap: PcbColorMap$1;
+}
+
+interface DrawElementsOptions {
+    layers?: PcbRenderLayer[];
+    /** Whether to render the soldermask layer. Defaults to false. */
+    drawSoldermask?: boolean;
+    /** Render top soldermask layer when drawSoldermask is enabled. Defaults to true if both layer flags are unset. */
+    drawSoldermaskTop?: boolean;
+    /** Render bottom soldermask layer when drawSoldermask is enabled. */
+    drawSoldermaskBottom?: boolean;
+    /** Whether to render the board material (substrate fill). Defaults to false. */
+    drawBoardMaterial?: boolean;
+    /** Minimum on-screen outline stroke width for pcb_board only. */
+    minBoardOutlineStrokePx?: number;
+    /** Whether to render pcb_note elements. Defaults to true. */
+    showPcbNotes?: boolean;
+}
+interface CanvasLike {
+    getContext(contextId: "2d"): CanvasContext | null;
+}
+declare class CircuitToCanvasDrawer {
+    private ctx;
+    private colorMap;
+    realToCanvasMat: Matrix;
+    constructor(canvasOrContext: CanvasLike | CanvasContext);
+    configure(config: DrawerConfig): void;
+    setCameraBounds(bounds: CameraBounds): void;
+    drawElements(elements: AnyCircuitElement[], options?: DrawElementsOptions): void;
+}
+
+interface DrawCircleParams {
+    ctx: CanvasContext;
+    center: {
+        x: number;
+        y: number;
+    };
+    radius: number;
+    fill?: string;
+    realToCanvasMat: Matrix;
+    stroke?: string;
+    strokeWidth?: number;
+    isStrokeDashed?: boolean;
+}
+declare function drawCircle(params: DrawCircleParams): void;
+
+interface DrawRectParams {
+    ctx: CanvasContext;
+    center: {
+        x: number;
+        y: number;
+    };
+    width: number;
+    height: number;
+    fill?: string;
+    realToCanvasMat: Matrix;
+    borderRadius?: number;
+    ccwRotationDegrees?: number;
+    stroke?: string;
+    strokeWidth?: number;
+    isStrokeDashed?: boolean;
+}
+declare function drawRect(params: DrawRectParams): void;
+
+interface DrawOvalParams {
+    ctx: CanvasContext;
+    center: {
+        x: number;
+        y: number;
+    };
+    radius_x: number;
+    radius_y: number;
+    fill?: string;
+    stroke?: string;
+    strokeWidth?: number;
+    realToCanvasMat: Matrix;
+    rotation?: number;
+}
+declare function drawOval(params: DrawOvalParams): void;
+
+interface DrawPillParams {
+    ctx: CanvasContext;
+    center: {
+        x: number;
+        y: number;
+    };
+    width: number;
+    height: number;
+    fill?: string;
+    realToCanvasMat: Matrix;
+    rotation?: number;
+    stroke?: string;
+    strokeWidth?: number;
+}
+declare function drawPill(params: DrawPillParams): void;
+
+interface DrawPolygonParams {
+    ctx: CanvasContext;
+    points: Array<{
+        x: number;
+        y: number;
+    }>;
+    fill: string;
+    realToCanvasMat: Matrix;
+}
+declare function drawPolygon(params: DrawPolygonParams): void;
+
+interface DrawLineParams {
+    ctx: CanvasContext;
+    start: {
+        x: number;
+        y: number;
+    };
+    end: {
+        x: number;
+        y: number;
+    };
+    strokeWidth: number;
+    stroke: string;
+    realToCanvasMat: Matrix;
+    lineCap?: "butt" | "round" | "square";
+}
+declare function drawLine(params: DrawLineParams): void;
+
+interface DrawPathParams {
+    ctx: CanvasContext;
+    points: Array<{
+        x: number;
+        y: number;
+    }>;
+    fill?: string;
+    stroke?: string;
+    strokeWidth?: number;
+    minStrokePx?: number;
+    realToCanvasMat: Matrix;
+    closePath?: boolean;
+}
+declare function drawPath(params: DrawPathParams): void;
+
+interface DrawArrowParams {
+    ctx: CanvasContext;
+    x: number;
+    y: number;
+    angle: number;
+    arrowSize: number;
+    color: string;
+    strokeWidth: number;
+}
+/**
+ * Draw an arrow at a point along a line
+ */
+declare function drawArrow(params: DrawArrowParams): void;
+
+interface DrawDimensionLineParams {
+    ctx: CanvasContext;
+    from: {
+        x: number;
+        y: number;
+    };
+    to: {
+        x: number;
+        y: number;
+    };
+    realToCanvasMat: Matrix;
+    color: string;
+    fontSize: number;
+    arrowSize?: number;
+    strokeWidth?: number;
+    text?: string;
+    textRotation?: number;
+    offset?: {
+        distance: number;
+        direction: {
+            x: number;
+            y: number;
+        };
+    };
+}
+declare function drawDimensionLine(params: DrawDimensionLineParams): void;
+
+type AlphabetLayout = {
+    width: number;
+    height: number;
+    glyphWidth: number;
+    letterSpacing: number;
+    spaceWidth: number;
+    strokeWidth: number;
+    lineHeight: number;
+    lines: string[];
+    lineWidths: number[];
+};
+declare function getAlphabetLayout(text: string, fontSize: number): AlphabetLayout;
+
+interface StrokeAlphabetTextParams {
+    ctx: CanvasContext;
+    text: string;
+    fontSize: number;
+    startX: number;
+    startY: number;
+    anchorAlignment?: NinePointAnchor;
+}
+declare function strokeAlphabetText(params: StrokeAlphabetTextParams): void;
+interface DrawTextParams {
+    ctx: CanvasContext;
+    text: string;
+    x: number;
+    y: number;
+    fontSize: number;
+    color: string;
+    realToCanvasMat: Matrix;
+    anchorAlignment: NinePointAnchor;
+    rotation?: number;
+    mirrorX?: boolean;
+    knockout?: boolean;
+    knockoutPadding?: {
+        top?: number;
+        bottom?: number;
+        left?: number;
+        right?: number;
+    };
+}
+declare function drawText(params: DrawTextParams): void;
+
+type AnchorAlignment = NinePointAnchor;
+declare function getTextStartPosition(alignment: NinePointAnchor, layout: AlphabetLayout): {
+    x: number;
+    y: number;
+};
+
+interface DrawPcbPlatedHoleParams {
+    ctx: CanvasContext;
+    hole: PcbPlatedHole;
+    realToCanvasMat: Matrix;
+    colorMap: PcbColorMap$1;
+    soldermaskMargin?: number;
+    drawSoldermask?: boolean;
+    layer?: "top" | "bottom";
+}
+declare function drawPcbPlatedHole(params: DrawPcbPlatedHoleParams): void;
+
+interface DrawPcbViaParams {
+    ctx: CanvasContext;
+    via: PCBVia;
+    realToCanvasMat: Matrix;
+    colorMap: PcbColorMap$1;
+    layer?: "top" | "bottom";
+}
+declare function drawPcbVia(params: DrawPcbViaParams): void;
+
+interface DrawPcbHoleParams {
+    ctx: CanvasContext;
+    hole: PcbHole;
+    realToCanvasMat: Matrix;
+    colorMap: PcbColorMap$1;
+    soldermaskMargin?: number;
+    drawSoldermask?: boolean;
+}
+declare function drawPcbHole(params: DrawPcbHoleParams): void;
+
+interface DrawPcbSmtPadParams {
+    ctx: CanvasContext;
+    pad: PcbSmtPad;
+    realToCanvasMat: Matrix;
+    colorMap: PcbColorMap$1;
+}
+declare function drawPcbSmtPad(params: DrawPcbSmtPadParams): void;
+
+/**
+ * Draws a soldermask ring for rectangular shapes with negative margin
+ * (soldermask appears inside the pad boundary)
+ */
+declare function drawSoldermaskRingForRect(ctx: CanvasContext, center: {
+    x: number;
+    y: number;
+}, width: number, height: number, margin: number, borderRadius: number, rotation: number, realToCanvasMat: Matrix, soldermaskColor: string, padColor: string, asymmetricMargins?: {
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+}): void;
+/**
+ * Draws a soldermask ring for circular shapes with negative margin
+ * (soldermask appears inside the pad boundary)
+ */
+declare function drawSoldermaskRingForCircle(ctx: CanvasContext, center: {
+    x: number;
+    y: number;
+}, radius: number, margin: number, realToCanvasMat: Matrix, soldermaskColor: string, padColor: string): void;
+/**
+ * Draws a soldermask ring for pill shapes with negative margin
+ * (soldermask appears inside the pad boundary)
+ */
+declare function drawSoldermaskRingForPill(ctx: CanvasContext, center: {
+    x: number;
+    y: number;
+}, width: number, height: number, margin: number, rotation: number, realToCanvasMat: Matrix, soldermaskColor: string, padColor: string): void;
+/**
+ * Draws a soldermask ring for oval shapes with negative margin
+ * (soldermask appears inside the hole boundary)
+ */
+declare function drawSoldermaskRingForOval(ctx: CanvasContext, center: {
+    x: number;
+    y: number;
+}, radius_x: number, radius_y: number, margin: number, rotation: number, realToCanvasMat: Matrix, soldermaskColor: string, holeColor: string): void;
+
+interface DrawPcbTraceParams {
+    ctx: CanvasContext;
+    trace: PcbTrace;
+    realToCanvasMat: Matrix;
+    colorMap: PcbColorMap$1;
+    vias?: PcbVia[];
+    platedHoles?: PcbPlatedHole[];
+}
+declare function drawPcbTrace(params: DrawPcbTraceParams): void;
+
+interface DrawPcbBoardParams {
+    ctx: CanvasContext;
+    board: PcbBoard;
+    realToCanvasMat: Matrix;
+    colorMap: PcbColorMap$1;
+    drawBoardMaterial: boolean;
+    minBoardOutlineStrokePx?: number;
+}
+declare function drawPcbBoard(params: DrawPcbBoardParams): void;
+
+interface DrawPcbPanelParams {
+    ctx: CanvasContext;
+    panel: PcbPanel;
+    realToCanvasMat: Matrix;
+    colorMap: PcbColorMap$1;
+    drawBoardMaterial: boolean;
+}
+declare function drawPcbPanelElement(params: DrawPcbPanelParams): void;
+
+interface DrawPcbSilkscreenTextParams {
+    ctx: CanvasContext;
+    text: PcbSilkscreenText;
+    realToCanvasMat: Matrix;
+    colorMap: PcbColorMap$1;
+}
+declare function drawPcbSilkscreenText(params: DrawPcbSilkscreenTextParams): void;
+
+interface DrawPcbSilkscreenRectParams {
+    ctx: CanvasContext;
+    rect: PcbSilkscreenRect;
+    realToCanvasMat: Matrix;
+    colorMap: PcbColorMap$1;
+}
+declare function drawPcbSilkscreenRect(params: DrawPcbSilkscreenRectParams): void;
+
+interface DrawPcbSilkscreenCircleParams {
+    ctx: CanvasContext;
+    circle: PcbSilkscreenCircle;
+    realToCanvasMat: Matrix;
+    colorMap: PcbColorMap$1;
+}
+declare function drawPcbSilkscreenCircle(params: DrawPcbSilkscreenCircleParams): void;
+
+interface DrawPcbSilkscreenLineParams {
+    ctx: CanvasContext;
+    line: PcbSilkscreenLine;
+    realToCanvasMat: Matrix;
+    colorMap: PcbColorMap$1;
+}
+declare function drawPcbSilkscreenLine(params: DrawPcbSilkscreenLineParams): void;
+
+interface DrawPcbSilkscreenPathParams {
+    ctx: CanvasContext;
+    path: PcbSilkscreenPath;
+    realToCanvasMat: Matrix;
+    colorMap: PcbColorMap$1;
+}
+declare function drawPcbSilkscreenPath(params: DrawPcbSilkscreenPathParams): void;
+
+interface DrawPcbSilkscreenPillParams {
+    ctx: CanvasContext;
+    pill: PcbSilkscreenPill;
+    realToCanvasMat: Matrix;
+    colorMap: PcbColorMap$1;
+}
+declare function drawPcbSilkscreenPill(params: DrawPcbSilkscreenPillParams): void;
+
+interface DrawPcbSilkscreenOvalParams {
+    ctx: CanvasContext;
+    oval: PcbSilkscreenOval;
+    realToCanvasMat: Matrix;
+    colorMap: PcbColorMap$1;
+}
+declare function drawPcbSilkscreenOval(params: DrawPcbSilkscreenOvalParams): void;
+
+interface DrawPcbCutoutParams {
+    ctx: CanvasContext;
+    cutout: PcbCutout;
+    realToCanvasMat: Matrix;
+    colorMap: PcbColorMap$1;
+}
+declare function drawPcbCutout(params: DrawPcbCutoutParams): void;
+
+interface DrawPcbKeepoutParams {
+    ctx: CanvasContext;
+    keepout: PCBKeepout;
+    realToCanvasMat: Matrix;
+    colorMap: PcbColorMap$1;
+}
+declare function drawPcbKeepout(params: DrawPcbKeepoutParams): void;
+
+interface DrawPcbCopperPourParams {
+    ctx: CanvasContext;
+    pour: PcbCopperPour;
+    realToCanvasMat: Matrix;
+    colorMap: PcbColorMap$1;
+}
+declare function drawPcbCopperPour(params: DrawPcbCopperPourParams): void;
+
+interface DrawPcbCopperTextParams {
+    ctx: CanvasContext;
+    text: PcbCopperText;
+    realToCanvasMat: Matrix;
+    colorMap: PcbColorMap$1;
+}
+declare function drawPcbCopperText(params: DrawPcbCopperTextParams): void;
+
+interface DrawPcbFabricationNoteTextParams {
+    ctx: CanvasContext;
+    text: PcbFabricationNoteText;
+    realToCanvasMat: Matrix;
+    colorMap: PcbColorMap$1;
+}
+declare function drawPcbFabricationNoteText(params: DrawPcbFabricationNoteTextParams): void;
+
+interface DrawPcbFabricationNoteRectParams {
+    ctx: CanvasContext;
+    rect: PcbFabricationNoteRect;
+    realToCanvasMat: Matrix;
+    colorMap: PcbColorMap$1;
+}
+declare function drawPcbFabricationNoteRect(params: DrawPcbFabricationNoteRectParams): void;
+
+interface DrawPcbNoteRectParams {
+    ctx: CanvasContext;
+    rect: PcbNoteRect;
+    realToCanvasMat: Matrix;
+    colorMap: PcbColorMap$1;
+}
+declare function drawPcbNoteRect(params: DrawPcbNoteRectParams): void;
+
+interface DrawPcbFabricationNotePathParams {
+    ctx: CanvasContext;
+    path: PcbFabricationNotePath;
+    realToCanvasMat: Matrix;
+    colorMap: PcbColorMap$1;
+}
+declare function drawPcbFabricationNotePath(params: DrawPcbFabricationNotePathParams): void;
+
+interface DrawPcbNotePathParams {
+    ctx: CanvasContext;
+    path: PcbNotePath;
+    realToCanvasMat: Matrix;
+    colorMap: PcbColorMap$1;
+}
+declare function drawPcbNotePath(params: DrawPcbNotePathParams): void;
+
+interface DrawPcbNoteTextParams {
+    ctx: CanvasContext;
+    text: PcbNoteText;
+    realToCanvasMat: Matrix;
+    colorMap: PcbColorMap$1;
+}
+declare function drawPcbNoteText(params: DrawPcbNoteTextParams): void;
+
+interface DrawPcbNoteDimensionParams {
+    ctx: CanvasContext;
+    pcbNoteDimension: PcbNoteDimension;
+    realToCanvasMat: Matrix;
+    colorMap: PcbColorMap$1;
+}
+declare function drawPcbNoteDimension(params: DrawPcbNoteDimensionParams): void;
+
+interface DrawPcbFabricationNoteDimensionParams {
+    ctx: CanvasContext;
+    pcbFabricationNoteDimension: PcbFabricationNoteDimension;
+    realToCanvasMat: Matrix;
+    colorMap: PcbColorMap$1;
+}
+declare function drawPcbFabricationNoteDimension(params: DrawPcbFabricationNoteDimensionParams): void;
+
+interface DrawPcbCourtyardCircleParams {
+    ctx: CanvasContext;
+    circle: PcbCourtyardCircle;
+    realToCanvasMat: Matrix;
+    colorMap: PcbColorMap$1;
+}
+declare function drawPcbCourtyardCircle(params: DrawPcbCourtyardCircleParams): void;
+
+type CircuitToCanvasModule_AlphabetLayout = AlphabetLayout;
+type CircuitToCanvasModule_AnchorAlignment = AnchorAlignment;
+type CircuitToCanvasModule_CameraBounds = CameraBounds;
+type CircuitToCanvasModule_CanvasContext = CanvasContext;
+type CircuitToCanvasModule_CircuitToCanvasDrawer = CircuitToCanvasDrawer;
+declare const CircuitToCanvasModule_CircuitToCanvasDrawer: typeof CircuitToCanvasDrawer;
+declare const CircuitToCanvasModule_DEFAULT_PCB_COLOR_MAP: typeof DEFAULT_PCB_COLOR_MAP;
+type CircuitToCanvasModule_DrawArrowParams = DrawArrowParams;
+type CircuitToCanvasModule_DrawCircleParams = DrawCircleParams;
+type CircuitToCanvasModule_DrawContext = DrawContext;
+type CircuitToCanvasModule_DrawDimensionLineParams = DrawDimensionLineParams;
+type CircuitToCanvasModule_DrawElementsOptions = DrawElementsOptions;
+type CircuitToCanvasModule_DrawLineParams = DrawLineParams;
+type CircuitToCanvasModule_DrawOvalParams = DrawOvalParams;
+type CircuitToCanvasModule_DrawPathParams = DrawPathParams;
+type CircuitToCanvasModule_DrawPcbBoardParams = DrawPcbBoardParams;
+type CircuitToCanvasModule_DrawPcbCopperPourParams = DrawPcbCopperPourParams;
+type CircuitToCanvasModule_DrawPcbCopperTextParams = DrawPcbCopperTextParams;
+type CircuitToCanvasModule_DrawPcbCourtyardCircleParams = DrawPcbCourtyardCircleParams;
+type CircuitToCanvasModule_DrawPcbCutoutParams = DrawPcbCutoutParams;
+type CircuitToCanvasModule_DrawPcbFabricationNoteDimensionParams = DrawPcbFabricationNoteDimensionParams;
+type CircuitToCanvasModule_DrawPcbFabricationNotePathParams = DrawPcbFabricationNotePathParams;
+type CircuitToCanvasModule_DrawPcbFabricationNoteRectParams = DrawPcbFabricationNoteRectParams;
+type CircuitToCanvasModule_DrawPcbFabricationNoteTextParams = DrawPcbFabricationNoteTextParams;
+type CircuitToCanvasModule_DrawPcbHoleParams = DrawPcbHoleParams;
+type CircuitToCanvasModule_DrawPcbKeepoutParams = DrawPcbKeepoutParams;
+type CircuitToCanvasModule_DrawPcbNoteDimensionParams = DrawPcbNoteDimensionParams;
+type CircuitToCanvasModule_DrawPcbNotePathParams = DrawPcbNotePathParams;
+type CircuitToCanvasModule_DrawPcbNoteRectParams = DrawPcbNoteRectParams;
+type CircuitToCanvasModule_DrawPcbNoteTextParams = DrawPcbNoteTextParams;
+type CircuitToCanvasModule_DrawPcbPanelParams = DrawPcbPanelParams;
+type CircuitToCanvasModule_DrawPcbPlatedHoleParams = DrawPcbPlatedHoleParams;
+type CircuitToCanvasModule_DrawPcbSilkscreenCircleParams = DrawPcbSilkscreenCircleParams;
+type CircuitToCanvasModule_DrawPcbSilkscreenLineParams = DrawPcbSilkscreenLineParams;
+type CircuitToCanvasModule_DrawPcbSilkscreenOvalParams = DrawPcbSilkscreenOvalParams;
+type CircuitToCanvasModule_DrawPcbSilkscreenPathParams = DrawPcbSilkscreenPathParams;
+type CircuitToCanvasModule_DrawPcbSilkscreenPillParams = DrawPcbSilkscreenPillParams;
+type CircuitToCanvasModule_DrawPcbSilkscreenRectParams = DrawPcbSilkscreenRectParams;
+type CircuitToCanvasModule_DrawPcbSilkscreenTextParams = DrawPcbSilkscreenTextParams;
+type CircuitToCanvasModule_DrawPcbSmtPadParams = DrawPcbSmtPadParams;
+type CircuitToCanvasModule_DrawPcbTraceParams = DrawPcbTraceParams;
+type CircuitToCanvasModule_DrawPcbViaParams = DrawPcbViaParams;
+type CircuitToCanvasModule_DrawPillParams = DrawPillParams;
+type CircuitToCanvasModule_DrawPolygonParams = DrawPolygonParams;
+type CircuitToCanvasModule_DrawRectParams = DrawRectParams;
+type CircuitToCanvasModule_DrawTextParams = DrawTextParams;
+type CircuitToCanvasModule_DrawerConfig = DrawerConfig;
+declare const CircuitToCanvasModule_drawArrow: typeof drawArrow;
+declare const CircuitToCanvasModule_drawCircle: typeof drawCircle;
+declare const CircuitToCanvasModule_drawDimensionLine: typeof drawDimensionLine;
+declare const CircuitToCanvasModule_drawLine: typeof drawLine;
+declare const CircuitToCanvasModule_drawOval: typeof drawOval;
+declare const CircuitToCanvasModule_drawPath: typeof drawPath;
+declare const CircuitToCanvasModule_drawPcbBoard: typeof drawPcbBoard;
+declare const CircuitToCanvasModule_drawPcbCopperPour: typeof drawPcbCopperPour;
+declare const CircuitToCanvasModule_drawPcbCopperText: typeof drawPcbCopperText;
+declare const CircuitToCanvasModule_drawPcbCourtyardCircle: typeof drawPcbCourtyardCircle;
+declare const CircuitToCanvasModule_drawPcbCutout: typeof drawPcbCutout;
+declare const CircuitToCanvasModule_drawPcbFabricationNoteDimension: typeof drawPcbFabricationNoteDimension;
+declare const CircuitToCanvasModule_drawPcbFabricationNotePath: typeof drawPcbFabricationNotePath;
+declare const CircuitToCanvasModule_drawPcbFabricationNoteRect: typeof drawPcbFabricationNoteRect;
+declare const CircuitToCanvasModule_drawPcbFabricationNoteText: typeof drawPcbFabricationNoteText;
+declare const CircuitToCanvasModule_drawPcbHole: typeof drawPcbHole;
+declare const CircuitToCanvasModule_drawPcbKeepout: typeof drawPcbKeepout;
+declare const CircuitToCanvasModule_drawPcbNoteDimension: typeof drawPcbNoteDimension;
+declare const CircuitToCanvasModule_drawPcbNotePath: typeof drawPcbNotePath;
+declare const CircuitToCanvasModule_drawPcbNoteRect: typeof drawPcbNoteRect;
+declare const CircuitToCanvasModule_drawPcbNoteText: typeof drawPcbNoteText;
+declare const CircuitToCanvasModule_drawPcbPanelElement: typeof drawPcbPanelElement;
+declare const CircuitToCanvasModule_drawPcbPlatedHole: typeof drawPcbPlatedHole;
+declare const CircuitToCanvasModule_drawPcbSilkscreenCircle: typeof drawPcbSilkscreenCircle;
+declare const CircuitToCanvasModule_drawPcbSilkscreenLine: typeof drawPcbSilkscreenLine;
+declare const CircuitToCanvasModule_drawPcbSilkscreenOval: typeof drawPcbSilkscreenOval;
+declare const CircuitToCanvasModule_drawPcbSilkscreenPath: typeof drawPcbSilkscreenPath;
+declare const CircuitToCanvasModule_drawPcbSilkscreenPill: typeof drawPcbSilkscreenPill;
+declare const CircuitToCanvasModule_drawPcbSilkscreenRect: typeof drawPcbSilkscreenRect;
+declare const CircuitToCanvasModule_drawPcbSilkscreenText: typeof drawPcbSilkscreenText;
+declare const CircuitToCanvasModule_drawPcbSmtPad: typeof drawPcbSmtPad;
+declare const CircuitToCanvasModule_drawPcbTrace: typeof drawPcbTrace;
+declare const CircuitToCanvasModule_drawPcbVia: typeof drawPcbVia;
+declare const CircuitToCanvasModule_drawPill: typeof drawPill;
+declare const CircuitToCanvasModule_drawPolygon: typeof drawPolygon;
+declare const CircuitToCanvasModule_drawRect: typeof drawRect;
+declare const CircuitToCanvasModule_drawSoldermaskRingForCircle: typeof drawSoldermaskRingForCircle;
+declare const CircuitToCanvasModule_drawSoldermaskRingForOval: typeof drawSoldermaskRingForOval;
+declare const CircuitToCanvasModule_drawSoldermaskRingForPill: typeof drawSoldermaskRingForPill;
+declare const CircuitToCanvasModule_drawSoldermaskRingForRect: typeof drawSoldermaskRingForRect;
+declare const CircuitToCanvasModule_drawText: typeof drawText;
+declare const CircuitToCanvasModule_getAlphabetLayout: typeof getAlphabetLayout;
+declare const CircuitToCanvasModule_getTextStartPosition: typeof getTextStartPosition;
+declare const CircuitToCanvasModule_strokeAlphabetText: typeof strokeAlphabetText;
+declare namespace CircuitToCanvasModule {
+  export { type CircuitToCanvasModule_AlphabetLayout as AlphabetLayout, type CircuitToCanvasModule_AnchorAlignment as AnchorAlignment, type CircuitToCanvasModule_CameraBounds as CameraBounds, type CircuitToCanvasModule_CanvasContext as CanvasContext, CircuitToCanvasModule_CircuitToCanvasDrawer as CircuitToCanvasDrawer, type CopperColorMap$1 as CopperColorMap, type CopperLayerName$1 as CopperLayerName, CircuitToCanvasModule_DEFAULT_PCB_COLOR_MAP as DEFAULT_PCB_COLOR_MAP, type CircuitToCanvasModule_DrawArrowParams as DrawArrowParams, type CircuitToCanvasModule_DrawCircleParams as DrawCircleParams, type CircuitToCanvasModule_DrawContext as DrawContext, type CircuitToCanvasModule_DrawDimensionLineParams as DrawDimensionLineParams, type CircuitToCanvasModule_DrawElementsOptions as DrawElementsOptions, type CircuitToCanvasModule_DrawLineParams as DrawLineParams, type CircuitToCanvasModule_DrawOvalParams as DrawOvalParams, type CircuitToCanvasModule_DrawPathParams as DrawPathParams, type CircuitToCanvasModule_DrawPcbBoardParams as DrawPcbBoardParams, type CircuitToCanvasModule_DrawPcbCopperPourParams as DrawPcbCopperPourParams, type CircuitToCanvasModule_DrawPcbCopperTextParams as DrawPcbCopperTextParams, type CircuitToCanvasModule_DrawPcbCourtyardCircleParams as DrawPcbCourtyardCircleParams, type CircuitToCanvasModule_DrawPcbCutoutParams as DrawPcbCutoutParams, type CircuitToCanvasModule_DrawPcbFabricationNoteDimensionParams as DrawPcbFabricationNoteDimensionParams, type CircuitToCanvasModule_DrawPcbFabricationNotePathParams as DrawPcbFabricationNotePathParams, type CircuitToCanvasModule_DrawPcbFabricationNoteRectParams as DrawPcbFabricationNoteRectParams, type CircuitToCanvasModule_DrawPcbFabricationNoteTextParams as DrawPcbFabricationNoteTextParams, type CircuitToCanvasModule_DrawPcbHoleParams as DrawPcbHoleParams, type CircuitToCanvasModule_DrawPcbKeepoutParams as DrawPcbKeepoutParams, type CircuitToCanvasModule_DrawPcbNoteDimensionParams as DrawPcbNoteDimensionParams, type CircuitToCanvasModule_DrawPcbNotePathParams as DrawPcbNotePathParams, type CircuitToCanvasModule_DrawPcbNoteRectParams as DrawPcbNoteRectParams, type CircuitToCanvasModule_DrawPcbNoteTextParams as DrawPcbNoteTextParams, type CircuitToCanvasModule_DrawPcbPanelParams as DrawPcbPanelParams, type CircuitToCanvasModule_DrawPcbPlatedHoleParams as DrawPcbPlatedHoleParams, type CircuitToCanvasModule_DrawPcbSilkscreenCircleParams as DrawPcbSilkscreenCircleParams, type CircuitToCanvasModule_DrawPcbSilkscreenLineParams as DrawPcbSilkscreenLineParams, type CircuitToCanvasModule_DrawPcbSilkscreenOvalParams as DrawPcbSilkscreenOvalParams, type CircuitToCanvasModule_DrawPcbSilkscreenPathParams as DrawPcbSilkscreenPathParams, type CircuitToCanvasModule_DrawPcbSilkscreenPillParams as DrawPcbSilkscreenPillParams, type CircuitToCanvasModule_DrawPcbSilkscreenRectParams as DrawPcbSilkscreenRectParams, type CircuitToCanvasModule_DrawPcbSilkscreenTextParams as DrawPcbSilkscreenTextParams, type CircuitToCanvasModule_DrawPcbSmtPadParams as DrawPcbSmtPadParams, type CircuitToCanvasModule_DrawPcbTraceParams as DrawPcbTraceParams, type CircuitToCanvasModule_DrawPcbViaParams as DrawPcbViaParams, type CircuitToCanvasModule_DrawPillParams as DrawPillParams, type CircuitToCanvasModule_DrawPolygonParams as DrawPolygonParams, type CircuitToCanvasModule_DrawRectParams as DrawRectParams, type CircuitToCanvasModule_DrawTextParams as DrawTextParams, type CircuitToCanvasModule_DrawerConfig as DrawerConfig, type PcbColorMap$1 as PcbColorMap, CircuitToCanvasModule_drawArrow as drawArrow, CircuitToCanvasModule_drawCircle as drawCircle, CircuitToCanvasModule_drawDimensionLine as drawDimensionLine, CircuitToCanvasModule_drawLine as drawLine, CircuitToCanvasModule_drawOval as drawOval, CircuitToCanvasModule_drawPath as drawPath, CircuitToCanvasModule_drawPcbBoard as drawPcbBoard, CircuitToCanvasModule_drawPcbCopperPour as drawPcbCopperPour, CircuitToCanvasModule_drawPcbCopperText as drawPcbCopperText, CircuitToCanvasModule_drawPcbCourtyardCircle as drawPcbCourtyardCircle, CircuitToCanvasModule_drawPcbCutout as drawPcbCutout, CircuitToCanvasModule_drawPcbFabricationNoteDimension as drawPcbFabricationNoteDimension, CircuitToCanvasModule_drawPcbFabricationNotePath as drawPcbFabricationNotePath, CircuitToCanvasModule_drawPcbFabricationNoteRect as drawPcbFabricationNoteRect, CircuitToCanvasModule_drawPcbFabricationNoteText as drawPcbFabricationNoteText, CircuitToCanvasModule_drawPcbHole as drawPcbHole, CircuitToCanvasModule_drawPcbKeepout as drawPcbKeepout, CircuitToCanvasModule_drawPcbNoteDimension as drawPcbNoteDimension, CircuitToCanvasModule_drawPcbNotePath as drawPcbNotePath, CircuitToCanvasModule_drawPcbNoteRect as drawPcbNoteRect, CircuitToCanvasModule_drawPcbNoteText as drawPcbNoteText, CircuitToCanvasModule_drawPcbPanelElement as drawPcbPanelElement, CircuitToCanvasModule_drawPcbPlatedHole as drawPcbPlatedHole, CircuitToCanvasModule_drawPcbSilkscreenCircle as drawPcbSilkscreenCircle, CircuitToCanvasModule_drawPcbSilkscreenLine as drawPcbSilkscreenLine, CircuitToCanvasModule_drawPcbSilkscreenOval as drawPcbSilkscreenOval, CircuitToCanvasModule_drawPcbSilkscreenPath as drawPcbSilkscreenPath, CircuitToCanvasModule_drawPcbSilkscreenPill as drawPcbSilkscreenPill, CircuitToCanvasModule_drawPcbSilkscreenRect as drawPcbSilkscreenRect, CircuitToCanvasModule_drawPcbSilkscreenText as drawPcbSilkscreenText, CircuitToCanvasModule_drawPcbSmtPad as drawPcbSmtPad, CircuitToCanvasModule_drawPcbTrace as drawPcbTrace, CircuitToCanvasModule_drawPcbVia as drawPcbVia, CircuitToCanvasModule_drawPill as drawPill, CircuitToCanvasModule_drawPolygon as drawPolygon, CircuitToCanvasModule_drawRect as drawRect, CircuitToCanvasModule_drawSoldermaskRingForCircle as drawSoldermaskRingForCircle, CircuitToCanvasModule_drawSoldermaskRingForOval as drawSoldermaskRingForOval, CircuitToCanvasModule_drawSoldermaskRingForPill as drawSoldermaskRingForPill, CircuitToCanvasModule_drawSoldermaskRingForRect as drawSoldermaskRingForRect, CircuitToCanvasModule_drawText as drawText, CircuitToCanvasModule_getAlphabetLayout as getAlphabetLayout, CircuitToCanvasModule_getTextStartPosition as getTextStartPosition, CircuitToCanvasModule_strokeAlphabetText as strokeAlphabetText };
+}
+
+interface PcbGridOptions {
+    cellSize: number;
+    lineColor?: string;
+    majorCellSize?: number;
+    majorLineColor?: string;
+}
+
+type CopperLayerName = "top" | "bottom" | "inner1" | "inner2" | "inner3" | "inner4" | "inner5" | "inner6";
+type CopperColorMap = Record<CopperLayerName, string> & {
+    [layer: string]: string;
+};
+interface PcbColorMap {
+    copper: CopperColorMap;
+    drill: string;
+    silkscreen: {
+        top: string;
+        bottom: string;
+    };
+    boardOutline: string;
+    soldermask: {
+        top: string;
+        bottom: string;
+    };
+    soldermaskWithCopperUnderneath: {
+        top: string;
+        bottom: string;
+    };
+    soldermaskOverCopper: {
+        top: string;
+        bottom: string;
+    };
+    substrate: string;
+    courtyard: {
+        top: string;
+        bottom: string;
+    };
+    keepout?: string;
+    debugComponent: {
+        fill: string | null;
+        stroke: string | null;
+    };
+}
+interface PcbColorOverrides {
+    copper?: Partial<PcbColorMap["copper"]>;
+    drill?: string;
+    silkscreen?: Partial<PcbColorMap["silkscreen"]>;
+    boardOutline?: string;
+    soldermask?: Partial<PcbColorMap["soldermask"]>;
+    soldermaskWithCopperUnderneath?: Partial<PcbColorMap["soldermaskWithCopperUnderneath"]>;
+    soldermaskOverCopper?: Partial<PcbColorMap["soldermaskOverCopper"]>;
+    substrate?: string;
+    courtyard?: Partial<PcbColorMap["courtyard"]>;
+    keepout?: string;
+    debugComponent?: Partial<PcbColorMap["debugComponent"]>;
+}
+
+interface PcbSvgOptions {
+    colorOverrides?: PcbColorOverrides;
+    width?: number;
+    height?: number;
+    shouldDrawErrors?: boolean;
+    showErrorsInTextOverlay?: boolean;
+    shouldDrawRatsNest?: boolean;
+    showCourtyards?: boolean;
+    showPcbGroups?: boolean;
+    layer?: "top" | "bottom";
+    matchBoardAspectRatio?: boolean;
+    backgroundColor?: string;
+    drawPaddingOutsideBoard?: boolean;
+    includeVersion?: boolean;
+    showSolderMask?: boolean;
+    showPcbNotes?: boolean;
+    grid?: PcbGridOptions;
+    showAnchorOffsets?: boolean;
+    viewport?: {
+        minX: number;
+        minY: number;
+        maxX: number;
+        maxY: number;
+    };
+    viewportTarget?: {
+        pcb_panel_id?: string;
+        pcb_board_id?: string;
+    };
+}
+interface PcbContext {
+    transform: Matrix;
+    layer?: "top" | "bottom";
+    shouldDrawErrors?: boolean;
+    showCourtyards?: boolean;
+    showPcbGroups?: boolean;
+    drawPaddingOutsideBoard?: boolean;
+    colorMap: PcbColorMap;
+    showSolderMask?: boolean;
+    showPcbNotes?: boolean;
+    showAnchorOffsets?: boolean;
+    circuitJson?: AnyCircuitElement[];
+}
+declare function convertCircuitJsonToPcbSvg(circuitJson: AnyCircuitElement[], options?: PcbSvgOptions): string;
+/**
+ * @deprecated use `convertCircuitJsonToPcbSvg` instead
+ */
+declare const circuitJsonToPcbSvg: typeof convertCircuitJsonToPcbSvg;
+
+interface Options$3 {
+    width?: number;
+    height?: number;
+    includeVersion?: boolean;
+    showErrorsInTextOverlay?: boolean;
+}
+interface AssemblySvgContext {
+    transform: Matrix;
+}
+declare function convertCircuitJsonToAssemblySvg(soup: AnyCircuitElement[], options?: Options$3): string;
+
+type LabelPosition = {
+    text: string;
+    aliases: string[];
+    elbow_end: {
+        x: number;
+        y: number;
+    };
+    label_pos: {
+        x: number;
+        y: number;
+    };
+    edge: "left" | "right" | "top" | "bottom";
+};
+
+interface Options$2 {
+    width?: number;
+    height?: number;
+    includeVersion?: boolean;
+    showErrorsInTextOverlay?: boolean;
+}
+interface PinoutLabel {
+    pcb_port: PcbPort;
+    aliases: string[];
+    edge: "left" | "right" | "top" | "bottom";
+}
+interface PinoutSvgContext {
+    transform: Matrix;
+    soup: AnyCircuitElement[];
+    board_bounds: {
+        minX: number;
+        minY: number;
+        maxX: number;
+        maxY: number;
+    };
+    styleScale: number;
+    label_positions: Map<string, LabelPosition>;
+    svgWidth: number;
+    svgHeight: number;
+}
+declare function convertCircuitJsonToPinoutSvg(soup: AnyCircuitElement[], options?: Options$2): string;
+
+declare const colorMap: {
+    "3d_viewer": {
+        background_bottom: string;
+        background_top: string;
+        board: string;
+        copper: string;
+        silkscreen_bottom: string;
+        silkscreen_top: string;
+        soldermask: string;
+        solderpaste: string;
+    };
+    board: {
+        anchor: string;
+        aux_items: string;
+        b_adhes: string;
+        b_crtyd: string;
+        b_fab: string;
+        b_mask: string;
+        b_paste: string;
+        b_silks: string;
+        background: string;
+        cmts_user: string;
+        copper: {
+            b: string;
+            f: string;
+            in1: string;
+            in10: string;
+            in11: string;
+            in12: string;
+            in13: string;
+            in14: string;
+            in15: string;
+            in16: string;
+            in17: string;
+            in18: string;
+            in19: string;
+            in2: string;
+            in20: string;
+            in21: string;
+            in22: string;
+            in23: string;
+            in24: string;
+            in25: string;
+            in26: string;
+            in27: string;
+            in28: string;
+            in29: string;
+            in3: string;
+            in30: string;
+            in4: string;
+            in5: string;
+            in6: string;
+            in7: string;
+            in8: string;
+            in9: string;
+        };
+        cursor: string;
+        drc: string;
+        drc_error: string;
+        drc_exclusion: string;
+        drc_warning: string;
+        dwgs_user: string;
+        eco1_user: string;
+        eco2_user: string;
+        edge_cuts: string;
+        f_adhes: string;
+        f_crtyd: string;
+        f_fab: string;
+        f_mask: string;
+        f_paste: string;
+        f_silks: string;
+        footprint_text_back: string;
+        footprint_text_front: string;
+        footprint_text_invisible: string;
+        grid: string;
+        grid_axes: string;
+        margin: string;
+        microvia: string;
+        no_connect: string;
+        pad_back: string;
+        pad_front: string;
+        pad_plated_hole: string;
+        pad_through_hole: string;
+        plated_hole: string;
+        ratsnest: string;
+        select_overlay: string;
+        through_via: string;
+        user_1: string;
+        user_2: string;
+        user_3: string;
+        user_4: string;
+        user_5: string;
+        user_6: string;
+        user_7: string;
+        user_8: string;
+        user_9: string;
+        via_blind_buried: string;
+        via_hole: string;
+        via_micro: string;
+        via_through: string;
+        worksheet: string;
+    };
+    gerbview: {
+        axes: string;
+        background: string;
+        dcodes: string;
+        grid: string;
+        layers: string[];
+        negative_objects: string;
+        worksheet: string;
+    };
+    meta: {
+        filename: string;
+        name: string;
+        version: number;
+    };
+    palette: string[];
+    schematic: {
+        aux_items: string;
+        background: string;
+        brightened: string;
+        bus: string;
+        bus_junction: string;
+        component_body: string;
+        component_outline: string;
+        cursor: string;
+        erc_error: string;
+        erc_warning: string;
+        fields: string;
+        grid: string;
+        grid_axes: string;
+        hidden: string;
+        junction: string;
+        label_global: string;
+        label_background: string;
+        label_hier: string;
+        label_local: string;
+        net_name: string;
+        no_connect: string;
+        note: string;
+        override_item_colors: boolean;
+        pin: string;
+        pin_name: string;
+        pin_number: string;
+        reference: string;
+        shadow: string;
+        sheet: string;
+        sheet_background: string;
+        sheet_fields: string;
+        sheet_filename: string;
+        sheet_label: string;
+        sheet_name: string;
+        table: string;
+        value: string;
+        wire: string;
+        wire_crossing: string;
+        worksheet: string;
+    };
+};
+type ColorMap = typeof colorMap;
+
+type ColorOverrides = {
+    schematic?: Partial<ColorMap["schematic"]>;
+};
+interface Options$1 {
+    colorOverrides?: ColorOverrides;
+    width?: number;
+    height?: number;
+    grid?: boolean | {
+        cellSize?: number;
+        labelCells?: boolean;
+    };
+    labeledPoints?: Array<{
+        x: number;
+        y: number;
+        label: string;
+    }>;
+    includeVersion?: boolean;
+    showErrorsInTextOverlay?: boolean;
+    drawPorts?: boolean;
+}
+declare function convertCircuitJsonToSchematicSvg(circuitJson: AnyCircuitElement[], options?: Options$1): string;
+/**
+ * @deprecated use `convertCircuitJsonToSchematicSvg` instead
+ */
+declare const circuitJsonToSchematicSvg: typeof convertCircuitJsonToSchematicSvg;
+
+type CircuitJsonWithSimulation = AnyCircuitElement | SimulationExperiment | SimulationTransientVoltageGraph | SimulationVoltageProbe;
+declare function isSimulationTransientVoltageGraph(value: CircuitJsonWithSimulation): value is SimulationTransientVoltageGraph;
+declare function isSimulationExperiment(value: CircuitJsonWithSimulation): value is SimulationExperiment;
+declare function isSimulationVoltageProbe(value: CircuitJsonWithSimulation): value is SimulationVoltageProbe;
+
+interface ConvertSchematicSimulationParams {
+    circuitJson: CircuitJsonWithSimulation[];
+    simulation_experiment_id: string;
+    simulation_transient_voltage_graph_ids?: string[];
+    width?: number;
+    height?: number;
+    schematicHeightRatio?: number;
+    schematicOptions?: Omit<Parameters<typeof convertCircuitJsonToSchematicSvg>[1], "width" | "height" | "includeVersion">;
+    includeVersion?: boolean;
+    /** When true, place the simulation graph above the schematic instead of below (defaults to false). */
+    graphAboveSchematic?: boolean;
+    showErrorsInTextOverlay?: boolean;
+}
+declare function convertCircuitJsonToSchematicSimulationSvg({ circuitJson, simulation_experiment_id, simulation_transient_voltage_graph_ids, width, height, schematicHeightRatio, schematicOptions, includeVersion, graphAboveSchematic, showErrorsInTextOverlay, }: ConvertSchematicSimulationParams): string;
+
+interface Options {
+    layer: "top" | "bottom";
+    width?: number;
+    height?: number;
+    includeVersion?: boolean;
+    showErrorsInTextOverlay?: boolean;
+}
+declare function convertCircuitJsonToSolderPasteMask(circuitJson: AnyCircuitElement[], options: Options): string;
+
+interface ConvertSimulationGraphParams {
+    circuitJson: CircuitJsonWithSimulation[];
+    simulation_experiment_id: string;
+    simulation_transient_voltage_graph_ids?: string[];
+    width?: number;
+    height?: number;
+    includeVersion?: boolean;
+}
+declare function convertCircuitJsonToSimulationGraphSvg({ circuitJson, simulation_experiment_id, simulation_transient_voltage_graph_ids, width, height, includeVersion, }: ConvertSimulationGraphParams): string;
+
+declare function getSoftwareUsedString(circuitJson: AnyCircuitElement[]): string | undefined;
+
+declare const CIRCUIT_TO_SVG_VERSION: string;
+
+declare const createSvgObjectsForSchComponentPortHovers: ({ component, transform, circuitJson, }: {
+    component: SchematicComponent;
+    transform: Matrix;
+    circuitJson: AnyCircuitElement[];
+}) => INode[];
+
+declare function createErrorTextOverlay(circuitJson: AnyCircuitElement[], dataType?: string): INode | null;
+
+type CircuitToSvgModule_AssemblySvgContext = AssemblySvgContext;
+declare const CircuitToSvgModule_CIRCUIT_TO_SVG_VERSION: typeof CIRCUIT_TO_SVG_VERSION;
+type CircuitToSvgModule_CircuitJsonWithSimulation = CircuitJsonWithSimulation;
+type CircuitToSvgModule_ColorMap = ColorMap;
+type CircuitToSvgModule_ColorOverrides = ColorOverrides;
+type CircuitToSvgModule_PcbColorMap = PcbColorMap;
+type CircuitToSvgModule_PcbColorOverrides = PcbColorOverrides;
+type CircuitToSvgModule_PcbContext = PcbContext;
+type CircuitToSvgModule_PcbSvgOptions = PcbSvgOptions;
+type CircuitToSvgModule_PinoutLabel = PinoutLabel;
+type CircuitToSvgModule_PinoutSvgContext = PinoutSvgContext;
+declare const CircuitToSvgModule_circuitJsonToPcbSvg: typeof circuitJsonToPcbSvg;
+declare const CircuitToSvgModule_circuitJsonToSchematicSvg: typeof circuitJsonToSchematicSvg;
+declare const CircuitToSvgModule_convertCircuitJsonToAssemblySvg: typeof convertCircuitJsonToAssemblySvg;
+declare const CircuitToSvgModule_convertCircuitJsonToPcbSvg: typeof convertCircuitJsonToPcbSvg;
+declare const CircuitToSvgModule_convertCircuitJsonToPinoutSvg: typeof convertCircuitJsonToPinoutSvg;
+declare const CircuitToSvgModule_convertCircuitJsonToSchematicSimulationSvg: typeof convertCircuitJsonToSchematicSimulationSvg;
+declare const CircuitToSvgModule_convertCircuitJsonToSchematicSvg: typeof convertCircuitJsonToSchematicSvg;
+declare const CircuitToSvgModule_convertCircuitJsonToSimulationGraphSvg: typeof convertCircuitJsonToSimulationGraphSvg;
+declare const CircuitToSvgModule_convertCircuitJsonToSolderPasteMask: typeof convertCircuitJsonToSolderPasteMask;
+declare const CircuitToSvgModule_createErrorTextOverlay: typeof createErrorTextOverlay;
+declare const CircuitToSvgModule_createSvgObjectsForSchComponentPortHovers: typeof createSvgObjectsForSchComponentPortHovers;
+declare const CircuitToSvgModule_getSoftwareUsedString: typeof getSoftwareUsedString;
+declare const CircuitToSvgModule_isSimulationExperiment: typeof isSimulationExperiment;
+declare const CircuitToSvgModule_isSimulationTransientVoltageGraph: typeof isSimulationTransientVoltageGraph;
+declare const CircuitToSvgModule_isSimulationVoltageProbe: typeof isSimulationVoltageProbe;
+declare namespace CircuitToSvgModule {
+  export { type CircuitToSvgModule_AssemblySvgContext as AssemblySvgContext, CircuitToSvgModule_CIRCUIT_TO_SVG_VERSION as CIRCUIT_TO_SVG_VERSION, type CircuitToSvgModule_CircuitJsonWithSimulation as CircuitJsonWithSimulation, type CircuitToSvgModule_ColorMap as ColorMap, type CircuitToSvgModule_ColorOverrides as ColorOverrides, type CircuitToSvgModule_PcbColorMap as PcbColorMap, type CircuitToSvgModule_PcbColorOverrides as PcbColorOverrides, type CircuitToSvgModule_PcbContext as PcbContext, type CircuitToSvgModule_PcbSvgOptions as PcbSvgOptions, type CircuitToSvgModule_PinoutLabel as PinoutLabel, type CircuitToSvgModule_PinoutSvgContext as PinoutSvgContext, CircuitToSvgModule_circuitJsonToPcbSvg as circuitJsonToPcbSvg, CircuitToSvgModule_circuitJsonToSchematicSvg as circuitJsonToSchematicSvg, CircuitToSvgModule_convertCircuitJsonToAssemblySvg as convertCircuitJsonToAssemblySvg, CircuitToSvgModule_convertCircuitJsonToPcbSvg as convertCircuitJsonToPcbSvg, CircuitToSvgModule_convertCircuitJsonToPinoutSvg as convertCircuitJsonToPinoutSvg, CircuitToSvgModule_convertCircuitJsonToSchematicSimulationSvg as convertCircuitJsonToSchematicSimulationSvg, CircuitToSvgModule_convertCircuitJsonToSchematicSvg as convertCircuitJsonToSchematicSvg, CircuitToSvgModule_convertCircuitJsonToSimulationGraphSvg as convertCircuitJsonToSimulationGraphSvg, CircuitToSvgModule_convertCircuitJsonToSolderPasteMask as convertCircuitJsonToSolderPasteMask, CircuitToSvgModule_createErrorTextOverlay as createErrorTextOverlay, CircuitToSvgModule_createSvgObjectsForSchComponentPortHovers as createSvgObjectsForSchComponentPortHovers, CircuitToSvgModule_getSoftwareUsedString as getSoftwareUsedString, CircuitToSvgModule_isSimulationExperiment as isSimulationExperiment, CircuitToSvgModule_isSimulationTransientVoltageGraph as isSimulationTransientVoltageGraph, CircuitToSvgModule_isSimulationVoltageProbe as isSimulationVoltageProbe };
+}
+
+declare const supportedModules: readonly ["circuit-json-to-bom-csv", "circuit-json-to-bpc", "circuit-json-to-connectivity-map", "circuit-json-to-gerber", "circuit-json-to-gltf", "circuit-json-to-kicad", "circuit-json-to-lbrn", "circuit-json-to-pnp-csv", "circuit-json-to-readable-netlist", "circuit-json-to-simple-3d", "circuit-json-to-spice", "circuit-json-to-step", "circuit-json-to-tscircuit", "circuit-to-canvas", "circuit-to-svg"];
+type SupportedModuleName = (typeof supportedModules)[number];
+type SupportedModuleSpecifier = SupportedModuleName | `${SupportedModuleName}@${string}`;
+interface SupportedModuleMap {
+    "circuit-json-to-bom-csv": typeof CircuitJsonToBomCsvModule;
+    "circuit-json-to-bpc": typeof CircuitJsonToBpcModule;
+    "circuit-json-to-connectivity-map": typeof CircuitJsonToConnectivityMapModule;
+    "circuit-json-to-gerber": typeof CircuitJsonToGerberModule;
+    "circuit-json-to-gltf": typeof CircuitJsonToGltfModule;
+    "circuit-json-to-kicad": typeof CircuitJsonToKicadModule;
+    "circuit-json-to-lbrn": typeof CircuitJsonToLbrnModule;
+    "circuit-json-to-pnp-csv": typeof CircuitJsonToPnpCsvModule;
+    "circuit-json-to-readable-netlist": typeof CircuitJsonToReadableNetlistModule;
+    "circuit-json-to-simple-3d": typeof CircuitJsonToSimple3dModule;
+    "circuit-json-to-spice": typeof CircuitJsonToSpiceModule;
+    "circuit-json-to-step": typeof CircuitJsonToStepModule;
+    "circuit-json-to-tscircuit": typeof CircuitJsonToTscircuitModule;
+    "circuit-to-canvas": typeof CircuitToCanvasModule;
+    "circuit-to-svg": typeof CircuitToSvgModule;
+}
+type StripVersion<TSpecifier extends string> = TSpecifier extends `${infer TBase}@${string}` ? TBase extends SupportedModuleName ? TBase : never : TSpecifier extends SupportedModuleName ? TSpecifier : never;
+declare const getImportUrl: (specifier: string) => string;
+declare function importer<TSpecifier extends SupportedModuleSpecifier>(specifier: TSpecifier): Promise<SupportedModuleMap[StripVersion<TSpecifier>]>;
+declare function importer(specifier: string): Promise<unknown>;
+
+export { type SupportedModuleMap, type SupportedModuleName, type SupportedModuleSpecifier, importer as default, getImportUrl, supportedModules };