@svgsketch/core 0.7.0 → 1.1.0

package/dist/index.d.mts

@@ -269,6 +269,75 @@ interface SerializedAnimationTimeline {
             x: number;
             y: number;
         };
+        /**
+         * CSS selector for a DOM element to animate directly, used when the
+         * animation target is not an editor Shape — e.g. an `<animateTransform
+         * xlink:href="#rect1"/>` whose target lives inside a `<clipPath>`
+         * definition. The track's `shapeId` is a synthetic `__dom__<id>` in
+         * this case (no editor Shape exists to bind to). Without this field,
+         * the SMIL exporter has no way to re-locate the target after a
+         * save/reload round-trip and silently drops every clip/mask-internal
+         * animation.
+         */
+        domTargetSelector?: string;
+        /**
+         * For `property === 'domTransformStack'` tracks: the original
+         * `<animateTransform>` `type` function (`translate` / `scale` /
+         * `rotate` / `skewX` / `skewY` / `matrix`). The SMIL exporter
+         * (`addDomTransformStackEntry`) early-returns when this is missing,
+         * silently dropping every stacked DOM-transform animation across
+         * save/reload. Per SVG Animation §19.4.2 the export must re-emit
+         * the same `type` — and per SMIL §4.2 the document-order index
+         * (`transformStackIndex`) controls additive composition of the
+         * stack. Both are essential for clip/mask internal animations.
+         */
+        transformFunction?: 'translate' | 'scale' | 'rotate' | 'skewX' | 'skewY' | 'matrix';
+        /**
+         * For `property === 'domTransformStack'` tracks: document-order
+         * index within the target element's `<animateTransform>` stack.
+         * The renderer sorts tracks by this index before applying the
+         * SMIL animation sandwich (SVG 2 §19.2.7).
+         */
+        transformStackIndex?: number;
+        /**
+         * For `property === 'domTransformStack'` tracks: the target
+         * element's pre-animation `transform` attribute value (the
+         * underlying value in the SMIL animation sandwich). Captured at
+         * import time.
+         */
+        transformBaseValue?: string;
+        /**
+         * For `property === 'domAttribute'` tracks: the SVG attribute name
+         * to write on the target element each frame (`cx`, `cy`, `r`, `x`,
+         * `y`, `width`, `height`, `opacity`, `fill-opacity`, `fill`,
+         * `stroke`, `d`, etc.). Generic carrier for `<animate>` / `<set>`
+         * inside `<clipPath>` / `<mask>` defs that the editor doesn't
+         * decompose into per-attribute first-class tracks. Set jointly with
+         * `domAttributeValueType` so the manager knows how to interpolate
+         * the raw keyframe values.
+         * @see SVG Animations §3.5
+         */
+        domAttribute?: string;
+        /**
+         * For `property === 'domAttribute'` tracks: how to interpolate the
+         * keyframe values. `'number'` → numeric tween; `'color'` → RGB
+         * channel tween via the existing color interp; `'string'` →
+         * discrete (no interpolation, holds each keyframe until the next).
+         * Determined at import time from the source `<animate>`'s
+         * `attributeName` (geometry → number, paint → color, others →
+         * string). `<set>` always produces `'string'` regardless of attr.
+         */
+        domAttributeValueType?: 'number' | 'color' | 'string';
+        /**
+         * SMIL `calcMode` (SVG Animations §2.10) — controls interpolation
+         * between keyframes. Persisted because it changes how the SMIL
+         * exporter materializes the track: `'discrete'` round-trips a
+         * single-keyframe track as `<set>` and a multi-keyframe track as one
+         * `<set>` per keyframe, while the absent/`'linear'` form emits a
+         * single `<animate values="…">`. Without this field, set-semantics
+         * tracks degrade to interpolated `<animate>` after save/reload.
+         */
+        calcMode?: 'linear' | 'discrete' | 'paced' | 'spline';
         keyframes: {
             time: number;
             value: number | string;
@@ -312,7 +381,7 @@ interface AnimatablePropertyDescriptor {
  * Only enums referenced by SerializedShape or HistorySnapshot live here.
  * Editor-only enums (Mode, ControlPointPosition, etc.) stay in the editor.
  */
-declare enum SplineCurveType {
+declare enum PathCurveType {
     LINEAR = "linear",
     QUADRATIC = "quadratic",
     CUBIC = "cubic",
@@ -321,7 +390,7 @@ declare enum SplineCurveType {
     BASIS = "basis",
     MIXED = "mixed"
 }
-declare enum SplinePointType {
+declare enum PathPointType {
     SMOOTH = "smooth",
     CORNER = "corner",
     SYMMETRIC = "symmetric"
@@ -400,6 +469,15 @@ interface LinearGradient {
      * element's bbox-normalised [0, 1] space. See `GradientUnits`.
      */
     gradientUnits?: GradientUnits;
+    /**
+     * SVG 2 §13.9 `color-interpolation` — color space for stop
+     * interpolation. Spec applies the property to gradient elements;
+     * `linearRGB` produces physically-linear blends, `sRGB` (the spec
+     * initial value) produces the perceptual blends most authors expect.
+     * Round-trip the attribute when authored so re-export does not
+     * silently shift mid-tone colors.
+     */
+    colorInterpolation?: 'auto' | 'sRGB' | 'linearRGB';
     /**
      * Original `id` from the imported source SVG. Runtime `id` is always
      * a fresh GUID (to keep editor uniqueness invariants), but `sourceId`
@@ -419,6 +497,14 @@ interface RadialGradient {
     r: number;
     ry: number;
     rotation: number;
+    /**
+     * Focal-circle radius (SVG 2 §14.2.3.1 `fr`). When present and > 0, the
+     * gradient's first stop is rendered along this circle (not at a single
+     * focal point) — produces a "donut" radial gradient. Same coordinate
+     * space as `r` (i.e. governed by `gradientUnits`). Defaults to 0
+     * when omitted, matching the spec's initial value and pre-SVG-2 behaviour.
+     */
+    fr?: number;
     stops: GradientStop[];
     spreadMethod: GradientSpreadMethod;
     opacity: number;
@@ -427,6 +513,8 @@ interface RadialGradient {
      * `r`/`ry` are in document user space. See `GradientUnits`.
      */
     gradientUnits?: GradientUnits;
+    /** See `LinearGradient.colorInterpolation`. */
+    colorInterpolation?: 'auto' | 'sRGB' | 'linearRGB';
     /** See `LinearGradient.sourceId`. */
     sourceId?: string;
 }
@@ -563,7 +651,7 @@ interface CustomPatternDef {
     /** Tile height in userSpaceOnUse coordinates. */
     height: number;
 }
-type FilterType = 'drop-shadow' | 'inner-shadow' | 'gaussian-blur' | 'motion-blur' | 'point-light' | 'spot-light' | 'diffuse-lighting' | 'specular-lighting' | 'outline' | 'sharpen' | 'pixelate' | 'warp' | 'morphology' | 'contouring-discrete' | 'contouring-table' | 'round-edges' | 'grayscale' | 'channel-painter' | 'brightness' | 'contrast' | 'opacity' | 'invert' | 'hue-rotate' | 'saturate' | 'black-and-white' | 'sepia' | 'duotone' | 'xray' | 'noise' | 'emboss' | 'film-grain' | 'watercolor' | 'gouache' | 'ink-blot' | 'crumpled-plastic' | 'riddled' | 'glow' | 'inner-glow' | 'raw-svg';
+type FilterType = 'drop-shadow' | 'inner-shadow' | 'gaussian-blur' | 'motion-blur' | 'point-light' | 'spot-light' | 'diffuse-lighting' | 'specular-lighting' | 'outline' | 'sharpen' | 'pixelate' | 'warp' | 'morphology' | 'contouring-discrete' | 'contouring-table' | 'round-edges' | 'grayscale' | 'channel-painter' | 'brightness' | 'contrast' | 'opacity' | 'invert' | 'hue-rotate' | 'saturate' | 'black-and-white' | 'sepia' | 'duotone' | 'xray' | 'noise' | 'emboss' | 'film-grain' | 'watercolor' | 'gouache' | 'ink-blot' | 'crumpled-plastic' | 'riddled' | 'glow' | 'inner-glow' | 'raw-svg' | 'svg-primitive-chain';
 type BlurQuality = 'normal' | 'high';
 interface BaseFilter {
     id: string;
@@ -831,14 +919,265 @@ interface RawSvgFilter extends BaseFilter {
     floodOpacity?: string;
     lightingColor?: string;
 }
-type ShapeFilter = DropShadowFilter | InnerShadowFilter | GaussianBlurFilter | MotionBlurFilter | PointLightFilter | SpotLightFilter | DiffuseLightingFilter | SpecularLightingFilter | OutlineFilter | SharpenFilter | PixelateFilter | WarpFilter | MorphologyFilter | ContouringDiscreteFilter | ContouringTableFilter | RoundEdgesFilter | GrayscaleFilter | ChannelPainterFilter | BrightnessFilter | ContrastFilter | OpacityFilter | InvertFilter | HueRotateFilter | SaturateFilter | BlackAndWhiteFilter | SepiaFilter | DuotoneFilter | XrayFilter | NoiseFilter | EmbossFilter | FilmGrainFilter | WatercolorFilter | GouacheFilter | InkBlotFilter | CrumpledPlasticFilter | RiddledFilter | GlowFilter | InnerGlowFilter | RawSvgFilter;
-type SegmentCurveType = 'LINEAR' | 'CUBIC' | 'QUADRATIC' | 'ARC';
-interface SplinePoint {
+type ShapeFilter = DropShadowFilter | InnerShadowFilter | GaussianBlurFilter | MotionBlurFilter | PointLightFilter | SpotLightFilter | DiffuseLightingFilter | SpecularLightingFilter | OutlineFilter | SharpenFilter | PixelateFilter | WarpFilter | MorphologyFilter | ContouringDiscreteFilter | ContouringTableFilter | RoundEdgesFilter | GrayscaleFilter | ChannelPainterFilter | BrightnessFilter | ContrastFilter | OpacityFilter | InvertFilter | HueRotateFilter | SaturateFilter | BlackAndWhiteFilter | SepiaFilter | DuotoneFilter | XrayFilter | NoiseFilter | EmbossFilter | FilmGrainFilter | WatercolorFilter | GouacheFilter | InkBlotFilter | CrumpledPlasticFilter | RiddledFilter | GlowFilter | InnerGlowFilter | RawSvgFilter | SvgPrimitiveChainFilter;
+/** Common attributes on every filter primitive (FE1 §7.2). */
+interface BaseFilterPrimitive {
+    /** Editor-only stable id; not serialized to SVG. */
+    id: string;
+    /** SourceGraphic | SourceAlpha | BackgroundImage | BackgroundAlpha |
+     *  FillPaint | StrokePaint | <filter-primitive-reference>. Omitted ⇒
+     *  defaults to previous primitive's result (or SourceGraphic if first). */
+    in?: string;
+    /** Custom result name for forward references. Omitted ⇒ implicit. */
+    result?: string;
+    /** Filter primitive subregion (FE1 §7.3). */
+    x?: string;
+    y?: string;
+    width?: string;
+    height?: string;
+    /** Per-primitive override of color-interpolation-filters. */
+    colorInterpolationFilters?: 'auto' | 'sRGB' | 'linearRGB';
+    /** Carry of attributes the editor doesn't model (style, class, data-*,
+     *  unknown spec attrs). Re-emitted verbatim. Keys exclude attrs already
+     *  modeled on this primitive. */
+    unknownAttrs?: Record<string, string>;
+    /** SMIL animation children attached to this primitive — preserved
+     *  verbatim. Each entry is the outerHTML of an <animate>, <set>,
+     *  <animateTransform>, or <animateMotion> element. */
+    animations?: string[];
+}
+/** Blend modes per Compositing 1 §3 + the FE1-specific extensions. */
+type FilterBlendMode = 'normal' | 'multiply' | 'screen' | 'overlay' | 'darken' | 'lighten' | 'color-dodge' | 'color-burn' | 'hard-light' | 'soft-light' | 'difference' | 'exclusion' | 'hue' | 'saturation' | 'color' | 'luminosity' | 'plus-darker' | 'plus-lighter';
+interface FeBlendPrimitive extends BaseFilterPrimitive {
+    type: 'feBlend';
+    in2?: string;
+    mode?: FilterBlendMode;
+    /** FE1 extension — boolean attribute, presence-based. */
+    noComposite?: boolean;
+}
+interface FeColorMatrixPrimitive extends BaseFilterPrimitive {
+    type: 'feColorMatrix';
+    matrixType?: 'matrix' | 'saturate' | 'hueRotate' | 'luminanceToAlpha';
+    /** Verbatim attribute string so we preserve the exact author spelling
+     *  (matrix arg counts, whitespace inside). Omitted ⇒ spec defaults
+     *  apply (matrix=identity, saturate=1, hueRotate=0). */
+    values?: string;
+}
+type TransferFunc = {
+    type: 'identity';
+} | {
+    type: 'table' | 'discrete';
+    tableValues: number[];
+} | {
+    type: 'linear';
+    slope?: number;
+    intercept?: number;
+} | {
+    type: 'gamma';
+    amplitude?: number;
+    exponent?: number;
+    offset?: number;
+};
+interface FeComponentTransferPrimitive extends BaseFilterPrimitive {
+    type: 'feComponentTransfer';
+    funcR?: TransferFunc;
+    funcG?: TransferFunc;
+    funcB?: TransferFunc;
+    funcA?: TransferFunc;
+}
+interface FeCompositePrimitive extends BaseFilterPrimitive {
+    type: 'feComposite';
+    in2?: string;
+    operator?: 'over' | 'in' | 'out' | 'atop' | 'xor' | 'lighter' | 'arithmetic';
+    k1?: number;
+    k2?: number;
+    k3?: number;
+    k4?: number;
+}
+interface FeConvolveMatrixPrimitive extends BaseFilterPrimitive {
+    type: 'feConvolveMatrix';
+    /** <number-optional-number>; preserved as authored (e.g. "3" or "3 3"). */
+    order?: string;
+    /** Space-separated kernel values, preserved as authored. */
+    kernelMatrix?: string;
+    divisor?: number;
+    bias?: number;
+    targetX?: number;
+    targetY?: number;
+    edgeMode?: 'duplicate' | 'wrap' | 'none';
+    /** <number-optional-number>; preserved as authored. */
+    kernelUnitLength?: string;
+    preserveAlpha?: boolean;
+}
+/** Light source elements (FE1 §16) — never appear at <filter> top level,
+ *  only as children of feDiffuseLighting/feSpecularLighting. */
+type FilterLightSource = {
+    kind: 'feDistantLight';
+    azimuth?: number;
+    elevation?: number;
+} | {
+    kind: 'fePointLight';
+    x?: number;
+    y?: number;
+    z?: number;
+} | {
+    kind: 'feSpotLight';
+    x?: number;
+    y?: number;
+    z?: number;
+    pointsAtX?: number;
+    pointsAtY?: number;
+    pointsAtZ?: number;
+    specularExponent?: number;
+    limitingConeAngle?: number;
+};
+interface FeDiffuseLightingPrimitive extends BaseFilterPrimitive {
+    type: 'feDiffuseLighting';
+    surfaceScale?: number;
+    diffuseConstant?: number;
+    /** <number-optional-number>; preserved as authored. */
+    kernelUnitLength?: string;
+    lightingColor?: string;
+    lightSource?: FilterLightSource;
+}
+interface FeSpecularLightingPrimitive extends BaseFilterPrimitive {
+    type: 'feSpecularLighting';
+    surfaceScale?: number;
+    specularConstant?: number;
+    specularExponent?: number;
+    kernelUnitLength?: string;
+    lightingColor?: string;
+    lightSource?: FilterLightSource;
+}
+interface FeDisplacementMapPrimitive extends BaseFilterPrimitive {
+    type: 'feDisplacementMap';
+    in2?: string;
+    scale?: number;
+    xChannelSelector?: 'R' | 'G' | 'B' | 'A';
+    yChannelSelector?: 'R' | 'G' | 'B' | 'A';
+}
+interface FeDropShadowPrimitive extends BaseFilterPrimitive {
+    type: 'feDropShadow';
+    dx?: number;
+    dy?: number;
+    /** <number-optional-number>; preserved as authored. */
+    stdDeviation?: string;
+    floodColor?: string;
+    /** Numeric value or the literal 'inherit'. */
+    floodOpacity?: string;
+}
+interface FeFloodPrimitive extends BaseFilterPrimitive {
+    type: 'feFlood';
+    floodColor?: string;
+    floodOpacity?: string;
+}
+interface FeGaussianBlurPrimitive extends BaseFilterPrimitive {
+    type: 'feGaussianBlur';
+    /** <number-optional-number>; preserved as authored (e.g. "3" or "3 1"). */
+    stdDeviation?: string;
+    edgeMode?: 'duplicate' | 'wrap' | 'none';
+}
+interface FeImagePrimitive extends BaseFilterPrimitive {
+    type: 'feImage';
+    /** Canonical (SVG 2). */
+    href?: string;
+    /** Back-compat alias re-emitted only when the original used xlink:href
+     *  and no href was authored. */
+    xlinkHref?: string;
+    preserveAspectRatio?: string;
+    crossorigin?: 'anonymous' | 'use-credentials';
+}
+interface FeMergePrimitive extends BaseFilterPrimitive {
+    type: 'feMerge';
+    /** <feMergeNode> children inlined. */
+    nodes: {
+        in?: string;
+    }[];
+}
+interface FeMorphologyPrimitive extends BaseFilterPrimitive {
+    type: 'feMorphology';
+    operator?: 'erode' | 'dilate';
+    /** <number-optional-number>; preserved as authored. */
+    radius?: string;
+}
+interface FeOffsetPrimitive extends BaseFilterPrimitive {
+    type: 'feOffset';
+    dx?: number;
+    dy?: number;
+}
+interface FeTilePrimitive extends BaseFilterPrimitive {
+    type: 'feTile';
+}
+interface FeTurbulencePrimitive extends BaseFilterPrimitive {
+    type: 'feTurbulence';
+    /** <number-optional-number>; preserved as authored. */
+    baseFrequency?: string;
+    numOctaves?: number;
+    seed?: number;
+    stitchTiles?: 'stitch' | 'noStitch';
+    turbulenceType?: 'fractalNoise' | 'turbulence';
+}
+type FilterPrimitive = FeBlendPrimitive | FeColorMatrixPrimitive | FeComponentTransferPrimitive | FeCompositePrimitive | FeConvolveMatrixPrimitive | FeDiffuseLightingPrimitive | FeSpecularLightingPrimitive | FeDisplacementMapPrimitive | FeDropShadowPrimitive | FeFloodPrimitive | FeGaussianBlurPrimitive | FeImagePrimitive | FeMergePrimitive | FeMorphologyPrimitive | FeOffsetPrimitive | FeTilePrimitive | FeTurbulencePrimitive;
+type FilterPrimitiveType = FilterPrimitive['type'];
+/**
+ * A `<filter>` element modeled as an ordered list of editable primitives.
+ *
+ * This variant is the parser's default when no curated stylized preset
+ * matches — it preserves every spec primitive 1:1 so imported third-party
+ * SVG round-trips with semantic equivalence and remains editable in the
+ * filters panel. Distinct from `RawSvgFilter` (which is opaque XML
+ * passthrough); this one walks the primitives.
+ */
+interface SvgPrimitiveChainFilter extends BaseFilter {
+    type: 'svg-primitive-chain';
+    /** <filter> wrapper attributes — all optional; omitted ⇒ UA spec default. */
+    filterUnits?: 'userSpaceOnUse' | 'objectBoundingBox';
+    primitiveUnits?: 'userSpaceOnUse' | 'objectBoundingBox';
+    x?: string;
+    y?: string;
+    width?: string;
+    height?: string;
+    filterColorInterpolation?: 'auto' | 'sRGB' | 'linearRGB';
+    /** Inheritable presentation attrs author placed on <filter> so child
+     *  primitives can resolve them via the CSS `inherit` keyword. */
+    floodColor?: string;
+    floodOpacity?: string;
+    lightingColor?: string;
+    /** <title> child text, captured for a11y/round-trip. */
+    filterTitle?: string;
+    filterDescription?: string;
+    /** SMIL animation children directly on <filter> (rare). */
+    filterAnimations?: string[];
+    /** The primitive chain. Order is significant — implicit input chains
+     *  match document order. */
+    primitives: FilterPrimitive[];
+}
+/**
+ * Per-segment command hint, recording the SVG path command the segment
+ * was authored with. Lets the serializer emit the original command form
+ * (H, V, S, T, A) when the current geometry still satisfies its
+ * constraints — and auto-demote to L/C/Q when a user edit invalidates
+ * the shorthand condition. Replaces the old `originalD` round-trip
+ * cache with a property of the geometry itself.
+ *
+ *  - LINEAR            → `L` (default for handle-less segments)
+ *  - HORIZONTAL        → `H`; valid when `from.y === to.y`
+ *  - VERTICAL          → `V`; valid when `from.x === to.x`
+ *  - CUBIC             → `C`
+ *  - SMOOTH_CUBIC      → `S`; valid when `to.handleIn` reflects the previous
+ *                        segment's exit-tangent about the previous endpoint
+ *  - QUADRATIC         → `Q`
+ *  - SMOOTH_QUADRATIC  → `T`; valid when the implicit control reflects the
+ *                        previous quadratic's control about the current point
+ *  - ARC               → `A`
+ */
+type SegmentCurveType = 'LINEAR' | 'HORIZONTAL' | 'VERTICAL' | 'CUBIC' | 'SMOOTH_CUBIC' | 'QUADRATIC' | 'SMOOTH_QUADRATIC' | 'ARC';
+interface PathPoint {
     x: number;
     y: number;
     handleIn?: Point;
     handleOut?: Point;
-    pointType: SplinePointType;
+    pointType: PathPointType;
     isSubpathStart?: boolean;
     segmentType?: SegmentCurveType;
     arcParams?: ArcParams$1;
@@ -850,6 +1189,12 @@ interface ArcParams$1 {
     largeArc: boolean;
     sweep: boolean;
 }
+/**
+ * Hyperlink target per SVG 2 §16.2. Kept for UI convenience — the four
+ * well-known keywords plus any authored `<XML-Name>` (custom named
+ * browsing context). Hyperlink shapes themselves store target as a plain
+ * string so arbitrary names round-trip.
+ */
 type LinkTarget = '_self' | '_blank' | '_parent' | '_top';
 type AriaRole = '' | 'img' | 'button' | 'link' | 'presentation' | 'none' | 'graphics-document' | 'graphics-object' | 'graphics-symbol';
 interface ShapeMetadata {
@@ -859,9 +1204,58 @@ interface ShapeMetadata {
     description: string;
     role: AriaRole;
     ariaLabel: string;
-    linkUrl: string;
-    linkTarget: LinkTarget;
     customData: Record<string, string>;
+    /**
+     * Generic ARIA attribute bag — every `aria-*` attribute *except*
+     * `aria-label` (which has its own dedicated field for the metadata
+     * panel's back-compat path). Keys are the full attribute name, e.g.
+     * `'aria-labelledby'`, `'aria-describedby'`, `'aria-hidden'`.
+     *
+     * Spec: SVG 2 §5.12.3 — "All aria- attributes" are valid on every SVG
+     * element. Stored verbatim so the full WAI-ARIA surface round-trips.
+     */
+    aria?: Record<string, string>;
+    /**
+     * Per-element `lang` / `xml:lang` value (SVG 2 §5.11.3). Authored
+     * `xml:lang` is preferred but `lang` is accepted as a fallback. Emit
+     * as `xml:lang` per spec recommendation.
+     */
+    lang?: string;
+    /**
+     * Per-element `tabindex` (SVG 2 §5.11.5). Stored as integer. Negative
+     * values are valid (focusable but not in the default tab order).
+     */
+    tabindex?: number;
+    /** Per-element `autofocus` (SVG 2 §5.11.6). Boolean attribute. */
+    autofocus?: boolean;
+    /**
+     * Per-element `xml:space` value (SVG 2 §5.11.4) for non-text shapes.
+     * Text-bearing shapes (`Text`) own their own `xml:space` lifecycle
+     * via the rich-text serializer.
+     */
+    xmlSpace?: 'default' | 'preserve';
+    /**
+     * Foreign-namespaced or prefixed attributes preserved verbatim for
+     * round-trip (SVG 2 §5.10 — "elements and attributes from foreign
+     * namespaces ... must be ignored for rendering ... [but] preserved
+     * when the SVG document is loaded and saved"). Covers `inkscape:`,
+     * `sodipodi:`, `serif:`, `figma:`, and any other authoring-tool
+     * markers, plus arbitrary user-defined namespaces. Stored as a list
+     * (rather than a record) to preserve ordering and to permit multiple
+     * attributes with the same local name across different namespaces.
+     */
+    foreignAttrs?: Array<{
+        name: string;
+        namespaceURI: string | null;
+        value: string;
+    }>;
+    /**
+     * Hyperlink target — when set, the shape is rendered inside an SVG `<a>`
+     * element with `href="${linkUrl}"`. Round-trips through SVG import/export.
+     */
+    linkUrl?: string;
+    /** Hyperlink target window — maps to `<a target="...">`. */
+    linkTarget?: LinkTarget;
     /**
      * Lossless carrier for any `<metadata>` elements that appeared as children
      * of this shape's SVG element. Stored as a serialized string containing
@@ -947,6 +1341,19 @@ interface DocumentMetadata {
      * `ShapeMetadata.rawDescription`; see there for the emit rule.
      */
     rawDescription?: string;
+    /**
+     * Lossless carrier for HTML metadata elements (`<link>`, `<meta>`)
+     * that appeared as direct children of the root `<svg>`. Stored as a
+     * serialized string of one or more elements in document order.
+     *
+     * Spec: SVG 2 §5.9 — "The HTML elements `meta`, `link` and `style`
+     * may appear inside the `svg` element". `<style>` is consumed by
+     * the CSS parser; `<link>` (often used for external stylesheets)
+     * and `<meta>` (charset, viewport hints, OpenGraph) round-trip
+     * verbatim through this field so downstream tooling that produced
+     * them sees its data preserved.
+     */
+    rawHtmlMetadata?: string;
     /**
      * Decimal precision for coordinate values when the document is
      * serialized — file save, cloud sync, undo capture, and SVG export.
@@ -1028,6 +1435,24 @@ interface DocumentStyle {
 }
 /** Type of a template variable's value. */
 type TemplateVariableType = 'string' | 'color' | 'number';
+/**
+ * How the variable participates in export. Two genuinely different
+ * substitution mechanisms — declaring intent up-front lets the export
+ * pipeline pick the right one.
+ *
+ *   - `live`     → emitted as `var(--name, fallback)` references; the
+ *                  variable definition rides along in a `<style>` block,
+ *                  so consumers can re-theme the SVG at runtime via the
+ *                  CSS cascade.
+ *   - `stamped`  → resolved to its literal value at export time. Used
+ *                  for `{{name}}` template-style stamping, and for
+ *                  attributes (`width`, `x`, geometry) where `var()`
+ *                  in attribute values has uneven interop.
+ *
+ * Defaults to `live` for `color` (well-supported in browsers), `stamped`
+ * for `number`/`string` (where attribute-level var() is unreliable).
+ */
+type TemplateVariableMode = 'live' | 'stamped';
 /**
  * Where a TemplateVariable came from. `user` is hand-authored in the
  * Variables panel; `palette` is auto-generated by the palette-token
@@ -1074,7 +1499,19 @@ interface TemplateVariable {
      * settings palette.
      */
     source?: TemplateVariableSource;
+    /**
+     * Substitution mode at export time. When omitted, callers should
+     * apply the type-based default in `defaultVariableMode()`:
+     * `color` → `live`, `number`/`string` → `stamped`.
+     */
+    mode?: TemplateVariableMode;
 }
+/**
+ * Type-based default substitution mode. Color variables work reliably as
+ * runtime `var()` references in browsers; numbers and strings are far
+ * better baked into literal attribute values at export time.
+ */
+declare function defaultVariableMode(type: TemplateVariableType): TemplateVariableMode;
 interface Guide {
     id: string;
     orientation: 'horizontal' | 'vertical';
@@ -1148,11 +1585,31 @@ interface SerializedShape {
         textDirection?: 'ltr' | 'rtl';
         unicodeBidi?: 'normal' | 'embed' | 'bidi-override' | 'isolate' | 'isolate-override' | 'plaintext';
         fontVariationSettings?: Record<string, number>;
-        charOffsets?: {
+        /**
+         * Per-glyph positioning data, mirroring SVG 2 §11.2's five attribute
+         * lists (`x`, `y`, `dx`, `dy`, `rotate`).
+         *
+         *  - `x`/`y` are absolute user coordinates; `null` means "no
+         *    override at this glyph — the cursor advances naturally".
+         *  - `dx`/`dy` are additive shifts on top of natural advance.
+         *  - `rotate` is per-glyph rotation in degrees.
+         *
+         * For backward compatibility, the legacy three-field shape
+         * `{x, y, rotate}` (produced before the spec-aligned model shipped)
+         * is still accepted on read; its `x`/`y` are interpreted as the
+         * additive shifts (`dx`/`dy`).
+         */
+        charOffsets?: ({
+            x: number | null;
+            y: number | null;
+            dx: number;
+            dy: number;
+            rotate: number;
+        } | {
             x: number;
             y: number;
             rotate: number;
-        }[];
+        })[];
         linePositions?: {
             x: number;
             dy: number;
@@ -1181,9 +1638,29 @@ interface SerializedShape {
         borderColor?: string;
         borderWidth?: number | string;
         strokeOpacity?: number;
+        /**
+         * Inherit `fill` from the ancestor cascade rather than emit an explicit
+         * attribute. Set at import for shapes inside `<defs>`/`<symbol>` that
+         * have no own `fill` — they're reachable only via `<use>`, whose shadow
+         * tree inherits paint from the `<use>` element itself (SVG 2 §5.5.4).
+         * Baking the SVG-default black onto the inner shape would block the
+         * `<use fill="…">` cascade and render the instance override dead.
+         */
+        inheritFill?: boolean;
+        /** See {@link inheritFill}. */
+        inheritStroke?: boolean;
         /** CSS `paint-order` (SVG 2). Canonical SVG token string, e.g.
          *  'stroke fill markers'. Omitted when equivalent to default 'normal'. */
         paintOrder?: string;
+        /**
+         * CSS Transforms 2 §6.2 — `transform-box` reference box. SVG
+         * default is `view-box`; persisted on the shape so authored values
+         * (`fill-box`, `stroke-box`) survive round-trip. The editor bakes
+         * `transform-origin` into a numeric pivot at import using the
+         * resolved box, so this field exists for export fidelity rather
+         * than rendering.
+         */
+        transformBox?: 'view-box' | 'fill-box' | 'stroke-box' | 'content-box' | 'border-box';
         /** Marker id applied as `marker-start` (rendered `url(#id)` in SVG). */
         markerStart?: string;
         /** Marker id applied as `marker-mid`. */
@@ -1304,17 +1781,49 @@ interface SerializedShape {
         /** @deprecated v2 — see `filterX`. */
         filterHeight?: string;
         rawTransform?: string;
-        splinePoints?: SplinePoint[];
-        splineCurveType?: SplineCurveType;
-        splineClosed?: boolean;
-        splineTension?: number;
-        splineArcParams?: ArcParams$1[];
+        ancestorTransform?: number[];
+        pathPoints?: PathPoint[];
+        pathCurveType?: PathCurveType;
+        pathClosed?: boolean;
+        pathTension?: number;
+        pathArcParams?: ArcParams$1[];
+        /**
+         * SVG 2 §6 `pathLength` — author's stated total length of the path.
+         * Used to scale distance-along-a-path computations (text-on-path,
+         * `<animateMotion>`, `stroke-dasharray`) by `pathLength / actualLength`.
+         * A non-negative number; negative values are an error per spec.
+         */
+        pathLength?: number;
+        /**
+         * CSS Vector Effects — `vector-effect` property. `non-scaling-stroke`
+         * keeps stroke width constant under zoom/transforms (heavily used in
+         * CAD/diagram SVGs). Applies to any graphic element, not just paths;
+         * persists at the SerializedShape state level so all shape types can
+         * round-trip it.
+         */
+        vectorEffect?: 'none' | 'non-scaling-stroke' | 'non-scaling-size' | 'non-rotation' | 'fixed-position';
         polylinePoints?: Point[];
         polylineClosed?: boolean;
         href?: string;
         originalWidth?: number;
         originalHeight?: number;
+        /**
+         * Editor-internal flag controlling whether interactive resize keeps
+         * the image's natural aspect ratio. NOT the SVG `preserveAspectRatio`
+         * attribute — this is purely a UX behavior switch on the resize
+         * handles. Persisted so the user's setting survives reload.
+         */
         preserveAspectRatio?: boolean;
+        /**
+         * SVG 2 §8.7 — verbatim `preserveAspectRatio` attribute value
+         * (e.g. `'xMidYMid slice'`, `'defer xMidYMid meet'`, `'none'`). When
+         * unset, the spec default applies. The editor canvas always renders
+         * `<image>` with `preserveAspectRatio="none"` so the visible box
+         * matches the resize handles; this field carries the author's
+         * intent through round-trip and is restored on export by
+         * `SvgExportFinalizer`.
+         */
+        specPreserveAspectRatio?: string;
         imageOpacity?: number;
         mediaKind?: 'audio' | 'video';
         mediaMimeType?: string;
@@ -1350,12 +1859,36 @@ interface SerializedShape {
          * soundtracks / captioned video versions.
          */
         systemLanguage?: string;
+        /**
+         * Space-separated list of required IRI references that the user agent
+         * must support for this shape to be rendered. SVG 2 §15.4 conditional
+         * processing — typically `http://www.w3.org/TR/SVG11/feature#…` strings.
+         * Persisted alongside `systemLanguage` so `<switch>` content round-trips.
+         */
+        requiredExtensions?: string;
         shapeInsideRef?: string;
         shapePadding?: number;
         isTextPath?: boolean;
-        textPathPoints?: SplinePoint[];
+        textPathPoints?: PathPoint[];
+        /**
+         * Curve type used to interpolate `textPathPoints` into a renderable
+         * path. Mirrors `pathCurveType` for plain path shapes; persisted
+         * separately so author-set text-path curves don't have to share the
+         * shape's geometry curve type.
+         */
+        textPathCurveType?: PathCurveType;
         textPathStartOffset?: number;
+        textPathStartOffsetUnit?: '%' | 'user';
         textPathSide?: 'left' | 'right';
+        textPathMethod?: 'align' | 'stretch';
+        textPathSpacing?: 'auto' | 'exact';
+        textPathLengthAdjust?: 'spacing' | 'spacingAndGlyphs';
+        textPathLength?: number;
+        textPathLengthUnit?: '%' | 'user';
+        textPathInlineFormat?: 'defs-path' | 'path-attr';
+        textPathRefShapeId?: string;
+        /** Transient: import-time href target id, resolved away by ImportExportManager. */
+        textPathImportRefId?: string;
         fillRule?: 'nonzero' | 'evenodd';
         strokeLinejoin?: 'miter' | 'round' | 'bevel';
         strokeLinecap?: 'butt' | 'round' | 'square';
@@ -1363,7 +1896,40 @@ interface SerializedShape {
         opacity?: number;
         blendMode?: string;
         shapeRendering?: 'auto' | 'optimizeSpeed' | 'crispEdges' | 'geometricPrecision';
+        textRendering?: 'auto' | 'optimizeSpeed' | 'optimizeLegibility' | 'geometricPrecision';
+        imageRendering?: 'auto' | 'optimizeSpeed' | 'optimizeQuality' | 'crisp-edges' | 'pixelated' | 'smooth' | 'high-quality';
+        colorRendering?: 'auto' | 'optimizeSpeed' | 'optimizeQuality';
+        /**
+         * SVG `color-interpolation` (SVG 2 §13.9). Selects the color space —
+         * sRGB or linearized RGB — used for *non-filter* color operations:
+         * gradient-stop interpolation, SMIL color animation interpolation,
+         * and the compositing/blending of graphics elements. The
+         * filter-pipeline analogue is `color-interpolation-filters`
+         * (carried separately on filter chains as `filterColorInterpolation`).
+         * Spec initial value: `sRGB`. Authors who pick `linearRGB` get
+         * physically-linear stop interpolation; missing this attribute on
+         * round-trip silently shifts mid-tone gradient colors.
+         */
+        colorInterpolation?: 'auto' | 'sRGB' | 'linearRGB';
+        /**
+         * SVG `display` presentation attribute as authored on the source
+         * element. Distinct from `visible` (editor's layer-hide boolean,
+         * which writes inline `style="display:none"`): `display: 'none'`
+         * here carries the author's intent through round-trip as an XML
+         * attribute (`<rect display="none"/>`), preserving SVG 2 §3.2.2
+         * semantics that `display:none` removes the element from the
+         * rendering tree.
+         */
+        display?: 'none';
         metadata?: Partial<ShapeMetadata>;
+        /**
+         * Shape-scoped `<script>` elements (SVG 2 §15.9 allows scripts as
+         * descendants of any container). Emitted as children of the shape's
+         * exported element on save; preserved verbatim through .svgs round-trip,
+         * undo/redo, copy/paste. Distinct from `HistorySnapshot.documentScripts`
+         * which sits at the SVG root and runs in document order.
+         */
+        scripts?: DocumentScript[];
         groupId?: string;
         cssClipPath?: string;
         cssMaskProperties?: Record<string, string>;
@@ -1382,6 +1948,53 @@ interface SerializedShape {
          * variant (`def.shapes`). Only meaningful on `symbol-instance` shapes.
          */
         variantKey?: string;
+        /**
+         * Per-instance presentation cascade (SVG 2 §5.5.4): attributes set on
+         * the source `<use>` element that are inherited into the symbol shadow
+         * tree on render and re-emitted on export. Keyed by the SVG attribute
+         * name in its canonical kebab-case form (`fill`, `stroke-width`,
+         * `color-interpolation-filters`, `paint-order`, etc.). Values are the
+         * verbatim attribute string — numeric parsing happens at the edit /
+         * render boundary, not at storage time.
+         *
+         * The map is the single source of truth: importing a `<use>` stores
+         * every presentation-class attribute the author wrote, applying it
+         * mirrors every entry onto the wrapper `<g>`, and exporting emits
+         * every entry back onto the `<use>`. No whitelist — any attribute the
+         * SVG cascade honors round-trips.
+         *
+         * Special case: `transform` is composed with the editor's geometry
+         * (position / rotation / skew / scale) rather than applied raw to the
+         * wrapper. See `SymbolInstance.buildTransformString`.
+         *
+         * Legacy (pre-refactor) documents may carry camelCase keys
+         * (`fillOpacity`, `strokeWidth`, …). `SymbolInstance.createFromSerialized`
+         * normalises them to kebab-case on load; no runtime readers of this
+         * field should assume either form.
+         *
+         * Only meaningful on `symbol-instance` shapes.
+         */
+        instancePresentation?: Record<string, string>;
+        /**
+         * Inline children for container shape types (`hyperlink`, `switch`,
+         * `container`, embedded `svg`). Each child is a self-contained
+         * `SerializedShape` rendered nested inside the parent's element.
+         *
+         * Groups (`type === 'group'`) do NOT use this field — they store
+         * children flat in `HistorySnapshot.shapes[]` and back-reference the
+         * parent group via `state.groupId`. The two pickup paths exist
+         * because groups predate the inline-children container model.
+         */
+        children?: SerializedShape[];
+        /** Legacy `xlink:href`, preserved alongside `href` for round-trip. */
+        hrefXlink?: string;
+        linkTarget?: '_self' | '_blank' | '_parent' | '_top' | string;
+        linkRel?: string;
+        linkDownload?: string;
+        linkPing?: string;
+        linkHreflang?: string;
+        linkType?: string;
+        linkReferrerPolicy?: string;
         /**
          * Id of the canvas shape this `shape-reference` (Linked Copy) targets.
          * A Linked Copy renders as a live clone of another top-level shape and
@@ -1446,6 +2059,44 @@ interface SerializedShape {
         topWidthPercent?: number;
         /** Document shape: wave amplitude as a % of height. */
         waveAmplitudePercent?: number;
+        /** View shape: viewBox X component (animatable axis of the 4-tuple). */
+        viewBoxX?: number;
+        /** View shape: viewBox Y component (animatable axis of the 4-tuple). */
+        viewBoxY?: number;
+        /** View shape: viewBox width component (animatable axis of the 4-tuple). */
+        viewBoxWidth?: number;
+        /** View shape: viewBox height component (animatable axis of the 4-tuple). */
+        viewBoxHeight?: number;
+        /** View shape: name used as `<view id="...">` and fragment URL target. */
+        viewName?: string;
+        /** View shape: optional preserveAspectRatio (SVG 2 §7.8 — animatable). */
+        viewPreserveAspectRatio?: string;
+        /** View shape: SVG 1.1 §16.5 zoomAndPan. */
+        viewZoomAndPan?: 'disable' | 'magnify';
+        /** View shape: deprecated SVG 1.1 viewTarget — preserved verbatim. */
+        viewTarget?: string;
+        /** View shape: when true, this View's viewBox becomes the root SVG viewBox. */
+        isHomeView?: boolean;
+        /** SvgShape: viewBox X component (animatable). */
+        svgViewBoxX?: number;
+        /** SvgShape: viewBox Y component (animatable). */
+        svgViewBoxY?: number;
+        /** SvgShape: viewBox width component (animatable). */
+        svgViewBoxWidth?: number;
+        /** SvgShape: viewBox height component (animatable). */
+        svgViewBoxHeight?: number;
+        /** SvgShape: preserveAspectRatio (SVG 2 §7.8 — animatable, discrete). */
+        svgPreserveAspectRatio?: string;
+        /** SvgShape: outermost = intrinsic doc size, embedded = viewport rect width. */
+        svgWidth?: number;
+        /** SvgShape: outermost = intrinsic doc size, embedded = viewport rect height. */
+        svgHeight?: number;
+        /** SvgShape: x position (no effect on outermost per §5.1.4 ¶3, embedded only). */
+        svgX?: number;
+        /** SvgShape: y position (no effect on outermost per §5.1.4 ¶3, embedded only). */
+        svgY?: number;
+        /** SvgShape: marks the singleton root <svg> shape (one per document). */
+        isRootSvg?: boolean;
     };
 }
 type SerializedViewbox = Viewbox;
@@ -1507,6 +2158,18 @@ interface HistorySnapshot {
      * MarkerManager and are NOT persisted here — only user-authored defs are.
      */
     library?: LibraryDef[];
+    /**
+     * Raw XML fragments for `<mask>` / `<clipPath>` defs that live in editor
+     * defs but have no typed entry in `library`. Populated by paste pipelines
+     * that clone source paint-server defs verbatim (preserving original ids so
+     * `url(#id)` refs resolve). Without this field, the save/reload cycle
+     * drops the masks entirely because `library` has no kind for them; shapes
+     * that reference those ids render without their mask.
+     *
+     * Each entry is a serialised fragment (`<mask id="…">…</mask>`) ready to
+     * `innerHTML`-append into editor defs on restore.
+     */
+    rawPaintServerDefs?: string[];
     /** @deprecated v2 — use `library`. Read-only: v1 docs migrate into `library`. */
     customPatterns?: CustomPatternDef[];
     /** @deprecated v2 — use `library`. Read-only: v1 docs migrate into `library`. */
@@ -1556,6 +2219,14 @@ interface SerializedGroup {
     parentId: string | null;
     /** CSS transform-origin value (e.g. "50px 50px") for group animations */
     transformOrigin?: string;
+    /**
+     * SVG `<g>` transform attribute (e.g. "matrix(...)" or "scale(2,1)").
+     * Preserved verbatim from import so the group carries its ancestor/own
+     * transform through serialization (clipboard, undo/redo, collab).
+     * Shapes inside stay in the group's local frame — the browser composes
+     * `groupTransform × child` natively at render.
+     */
+    transform?: string;
     /**
      * Zero-based position of this group among its parent container's
      * children (including both sibling groups and sibling shape nodes).
@@ -1576,6 +2247,13 @@ interface SerializedGroup {
     filter?: string;
     cssFilter?: string;
     mixBlendMode?: string;
+    /**
+     * CSS `isolation` (Compositing & Blending §6.1). CSS-only property —
+     * no SVG presentation-attribute form, so it lives in inline style on
+     * the group element. Round-tripped here so authored
+     * `<g style="isolation:isolate">` survives serialize/restore.
+     */
+    isolation?: string;
     clipPath?: string;
     mask?: string;
     /**
@@ -1700,7 +2378,28 @@ interface LibraryDefBase {
  */
 interface SymbolLibraryDef extends LibraryDefBase {
     kind: 'symbol';
+    /**
+     * Source SVG element form for round-trip fidelity. Most symbols are
+     * authored as `<symbol>` (SVG 2 §5.5.1); `<defs><g id="X"/>` referenced
+     * by `<use href="#X"/>` is a legally distinct pattern that the editor
+     * also models as a SymbolLibraryDef but must export as `<g>` to remain
+     * spec-faithful — `<symbol>` would silently introduce viewport-
+     * establishment (SVG 2 §5.5.2) and `overflow: hidden` defaulting that
+     * the source `<g>` does not have. Default `'symbol'` for backward
+     * compatibility with documents authored before this field existed.
+     */
+    defKind?: 'symbol' | 'group';
     viewBox: string;
+    /**
+     * Wrapper attributes from the source `<g id="X">` def root that apply to
+     * the def's contents (transform, opacity, fill cascade, mask, filter,
+     * clip-path). Re-emitted on the exported `<g id="X">` when `defKind === 'group'`
+     * — `<symbol>` doesn't legally accept these attributes per SVG 2 §5.5.1.
+     * Without this, `<use href="#X"/>` would silently render the children at
+     * their unwrapped local coords / paint, losing every non-id attribute on
+     * the source `<g>` def root.
+     */
+    wrapperAttrs?: Record<string, string>;
     /**
      * Default variant shapes. When `variantAxes` is present this represents the
      * variant where every axis is at its first value.
@@ -1849,6 +2548,7 @@ interface CommonNodeProps {
     gapLength: number;
     dashOffset: number;
     strokeDasharray: string | null;
+    colorInterpolation: 'auto' | 'sRGB' | 'linearRGB' | null;
     filters: unknown[];
     filterColorInterpolation: 'auto' | 'sRGB' | 'linearRGB' | null;
     filterUnits: 'userSpaceOnUse' | 'objectBoundingBox' | null;
@@ -1858,6 +2558,7 @@ interface CommonNodeProps {
     filterWidth: string | null;
     filterHeight: string | null;
     rawTransform: string | null;
+    ancestorTransform: number[] | null;
     metadata: unknown | null;
     cssClipPath: string | null;
     cssMaskProperties: Record<string, string> | null;
@@ -1933,11 +2634,22 @@ interface TextNodeProps extends CommonNodeProps {
     scaleAnchor: Point | null;
     useRichText: boolean;
     richTextData: unknown | null;
-    charOffsets: {
+    /**
+     * Per-glyph positioning data — see `SerializedShape['state'].charOffsets`
+     * in `serialized.ts` for full semantics.  Legacy `{x, y, rotate}` form
+     * accepted on read for back-compat with pre-spec-aligned saves.
+     */
+    charOffsets: ({
+        x: number | null;
+        y: number | null;
+        dx: number;
+        dy: number;
+        rotate: number;
+    } | {
         x: number;
         y: number;
         rotate: number;
-    }[] | null;
+    })[] | null;
     fontVariationSettings: Record<string, number>;
     isTextPath: boolean;
     textPathPoints: unknown[] | null;
@@ -1957,14 +2669,14 @@ interface ImageNodeProps extends CommonNodeProps {
     preserveAspectRatio: boolean;
     imageOpacity: number;
 }
-interface SplineNodeProps extends CommonNodeProps {
+interface PathNodeProps extends CommonNodeProps {
     x: number;
     y: number;
     width: number;
     height: number;
-    splinePoints: unknown[];
-    splineArcParams: unknown[];
-    splineControlBounds: {
+    pathPoints: unknown[];
+    pathArcParams: unknown[];
+    pathControlBounds: {
         x: number;
         y: number;
         width: number;
@@ -2042,7 +2754,7 @@ interface NodeTypePropsMap {
     line: LineNodeProps;
     text: TextNodeProps;
     image: ImageNodeProps;
-    spline: SplineNodeProps;
+    path: PathNodeProps;
     polyline: PolylineNodeProps;
     triangle: TriangleNodeProps;
     ngon: NGonNodeProps;
@@ -2057,7 +2769,7 @@ interface NodeTypePropsMap {
     document: DocumentNodeProps;
 }
 /** Union of all node prop types. */
-type AnyNodeProps = RectangleNodeProps | SquareNodeProps | CircleNodeProps | EllipseNodeProps | LineNodeProps | TextNodeProps | ImageNodeProps | SplineNodeProps | PolylineNodeProps | TriangleNodeProps | NGonNodeProps | StarNodeProps | CrossNodeProps | RingNodeProps | SpiralNodeProps | GearNodeProps | ArrowNodeProps | SymbolInstanceNodeProps | GroupNodeProps | DocumentNodeProps;
+type AnyNodeProps = RectangleNodeProps | SquareNodeProps | CircleNodeProps | EllipseNodeProps | LineNodeProps | TextNodeProps | ImageNodeProps | PathNodeProps | PolylineNodeProps | TriangleNodeProps | NGonNodeProps | StarNodeProps | CrossNodeProps | RingNodeProps | SpiralNodeProps | GearNodeProps | ArrowNodeProps | SymbolInstanceNodeProps | GroupNodeProps | DocumentNodeProps;
 
 /**
  * @svgsketch/core — Schema migrations.
@@ -2452,6 +3164,28 @@ declare function renderToSvg(snapshot: HistorySnapshot, options?: RenderOptions)
  * @packageDocumentation
  */
 
+/**
+ * Render a single `FilterPrimitive` to its SVG element string.
+ *
+ * Walks every modeled spec attribute and re-emits it. Author-preserved
+ * attributes (e.g. <number-optional-number> spellings, kernelMatrix
+ * whitespace) are stored as strings on the primitive and emitted verbatim,
+ * so import → render produces semantically equivalent output.
+ *
+ * `unknownAttrs` are emitted last (alphabetised) so re-export is stable.
+ * `animations` children are appended inside the element.
+ */
+declare function renderFilterPrimitive(p: FilterPrimitive): string;
+/**
+ * Render an `SvgPrimitiveChainFilter` as a complete `<filter>` element.
+ *
+ * Wrapper attributes are author-faithful: omitted ⇒ unset on the element ⇒
+ * UA spec defaults apply (filterUnits=objectBoundingBox, primitiveUnits=
+ * userSpaceOnUse, region -10%/-10%/120%/120%, color-interpolation-filters=
+ * linearRGB). The chain is emitted in document order with no synthetic
+ * `in`/`result` rewriting.
+ */
+declare function renderSvgPrimitiveChainFilter(filterId: string, f: SvgPrimitiveChainFilter): string;
 /**
  * Render SVG filter primitive string(s) for a single filter.
  *
@@ -3415,6 +4149,68 @@ declare abstract class ShapeBuilder<T extends ShapeBuilder<T>> {
     cssClipPath(value: string): T;
     /** Set CSS mask sub-properties (`mask-image`, `mask-mode`, etc.). */
     cssMaskProperties(props: Record<string, string>): T;
+    /**
+     * SVG 2 §13.4 `vector-effect`. `non-scaling-stroke` keeps stroke width
+     * constant under zoom and transforms (heavily used in CAD/diagram SVGs).
+     */
+    vectorEffect(value: 'none' | 'non-scaling-stroke' | 'non-scaling-size' | 'non-rotation' | 'fixed-position'): T;
+    /** CSS Transforms 2 `transform-box`. */
+    transformBox(value: 'view-box' | 'fill-box' | 'stroke-box' | 'content-box' | 'border-box'): T;
+    /** SVG 2 §13.10 `paint-order` (e.g. `'stroke fill'`, `'fill stroke markers'`). */
+    paintOrder(value: string): T;
+    /** Compositing & Blending 2 `mix-blend-mode` (e.g. `'multiply'`, `'screen'`). */
+    blendMode(value: string): T;
+    /**
+     * SVG `visibility` attribute — paint-only hiding that preserves layout.
+     * Distinct from `.visible(false)` which sets `display:none`.
+     */
+    visibility(value: 'visible' | 'hidden' | 'collapse'): T;
+    /** SVG 2 §13.6 `shape-rendering`. */
+    shapeRendering(value: 'auto' | 'optimizeSpeed' | 'crispEdges' | 'geometricPrecision'): T;
+    /** Color-interpolation hint for filter chains attached to this shape. */
+    filterColorInterpolation(value: 'auto' | 'sRGB' | 'linearRGB'): T;
+    /**
+     * Suppress the shape-level `fill` so the `<use>` cascade can drive it
+     * (used by symbol instances with `instancePresentation`).
+     */
+    inheritFill(value?: boolean): T;
+    /** Suppress the shape-level `stroke` so the `<use>` cascade can drive it. */
+    inheritStroke(value?: boolean): T;
+    /** SVG 2 §5.8.5 `systemLanguage` conditional-processing attribute (BCP 47 tag). */
+    systemLanguage(tag: string): T;
+    /** SVG 2 §5.8 `requiredExtensions` conditional-processing attribute. */
+    requiredExtensions(value: string): T;
+    /**
+     * Reference a library-registered fill (gradient or pattern) by id.
+     * The `kind` parameter tells the renderer which `<defs>` shape to expect;
+     * it's the discriminator on the matching `LibraryDef` entry.
+     * Mutually exclusive with `.fill()`/`.fillGradient()`/`.fillPattern()`.
+     */
+    fillLibrary(id: string, kind?: 'linear-gradient' | 'radial-gradient' | 'pattern'): T;
+    /** Reference a library-registered stroke (gradient or pattern) by id. */
+    strokeLibrary(id: string, kind?: 'linear-gradient' | 'radial-gradient' | 'pattern'): T;
+    /**
+     * Reference one or more library-registered filters by id. The chain is
+     * composed in order, then merged with any inline `.filter()`/`.dropShadow()`/etc.
+     */
+    filterLibrary(...ids: string[]): T;
+    /**
+     * Reference a library-registered marker for the start vertex.
+     * Distinct from the `Line`/`Path` `.markerStart()` preset accessors —
+     * those set the `startEndpoint` preset, this points at a library def id.
+     */
+    markerStartRef(id: string): T;
+    /** Reference a library-registered marker for intermediate vertices. */
+    markerMidRef(id: string): T;
+    /** Reference a library-registered marker for the end vertex. */
+    markerEndRef(id: string): T;
+    /**
+     * Bind a shape property to a template variable name. The variable must be
+     * registered on the document via `Document.defineVariable(...)`. At export
+     * time the property's serialized value is replaced by `{{varName}}`, which
+     * `Document.toSVG({ variables })` then substitutes.
+     */
+    bind(propertyName: string, variableName: string): T;
     /** Set shape metadata (name, title, description, etc). */
     metadata(meta: Partial<ShapeMetadata>): T;
     /** Assign this shape to a group. */
@@ -3538,6 +4334,26 @@ declare class Text extends ShapeBuilder<Text> {
     shapePadding(value: number): Text;
     /** Set rich text data for per-segment styling. */
     richTextData(data: RichTextData): Text;
+    /**
+     * Toggle rich-text rendering. When `true`, `richTextData` drives output and
+     * the plain `text` field is treated as a fallback. When `false` (default),
+     * the plain `text` field is rendered.
+     */
+    useRichText(flag?: boolean): Text;
+    /**
+     * Set per-line position overrides. Used when imported `<tspan>` runs
+     * carried explicit `x`/`y`/`dx`/`dy` lists that the editor must round-trip.
+     */
+    linePositions(positions: {
+        x?: number | null;
+        y?: number | null;
+        dx?: number;
+        dy?: number;
+    }[]): Text;
+    /** SVG `textLength` attribute (target advance width). */
+    textLength(value: number): Text;
+    /** SVG `lengthAdjust` attribute (`spacing` or `spacingAndGlyphs`). */
+    lengthAdjust(value: 'spacing' | 'spacingAndGlyphs'): Text;
 }
 declare abstract class PolygonShapeBuilder<T extends PolygonShapeBuilder<T>> extends ShapeBuilder<T> {
     constructor(type: SerializedShape['type'], cx: number, cy: number, radius: number);
@@ -3600,26 +4416,195 @@ declare class Arrow extends PolygonShapeBuilder<Arrow> {
     /** Set the arrow shaft width as a percent (0–100). */
     shaftWidth(percent: number): Arrow;
 }
-declare class Spline extends ShapeBuilder<Spline> {
-    constructor(points?: (Point | SplinePoint)[]);
+declare class Heart extends PolygonShapeBuilder<Heart> {
+    constructor(cx: number, cy: number, radius: number);
+    /** Set the lobe radius as a percent of the bounding circle (30–70). */
+    lobeRadius(percent: number): Heart;
+    /** Set the cleft (top notch) depth as a percent (10–50). */
+    cleftDepth(percent: number): Heart;
+}
+declare class Lightning extends PolygonShapeBuilder<Lightning> {
+    constructor(cx: number, cy: number, radius: number);
+    /** Set the number of zigzag bend segments. */
+    segments(n: number): Lightning;
+    /** Set the horizontal sway as a percent (10–80). */
+    jaggedness(percent: number): Lightning;
+    /** Set the bolt ribbon thickness as a percent (10–60). */
+    thickness(percent: number): Lightning;
+}
+declare class Cloud extends PolygonShapeBuilder<Cloud> {
+    constructor(cx: number, cy: number, radius: number);
+    /** Set the number of bumps around the cloud silhouette. */
+    bumps(n: number): Cloud;
+    /** Set the puffiness (bump radius) as a percent. */
+    puffiness(percent: number): Cloud;
+}
+declare class SpeechBubble extends PolygonShapeBuilder<SpeechBubble> {
+    constructor(cx: number, cy: number, radius: number);
+    /** Set the tail angle in degrees (0 = right, 90 = down, etc.). */
+    tailAngle(degrees: number): SpeechBubble;
+    /** Set the tail length as a percent of the bounding radius. */
+    tailLength(percent: number): SpeechBubble;
+    /** Set the tail base width as a percent of the bounding radius. */
+    tailWidth(percent: number): SpeechBubble;
+}
+/**
+ * Mixin base for shape builders whose `state.children` is an inline array
+ * of `SerializedShape`. Hyperlink, Switch, Container, NestedSvg all extend
+ * this. The `.add()` method accepts another `ShapeBuilder` (its `.build()`
+ * is called immediately) or a raw `SerializedShape`.
+ */
+declare abstract class ContainerShapeBuilder<T extends ContainerShapeBuilder<T>> extends ShapeBuilder<T> {
+    /** Append a shape (builder or pre-built SerializedShape) as a child. */
+    add(shape: ShapeBuilder<any> | SerializedShape): T;
+    /** Append multiple children in a single call. */
+    addAll(...shapes: (ShapeBuilder<any> | SerializedShape)[]): T;
+    /** Replace the children array wholesale. */
+    children(shapes: (ShapeBuilder<any> | SerializedShape)[]): T;
+}
+declare class Hyperlink extends ContainerShapeBuilder<Hyperlink> {
+    constructor(href?: string);
+    /** Set the link target URL (`href` attribute). */
+    href(value: string): Hyperlink;
+    /** Set the legacy `xlink:href` (kept for round-trip with SVG 1.1 sources). */
+    hrefXlink(value: string): Hyperlink;
+    /** Set the link target window — `'_self'`, `'_blank'`, etc. */
+    target(value: '_self' | '_blank' | '_parent' | '_top' | string): Hyperlink;
+    /** Set the `download` attribute (file name hint for download links). */
+    download(value: string): Hyperlink;
+    /** Set the `rel` attribute (e.g. `'noopener noreferrer'`). */
+    rel(value: string): Hyperlink;
+    /** Set the `ping` attribute (space-separated URLs notified on click). */
+    ping(value: string): Hyperlink;
+    /** Set the `hreflang` attribute. */
+    hreflang(value: string): Hyperlink;
+    /** Set the `type` attribute (MIME type hint for the destination). */
+    type(value: string): Hyperlink;
+    /** Set the `referrerpolicy` attribute. */
+    referrerPolicy(value: string): Hyperlink;
+}
+declare class Switch extends ContainerShapeBuilder<Switch> {
+    constructor();
+}
+/**
+ * Generic container shape: emits `<g>` wrapping inline children. Distinct
+ * from the editor's `Group` system, which uses flat-with-`groupId` storage —
+ * use this when programmatically composing a document where you want the
+ * children persisted under their parent rather than in the flat shapes array.
+ */
+declare class Container extends ContainerShapeBuilder<Container> {
+    constructor();
+}
+declare class View extends ShapeBuilder<View> {
+    constructor(viewBox?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    });
+    /** Set the viewBox (x, y, width, height) the view exposes. */
+    viewBox(x: number, y: number, width: number, height: number): View;
+    /** Human-readable name (round-tripped as `data-view-name`). */
+    name(value: string): View;
+    /** SVG 2 `preserveAspectRatio` (e.g. `'xMidYMid meet'`). */
+    preserveAspectRatio(value: string): View;
+    /** Legacy `zoomAndPan` attribute (`'disable' | 'magnify'`). */
+    zoomAndPan(value: 'disable' | 'magnify'): View;
+    /** SVG `viewTarget` attribute. */
+    viewTarget(value: string): View;
+    /** Mark this view as the canonical "home" view of the document. */
+    asHome(value?: boolean): View;
+}
+declare class NestedSvg extends ContainerShapeBuilder<NestedSvg> {
+    constructor(x?: number, y?: number, width?: number, height?: number);
+    /** Set the position on the parent canvas. */
+    position(x: number, y: number): NestedSvg;
+    /** Set width and height on the parent canvas. */
+    size(width: number, height: number): NestedSvg;
+    /** Set the `viewBox` (the inner coordinate system). */
+    viewBox(x: number, y: number, width: number, height: number): NestedSvg;
+    /** SVG 2 `preserveAspectRatio` for the nested viewport. */
+    preserveAspectRatio(value: string): NestedSvg;
+    /** Mark this as the root SVG element (rare; typically only one per document). */
+    asRoot(value?: boolean): NestedSvg;
+}
+declare class ShapeReference extends ShapeBuilder<ShapeReference> {
+    constructor(targetShapeId?: string);
+    /** ID of the shape this reference clones. */
+    target(shapeId: string): ShapeReference;
+    /** Offset from the source's reference point (mapped to `<use x>`/`<use y>`). */
+    offset(x: number, y: number): ShapeReference;
+    /** Override the rendered width/height (mapped to `<use width>`/`<use height>`). */
+    size(width: number, height: number): ShapeReference;
+}
+declare abstract class MediaShapeBuilder<T extends MediaShapeBuilder<T>> extends ShapeBuilder<T> {
+    /** Position on the canvas. */
+    position(x: number, y: number): T;
+    /** Bounding-box width/height of the foreignObject wrapper. */
+    size(width: number, height: number): T;
+    /** Source URL or data URI. */
+    src(href: string): T;
+    /** MIME type hint (e.g. `'video/mp4'`, `'audio/mpeg'`). */
+    mimeType(value: string): T;
+    /** Source duration in seconds (set by the editor on `loadedmetadata`). */
+    naturalDuration(seconds: number): T;
+    /** Timeline offset where playback starts. */
+    begin(seconds: number): T;
+    /** Source-relative in/out trim (seconds). */
+    trim(start: number, end: number): T;
+    volume(value: number): T;
+    muted(value?: boolean): T;
+    loop(value?: boolean): T;
+    playbackRate(value: number): T;
+    /** Convenience volume ramps applied live by the sync controller. */
+    fade(inDuration: number, outDuration: number): T;
+    /** SVG conditional-processing `systemLanguage` (BCP 47 tag). */
+    language(tag: string): T;
+}
+declare class Video extends MediaShapeBuilder<Video> {
+    constructor(href?: string);
+    /** First-frame thumbnail URL or data URI. */
+    poster(href: string): Video;
+    /** Crop window in source-pixel space. */
+    sourceRect(rect: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }): Video;
+}
+declare class Audio extends MediaShapeBuilder<Audio> {
+    constructor(href?: string);
+}
+declare class Path extends ShapeBuilder<Path> {
+    constructor(points?: (Point | PathPoint)[]);
     /** Set the spline points. */
-    points(pts: (Point | SplinePoint)[]): Spline;
+    points(pts: (Point | PathPoint)[]): Path;
     /** Add a point to the spline. */
-    addPoint(x: number, y: number): Spline;
+    addPoint(x: number, y: number): Path;
     /** Set the curve type. */
-    curveType(type: SplineCurveType): Spline;
+    curveType(type: PathCurveType): Path;
     /** Set whether the spline is closed. */
-    closed(value?: boolean): Spline;
+    closed(value?: boolean): Path;
     /** Set the tension for Catmull-Rom curves (0–1). */
-    tension(value: number): Spline;
+    tension(value: number): Path;
     /** Set arc params for ARC curve type. */
-    arcParams(params: ArcParams$1[]): Spline;
+    arcParams(params: ArcParams$1[]): Path;
     /** Set the start endpoint marker. */
-    markerStart(style: EndpointStyle): Spline;
+    markerStart(style: EndpointStyle): Path;
     /** Set the end endpoint marker. */
-    markerEnd(style: EndpointStyle): Spline;
+    markerEnd(style: EndpointStyle): Path;
     /** Convenience: set both markers. */
-    markers(start: EndpointStyle, end: EndpointStyle): Spline;
+    markers(start: EndpointStyle, end: EndpointStyle): Path;
+    /**
+     * Resolve this path to its SVG `d` attribute string. Useful for path-morph
+     * animations: the `d` track property accepts a `d` string per keyframe, and
+     * SMIL interpolates between matching command sequences character-by-character.
+     *
+     * The output uses the same geometry pipeline as `Document.toSVG()`, so the
+     * animated values match the static render of the same path exactly.
+     */
+    toD(): string;
 }
 declare class Polyline extends ShapeBuilder<Polyline> {
     constructor(points?: Point[]);
@@ -3746,7 +4731,7 @@ declare class Track {
      *
      * @example
      * ```ts
-     * const curve = new Spline(...).id('curve');
+     * const curve = new Path(...).id('curve');
      * doc.add(curve);
      *
      * const track = new Track('rect-1', 'pathMotion')
@@ -3945,6 +4930,16 @@ declare class Document {
         viewBox?: string;
         thumbnail?: string;
         groups?: SerializedGroup[];
+        /** SVG-element form: `'symbol'` (the default) or `'group'` (`<defs><g>`). */
+        defKind?: 'symbol' | 'group';
+        /** Wrapper attributes from a source `<g id>` def root, when `defKind === 'group'`. */
+        wrapperAttrs?: Record<string, string>;
+        /** Named variant axes, e.g. `[{ name: 'color', values: ['red', 'blue'] }]`. */
+        variantAxes?: SerializedVariantAxis[];
+        /** Variant shape arrays keyed by canonical `axis=val,…` string. */
+        variants?: Record<string, SerializedShape[]>;
+        /** Per-variant thumbnails keyed by canonical variant string. */
+        variantThumbnails?: Record<string, string>;
     }): string;
     /**
      * Place a symbol instance on the canvas.
@@ -3952,14 +4947,88 @@ declare class Document {
      * @param symbolId - The ID of the symbol definition.
      * @param x - X position.
      * @param y - Y position.
-     * @param width - Instance width (optional).
-     * @param height - Instance height (optional).
+     * @param widthOrOptions - Instance width, or an options bag.
+     * @param height - Instance height (only when `widthOrOptions` is a number).
      */
-    placeSymbolInstance(symbolId: string, x: number, y: number, width?: number, height?: number): Document;
+    placeSymbolInstance(symbolId: string, x: number, y: number, widthOrOptions?: number | {
+        width?: number;
+        height?: number;
+        /** Selected variant key, e.g. `'color=red,size=large'`. */
+        variantKey?: string;
+        /** Per-inner-shape state patches applied to this instance only. */
+        symbolOverrides?: Record<string, Partial<SerializedShape['state']>>;
+        /** Per-instance attribute cascade applied to the `<use>` element (SVG 2 §5.5.4). */
+        instancePresentation?: Record<string, string>;
+    }, height?: number): Document;
     /** Remove a symbol definition by ID. */
     removeSymbol(id: string): boolean;
     /** Get all symbol definitions. */
     get symbols(): readonly SerializedSymbolDef[];
+    /**
+     * Register a marker definition. Shapes can then reference the marker by
+     * id via `.markerStartRef(id)` / `.markerMidRef(id)` / `.markerEndRef(id)`.
+     *
+     * @returns The marker library def id.
+     */
+    defineMarker(name: string, shapes: (ShapeBuilder<any> | SerializedShape)[], options?: {
+        viewBox?: string;
+        refX?: number;
+        refY?: number;
+        markerWidth?: number;
+        markerHeight?: number;
+        markerUnits?: 'strokeWidth' | 'userSpaceOnUse';
+        orient?: 'auto' | 'auto-start-reverse' | number;
+        thumbnail?: string;
+        groups?: SerializedGroup[];
+    }): string;
+    /**
+     * Register a reusable filter chain. Shapes reference it via `.filterLibrary(id)`.
+     *
+     * @returns The filter library def id.
+     */
+    defineFilter(name: string, filters: ShapeFilter[], options?: {
+        colorInterpolation?: 'auto' | 'sRGB' | 'linearRGB';
+        filterUnits?: 'userSpaceOnUse' | 'objectBoundingBox';
+        primitiveUnits?: 'userSpaceOnUse' | 'objectBoundingBox';
+        x?: string;
+        y?: string;
+        width?: string;
+        height?: string;
+        thumbnail?: string;
+    }): string;
+    /**
+     * Register a reusable linear gradient. Shapes reference it via `.fillLibrary(id)`.
+     *
+     * @returns The library def id.
+     */
+    defineLinearGradientLibrary(name: string, gradient: LinearGradientBuilder | LinearGradient, options?: {
+        thumbnail?: string;
+    }): string;
+    /**
+     * Register a reusable radial gradient. Shapes reference it via `.fillLibrary(id, 'radial-gradient')`.
+     *
+     * @returns The library def id.
+     */
+    defineRadialGradientLibrary(name: string, gradient: RadialGradientBuilder | RadialGradient, options?: {
+        thumbnail?: string;
+    }): string;
+    /**
+     * Register a reusable pattern. Shapes reference it via `.fillLibrary(id, 'pattern')`.
+     *
+     * @returns The library def id.
+     */
+    definePatternLibrary(name: string, pattern: PatternBuilder | PatternFill, options?: {
+        thumbnail?: string;
+    }): string;
+    /** Remove a library def (marker / filter / gradient / pattern) by id. */
+    removeLibraryDef(id: string): boolean;
+    /** Read-only view of every registered library def. */
+    get library(): readonly LibraryDef[];
+    /**
+     * Push a library def, lazily initializing `_snapshot.library` and
+     * deduplicating by id (last write wins).
+     */
+    private _pushLibraryDef;
     /**
      * Add a clip group.
      *
@@ -4178,4 +5247,4 @@ declare class Document {
     private _ensureMetadata;
 }
 
-export { type AnimatablePropertyDescriptor, type AnimationKeyframe, type AnimationTimeline, type AnimationTrack, type AnimationTrigger, type AnimationTriggerType, type AnyNodeProps, type ArcParams$1 as ArcParams, type AriaRole, Arrow, type ArrowNodeProps, BUILTIN_MARKER_ID_MAP, type BaseFilter, type BlackAndWhiteFilter, type BlurQuality, type BrightnessFilter, CURRENT_SCHEMA_VERSION, type ChannelPainterFilter, Circle, type CircleNodeProps, type CodeFormat, type CodegenOptions, type CommonNodeProps, type ConnectionDirection, type ConnectionPoint, type ContouringDiscreteFilter, type ContouringTableFilter, type ContrastFilter, type CornerShapeValue, type CreateDocumentOptions, type CreateShapeOptions, Cross, type CrossNodeProps, type CrumpledPlasticFilter, type CustomPatternDef, type CycleBehavior, DEFAULT_COORDINATE_PRECISION, type DiffuseLightingFilter, Document, type DocumentMetadata, type DocumentNodeProps, type DocumentOptions, type DocumentScript, type DocumentStyle, type DropShadowFilter, type DuotoneFilter, EASING_CURVES, EVENT_TRIGGER_OPTIONS, EasingType, Ellipse, type EllipseNodeProps, type EmbossFilter, type ExtractedVariables, type FillType, type FilmGrainFilter, type FilterLibraryDef, type FilterType, type GaussianBlurFilter, Gear, type GearNodeProps, type GlowFilter, type GouacheFilter, type GradientDefinition, type GradientSpreadMethod, type GradientStop, type GradientUnits, type GrayscaleFilter, type GroupNodeProps, type Guide, type HistorySnapshot, type HueRotateFilter, type ImageAttribution, type ImageNodeProps, ImageShape, type InkBlotFilter, type InnerGlowFilter, type InnerShadowFilter, type InvertFilter, LIBRARY_EMIT_ORDER, type LibraryDef, type LibraryDefBase, type LibraryDefOfKind, type LibraryKind, type LicenseType, type LightSource, Line, type LineEndpointValue, type LineNodeProps, type LinearEasingPoint, type LinearGradient, LinearGradientBuilder, type LinearGradientLibraryDef, type LinkTarget, MARKER_HEIGHT, MARKER_VIEWBOX, MARKER_WIDTH, MAX_COORDINATE_PRECISION, MIGRATIONS, type MarkerDescriptor, type MarkerLibraryDef, type Measurement, type Migration, type MorphologyFilter, type MorphologyOperator, type MotionBlurFilter, NGon, type NGonNodeProps, type NodeTypePropsMap, type NoiseFilter, type OpacityFilter, type OutlineFilter, type OutlinePosition, type ParseOptions, PatternBuilder, type PatternElement, type PatternFill, type PatternLibraryDef, type PatternParams, type PatternSvgContentResult, type PatternType, type PixelateFilter, type Point, type PointLightFilter, type PolygonBaseNodeProps, Polyline, type PolylineNodeProps, type RadialGradient, RadialGradientBuilder, type RadialGradientLibraryDef, type RawSvgFilter, Rectangle, type RectangleNodeProps, type RenderOptions, type RichTextData, type RichTextLine, type RichTextSegment, type RichTextSegmentStyle, type RiddledFilter, Ring, type RingNodeProps, type RoundEdgesFilter, type SaturateFilter, type SegmentCurveType, type SepiaFilter, type SerializedAnimationTimeline, type SerializedClipMaskGroup, type SerializedGroup, type SerializedMarkerDef, type SerializedShape, type SerializedSymbolDef, type SerializedVariantAxis, type SerializedViewbox, ShapeBuilder, type ShapeFilter, type ShapeMetadata, type SharpenFilter, type SpecularLightingFilter, Spiral, type SpiralNodeProps, Spline, SplineCurveType, type SplineNodeProps, type SplinePoint, SplinePointType, type SpotLightFilter, Square, type SquareNodeProps, Star, type StarNodeProps, type StepPosition, type StepsParams, type StringifyOptions, type StrokeType, type SymbolInstanceNodeProps, type SymbolLibraryDef, type TemplateVariable, type TemplateVariableSource, type TemplateVariableType, Text, type TextNodeProps, Timeline, Track, Triangle, type TriangleNodeProps, type ValidationError, type ValidationResult, type VariableMap, type Viewbox, type WarpFilter, type WarpType, type WatercolorFilter, type XrayFilter, collectReferencedLibraryIds, computeArrowVertices, computeCloudPath, computeCrossVertices, computeDashArray, computeGearPath, computeGearVertices, computeHeartPath, computeLightningVertices, computePolygonVertices, computeRectanglePath, computeRingPath, computeSpeechBubbleVertices, computeSpiralPath, computeSplinePath, computeStarVertices, createDocument, createShape, createViewbox, escXml, extractVariables, filterAttr, generateCode, generateCssCode, generateD3Code, generateId, generatePatternSvgContent, generateReactCode, generateSvgCode, generateVueCode, getBuiltInMarkerDefs, getEasingCubicBezier, getEffectivePrecision, getMarkerDescriptors, getPatternElements, linearGradient, migrateSnapshot, parseDocument, parseVariableArgs, pattern, radialGradient, renderAnimationElements, renderBuiltinMarkerDefs, renderCircle, renderEllipse, renderFilterDefs, renderFilterLibraryDef, renderFilterPrimitivesForType, renderImage, renderLibraryDef, renderLibraryDefs, renderLine, renderLinearGradientLibraryDef, renderMarkerLibraryDef, renderPatternLibraryDef, renderPolygonShape, renderPolyline, renderRadialGradientLibraryDef, renderRectangle, renderReferencedLibraryDefs, renderShape, renderSpline, renderSymbolLibraryDef, renderText, renderToSvg, roundCoord, roundNumberString, roundSerializedShape, roundSnapshot, stringifyDocument, substituteString, substituteVariables, validateSnapshot, verticesToPath };
+export { type AnimatablePropertyDescriptor, type AnimationKeyframe, type AnimationTimeline, type AnimationTrack, type AnimationTrigger, type AnimationTriggerType, type AnyNodeProps, type ArcParams$1 as ArcParams, type AriaRole, Arrow, type ArrowNodeProps, Audio, BUILTIN_MARKER_ID_MAP, type BaseFilter, type BaseFilterPrimitive, type BlackAndWhiteFilter, type BlurQuality, type BrightnessFilter, CURRENT_SCHEMA_VERSION, type ChannelPainterFilter, Circle, type CircleNodeProps, Cloud, type CodeFormat, type CodegenOptions, type CommonNodeProps, type ConnectionDirection, type ConnectionPoint, Container, ContainerShapeBuilder, type ContouringDiscreteFilter, type ContouringTableFilter, type ContrastFilter, type CornerShapeValue, type CreateDocumentOptions, type CreateShapeOptions, Cross, type CrossNodeProps, type CrumpledPlasticFilter, type CustomPatternDef, type CycleBehavior, DEFAULT_COORDINATE_PRECISION, type DiffuseLightingFilter, Document, type DocumentMetadata, type DocumentNodeProps, type DocumentOptions, type DocumentScript, type DocumentStyle, type DropShadowFilter, type DuotoneFilter, EASING_CURVES, EVENT_TRIGGER_OPTIONS, EasingType, Ellipse, type EllipseNodeProps, type EmbossFilter, type ExtractedVariables, type FeBlendPrimitive, type FeColorMatrixPrimitive, type FeComponentTransferPrimitive, type FeCompositePrimitive, type FeConvolveMatrixPrimitive, type FeDiffuseLightingPrimitive, type FeDisplacementMapPrimitive, type FeDropShadowPrimitive, type FeFloodPrimitive, type FeGaussianBlurPrimitive, type FeImagePrimitive, type FeMergePrimitive, type FeMorphologyPrimitive, type FeOffsetPrimitive, type FeSpecularLightingPrimitive, type FeTilePrimitive, type FeTurbulencePrimitive, type FillType, type FilmGrainFilter, type FilterBlendMode, type FilterLibraryDef, type FilterLightSource, type FilterPrimitive, type FilterPrimitiveType, type FilterType, type GaussianBlurFilter, Gear, type GearNodeProps, type GlowFilter, type GouacheFilter, type GradientDefinition, type GradientSpreadMethod, type GradientStop, type GradientUnits, type GrayscaleFilter, type GroupNodeProps, type Guide, Heart, type HistorySnapshot, type HueRotateFilter, Hyperlink, type ImageAttribution, type ImageNodeProps, ImageShape, type InkBlotFilter, type InnerGlowFilter, type InnerShadowFilter, type InvertFilter, LIBRARY_EMIT_ORDER, type LibraryDef, type LibraryDefBase, type LibraryDefOfKind, type LibraryKind, type LicenseType, type LightSource, Lightning, Line, type LineEndpointValue, type LineNodeProps, type LinearEasingPoint, type LinearGradient, LinearGradientBuilder, type LinearGradientLibraryDef, type LinkTarget, MARKER_HEIGHT, MARKER_VIEWBOX, MARKER_WIDTH, MAX_COORDINATE_PRECISION, MIGRATIONS, type MarkerDescriptor, type MarkerLibraryDef, type Measurement, type Migration, type MorphologyFilter, type MorphologyOperator, type MotionBlurFilter, NGon, type NGonNodeProps, NestedSvg, type NodeTypePropsMap, type NoiseFilter, type OpacityFilter, type OutlineFilter, type OutlinePosition, type ParseOptions, Path, PathCurveType, type PathNodeProps, type PathPoint, PathPointType, PatternBuilder, type PatternElement, type PatternFill, type PatternLibraryDef, type PatternParams, type PatternSvgContentResult, type PatternType, type PixelateFilter, type Point, type PointLightFilter, type PolygonBaseNodeProps, Polyline, type PolylineNodeProps, type RadialGradient, RadialGradientBuilder, type RadialGradientLibraryDef, type RawSvgFilter, Rectangle, type RectangleNodeProps, type RenderOptions, type RichTextData, type RichTextLine, type RichTextSegment, type RichTextSegmentStyle, type RiddledFilter, Ring, type RingNodeProps, type RoundEdgesFilter, type SaturateFilter, type SegmentCurveType, type SepiaFilter, type SerializedAnimationTimeline, type SerializedClipMaskGroup, type SerializedGroup, type SerializedMarkerDef, type SerializedShape, type SerializedSymbolDef, type SerializedVariantAxis, type SerializedViewbox, ShapeBuilder, type ShapeFilter, type ShapeMetadata, ShapeReference, type SharpenFilter, type SpecularLightingFilter, SpeechBubble, Spiral, type SpiralNodeProps, type SpotLightFilter, Square, type SquareNodeProps, Star, type StarNodeProps, type StepPosition, type StepsParams, type StringifyOptions, type StrokeType, type SvgPrimitiveChainFilter, Switch, type SymbolInstanceNodeProps, type SymbolLibraryDef, type TemplateVariable, type TemplateVariableMode, type TemplateVariableSource, type TemplateVariableType, Text, type TextNodeProps, Timeline, Track, type TransferFunc, Triangle, type TriangleNodeProps, type ValidationError, type ValidationResult, type VariableMap, Video, View, type Viewbox, type WarpFilter, type WarpType, type WatercolorFilter, type XrayFilter, collectReferencedLibraryIds, computeArrowVertices, computeCloudPath, computeCrossVertices, computeDashArray, computeGearPath, computeGearVertices, computeHeartPath, computeLightningVertices, computePolygonVertices, computeRectanglePath, computeRingPath, computeSpeechBubbleVertices, computeSpiralPath, computeSplinePath, computeStarVertices, createDocument, createShape, createViewbox, defaultVariableMode, escXml, extractVariables, filterAttr, generateCode, generateCssCode, generateD3Code, generateId, generatePatternSvgContent, generateReactCode, generateSvgCode, generateVueCode, getBuiltInMarkerDefs, getEasingCubicBezier, getEffectivePrecision, getMarkerDescriptors, getPatternElements, linearGradient, migrateSnapshot, parseDocument, parseVariableArgs, pattern, radialGradient, renderAnimationElements, renderBuiltinMarkerDefs, renderCircle, renderEllipse, renderFilterDefs, renderFilterLibraryDef, renderFilterPrimitive, renderFilterPrimitivesForType, renderImage, renderLibraryDef, renderLibraryDefs, renderLine, renderLinearGradientLibraryDef, renderMarkerLibraryDef, renderPatternLibraryDef, renderPolygonShape, renderPolyline, renderRadialGradientLibraryDef, renderRectangle, renderReferencedLibraryDefs, renderShape, renderSpline, renderSvgPrimitiveChainFilter, renderSymbolLibraryDef, renderText, renderToSvg, roundCoord, roundNumberString, roundSerializedShape, roundSnapshot, stringifyDocument, substituteString, substituteVariables, validateSnapshot, verticesToPath };