ts-prorm-orm 1.1.0 → 1.2.0

package/dist/diagrams/chen-diagram.d.ts

@@ -0,0 +1,70 @@
+/**
+ * ChenDiagram — renders a classic Chen-notation Entity-Relationship diagram
+ * as SVG, built against a real DOM document (via svg-dom) rather than
+ * concatenated markup.
+ *
+ * Chen notation (distinct from crow's-foot):
+ *   - Entities       → rectangles (weak entities get a double border)
+ *   - Relationships  → diamonds placed between the two entities they connect,
+ *                      with cardinality labels (1, N, M) on the connecting lines
+ *   - Attributes     → ellipses connected to their entity by a line; key
+ *                      attributes have underlined text, multivalued get a double
+ *                      ellipse, derived get a dashed ellipse.
+ *
+ * Options honor `theme` (light|dark canvas/text) and `color` (accent for
+ * entities/diamonds) via resolveTheme/resolveAccent, so both flags change the
+ * generated output. The viewBox is auto-sized to the laid-out geometry.
+ *
+ * Usage:
+ *   const diag = new ChenDiagram({ entities: [...], relationships: [...] });
+ *   diag.save('./diagrams/er.svg');   // or: diag.generate()
+ */
+export interface ChenAttribute {
+    name: string;
+    key?: boolean;
+    multivalued?: boolean;
+    derived?: boolean;
+}
+export interface ChenEntity {
+    name: string;
+    weak?: boolean;
+    attributes?: ChenAttribute[];
+}
+export interface ChenRelationship {
+    name: string;
+    from: string;
+    to: string;
+    fromCardinality?: string;
+    toCardinality?: string;
+}
+export interface ChenDiagramOptions {
+    entities: ChenEntity[];
+    relationships?: ChenRelationship[];
+    title?: string;
+    theme?: 'light' | 'dark';
+    color?: string;
+}
+export declare class ChenDiagram {
+    private opts;
+    private static readonly PAD;
+    private static readonly TITLE_H;
+    private static readonly ENT_W;
+    private static readonly ENT_H;
+    private static readonly DIA_W;
+    private static readonly DIA_H;
+    private static readonly ATTR_RX;
+    private static readonly ATTR_RY;
+    private static readonly ATTR_DIST;
+    private static readonly COL_GAP;
+    private static readonly ROW_GAP;
+    constructor(options: ChenDiagramOptions);
+    private attributePositions;
+    private drawAttribute;
+    private drawEntity;
+    private drawRelationship;
+    generate(): string;
+    /**
+     * Write the SVG to a file. Creates parent directories if needed.
+     */
+    save(outputPath: string): string;
+}

package/dist/diagrams/chen-diagram.js

@@ -120,7 +120,7 @@ class ChenDiagram {
             ry,
             fill: t.cardBg,
             stroke: accent.mid,
-            'stroke-width': 1.8,
+            'stroke-width': 1.6,
             'stroke-dasharray': strokeDash,
         });
         const label = attr.name.length > 14 ? attr.name.slice(0, 13) + '…' : attr.name;
@@ -128,9 +128,9 @@ class ChenDiagram {
             .child('text', {
             x: at.x,
             y: at.y + 4,
-            'font-family': 'system-ui,-apple-system,sans-serif',
+            'font-family': palette_1.FONTS.body,
             'font-size': 12,
-            'font-weight': attr.key ? 700 : 500,
+            'font-weight': attr.key ? 600 : 400,
             fill: t.textPrimary,
             'text-anchor': 'middle',
             // key attributes are underlined in Chen notation
@@ -150,10 +150,10 @@ class ChenDiagram {
                 y: y - 5,
                 width: W + 10,
                 height: H + 10,
-                rx: 4,
+                rx: 0,
                 fill: 'none',
-                stroke: accent.from,
-                'stroke-width': 1.6,
+                stroke: accent.mid,
+                'stroke-width': 1.4,
             });
         }
         svg.child('rect', {
@@ -161,18 +161,18 @@ class ChenDiagram {
             y,
             width: W,
             height: H,
-            rx: 4,
+            rx: 0,
             fill: accent.light,
-            stroke: accent.from,
-            'stroke-width': 2.2,
+            stroke: accent.mid,
+            'stroke-width': 1.6,
         });
         svg
             .child('text', {
             x: p.center.x,
             y: p.center.y + 5,
-            'font-family': 'system-ui,-apple-system,sans-serif',
-            'font-size': 16,
-            'font-weight': 700,
+            'font-family': palette_1.FONTS.heading,
+            'font-size': 17,
+            'font-weight': 600,
             fill: accent.text,
             'text-anchor': 'middle',
         })
@@ -188,18 +188,18 @@ class ChenDiagram {
             y1: a.y,
             x2: mid.x,
             y2: mid.y,
-            stroke: t.textPrimary,
-            'stroke-width': 1.6,
+            stroke: palette_1.INDUSTRY.neutral[600],
+            'stroke-width': 1.4,
         });
         svg.child('line', {
             x1: mid.x,
             y1: mid.y,
             x2: b.x,
             y2: b.y,
-            stroke: t.textPrimary,
-            'stroke-width': 1.6,
+            stroke: palette_1.INDUSTRY.neutral[600],
+            'stroke-width': 1.4,
         });
-        // diamond (polygon) centered on mid
+        // diamond (polygon) centered on mid — solid accent fill, white label
         const pts = [
             `${mid.x},${mid.y - DH / 2}`,
             `${mid.x + DW / 2},${mid.y}`,
@@ -208,18 +208,18 @@ class ChenDiagram {
         ].join(' ');
         svg.child('polygon', {
             points: pts,
-            fill: accent.to,
-            stroke: accent.from,
-            'stroke-width': 2.2,
+            fill: accent.mid,
+            stroke: accent.text,
+            'stroke-width': 1.4,
         });
         svg
             .child('text', {
             x: mid.x,
             y: mid.y + 5,
-            'font-family': 'system-ui,-apple-system,sans-serif',
-            'font-size': 13,
-            'font-weight': 700,
-            fill: accent.text,
+            'font-family': palette_1.FONTS.heading,
+            'font-size': 14,
+            'font-weight': 600,
+            fill: '#FFFFFF',
             'text-anchor': 'middle',
         })
             .text(rel.name);
@@ -233,9 +233,9 @@ class ChenDiagram {
                 .child('text', {
                 x: lx,
                 y: ly,
-                'font-family': "'SF Mono',monospace",
-                'font-size': 14,
-                'font-weight': 700,
+                'font-family': palette_1.FONTS.mono,
+                'font-size': 13,
+                'font-weight': 600,
                 fill: t.textPrimary,
                 'text-anchor': 'middle',
             })
@@ -296,7 +296,9 @@ class ChenDiagram {
         const svgH = Math.ceil(maxY + PAD);
         const doc = new svg_dom_1.SvgDocument(svgW, svgH);
         const svg = doc.root;
-        // ── Background ──────────────────────────────────────────────────────
+        // Web fonts for browser renderers.
+        doc.style(palette_1.FONT_IMPORT);
+        // ── Ground ──────────────────────────────────────────────────────────
         svg.child('rect', { width: svgW, height: svgH, fill: t.canvasBg });
         // ── Title ───────────────────────────────────────────────────────────
         if (title) {
@@ -304,9 +306,9 @@ class ChenDiagram {
                 .child('text', {
                 x: PAD,
                 y: PAD,
-                'font-family': 'system-ui,-apple-system,sans-serif',
-                'font-size': 22,
-                'font-weight': 800,
+                'font-family': palette_1.FONTS.heading,
+                'font-size': 24,
+                'font-weight': 600,
                 fill: t.textPrimary,
             })
                 .text(title);

package/dist/diagrams/class-diagram.d.ts

@@ -0,0 +1,78 @@
+/**
+ * ClassDiagram — renders one or more classes as UML class boxes.
+ *
+ * Each class box has three compartments:
+ *  - a title bar (class name + optional «stereotype»),
+ *  - an attributes compartment (`+ name: type`, with +/-/# visibility markers),
+ *  - a methods compartment (`+ name(args): returnType`).
+ *
+ * Multiple classes are laid out in a responsive grid (wrapping after N
+ * columns). When a class declares `extends`, a UML inheritance connector
+ * (hollow triangle arrowhead) is drawn to its parent; when it declares plain
+ * associations, a simple line connector is drawn instead.
+ *
+ * `--theme light|dark` drives canvas/box/text colors and `--color <name|hex>`
+ * drives the accent used for title bars — both genuinely change fill/stroke
+ * values in the generated SVG.
+ *
+ * Usage:
+ *   const diag = new ClassDiagram({ classes: [ … ] });
+ *   diag.save('./diagrams/classes.svg');
+ *   // or:
+ *   const svgString = diag.generate();
+ */
+export interface UmlAttribute {
+    name: string;
+    type?: string;
+    visibility?: 'public' | 'private' | 'protected';
+    static?: boolean;
+}
+export interface UmlMethod {
+    name: string;
+    args?: string;
+    returns?: string;
+    visibility?: 'public' | 'private' | 'protected';
+}
+export interface UmlClass {
+    name: string;
+    stereotype?: string;
+    attributes?: UmlAttribute[];
+    methods?: UmlMethod[];
+    /** Name of a parent class in this diagram (drawn as inheritance). */
+    extends?: string;
+    /** Names of associated classes in this diagram (drawn as plain lines). */
+    associations?: string[];
+}
+export interface ClassDiagramOptions {
+    classes: UmlClass[];
+    title?: string;
+    theme?: 'light' | 'dark';
+    /** Named palette (e.g. "emerald") or a hex color string. */
+    color?: string;
+    /** Number of columns before wrapping. Defaults to an auto value. */
+    columns?: number;
+}
+export declare class ClassDiagram {
+    private opts;
+    private static readonly BOX_W;
+    private static readonly TITLE_H;
+    private static readonly STEREO_EXTRA;
+    private static readonly ROW_H;
+    private static readonly COMPARTMENT_PAD;
+    private static readonly GAP_X;
+    private static readonly GAP_Y;
+    private static readonly PAD;
+    private static readonly TITLE_BAR_H;
+    constructor(options: ClassDiagramOptions);
+    private boxHeight;
+    private layout;
+    generate(): string;
+    private center;
+    private drawAssociation;
+    private drawInheritance;
+    private drawClassBox;
+    /**
+     * Write the SVG to a file. Creates parent directories if needed.
+     */
+    save(outputPath: string): string;
+}

package/dist/diagrams/class-diagram.js

@@ -61,6 +61,15 @@ const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const palette_1 = require("./palette");
 const svg_dom_1 = require("./svg-dom");
+// ─── Industry design system ────────────────────────────────────────────────
+// Barlow / JetBrains Mono typography, hairline borders and square "blueprint"
+// corners are fixed by the Industry spec; accent + surface colours still route
+// through resolveAccent / resolveTheme so --color / --theme keep working.
+const IND_FONT_HEAD = '"Barlow Condensed", system-ui, sans-serif';
+const IND_FONT_BODY = '"Barlow", system-ui, sans-serif';
+const IND_FONT_MONO = 'ui-monospace, "JetBrains Mono", "SF Mono", Menlo, monospace';
+const IND_HAIRLINE = 'rgba(29,31,32,0.16)';
+const IND_FONT_IMPORT = "@import url('https://fonts.googleapis.com/css2?family=Barlow:wght@400;500;700&family=Barlow+Condensed:wght@400;600&family=JetBrains+Mono&display=swap');";
 const VIS_MARK = {
     public: '+',
     private: '-',
@@ -150,27 +159,19 @@ class ClassDiagram {
         const svgH = maxBottom + ClassDiagram.PAD;
         const doc = new svg_dom_1.SvgDocument(svgW, svgH);
         const svg = doc.root;
-        // Background.
+        // Background + embedded Industry web-fonts.
         svg.child('rect', { width: svgW, height: svgH, fill: t.canvasBg });
-        // Accent gradient for title bars + a drop shadow.
-        doc.linearGradient('classHdr', [
-            [0, accent.from],
-            [55, accent.mid],
-            [100, accent.to],
-        ]);
-        const filter = doc
-            .defs()
-            .child('filter', { id: 'classShadow', x: '-8%', y: '-8%', width: '116%', height: '120%' });
-        filter.child('feDropShadow', { dx: 0, dy: 4, stdDeviation: 7, 'flood-color': '#00000022' });
+        svg.child('style').text(IND_FONT_IMPORT);
+        // Blueprint style: solid accent header bars + hairline frames, no gradients.
         // Optional diagram title.
         if (title) {
             svg
                 .child('text', {
                 x: ClassDiagram.PAD,
                 y: ClassDiagram.PAD + 8,
-                'font-family': 'system-ui,-apple-system,sans-serif',
+                'font-family': IND_FONT_HEAD,
                 'font-size': 20,
-                'font-weight': 800,
+                'font-weight': 600,
                 fill: t.textPrimary,
             })
                 .text(title);
@@ -254,36 +255,31 @@ class ClassDiagram {
         const { cls, x, y, w, h, titleH, attrH } = p;
         const attrs = cls.attributes ?? [];
         const methods = cls.methods ?? [];
-        // Outer box.
+        // Outer box (white interior, hairline border, square corners).
         svg.child('rect', {
             x,
             y,
             width: w,
             height: h,
-            rx: 8,
             fill: t.cardBg,
             stroke: t.border,
-            'stroke-width': 1.5,
-            filter: 'url(#classShadow)',
+            'stroke-width': 1,
         });
-        // Title bar (accent gradient).
+        // Title bar (solid accent — blueprint label bar).
         svg.child('rect', {
             x,
             y,
             width: w,
             height: titleH,
-            rx: 8,
-            fill: 'url(#classHdr)',
+            fill: accent.mid,
         });
-        // Square off the bottom of the rounded title bar.
-        svg.child('rect', { x, y: y + titleH - 8, width: w, height: 8, fill: 'url(#classHdr)' });
         let titleTextY = y + 26;
         if (cls.stereotype) {
             svg
                 .child('text', {
                 x: x + w / 2,
                 y: y + 18,
-                'font-family': 'system-ui,sans-serif',
+                'font-family': IND_FONT_BODY,
                 'font-size': 11,
                 'font-style': 'italic',
                 fill: 'rgba(255,255,255,0.85)',
@@ -296,9 +292,9 @@ class ClassDiagram {
             .child('text', {
             x: x + w / 2,
             y: titleTextY,
-            'font-family': 'system-ui,-apple-system,sans-serif',
+            'font-family': IND_FONT_HEAD,
             'font-size': 15,
-            'font-weight': 800,
+            'font-weight': 600,
             fill: '#FFFFFF',
             'text-anchor': 'middle',
         })
@@ -322,7 +318,7 @@ class ClassDiagram {
                 .child('text', {
                 x: x + 12,
                 y: rowY,
-                'font-family': "'SF Mono','Fira Code',monospace",
+                'font-family': IND_FONT_MONO,
                 'font-size': 12,
                 'font-weight': 500,
                 'text-decoration': a.static ? 'underline' : undefined,
@@ -349,7 +345,7 @@ class ClassDiagram {
                 .child('text', {
                 x: x + 12,
                 y: rowY,
-                'font-family': "'SF Mono','Fira Code',monospace",
+                'font-family': IND_FONT_MONO,
                 'font-size': 12,
                 'font-weight': 500,
                 fill: t.textSecondary,

package/dist/diagrams/dependency-diagram.d.ts

@@ -0,0 +1,82 @@
+/**
+ * DependencyDiagram — renders a directed dependency graph of models/tables.
+ *
+ * Nodes are models/tables; a directed edge `from → to` means "from depends on
+ * to" (e.g. table `from` holds a foreign key into table `to`). The generator:
+ *
+ *  - Computes a layered / topological layout: each node's layer is the longest
+ *    dependency path to a leaf. Nodes with no dependencies sit in layer 0;
+ *    their dependents fan out into higher layers.
+ *  - Detects cycles (back edges) with a DFS colouring pass and visually flags
+ *    the cyclic edges in red. The layering pass carries its own visited guard
+ *    so a cycle can never send it into an infinite loop.
+ *  - Draws each node as a labelled rounded box sized to its label, with arrows
+ *    between dependent boxes.
+ *
+ * Accent colour (`color`) drives the node fills / arrowheads; the theme
+ * (`light` | `dark`) drives the canvas + text colours. Both genuinely change
+ * real fill/stroke values in the emitted SVG. The viewBox auto-sizes to the
+ * computed layout.
+ *
+ * Usage:
+ *   const d = new DependencyDiagram({ nodes, edges, title: 'Schema deps' });
+ *   const svg = d.generate();
+ *   d.save('./diagrams/deps.svg');
+ */
+export interface DepNode {
+    name: string;
+    group?: string;
+}
+export interface DepEdge {
+    from: string;
+    to: string;
+    label?: string;
+}
+export interface DependencyDiagramOptions {
+    nodes: DepNode[];
+    edges: DepEdge[];
+    title?: string;
+    theme?: 'light' | 'dark';
+    /** Named palette or hex accent colour */
+    color?: string;
+    direction?: 'horizontal' | 'vertical';
+}
+export declare class DependencyDiagram {
+    private opts;
+    private static readonly PAD;
+    private static readonly TITLE_H;
+    private static readonly NODE_H;
+    private static readonly CHAR_W;
+    private static readonly NODE_PAD_X;
+    private static readonly MIN_NODE_W;
+    private static readonly LAYER_GAP;
+    private static readonly NODE_GAP;
+    private static readonly R;
+    constructor(options: DependencyDiagramOptions);
+    /** Adjacency: node → the nodes it depends on (its outgoing edge targets). */
+    private buildAdjacency;
+    /**
+     * Assign each node a layer = longest dependency path length (0 for nodes with
+     * no dependencies). Uses memoisation plus an on-stack guard so cyclic edges
+     * are simply skipped and never cause infinite recursion.
+     */
+    private computeLayers;
+    /**
+     * Detect cyclic edges via DFS colouring. Returns a set of "from→to" keys that
+     * are back edges (participate in a cycle).
+     */
+    private detectCyclicEdges;
+    private nodeWidth;
+    /**
+     * Point on the boundary of a rectangle along the line from the rect centre
+     * toward an external point — used so arrowheads land on the box edge.
+     */
+    private edgePoint;
+    generate(): string;
+    private place;
+    private defineArrow;
+    /**
+     * Write the SVG to a file, creating parent directories as needed.
+     */
+    save(outputPath: string): string;
+}

package/dist/diagrams/dependency-diagram.js

@@ -63,6 +63,15 @@ const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const palette_1 = require("./palette");
 const svg_dom_1 = require("./svg-dom");
+// ─── Industry design system ────────────────────────────────────────────────
+// Barlow / JetBrains Mono typography, hairline borders and square "blueprint"
+// corners are fixed by the Industry spec; accent + surface colours still route
+// through resolveAccent / resolveTheme so --color / --theme keep working.
+const IND_FONT_HEAD = '"Barlow Condensed", system-ui, sans-serif';
+const IND_FONT_BODY = '"Barlow", system-ui, sans-serif';
+const IND_FONT_MONO = 'ui-monospace, "JetBrains Mono", "SF Mono", Menlo, monospace';
+const IND_HAIRLINE = 'rgba(29,31,32,0.16)';
+const IND_FONT_IMPORT = "@import url('https://fonts.googleapis.com/css2?family=Barlow:wght@400;500;700&family=Barlow+Condensed:wght@400;600&family=JetBrains+Mono&display=swap');";
 // ─── Main class ──────────────────────────────────────────────────────────────
 class DependencyDiagram {
     constructor(options) {
@@ -259,8 +268,9 @@ class DependencyDiagram {
         // ── Build the document ──────────────────────────────────────────────
         const doc = new svg_dom_1.SvgDocument(svgW, svgH);
         const svg = doc.root;
-        // Background
+        // Background + embedded Industry web-fonts.
         svg.child('rect', { width: svgW, height: svgH, fill: t.canvasBg });
+        svg.child('style').text(IND_FONT_IMPORT);
         // Arrowhead markers (accent + cyclic red).
         const CYCLE_COLOR = '#DC2626';
         this.defineArrow(doc, 'depArrow', accent.mid);
@@ -270,9 +280,9 @@ class DependencyDiagram {
             .child('text', {
             x: PAD,
             y: PAD + 6,
-            'font-family': 'system-ui,-apple-system,sans-serif',
+            'font-family': IND_FONT_HEAD,
             'font-size': 22,
-            'font-weight': 800,
+            'font-weight': 600,
             fill: t.textPrimary,
         })
             .text(title);
@@ -280,7 +290,7 @@ class DependencyDiagram {
             .child('text', {
             x: PAD,
             y: PAD + 26,
-            'font-family': 'system-ui,sans-serif',
+            'font-family': IND_FONT_BODY,
             'font-size': 11,
             fill: t.textSecondary,
         })
@@ -331,7 +341,7 @@ class DependencyDiagram {
                     .child('text', {
                     x: (start.x + end.x) / 2,
                     y: (start.y + end.y) / 2 - 4,
-                    'font-family': "'SF Mono',monospace",
+                    'font-family': IND_FONT_MONO,
                     'font-size': 9,
                     fill: isCyclic ? CYCLE_COLOR : t.textSecondary,
                     'text-anchor': 'middle',
@@ -350,15 +360,14 @@ class DependencyDiagram {
                 y: p.y,
                 width: p.w,
                 height: p.h,
-                rx: R,
                 fill: p.fill,
                 stroke: p.stroke,
-                'stroke-width': 2,
+                'stroke-width': 1,
             });
             g.child('text', {
                 x: p.x + p.w / 2,
                 y: p.y + p.h / 2 + 5,
-                'font-family': "'SF Mono','Fira Code',monospace",
+                'font-family': IND_FONT_MONO,
                 'font-size': 14,
                 'font-weight': 700,
                 fill: p.text,
@@ -368,7 +377,7 @@ class DependencyDiagram {
             g.child('text', {
                 x: p.x + 8,
                 y: p.y + 13,
-                'font-family': 'system-ui,sans-serif',
+                'font-family': IND_FONT_BODY,
                 'font-size': 9,
                 'font-weight': 700,
                 fill: p.text,

package/dist/diagrams/er-diagram.d.ts

@@ -0,0 +1,82 @@
+/**
+ * ERDiagram — generates a fully-rendered Entity-Relationship diagram SVG for
+ * a collection of ORM models and their associations, styled to the "Industry"
+ * blueprint design system.
+ *
+ * Look:
+ *  - #f2f2f3 ground with a faint hairline blueprint grid
+ *  - Solid accent (#5980a6) banner, Barlow Condensed title
+ *  - White entity cards on a grid: SQUARE corners, 1px hairline borders, a solid
+ *    accent / accent-2 (two-tone) header bar — no vibrant gradients or shadows
+ *  - Compact rows: name (mono) + type (mono, neutral) + PK/FK marks
+ *  - Hairline crow's-foot relationship connectors with mono cardinality marks
+ *  - Legend bottom-right, Barlow labels
+ *  - Fully self-contained SVG (fonts via an embedded @import + system fallbacks)
+ *
+ * Usage:
+ *   const er = new ERDiagram({
+ *     title: 'E-Commerce Schema',
+ *     models: [userDef, productDef, orderDef],
+ *   });
+ *   er.save('./diagrams/schema.svg');
+ */
+import { ModelDiagramOptions } from './model-diagram';
+export interface ERDiagramOptions {
+    /** Diagram title shown in the top banner */
+    title?: string;
+    /** All models to include in the diagram */
+    models: ModelDiagramOptions[];
+    /**
+     * Number of entity columns in the grid.
+     * @default 3
+     */
+    columns?: number;
+    /** Horizontal gap between entity boxes (px) */
+    hGap?: number;
+    /** Vertical gap between entity boxes (px) */
+    vGap?: number;
+    /** Theme mode: light or dark */
+    theme?: 'light' | 'dark';
+    /** Named palette (e.g. "industry") or hex color for the accent */
+    color?: string;
+}
+export declare class ERDiagram {
+    private opts;
+    private static readonly BOX_W;
+    private static readonly BOX_HDR;
+    private static readonly BOX_ROW;
+    private static readonly BOX_FOOT;
+    private static readonly MIN_H;
+    private static readonly BANNER_H;
+    private static readonly LEGEND_W;
+    private static readonly LEGEND_PAD;
+    private static readonly MARGIN;
+    private accentMid;
+    private accentText;
+    private accentLight;
+    private accent2Mid;
+    private accent2Text;
+    private accent2Light;
+    constructor(options: ERDiagramOptions);
+    /** Two-tone entity styling — even entities accent, odd accent-2. */
+    private entityStyle;
+    private boxHeight;
+    private computeLayout;
+    private renderBox;
+    private renderRelationships;
+    private crowFoot;
+    private singleBar;
+    private renderBanner;
+    private renderLegend;
+    /**
+     * Embedded font @import so browsers resolve Barlow / JetBrains Mono. Wrapped
+     * in CDATA because the Google-Fonts URL contains raw `&` separators that
+     * would otherwise be invalid XML in this string-built document.
+     */
+    private fontDefs;
+    generate(): string;
+    /**
+     * Write the SVG to a file. Creates parent directories if needed.
+     */
+    save(outputPath: string): string;
+}