@pixerate/editor 0.42.0 → 0.43.0

package/dist/vector/index.d.ts

@@ -1,4 +1,4 @@
-import { C as CanvasGradientDef, A as AffineMatrix, B as BezierPathInput, a as BezierPath, S as SvgGradientDef, b as StrokeJoin, c as StrokeCap, d as BezierSegment, P as PlanarMap, e as PathfinderOperation, f as PathfinderShape, G as GradientStop } from '../pathfinder-D7hXenzu.js';
+import { C as CanvasGradientDef, A as AffineMatrix, B as BezierPathInput, a as BezierPath, S as SvgGradientDef, b as StrokeJoin, c as StrokeCap, d as BezierSegment, P as PlanarMap, e as PathfinderOperation, f as PathfinderShape } from '../pathfinder-D98S2lV5.js';
 import { P as Point } from '../types-BFkYA4eF.js';
 import { H as HistoryManager } from '../HistoryManager-DWSLd6Tf.js';
 import { C as CommandSpec } from '../registry-DhVUZioj.js';
@@ -58,8 +58,93 @@ interface VectorSubpath {
     /** Joins the last anchor back to the first. */
     closed: boolean;
 }
+/**
+ * Gradient styles: `linear` (start → end), `radial` (centred on the start, reaching the end;
+ * focal point and aspect), `conic` (an angle sweep around the start, from the end's direction
+ * towards the aspect handle's: clockwise on screen), `reflected` (linear mirrored about the
+ * start) and `diamond` (`|u| + |v|` in the gradient's frame: a rhombus through the end and the
+ * aspect handle).
+ */
+type VectorGradientType = 'linear' | 'radial' | 'conic' | 'reflected' | 'diamond';
+declare const VECTOR_GRADIENT_TYPES: readonly VectorGradientType[];
+/** What a gradient paints past its ends: the end colours, mirrored periods or repeated periods. */
+type VectorGradientSpread = 'pad' | 'reflect' | 'repeat';
+declare const VECTOR_GRADIENT_SPREADS: readonly VectorGradientSpread[];
+/** Where colours mix between stops: sRGB (SVG's own), linear light or Oklab. */
+type VectorGradientInterpolation = 'srgb' | 'linear' | 'oklab';
+declare const VECTOR_GRADIENT_INTERPOLATIONS: readonly VectorGradientInterpolation[];
+/**
+ * The space a gradient's points are in: fractions of the shape's bounding box (SVG's
+ * `objectBoundingBox`, the default) or the node's own coordinates (`userSpaceOnUse`).
+ */
+type VectorGradientUnits = 'objectBoundingBox' | 'userSpaceOnUse';
+/**
+ * How a gradient lies on a stroke: `within` (laid over the stroke's area like a fill), `along`
+ * (t runs from 0 at the start of each subpath to 1 at its end) or `across` (from the stroke's
+ * left edge to its right edge, looking along the path).
+ */
+type VectorStrokeGradientMode = 'within' | 'along' | 'across';
+declare const VECTOR_STROKE_GRADIENT_MODES: readonly VectorStrokeGradientMode[];
+/** A colour stop. `opacity` multiplies the colour's own alpha. */
+interface VectorGradientStop {
+    /** 0–1. */
+    offset: number;
+    color: string;
+    /** 0–1, default 1. */
+    opacity?: number;
+    /**
+     * Where, between this stop and the next (0–1 of the way), the colour is half-way between
+     * them. Default 0.5 (an even mix).
+     */
+    midpoint?: number;
+}
+/**
+ * A gradient paint. `CanvasGradientDef` (the canvas package's linear `angle` / radial
+ * `cx, cy, r` gradients) is a valid value: those fields are the shorthand form. Explicit
+ * geometry (`start` / `end`, in `units`) wins over the shorthand.
+ */
+interface VectorGradient {
+    type: VectorGradientType;
+    stops: VectorGradientStop[];
+    /**
+     * Shorthand direction in degrees, CSS style (0 points up, clockwise): a linear or reflected
+     * gradient's direction across the box (default 180), a conic gradient's start angle or a
+     * diamond's turn (default 90).
+     */
+    angle?: number;
+    /** Shorthand centre and radius of radial, conic and diamond gradients (fractions of the box, default 0.5). */
+    cx?: number;
+    cy?: number;
+    r?: number;
+    /** Where t = 0: a linear gradient's start, the centre of the other styles. */
+    start?: Vec2;
+    /** Where t = 1 along the gradient's main axis (a radial gradient's radius). */
+    end?: Vec2;
+    /**
+     * The end of the secondary axis (radial, conic and diamond): its distance from `start` over
+     * the main axis' length is the aspect ratio. Absent: square to the main axis, as long.
+     */
+    width?: Vec2 | null;
+    /** A radial gradient's focal point (where t = 0); absent: the centre. */
+    focal?: Vec2 | null;
+    /** Radius of the focal circle as a fraction of the radius (SVG `fr`, default 0). */
+    focalRadius?: number;
+    /** Space of `start`, `end`, `width` and `focal` (default `objectBoundingBox`). */
+    units?: VectorGradientUnits;
+    /** Default `pad`. */
+    spread?: VectorGradientSpread;
+    /** Default `srgb`. */
+    interpolation?: VectorGradientInterpolation;
+    /**
+     * 0–1: how far the colours follow a smooth spline through the stops instead of straight
+     * lines (Photoshop's Smoothness). Default 0.
+     */
+    smoothness?: number;
+    /** On a stroke: how the gradient lies on it (default `within`). Ignored on fills. */
+    strokeMode?: VectorStrokeGradientMode;
+}
 /** A fill or stroke: any CSS colour, a gradient, or `null` / `'none'` for no paint. */
-type VectorPaint = string | CanvasGradientDef | null;
+type VectorPaint = string | VectorGradient | CanvasGradientDef | null;
 type VectorFillRule = 'nonzero' | 'evenodd';
 type VectorLineCap = 'butt' | 'round' | 'square';
 type VectorLineJoin = 'miter' | 'round' | 'bevel';
@@ -236,7 +321,7 @@ interface VectorHandleRef extends VectorAnchorRef {
  * blends the shape clicked first into the one clicked next (clicking an anchor of a closed path
  * starts the blend there).
  */
-type VectorTool = 'select' | 'direct' | 'pen' | 'pencil' | 'rect' | 'ellipse' | 'polygon' | 'star' | 'line' | 'scissors' | 'knife' | 'eraser' | 'width' | 'shapeBuilder' | 'paintBucket' | 'blend';
+type VectorTool = 'select' | 'direct' | 'pen' | 'pencil' | 'rect' | 'ellipse' | 'polygon' | 'star' | 'line' | 'scissors' | 'knife' | 'eraser' | 'width' | 'shapeBuilder' | 'paintBucket' | 'blend' | 'gradient';
 declare const VECTOR_TOOLS: readonly VectorTool[];
 /** Keyboard modifiers held during a pointer event. */
 interface VectorModifiers {
@@ -392,11 +477,6 @@ interface VectorSegmentRef {
     segment: number;
 }
 
-/**
- * Vector path geometry: anchors and handles to Bézier paths and back, bounds, hit-testing,
- * affine transforms, segment splitting, anchor-type conversion and shape factories.
- */
-
 declare const cloneAnchor: (a: VectorAnchor) => VectorAnchor;
 declare const cloneSubpath: (s: VectorSubpath) => VectorSubpath;
 /** A deep copy of a node (ids kept). */
@@ -577,6 +657,257 @@ declare function lineSubpath(a: Vec2, b: Vec2): VectorSubpath;
 /** Rounds every coordinate to `precision` decimals (stable JSON and SVG output). */
 declare function roundSubpaths(subpaths: readonly VectorSubpath[], precision?: number): VectorSubpath[];
 
+/** True when `paint` is a gradient (any style). */
+declare function isVectorGradient(paint: VectorPaint | undefined): paint is VectorGradient;
+/** Straight-alpha sRGB channels, 0–1. */
+type VectorRgba = [number, number, number, number];
+/** A CSS colour as 0–1 channels (hex, `rgb()`, `transparent`, `black`, `white`), or null. */
+declare function parseVectorColor(color: string): VectorRgba | null;
+/** Fewest stops a gradient keeps when one is removed. */
+declare const VECTOR_GRADIENT_MIN_STOPS = 2;
+/**
+ * Where relative position `u` of a segment lands once its midpoint is `m` (0.5 = unchanged): the
+ * colour is half-way at `m`, linear on either side (photocraft `midpoint_remap`).
+ */
+declare function gradientMidpointRemap(u: number, m: number): number;
+/** The stops sorted by offset (stable), offsets clamped to 0–1, unreadable offsets dropped. */
+declare function sortedVectorGradientStops(g: Pick<VectorGradient, 'stops'>): VectorGradientStop[];
+/** Does the gradient need extra stops to look the same in SVG (midpoints, smoothness or a non-sRGB space)? */
+declare function vectorGradientNeedsExpansion(g: VectorGradient): boolean;
+/** A gradient's colour ramp, prepared for sampling. */
+interface VectorGradientRamp {
+    /** Straight-alpha sRGB at `t` (clamped to 0–1). */
+    sample(t: number): VectorRgba;
+}
+/**
+ * The colour ramp of a gradient (midpoints, smoothness and interpolation space applied), or null
+ * when a stop colour is not one `parseVectorColor` reads.
+ */
+declare function vectorGradientRamp(g: Pick<VectorGradient, 'stops' | 'interpolation' | 'smoothness'>): VectorGradientRamp | null;
+/** What the gradient paints at `t` (0–1 along its stops): `#rrggbb` and opacity. */
+declare function sampleVectorGradient(g: VectorGradient, t: number): {
+    color: string;
+    opacity: number;
+};
+/**
+ * Plain stops (no midpoints) that SVG's sRGB interpolation turns into the gradient's colours:
+ * the stops as they are when nothing needs expanding; one extra stop per off-centre midpoint for
+ * sRGB without smoothness (exact: the midpoint makes each half linear); otherwise stops placed
+ * adaptively until linear interpolation between them is within `tolerance` (0–1 per channel,
+ * default half a level) of the true curve everywhere they were checked.
+ */
+declare function expandVectorGradientStops(g: VectorGradient, options?: {
+    tolerance?: number;
+}): VectorGradientStop[];
+/** Linear interpolation between plain stops (what SVG draws from them), straight alpha. */
+declare function samplePlainStops(stops: readonly VectorGradientStop[], t: number): VectorRgba;
+/** The gradient with its stops reversed, each midpoint measured from the other side (vectorcraft `reverse`). */
+declare function reverseVectorGradient<T extends Pick<VectorGradient, 'stops'>>(g: T): T;
+/** A stop added at `offset` painting what the gradient paints there; returns the stops and its index. */
+declare function insertVectorGradientStop(g: VectorGradient, offset: number): {
+    stops: VectorGradientStop[];
+    index: number;
+};
+/** Stop `index` moved to `offset` (re-sorted); returns the stops and its new index. */
+declare function moveVectorGradientStop(stops: readonly VectorGradientStop[], index: number, offset: number): {
+    stops: VectorGradientStop[];
+    index: number;
+};
+/** The stops without stop `index`, or null when that would leave fewer than two. */
+declare function removeVectorGradientStop(stops: readonly VectorGradientStop[], index: number): VectorGradientStop[] | null;
+/** Where (0–1 along the gradient) the midpoint after stop `index` sits, or null for the last stop. */
+declare function vectorGradientMidpointPosition(stops: readonly VectorGradientStop[], index: number): number | null;
+/** The midpoint of stop `index` that puts it at position `pos` (clamped to 0.05–0.95), or null. */
+declare function vectorGradientMidpointFromPosition(stops: readonly VectorGradientStop[], index: number, pos: number): number | null;
+/**
+ * The part of the gradient from `from` to `to` (0–1, either order) as plain stops over 0–1
+ * (vectorcraft `span`): the colours at both ends plus the expanded stops between them.
+ */
+declare function spanVectorGradientStops(g: VectorGradient, from: number, to: number, expanded?: VectorGradientStop[]): VectorGradientStop[];
+/** A gradient's frame points, in its units (see `VectorGradient`). */
+interface VectorGradientPoints {
+    start: Vec2;
+    end: Vec2;
+    width: Vec2;
+    focal: Vec2 | null;
+    focalRadius: number;
+    units: VectorGradientUnits;
+}
+/** Whether the gradient carries its own points (rather than the angle / centre shorthand). */
+declare const hasExplicitGradientGeometry: (g: VectorGradient) => boolean;
+/** The gradient's frame points in its units, the shorthand resolved (it is always in the box). */
+declare function vectorGradientPoints(g: VectorGradient): VectorGradientPoints;
+/**
+ * The unit box → `bounds` matrix of `objectBoundingBox` gradients. A side with no extent (a
+ * horizontal or vertical line) takes the other side's, centred, so the gradient still paints
+ * (SVG paints nothing there).
+ */
+declare function vectorBoxMatrix(bounds: VectorBounds | null | undefined): VectorMatrix;
+/** The gradient's units → node space (the box matrix for `objectBoundingBox`, else the identity). */
+declare function vectorGradientUnitsMatrix(g: VectorGradient, bounds: VectorBounds | null | undefined): VectorMatrix;
+/** The gradient's unit frame → node space: u = 1 at the end, v = 1 at the width point. */
+declare function vectorGradientMatrix(g: VectorGradient, bounds: VectorBounds | null | undefined): VectorMatrix;
+/**
+ * t of a radial gradient at unit-frame point `q` with the focal circle centred on `f` with radius
+ * `fr` and the end circle the unit circle (SVG's two-point conical gradient). With `fr = 0` this
+ * is the focal ray: t is the distance from the focal point to `q` over the distance from it to
+ * the circle along the same ray (effectcraft `GradientRamp::t`, vectorcraft `param_at`).
+ */
+declare function vectorGradientFocalParam(q: Vec2, f?: Vec2, fr?: number): number;
+/**
+ * The raw gradient parameter (before the spread) of a style at unit-frame point `q`: linear `u`,
+ * reflected `|u|`, diamond `|u| + |v|`, conic the turn from the u axis towards the v axis (0–1),
+ * radial the distance through the focal circle (photocraft `gradient_t`).
+ */
+declare function vectorGradientParam(type: VectorGradientType, q: Vec2, focal?: {
+    f: Vec2;
+    fr: number;
+} | null): number;
+/** `t` folded into 0–1 by a spread mode. */
+declare function applyVectorGradientSpread(t: number, spread?: VectorGradientSpread): number;
+/** The gradient's t (spread applied) at node-space point `p` of a shape with box `bounds`. */
+declare function vectorGradientTAt(g: VectorGradient, bounds: VectorBounds | null | undefined, p: Vec2): number;
+/** What the gradient paints at node-space point `p` (straight-alpha sRGB, 0–1). */
+declare function sampleVectorGradientAt(g: VectorGradient, bounds: VectorBounds | null | undefined, p: Vec2): VectorRgba;
+/** The main axis length over the secondary's: |width − start| / |end − start| (signed by side). */
+declare function vectorGradientAspect(g: VectorGradient): number;
+/** The gradient with explicit points (in its units) replacing the shorthand. */
+declare function explicitVectorGradient(g: VectorGradient): VectorGradient;
+/**
+ * The gradient in the node's own space (`userSpaceOnUse`), painting what it paints on a shape
+ * with box `bounds` (vectorcraft `GradientPaint::pin`): its points mapped through the box.
+ */
+declare function pinVectorGradient(g: VectorGradient, bounds: VectorBounds | null | undefined): VectorGradient;
+/**
+ * The gradient after the node's geometry is mapped by `m`: a `userSpaceOnUse` gradient's points
+ * are mapped too (any affine map keeps every style's t, since t is measured in the frame the
+ * three points span); a box gradient follows the box and is unchanged.
+ */
+declare function transformVectorGradient(g: VectorGradient, m: VectorMatrix): VectorGradient;
+/** A paint after its node's geometry is mapped by `m` (colours unchanged). */
+declare function transformVectorPaint<T extends VectorPaint | undefined>(paint: T, m: VectorMatrix): T;
+/**
+ * An on-canvas handle of a gradient: `start` (a radial, conic or diamond gradient's centre),
+ * `end` (a linear or reflected gradient's end), `radius` (the end of the others), `aspect` (the
+ * secondary axis' end) and `focal` (radial).
+ */
+type VectorGradientHandle = 'start' | 'end' | 'radius' | 'aspect' | 'focal';
+/** Whether the style has a centre with a radius (rather than a start and an end). */
+declare const isCentredVectorGradient: (type: VectorGradientType) => type is "radial" | "conic" | "diamond";
+/** The handles of a gradient in the space `toWorld` maps the node's space to (the document, the screen). */
+declare function vectorGradientHandles(g: VectorGradient, bounds: VectorBounds | null | undefined, toWorld?: VectorMatrix): {
+    start: Vec2;
+    end: Vec2;
+    aspect: Vec2 | null;
+    focal: Vec2 | null;
+};
+/**
+ * The gradient (pinned to the node's space) with a handle dragged to node-space point `to`.
+ * `start` moves the whole gradient by `to − from`; `end` / `radius` move the end, the secondary
+ * axis and focal point following; `aspect` sets the secondary axis' length square to the main
+ * one; `focal` sets the focal point (pulled inside the circle; null centres it).
+ */
+declare function moveVectorGradientHandle(g: VectorGradient, bounds: VectorBounds | null | undefined, handle: VectorGradientHandle, to: Vec2, from?: Vec2): VectorGradient;
+/** The gradient set to run from `start` to `end` (node space), its secondary axis square to it with its aspect kept. */
+declare function setVectorGradientVector(g: VectorGradient, bounds: VectorBounds | null | undefined, start: Vec2, end: Vec2): VectorGradient;
+/** Most periods a spread is expanded to (vectorcraft `MAX_PERIODS`). */
+declare const VECTOR_GRADIENT_MAX_PERIODS = 64;
+/**
+ * Stops repeating the gradient's plain stops over periods `lo` … `hi` (integers, at most
+ * `VECTOR_GRADIENT_MAX_PERIODS`), period `k` mirrored when `mirrored(k)`; offsets over 0–1 span
+ * the whole range (vectorcraft `spread::expand`, which emulates `reflect` and `repeat` this way).
+ */
+declare function periodicVectorGradientStops(stops: readonly VectorGradientStop[], lo: number, hi: number, mirrored: (k: number) => boolean): VectorGradientStop[];
+/**
+ * A linear or reflected gradient's spread as stop periods over `area` (node space), for
+ * renderers (and combinations) without the spread mode: vectorcraft's SVG import emulates
+ * `reflect` and `repeat` this way. Returns where the periods start and end and their stops, or
+ * null when a linear gradient pads (nothing to repeat). Reflected gradients always get at least
+ * the period either side of the start (the one before it mirrored). `from` / `to` are the
+ * periods' ends along the frame's u axis (`matrix` maps the frame to node space).
+ */
+declare function expandVectorGradientSpread(g: VectorGradient, bounds: VectorBounds | null | undefined, area: VectorBounds): {
+    start: Vec2;
+    end: Vec2;
+    from: number;
+    to: number;
+    matrix: VectorMatrix;
+    stops: VectorGradientStop[];
+    capped: boolean;
+} | null;
+/**
+ * A `<pattern>` paint server in user space: draw `gradients` (inside it or in `<defs>`) and then
+ * each tile (`d` filled with `fill`) in order, all in the painted element's user space (the
+ * `viewBox` in `attrs` matches the tile, so keep it). Conic and diamond gradients, and gradients along
+ * or across a stroke, take this form.
+ */
+interface VectorSvgPatternDef {
+    id: string;
+    type: 'pattern';
+    /** `x`, `y`, `width`, `height`, `patternUnits="userSpaceOnUse"` and the matching `viewBox`. */
+    attrs: Record<string, string | number>;
+    gradients: SvgGradientDef[];
+    tiles: {
+        d: string;
+        fill: string;
+    }[];
+}
+/** A paint server for `fill` / `stroke`: a gradient element or a pattern of gradient tiles. */
+type VectorPaintDef = SvgGradientDef | VectorSvgPatternDef;
+interface VectorGradientSvgOptions {
+    /** The shape's box in its own space (for `objectBoundingBox` gradients). */
+    bounds?: VectorBounds | null;
+    /** The area the paint must cover (pattern tiles, spread periods); default `bounds` padded by 1. */
+    area?: VectorBounds | null;
+    /** Wedges of a conic gradient (default 72: 5° each). */
+    wedges?: number;
+    precision?: number;
+}
+/** The area a gradient on a shape with box `bounds` paints (the box padded by 1). */
+declare const vectorGradientArea: (bounds: VectorBounds | null | undefined) => VectorBounds;
+/**
+ * A user-space pattern tile over `area`. Without a `viewBox` SVG puts the content's origin at the
+ * tile's corner; the matching `viewBox` keeps the content in the painted element's user space.
+ */
+declare function patternAttrs(area: VectorBounds): Record<string, string>;
+/**
+ * The SVG paint servers of a gradient on a shape: the first def's id is `id` (reference it as
+ * `url(#id)`), any others are what it uses. All are in the user space of the element painted
+ * (the node's own space).
+ */
+declare function vectorGradientSvgDefs(g: VectorGradient, id: string, options?: VectorGradientSvgOptions): VectorPaintDef[];
+/**
+ * What a `userSpaceOnUse` paint server from `vectorGradientSvgDefs` paints at point `p` (straight
+ * alpha, 0–1) the way an SVG renderer would: a gradient's stops interpolated in sRGB, a pattern's
+ * topmost tile containing `p`. Null for a point no tile covers.
+ */
+declare function sampleVectorPaintDefAt(defs: readonly VectorPaintDef[], id: string, p: Vec2): VectorRgba | null;
+/**
+ * A gradient from untrusted input (agent commands, SVG data attributes), or null when it is not
+ * one: unknown fields dropped, numbers clamped, at least one stop.
+ */
+declare function sanitizeVectorGradient(input: unknown): VectorGradient | null;
+/**
+ * A gradient changed to style `type`, keeping its stops, colour settings and placement: explicit
+ * points stay where they are (a linear end becomes a radius), shorthand is redone for the style.
+ */
+declare function convertVectorGradient(g: VectorGradient, type: VectorGradientType): VectorGradient;
+/** A default gradient for a paint that was a colour (or nothing): the colour fading to white. */
+declare function defaultVectorGradient(type?: VectorGradientType, from?: VectorPaint): VectorGradient;
+/**
+ * Changes to a gradient (`vector.setGradient`, the gradient editor): any gradient field, plus
+ * `aspect` (the secondary axis' length over the main one, square to it) and `reverse`. `focal` or
+ * `width` set to null removes them.
+ */
+interface VectorGradientPatch extends Partial<Omit<VectorGradient, 'focal' | 'width'>> {
+    focal?: Vec2 | null;
+    width?: Vec2 | null;
+    aspect?: number;
+    reverse?: boolean;
+}
+/** `g` with `patch` applied (a style change converts it first), or null when the result is not a gradient. */
+declare function applyVectorGradientPatch(g: VectorGradient, patch: VectorGradientPatch): VectorGradient | null;
+
 interface VectorSvgExportOptions {
     /** Decimal places for coordinates (default 3). */
     precision?: number;
@@ -599,10 +930,23 @@ interface VectorSvgExportOptions {
 declare function vectorCornersAttribute(subpaths: readonly VectorSubpath[], precision?: number): string;
 /** Puts `data-vector-corners` back on subpaths (malformed entries are ignored). */
 declare function applyVectorCornersAttribute(subpaths: VectorSubpath[], value: string): VectorSubpath[];
-/** A paint as an SVG attribute value plus the gradient def it needs (if any). */
-declare function vectorPaintToSvg(paint: VectorPaint | undefined, gradientId: string): {
+/** Where a paint goes: what `vectorPaintToSvg` needs to place a gradient on a shape. */
+interface VectorPaintSvgOptions {
+    /** The path painted (its box places `objectBoundingBox` gradients; strokes need its geometry). */
+    node?: VectorPathNode;
+    /** `stroke` lays `along` / `across` gradients on the stroke and covers its reach (default `fill`). */
+    role?: 'fill' | 'stroke';
+    precision?: number;
+}
+/** The box of a path's drawn outline in its own space (null when it has no points). */
+declare function vectorPathLocalBounds(node: VectorPathNode): VectorBounds | null;
+/**
+ * A paint as an SVG attribute value plus the paint servers it needs (`url(#id)` refers to the
+ * first). Gradients sit in the painted element's user space (the node's own space).
+ */
+declare function vectorPaintToSvg(paint: VectorPaint | undefined, gradientId: string, options?: VectorPaintSvgOptions): {
     value: string;
-    gradient: SvgGradientDef | null;
+    defs: VectorPaintDef[];
 };
 /** The parts of an aligned or arrowed stroke (see `VectorRenderPath.strokeParts`). */
 interface VectorRenderStrokeParts {
@@ -833,6 +1177,85 @@ declare function pressureWidthProfile(samples: readonly {
     tolerance?: number;
 }): VectorWidthPoint[];
 
+/**
+ * The Gradient tool's on-canvas annotator: a bar from the start (or centre) handle to the end (or
+ * radius) handle with the colour stops under it and midpoint diamonds above it, plus a radial,
+ * conic or diamond gradient's extent outline, aspect handle and (radial) focal point. All in
+ * screen pixels, for hit-testing and the overlay.
+ *
+ * After vectorcraft `crates/tools/src/xform/gradient.rs` (`Annotator`: stop chips below the bar,
+ * midpoints above it, a stop dragged off the bar is removed, a click on the bar adds one), ArtCraft,
+ * MIT OR Apache-2.0 — see THIRD_PARTY_NOTICES.md.
+ */
+
+/** Which paint of the selection the Gradient tool and the gradient editor work on. */
+type VectorGradientTarget = 'fill' | 'stroke';
+/** A part of the annotator under the pointer. */
+type VectorGradientPart = {
+    kind: 'handle';
+    handle: VectorGradientHandle;
+} | {
+    kind: 'stop';
+    index: number;
+} | {
+    kind: 'midpoint';
+    index: number;
+}
+/** The bar at `offset` (0–1): a click adds a stop there, a drag moves the gradient. */
+ | {
+    kind: 'bar';
+    offset: number;
+};
+/** Distance of the stop chips below the bar, the midpoint diamonds above it (screen pixels). */
+declare const VECTOR_GRADIENT_STOP_GAP = 12;
+declare const VECTOR_GRADIENT_MIDPOINT_GAP = 9;
+/** How far off the bar a dragged stop goes before it is removed (screen pixels). */
+declare const VECTOR_GRADIENT_OFF_BAR = 24;
+interface VectorGradientAnnotator {
+    nodeId: string;
+    target: VectorGradientTarget;
+    gradient: VectorGradient;
+    /** The path's box in its own space. */
+    bounds: VectorBounds | null;
+    /** The path's own space → document. */
+    world: AffineMatrix;
+    /** Screen positions of the handles. */
+    start: Vec2;
+    end: Vec2;
+    /** Radial, conic and diamond gradients. */
+    aspect: Vec2 | null;
+    /** Radial gradients. */
+    focal: Vec2 | null;
+    /** Unit normal to the bar towards the stop chips (screen). */
+    normal: Vec2;
+    /** Stops (sorted, as the gradient stores them) with their chips' screen positions. */
+    stops: (VectorGradientStop & {
+        index: number;
+        x: number;
+        y: number;
+    })[];
+    /** The midpoint diamond after each stop but the last (screen). */
+    midpoints: {
+        index: number;
+        x: number;
+        y: number;
+        midpoint: number;
+    }[];
+    /** Screen path of the extent: an ellipse (radial, conic) or a rhombus (diamond). */
+    extent: string | null;
+}
+/** The path whose `target` paint the annotator shows: the first path of the selection with a gradient there. */
+declare function vectorGradientTargetPath(doc: VectorDocument, selection: readonly string[], target: VectorGradientTarget): VectorPathNode | null;
+/** The annotator of the selection's gradient (`target` paint), in screen pixels, or null when it has none. */
+declare function getVectorGradientAnnotator(doc: VectorDocument, selection: readonly string[], viewport: VectorViewport, target: VectorGradientTarget): VectorGradientAnnotator | null;
+/** Where `p` lies relative to the bar: offset along it (0 at the start, 1 at the end) and distance towards the stop chips. */
+declare function vectorGradientBarPosition(a: Pick<VectorGradientAnnotator, 'start' | 'end' | 'normal'>, p: Vec2): {
+    offset: number;
+    across: number;
+};
+/** The annotator part under screen point `p`: stops, then midpoints, the handles and the bar. */
+declare function hitVectorGradientAnnotator(a: VectorGradientAnnotator, p: Vec2): VectorGradientPart | null;
+
 /**
  * What a guide line shows: `align` lines run from a target through the snapped point or box,
  * `construction` lines from where a drawn point leaves, `spacing` marks equal gaps and `size`
@@ -1170,6 +1593,8 @@ interface VectorHover {
     };
     /** A spot on a stroke away from its width points (width tool). */
     strokeSpot?: VectorStrokeSpot;
+    /** A part of the gradient annotator (gradient tool). */
+    gradient?: VectorGradientPart;
 }
 /** The drag in progress, for overlays and status text. */
 type VectorInteraction = {
@@ -1224,6 +1649,13 @@ type VectorInteraction = {
 } | {
     type: 'pen';
     nodeId: string;
+}
+/** A gradient tool drag: drawing a new vector, or a handle, stop, midpoint or the bar (`removing`: a stop dragged off the bar). */
+ | {
+    type: 'gradient';
+    part: 'create' | VectorGradientPart['kind'];
+    handle?: VectorGradientHandle;
+    removing?: boolean;
 } | {
     type: 'pan';
 };
@@ -1269,6 +1701,11 @@ interface VectorEditorState {
     blendStart: VectorBlendStart | null;
     /** Options new blends get. */
     blendDefaults: VectorBlendOptions;
+    /** The paint the gradient tool and gradient editor work on, and the selected stop (index into the sorted stops). */
+    gradientEdit: {
+        target: VectorGradientTarget;
+        stop: number | null;
+    };
     canUndo: boolean;
     canRedo: boolean;
     undoLabel: string;
@@ -1524,6 +1961,7 @@ declare class VectorEditorController {
     private blendStart;
     /** Options new blends get (the toolbars edit them along with the selected blend's). */
     private blendDefaults;
+    private gradientEdit;
     /** What the highlight shows, to skip notifying when the pointer stays over the same face. */
     private builderHoverKey;
     private readonly createId;
@@ -1536,7 +1974,13 @@ declare class VectorEditorController {
     private revision;
     private state;
     constructor(options?: VectorEditorOptions);
-    /** Stops listening to the history. */
+    /** Listens to the history (once; again after `destroy`). */
+    private connect;
+    private historyDiffers;
+    /**
+     * Stops listening to the history and drops all listeners. A later `subscribe` reconnects, so a
+     * controller torn down by React StrictMode's double effect keeps working when it is reused.
+     */
     destroy(): void;
     /** The current snapshot (stable until the next change). */
     getState: () => VectorEditorState;
@@ -1658,6 +2102,47 @@ declare class VectorEditorController {
     } | null, options?: {
         ids?: readonly string[];
     }): VectorActionResult;
+    /** Which paint (fill or stroke) the gradient tool and editor work on. */
+    setGradientTarget(target: VectorGradientTarget): void;
+    /** Selects a stop of the gradient being edited (index into its sorted stops), or none. */
+    selectGradientStop(index: number | null): void;
+    /** The gradient tool's annotator for the selection (screen pixels), or null when its paint is not a gradient. */
+    getGradientAnnotator(): VectorGradientAnnotator | null;
+    /** Unlocked paths of `ids` (default: the selection). */
+    private gradientPaths;
+    /**
+     * Edits the gradient of the `target` paint (default: the editor's) of the selected (or given)
+     * paths with `patch`: a colour or no paint becomes a gradient (`patch.type`, default linear,
+     * from the colour to white). Consecutive edits with the same `merge` key are one undo step.
+     */
+    setGradient(patch: VectorGradientPatch, options?: {
+        ids?: readonly string[];
+        target?: VectorGradientTarget;
+        label?: string;
+        merge?: string;
+    }): VectorActionResult;
+    /** Applies `fn` to every target gradient of the selection (paths whose paint is not a gradient are skipped). */
+    private editGradients;
+    /** Changes stop `index` (colour, opacity, offset or midpoint) of the selection's gradients; selects it. */
+    setGradientStop(index: number, patch: {
+        color?: string;
+        opacity?: number;
+        offset?: number;
+        midpoint?: number;
+    }, options?: {
+        merge?: string;
+    }): VectorActionResult;
+    /** Adds a stop at `offset` (painting what the gradient paints there) to the selection's gradients and selects it. */
+    addGradientStop(offset: number): VectorActionResult;
+    /** Removes stop `index` of the selection's gradients (never below two stops). */
+    removeGradientStop(index: number): VectorActionResult;
+    /** Reverses the selection's gradients (stops and midpoints). */
+    reverseGradient(): VectorActionResult;
+    /** `doc` with path `id`'s `target` paint replaced. */
+    private withGradient;
+    private downGradient;
+    private moveGradient;
+    private upGradient;
     /** Removes one width point of a path's profile. */
     removeWidthPoint(ref: Pick<VectorWidthPointRef, 'nodeId' | 'index'>): VectorActionResult;
     /** Removes width points (default: the selected ones — the width tool's Delete), as one undo step. */
@@ -2357,8 +2842,12 @@ interface VectorSceneRenderData {
     width: number;
     height: number;
     background?: string;
-    /** Gradients referenced by `fill` / `stroke` values. */
-    defs: SvgGradientDef[];
+    /**
+     * Paint servers referenced by `fill` / `stroke` values: `<linearGradient>` /
+     * `<radialGradient>` descriptors and `pattern`s (conic, diamond and stroke-mode gradients:
+     * draw each of `gradients`, then each tile filled, inside a `<pattern>`).
+     */
+    defs: VectorPaintDef[];
     /** Visible nodes, bottom to top. */
     nodes: VectorRenderNode[];
 }
@@ -2528,9 +3017,62 @@ interface VectorOverlayRenderData {
             hovered: boolean;
         }[];
     };
+    /** The gradient tool's annotator over the selection's gradient (screen space), or null. */
+    gradient: VectorRenderGradientAnnotator | null;
     /** A short status, e.g. "W 120 × H 80" or "45°". */
     status: string | null;
 }
+/**
+ * The gradient annotator in screen pixels: draw the `extent` outline (dashed), the bar from
+ * `start` to `end`, the handles, each stop's chip (a swatch at `x, y` with a tick to `barX, barY`;
+ * `removing`: the dragged stop is off the bar and will be deleted, draw it faded) and the
+ * midpoint diamonds.
+ */
+interface VectorRenderGradientAnnotator {
+    nodeId: string;
+    type: VectorGradientType;
+    start: {
+        x: number;
+        y: number;
+        hovered: boolean;
+    };
+    /** `radius` for radial, conic and diamond gradients. */
+    end: {
+        x: number;
+        y: number;
+        hovered: boolean;
+        handle: 'end' | 'radius';
+    };
+    aspect: {
+        x: number;
+        y: number;
+        hovered: boolean;
+    } | null;
+    focal: {
+        x: number;
+        y: number;
+        hovered: boolean;
+    } | null;
+    stops: {
+        index: number;
+        x: number;
+        y: number;
+        barX: number;
+        barY: number;
+        color: string;
+        opacity: number;
+        selected: boolean;
+        hovered: boolean;
+    }[];
+    midpoints: {
+        index: number;
+        x: number;
+        y: number;
+        hovered: boolean;
+    }[];
+    extent: string | null;
+    removing: boolean;
+}
 /** Distance between the Shape Builder's hatch lines over a face (screen pixels). */
 declare const VECTOR_BUILDER_HATCH_GAP = 6;
 /**
@@ -2680,6 +3222,38 @@ declare const VECTOR_CORNER_KIND_LABELS: Readonly<Record<VectorCornerKind, strin
 declare const VECTOR_ARROWHEAD_LABELS: Readonly<Record<VectorArrowhead, string>>;
 /** A paint as `#rrggbb` for `<input type="color">`, or null for none, gradients and other CSS colours. */
 declare function vectorPaintToHex(paint: VectorPaint | undefined): string | null;
+declare const VECTOR_GRADIENT_TYPE_LABELS: Readonly<Record<VectorGradientType, string>>;
+declare const VECTOR_GRADIENT_SPREAD_LABELS: Readonly<Record<VectorGradientSpread, string>>;
+declare const VECTOR_GRADIENT_INTERPOLATION_LABELS: Readonly<Record<VectorGradientInterpolation, string>>;
+declare const VECTOR_STROKE_GRADIENT_MODE_LABELS: Readonly<Record<VectorStrokeGradientMode, string>>;
+/** What a gradient editor shows for the selection's `target` paint (see `getVectorGradientEditor`). */
+interface VectorGradientEditorData {
+    target: 'fill' | 'stroke';
+    /** The first selected path's paint is a gradient. */
+    gradient: VectorGradient | null;
+    /** The paint as a `#rrggbb` colour when it is one (what a new gradient starts from). */
+    color: string | null;
+    /** Sorted stops; `index` is what `setGradientStop` takes. */
+    stops: (VectorGradientStop & {
+        index: number;
+        selected: boolean;
+    })[];
+    selected: (VectorGradientStop & {
+        index: number;
+        last: boolean;
+    }) | null;
+    /** A CSS `linear-gradient(to right, …)` of the ramp (midpoints and colour space expanded). */
+    preview: string | null;
+    type: VectorGradientType | null;
+    spread: VectorGradientSpread;
+    interpolation: VectorGradientInterpolation;
+    smoothness: number;
+    strokeMode: VectorStrokeGradientMode;
+    /** The selected paths' gradients differ. */
+    mixed: boolean;
+}
+/** The gradient editor of the selection's fill or stroke (`state.gradientEdit.target`), or null with nothing selected. */
+declare function getVectorGradientEditor(state: Pick<VectorEditorState, 'document' | 'selection' | 'gradientEdit'>): VectorGradientEditorData | null;
 /** A path-editing button of the bundled toolbars. */
 interface VectorPathAction {
     id: 'join' | 'average' | 'cut' | 'clean' | 'smooth' | 'outline';
@@ -3267,7 +3841,7 @@ declare function vectorFillMap(doc: VectorDocument, gap?: number): PlanarMap | n
  *   pair turns the same way), so a nonzero fill keeps its holes.
  * - **In-betweens** follow the shapes' best-fit rotation and scale (Procrustes), with the
  *   leftover difference blended in linearly, so a turning shape turns instead of collapsing.
- * - **Paint**: colours mix in OKLab, gradients of one kind resample their stops to a common
+ * - **Paint**: colours mix in OKLab, gradients of one style resample their stops to a common
  *   set, a missing paint fades from transparent; stroke width, opacity, dashes, arrowhead
  *   scales and width profiles interpolate, and the rest switches halfway.
  * - **Transforms**: both shapes are blended in their parent's space; the in-between's rigid
@@ -3368,8 +3942,11 @@ declare function interpolateMorphContours(a: readonly VectorMorphContour[], b: r
 declare function interpolateRigidMatrix(a: AffineMatrix, b: AffineMatrix, t: number): AffineMatrix;
 /** Two colours mixed in OKLab (premultiplied alpha); unreadable colours switch halfway. */
 declare function interpolateVectorColor(a: string, b: string, t: number): string;
-/** A gradient's stops resampled at `offsets`, each painting what the gradient paints there. */
-declare function resampleGradientStops(g: CanvasGradientDef, offsets: readonly number[]): GradientStop[];
+/**
+ * A gradient's stops resampled at `offsets`, each painting what the gradient paints there (its
+ * midpoints, smoothness and interpolation space included).
+ */
+declare function resampleGradientStops(g: VectorGradient, offsets: readonly number[]): VectorGradientStop[];
 /**
  * Interpolates paints: colours in OKLab, gradients of one kind with their stops resampled to a
  * common set, a colour and a gradient through a gradient of that colour, and a missing paint
@@ -3561,4 +4138,15 @@ declare function repeatPaths(paths: readonly BezierPath[], r: VectorEffectParams
 /** The middle of the paths' bounds (the origin when they are empty). */
 declare function pathsCenter(paths: readonly BezierPath[]): Vec2;
 
-export { type AddVectorNodeOptions, AffineMatrix, DEFAULT_VECTOR_BLEND_DISTANCE, DEFAULT_VECTOR_BLEND_STEPS, DEFAULT_VECTOR_PATH_EDIT, DEFAULT_VECTOR_SNAP, IDENTITY_MATRIX, KAPPA, LazyMouse, type NearestSegment, type RecognizeInkOptions, SvgGradientDef, VECTOR_ARROWHEADS, VECTOR_ARROWHEAD_LABELS, VECTOR_BLEND_MAX_SMOOTH_STEPS, VECTOR_BLEND_MAX_STEPS, VECTOR_BLEND_SPACINGS, VECTOR_BLEND_SPACING_LABELS, VECTOR_BUILDER_HATCH_GAP, VECTOR_CLIPBOARD_TYPE, VECTOR_CONSTRUCTION_ANGLES, VECTOR_CORNER_KINDS, VECTOR_CORNER_KIND_LABELS, VECTOR_CORNER_WIDGET_INSET, VECTOR_EDIT_TOGGLES, VECTOR_EFFECT_DEFAULTS, VECTOR_EFFECT_LABELS, VECTOR_EFFECT_MENU, VECTOR_EFFECT_PARAM_SPECS, VECTOR_EFFECT_TYPES, VECTOR_FILL_GAP, VECTOR_INK_MAX_CORNERS, VECTOR_MERGE_MODES, VECTOR_OVERLAY_THEME, VECTOR_PATHFINDER_ACTIONS, VECTOR_PATHFINDER_LABELS, VECTOR_PATHFINDER_OPERATIONS, VECTOR_PATH_ACTIONS, VECTOR_PENCIL_STRING_PX, VECTOR_PRESSURE_NOMINAL, VECTOR_ROTATE_HANDLE_OFFSET, VECTOR_STROKE_ALIGN_LABELS, VECTOR_STYLE_KEYS, VECTOR_TOOLS, VECTOR_TOOL_GLYPHS, VECTOR_TOOL_SHORTCUTS, VECTOR_TRANSFORM_HANDLES, VECTOR_WIDTH_PRESETS, VECTOR_WIDTH_PRESET_IDS, VECTOR_WIDTH_PROFILE_MAX_POINTS, VECTOR_WIDTH_PROFILE_MAX_SCALE, VECTOR_WIDTH_SAME_T, type VariableStrokeOptions, type Vec2, type VectorActionResult, type VectorAlign, type VectorAnchor, type VectorAnchorRef, type VectorAnchorType, type VectorAppearanceShape, type VectorArrange, type VectorArrowAlign, type VectorArrowhead, type VectorArrowheadShape, type VectorAverageAxis, type VectorBlend, type VectorBlendControls, type VectorBlendInput, type VectorBlendOptions, type VectorBlendRail, type VectorBlendSpacing, type VectorBlendStart, type VectorBooleanOperand, type VectorBooleanOperation, type VectorBounds, type VectorBuilderHit, type VectorBuilderLinePiece, type VectorBuilderPreview, type VectorBuilderReplacement, type VectorBuilderTouched, type VectorCommandOptions, type VectorCorner, type VectorCornerInfo, type VectorCornerKind, type VectorCornerWidget, type VectorDefaults, type VectorDistribute, type VectorDocument, VectorEditorController, type VectorEditorOptions, type VectorEditorState, type VectorEffect, type VectorEffectParamSpec, type VectorEffectParamsMap, type VectorEffectType, type VectorEffectsPanelData, type VectorEffectsPanelItem, type VectorFillRule, type VectorGroupNode, type VectorGuideKind, type VectorGuideLabel, type VectorGuideLine, type VectorHandleRef, type VectorHitTestOptions, type VectorHover, type VectorInkShape, type VectorInteraction, type VectorKeyInput, type VectorLineCap, type VectorLineJoin, type VectorMatrix, type VectorMergeMode, type VectorModifiers, type VectorMorph, type VectorMorphContour, type VectorMorphCorrespondence, type VectorMorphOptions, type VectorNode, type VectorNodeListing, type VectorOverlayRenderData, type VectorPaint, type VectorPathAction, type VectorPathEditOptions, type VectorPathEntry, type VectorPathKeyframe, type VectorPathNode, type VectorPathfinderAction, type VectorPathfinderOperation, type VectorPathfinderPaint, type VectorPointSnap, type VectorPointerInput, type VectorRectSnap, type VectorRenderAnchor, type VectorRenderCornerWidget, type VectorRenderGroup, type VectorRenderGuideLabel, type VectorRenderGuideLine, type VectorRenderHandle, type VectorRenderNode, type VectorRenderPath, type VectorRenderStrokeParts, type VectorRenderWidthPoint, type VectorRepeaterCopy, type VectorScaleSnap, type VectorSceneRenderData, type VectorSegmentRef, type VectorSelectionBoxGeometry, type VectorSelectionFrame, type VectorSelectionStyle, type VectorShapeBuilderFace, type VectorShapeBuilderMap, type VectorShapeBuilderPlan, type VectorShapeBuilderResult, type VectorShapeInput, type VectorSnapGuides, type VectorSnapKind, type VectorSnapLeave, type VectorSnapOptions, VectorSnapTargets, type VectorStrokeAlign, type VectorStrokeParts, type VectorStrokeSpot, type VectorStyle, type VectorSubpath, type VectorSvgExportOptions, type VectorSvgImportOptions, type VectorTaperOptions, type VectorTool, type VectorTransformHandle, type VectorViewport, type VectorWaveOptions, type VectorWidthHandle, type VectorWidthPoint, type VectorWidthPointEdit, type VectorWidthPointRef, type VectorWidthPreset, type VectorWidthPresetInfo, activeVectorEffects, addBuilderHit, applyMatrix, applyMatrixLinear, applyVectorBlendOptions, applyVectorCornersAttribute, applyVectorEffects, arrowheadInset, arrowheadPath, arrowheadWeight, bendSegment, bezierToSubpaths, boundsFromPoints, boundsIntersect, clearVectorLiveBooleanCache, cloneAnchor, cloneSubpath, cloneVectorDocument, cloneVectorNode, collectPathNodes, constrainToLeave, convertAnchor, cornerBisectorPoint, cornerRadiusChange, cornerSetback, correspondMorphContours, createVectorCommands, createVectorEffect, createVectorMorph, curvatureMoveAnchor, cutSubpathAt, dashIntervals, decomposeRigid, effectPathLength, effectPathVertexCount, effectiveStrokeAlign, ellipseSubpath, eraseFromFill, eraseFromOutline, eraserRegion, evaluateVectorPathKeyframes, expandVectorAppearance, expandVectorAppearances, expandVectorBlend, expandVectorCorners, expandVectorCornersOf, findVectorNode, fitCornerRadius, foldVectorBooleanOperands, generateVectorBlendChildren, generateWidthProfile, getAnchor, getAnchorWorld, getEditablePathIds, getTransformHandlePositions, getVectorBlendControls, getVectorCornerWidgets, getVectorEffectsPanel, getVectorEnteredGroups, getVectorOverlayRenderData, getVectorSceneRenderData, getVectorSelectionBoxGeometry, getVectorSelectionFrame, getVectorSelectionStyle, getVectorWidthHandles, getVisibleAnchors, getVisibleHandles, hasOwnVectorAppearance, hasPaint, hasStrokeExtras, hasVectorAppearance, hasVectorCorners, hitTestVectorNode, hitTestVectorNodes, hitTestVectorStroke, inferAnchorType, insertAnchor, insertWidthPoint, interpolateMorphContours, interpolateRigidMatrix, interpolateVectorColor, interpolateVectorPaint, interpolateVectorPaths, interpolateVectorStyle, interpolateWidthProfiles, invertMatrix, isClosedBezierShape, isIdentityMatrix, isUniformWidthProfile, isVectorBlendGroup, isVectorLiveBoolean, isVectorTextTarget, joinSubpaths, knifePath, lineSubpath, locateVectorNode, matrixRotation, mergePaths, mirrorWidthProfile, morphContourToSubpath, morphPathsCross, moveAnchorHandle, multiplyMatrices, nearestSegment, nearestStrokePosition, nextVectorCornerKind, nodeMatrix, normalizeVectorEffectParams, offsetPaths, parseSvgTransform, parseVectorSvg, pathsCenter, planShapeBuilder, polygonSubpath, polylineBounds, pressureWidthProfile, puckerBloatPaths, recognizeInkShape, rectSubpath, refineMorphContour, refreshVectorBlends, releaseVectorBlend, removeAnchorKeepingShape, removeAnchors, removeAnchorsKeepingShape, removeRedundantPoints, removeWidthPoints, repeatPaths, resampleGradientStops, resolveVectorBlendOptions, reverseMorphContour, reverseSubpath, reverseWidthProfile, rotateMatrix, roundCornerPaths, roundSubpaths, samplePolyline, sanitizeVectorEffects, sanitizeWidthProfile, scaleFor, scaleMatrix, setAnchorCorner, setSubpathCorners, setWidthPoint, simplifyPolyline, smoothSubpath, splitIntoFaces, splitSubpathAt, starSubpath, strokePositionPoint, strokeWidthProfileOf, subpathEnclosesArea, subpathPointAt, subpathSegment, subpathSegmentCount, subpathToMorphContour, subpathsToBezier, taperWaveFactor, toVectorKeyInput, toVectorModifiers, toVectorPointerInput, transformVectorEffects, transformVectorNode, translateAnchor, translateMatrix, trimIntervals, trimPaths, trimPathsIndividually, turnMorphContour, twistPaths, unionBounds, variableStrokeOutline, variableStrokeRings, vectorAppearanceNodes, vectorAppearanceOutline, vectorAppearanceShapes, vectorBlendColorDistance, vectorBlendKeyTargets, vectorBlendKeys, vectorBlendRail, vectorBlendRailAt, vectorBlendSpine, vectorBlendStepCount, vectorBuilderErasedEdges, vectorCornerAt, vectorCorners, vectorCornersAttribute, vectorDiamondPath, vectorDocumentToSvg, vectorEnteredGroups, vectorFillMap, vectorInkShapeName, vectorLiveBooleanSteps, vectorNodeBounds, vectorNodeRotation, vectorNodeToBezier, vectorOperandOperation, vectorPaintToHex, vectorPaintToSvg, vectorParentMatrix, vectorPathData, vectorPathEntries, vectorPathWorldBezier, vectorPathfinderShape, vectorRepeaterCopies, vectorResizeCursor, vectorResultStyle, vectorShapeBuilderHit, vectorShapeBuilderMap, vectorStrokeLineArea, vectorStrokeOutline, vectorStrokeOutlinePath, vectorStrokeParts, vectorStrokeReach, vectorStrokeSvgParts, vectorStrokeWidthGeometry, vectorToolLabel, vectorWorldMatrix, walkVectorNodes, widthProfileAt, widthProfileFromAttribute, widthProfileMaxScale, widthProfilePreset, widthProfilePresetId, widthProfileToAttribute, wigglePaths, zigzagPaths };
+/**
+ * The paint server of a gradient along or across the stroke of `node` (in its own space): a
+ * pattern whose first def id is `id`. `area` defaults to the path's box padded by the stroke's
+ * reach.
+ */
+declare function vectorStrokeGradientDefs(g: VectorGradient, id: string, node: VectorPathNode, options?: {
+    bounds?: VectorBounds | null;
+    area?: VectorBounds | null;
+    precision?: number;
+}): VectorPaintDef[];
+
+export { type AddVectorNodeOptions, AffineMatrix, DEFAULT_VECTOR_BLEND_DISTANCE, DEFAULT_VECTOR_BLEND_STEPS, DEFAULT_VECTOR_PATH_EDIT, DEFAULT_VECTOR_SNAP, IDENTITY_MATRIX, KAPPA, LazyMouse, type NearestSegment, type RecognizeInkOptions, SvgGradientDef, VECTOR_ARROWHEADS, VECTOR_ARROWHEAD_LABELS, VECTOR_BLEND_MAX_SMOOTH_STEPS, VECTOR_BLEND_MAX_STEPS, VECTOR_BLEND_SPACINGS, VECTOR_BLEND_SPACING_LABELS, VECTOR_BUILDER_HATCH_GAP, VECTOR_CLIPBOARD_TYPE, VECTOR_CONSTRUCTION_ANGLES, VECTOR_CORNER_KINDS, VECTOR_CORNER_KIND_LABELS, VECTOR_CORNER_WIDGET_INSET, VECTOR_EDIT_TOGGLES, VECTOR_EFFECT_DEFAULTS, VECTOR_EFFECT_LABELS, VECTOR_EFFECT_MENU, VECTOR_EFFECT_PARAM_SPECS, VECTOR_EFFECT_TYPES, VECTOR_FILL_GAP, VECTOR_GRADIENT_INTERPOLATIONS, VECTOR_GRADIENT_INTERPOLATION_LABELS, VECTOR_GRADIENT_MAX_PERIODS, VECTOR_GRADIENT_MIDPOINT_GAP, VECTOR_GRADIENT_MIN_STOPS, VECTOR_GRADIENT_OFF_BAR, VECTOR_GRADIENT_SPREADS, VECTOR_GRADIENT_SPREAD_LABELS, VECTOR_GRADIENT_STOP_GAP, VECTOR_GRADIENT_TYPES, VECTOR_GRADIENT_TYPE_LABELS, VECTOR_INK_MAX_CORNERS, VECTOR_MERGE_MODES, VECTOR_OVERLAY_THEME, VECTOR_PATHFINDER_ACTIONS, VECTOR_PATHFINDER_LABELS, VECTOR_PATHFINDER_OPERATIONS, VECTOR_PATH_ACTIONS, VECTOR_PENCIL_STRING_PX, VECTOR_PRESSURE_NOMINAL, VECTOR_ROTATE_HANDLE_OFFSET, VECTOR_STROKE_ALIGN_LABELS, VECTOR_STROKE_GRADIENT_MODES, VECTOR_STROKE_GRADIENT_MODE_LABELS, VECTOR_STYLE_KEYS, VECTOR_TOOLS, VECTOR_TOOL_GLYPHS, VECTOR_TOOL_SHORTCUTS, VECTOR_TRANSFORM_HANDLES, VECTOR_WIDTH_PRESETS, VECTOR_WIDTH_PRESET_IDS, VECTOR_WIDTH_PROFILE_MAX_POINTS, VECTOR_WIDTH_PROFILE_MAX_SCALE, VECTOR_WIDTH_SAME_T, type VariableStrokeOptions, type Vec2, type VectorActionResult, type VectorAlign, type VectorAnchor, type VectorAnchorRef, type VectorAnchorType, type VectorAppearanceShape, type VectorArrange, type VectorArrowAlign, type VectorArrowhead, type VectorArrowheadShape, type VectorAverageAxis, type VectorBlend, type VectorBlendControls, type VectorBlendInput, type VectorBlendOptions, type VectorBlendRail, type VectorBlendSpacing, type VectorBlendStart, type VectorBooleanOperand, type VectorBooleanOperation, type VectorBounds, type VectorBuilderHit, type VectorBuilderLinePiece, type VectorBuilderPreview, type VectorBuilderReplacement, type VectorBuilderTouched, type VectorCommandOptions, type VectorCorner, type VectorCornerInfo, type VectorCornerKind, type VectorCornerWidget, type VectorDefaults, type VectorDistribute, type VectorDocument, VectorEditorController, type VectorEditorOptions, type VectorEditorState, type VectorEffect, type VectorEffectParamSpec, type VectorEffectParamsMap, type VectorEffectType, type VectorEffectsPanelData, type VectorEffectsPanelItem, type VectorFillRule, type VectorGradient, type VectorGradientAnnotator, type VectorGradientEditorData, type VectorGradientHandle, type VectorGradientInterpolation, type VectorGradientPart, type VectorGradientPatch, type VectorGradientPoints, type VectorGradientRamp, type VectorGradientSpread, type VectorGradientStop, type VectorGradientSvgOptions, type VectorGradientTarget, type VectorGradientType, type VectorGradientUnits, type VectorGroupNode, type VectorGuideKind, type VectorGuideLabel, type VectorGuideLine, type VectorHandleRef, type VectorHitTestOptions, type VectorHover, type VectorInkShape, type VectorInteraction, type VectorKeyInput, type VectorLineCap, type VectorLineJoin, type VectorMatrix, type VectorMergeMode, type VectorModifiers, type VectorMorph, type VectorMorphContour, type VectorMorphCorrespondence, type VectorMorphOptions, type VectorNode, type VectorNodeListing, type VectorOverlayRenderData, type VectorPaint, type VectorPaintDef, type VectorPaintSvgOptions, type VectorPathAction, type VectorPathEditOptions, type VectorPathEntry, type VectorPathKeyframe, type VectorPathNode, type VectorPathfinderAction, type VectorPathfinderOperation, type VectorPathfinderPaint, type VectorPointSnap, type VectorPointerInput, type VectorRectSnap, type VectorRenderAnchor, type VectorRenderCornerWidget, type VectorRenderGradientAnnotator, type VectorRenderGroup, type VectorRenderGuideLabel, type VectorRenderGuideLine, type VectorRenderHandle, type VectorRenderNode, type VectorRenderPath, type VectorRenderStrokeParts, type VectorRenderWidthPoint, type VectorRepeaterCopy, type VectorRgba, type VectorScaleSnap, type VectorSceneRenderData, type VectorSegmentRef, type VectorSelectionBoxGeometry, type VectorSelectionFrame, type VectorSelectionStyle, type VectorShapeBuilderFace, type VectorShapeBuilderMap, type VectorShapeBuilderPlan, type VectorShapeBuilderResult, type VectorShapeInput, type VectorSnapGuides, type VectorSnapKind, type VectorSnapLeave, type VectorSnapOptions, VectorSnapTargets, type VectorStrokeAlign, type VectorStrokeGradientMode, type VectorStrokeParts, type VectorStrokeSpot, type VectorStyle, type VectorSubpath, type VectorSvgExportOptions, type VectorSvgImportOptions, type VectorSvgPatternDef, type VectorTaperOptions, type VectorTool, type VectorTransformHandle, type VectorViewport, type VectorWaveOptions, type VectorWidthHandle, type VectorWidthPoint, type VectorWidthPointEdit, type VectorWidthPointRef, type VectorWidthPreset, type VectorWidthPresetInfo, activeVectorEffects, addBuilderHit, applyMatrix, applyMatrixLinear, applyVectorBlendOptions, applyVectorCornersAttribute, applyVectorEffects, applyVectorGradientPatch, applyVectorGradientSpread, arrowheadInset, arrowheadPath, arrowheadWeight, bendSegment, bezierToSubpaths, boundsFromPoints, boundsIntersect, clearVectorLiveBooleanCache, cloneAnchor, cloneSubpath, cloneVectorDocument, cloneVectorNode, collectPathNodes, constrainToLeave, convertAnchor, convertVectorGradient, cornerBisectorPoint, cornerRadiusChange, cornerSetback, correspondMorphContours, createVectorCommands, createVectorEffect, createVectorMorph, curvatureMoveAnchor, cutSubpathAt, dashIntervals, decomposeRigid, defaultVectorGradient, effectPathLength, effectPathVertexCount, effectiveStrokeAlign, ellipseSubpath, eraseFromFill, eraseFromOutline, eraserRegion, evaluateVectorPathKeyframes, expandVectorAppearance, expandVectorAppearances, expandVectorBlend, expandVectorCorners, expandVectorCornersOf, expandVectorGradientSpread, expandVectorGradientStops, explicitVectorGradient, findVectorNode, fitCornerRadius, foldVectorBooleanOperands, generateVectorBlendChildren, generateWidthProfile, getAnchor, getAnchorWorld, getEditablePathIds, getTransformHandlePositions, getVectorBlendControls, getVectorCornerWidgets, getVectorEffectsPanel, getVectorEnteredGroups, getVectorGradientAnnotator, getVectorGradientEditor, getVectorOverlayRenderData, getVectorSceneRenderData, getVectorSelectionBoxGeometry, getVectorSelectionFrame, getVectorSelectionStyle, getVectorWidthHandles, getVisibleAnchors, getVisibleHandles, gradientMidpointRemap, hasExplicitGradientGeometry, hasOwnVectorAppearance, hasPaint, hasStrokeExtras, hasVectorAppearance, hasVectorCorners, hitTestVectorNode, hitTestVectorNodes, hitTestVectorStroke, hitVectorGradientAnnotator, inferAnchorType, insertAnchor, insertVectorGradientStop, insertWidthPoint, interpolateMorphContours, interpolateRigidMatrix, interpolateVectorColor, interpolateVectorPaint, interpolateVectorPaths, interpolateVectorStyle, interpolateWidthProfiles, invertMatrix, isCentredVectorGradient, isClosedBezierShape, isIdentityMatrix, isUniformWidthProfile, isVectorBlendGroup, isVectorGradient, isVectorLiveBoolean, isVectorTextTarget, joinSubpaths, knifePath, lineSubpath, locateVectorNode, matrixRotation, mergePaths, mirrorWidthProfile, morphContourToSubpath, morphPathsCross, moveAnchorHandle, moveVectorGradientHandle, moveVectorGradientStop, multiplyMatrices, nearestSegment, nearestStrokePosition, nextVectorCornerKind, nodeMatrix, normalizeVectorEffectParams, offsetPaths, parseSvgTransform, parseVectorColor, parseVectorSvg, pathsCenter, patternAttrs, periodicVectorGradientStops, pinVectorGradient, planShapeBuilder, polygonSubpath, polylineBounds, pressureWidthProfile, puckerBloatPaths, recognizeInkShape, rectSubpath, refineMorphContour, refreshVectorBlends, releaseVectorBlend, removeAnchorKeepingShape, removeAnchors, removeAnchorsKeepingShape, removeRedundantPoints, removeVectorGradientStop, removeWidthPoints, repeatPaths, resampleGradientStops, resolveVectorBlendOptions, reverseMorphContour, reverseSubpath, reverseVectorGradient, reverseWidthProfile, rotateMatrix, roundCornerPaths, roundSubpaths, samplePlainStops, samplePolyline, sampleVectorGradient, sampleVectorGradientAt, sampleVectorPaintDefAt, sanitizeVectorEffects, sanitizeVectorGradient, sanitizeWidthProfile, scaleFor, scaleMatrix, setAnchorCorner, setSubpathCorners, setVectorGradientVector, setWidthPoint, simplifyPolyline, smoothSubpath, sortedVectorGradientStops, spanVectorGradientStops, splitIntoFaces, splitSubpathAt, starSubpath, strokePositionPoint, strokeWidthProfileOf, subpathEnclosesArea, subpathPointAt, subpathSegment, subpathSegmentCount, subpathToMorphContour, subpathsToBezier, taperWaveFactor, toVectorKeyInput, toVectorModifiers, toVectorPointerInput, transformVectorEffects, transformVectorGradient, transformVectorNode, transformVectorPaint, translateAnchor, translateMatrix, trimIntervals, trimPaths, trimPathsIndividually, turnMorphContour, twistPaths, unionBounds, variableStrokeOutline, variableStrokeRings, vectorAppearanceNodes, vectorAppearanceOutline, vectorAppearanceShapes, vectorBlendColorDistance, vectorBlendKeyTargets, vectorBlendKeys, vectorBlendRail, vectorBlendRailAt, vectorBlendSpine, vectorBlendStepCount, vectorBoxMatrix, vectorBuilderErasedEdges, vectorCornerAt, vectorCorners, vectorCornersAttribute, vectorDiamondPath, vectorDocumentToSvg, vectorEnteredGroups, vectorFillMap, vectorGradientArea, vectorGradientAspect, vectorGradientBarPosition, vectorGradientFocalParam, vectorGradientHandles, vectorGradientMatrix, vectorGradientMidpointFromPosition, vectorGradientMidpointPosition, vectorGradientNeedsExpansion, vectorGradientParam, vectorGradientPoints, vectorGradientRamp, vectorGradientSvgDefs, vectorGradientTAt, vectorGradientTargetPath, vectorGradientUnitsMatrix, vectorInkShapeName, vectorLiveBooleanSteps, vectorNodeBounds, vectorNodeRotation, vectorNodeToBezier, vectorOperandOperation, vectorPaintToHex, vectorPaintToSvg, vectorParentMatrix, vectorPathData, vectorPathEntries, vectorPathLocalBounds, vectorPathWorldBezier, vectorPathfinderShape, vectorRepeaterCopies, vectorResizeCursor, vectorResultStyle, vectorShapeBuilderHit, vectorShapeBuilderMap, vectorStrokeGradientDefs, vectorStrokeLineArea, vectorStrokeOutline, vectorStrokeOutlinePath, vectorStrokeParts, vectorStrokeReach, vectorStrokeSvgParts, vectorStrokeWidthGeometry, vectorToolLabel, vectorWorldMatrix, walkVectorNodes, widthProfileAt, widthProfileFromAttribute, widthProfileMaxScale, widthProfilePreset, widthProfilePresetId, widthProfileToAttribute, wigglePaths, zigzagPaths };