@pixerate/editor 0.124.0 → 0.125.0

package/dist/helpers-BBLlekuM.d.ts

@@ -0,0 +1,2009 @@
+import { J as JsonSchema, S as SchemaValidationError } from './schema-Di0CS6Pe.js';
+import { a as MotionBehavior } from './behavior-Ymbld6jL.js';
+import { b as AnimationEasing } from './easing-lM0Xo9Ni.js';
+import { b as AnimationLoopMode } from './evaluate-CfmT6xA3.js';
+import { C as CanvasGradientDef } from './gradient-KDfCvhuj.js';
+import { W as WarpStyle, a as WarpMesh } from './types-CwMPoRMU.js';
+
+/**
+ * Export to Flair (`@pixerate/flair`): a scene becomes an `SvgMotion` (one SVG plus a list of
+ * from → to changes on its elements), a catalog `VectorEffect`, or an `EffectDocument` for
+ * Flair's effect editor. The types are mirrored here so this package does not depend on Flair.
+ *
+ * Changes are exact where Flair can express them: a change with a linear, cubic-out or
+ * cubic-in-out curve (the editor's defaults) is one change, and so (Flair 0.36 and later) is
+ * one with any cubic-bezier curve, written as `[x1, y1, x2, y2]`. Anything else (springs,
+ * elastic, `hold`, morphs and live-effect tweens) is sampled at the
+ * scene's `fps` into short linear changes, which Flair plays the same way. Pulses, shakes,
+ * teeters, waves, wiggles and colour pulses are one change with a `behavior` (Flair 0.38).
+ *
+ * Reveals (`wipe`, `iris`, `split`) wrap their node in a group clipped through a rect or circle
+ * in the group's own box units (`clipPathUnits="objectBoundingBox"`), as Flair's
+ * `entrance.wipe` does, and animate the shape's attributes. A follow wraps its node in a group
+ * that Flair's `along` carries along a copy of the path in the node's parent's units (written
+ * in `<defs>`, so the path may be hidden or anywhere), turning with it for `orient`, as
+ * Flair's `path.follow` does.
+ */
+/** Flair's easing names. */
+type FlairEaseName = 'linear' | 'in-out' | 'out';
+/** Flair's spring ease (Flair 0.39 and later): the editor's spring, number for number. */
+interface FlairSpringEase {
+    spring: {
+        mass?: number;
+        stiffness?: number;
+        damping?: number;
+        velocity?: number;
+    };
+}
+/** A Flair easing: a name, (Flair 0.36 and later) a CSS cubic-bezier `[x1, y1, x2, y2]`, or (0.39) a spring. */
+type FlairEase = FlairEaseName | readonly [number, number, number, number] | FlairSpringEase;
+/** Flair's curves, for matching. */
+declare const FLAIR_EASES: Readonly<Record<FlairEaseName, (t: number) => number>>;
+/** One change of a Flair `SvgMotion` (mirrors `SvgAnimation` in `@pixerate/flair/vector`). */
+interface FlairSvgAnimation {
+    id?: string;
+    step?: number;
+    delay?: number;
+    ms?: number;
+    ease?: FlairEase;
+    attrs?: Record<string, readonly [string | number, string | number]>;
+    draw?: boolean | readonly [number, number];
+    /** Moves the element along a path (by id), from and to the fractions of its length in `at`. */
+    along?: string;
+    at?: readonly [number, number];
+    /** With `along`: turns the element with the path's direction. */
+    orient?: boolean;
+    /** Flair 0.38 and later: how the change swings from → to (see `MotionBehavior`). */
+    behavior?: MotionBehavior;
+    /** Flair 0.39 and later: stepped time, held on a grid of this many frames per second. */
+    strobe?: number;
+    /** Flair 0.39 and later: whole cycles to play (default 1); with `alternate`, every other one backwards. */
+    repeat?: number;
+    alternate?: boolean;
+    /** Flair features scenes do not have (imports skip them with a note). */
+    count?: readonly [number, number];
+    /** With `count`: how the number is written (Flair's number format) and to how many decimals. */
+    format?: string;
+    decimals?: number;
+    write?: string;
+    /** With `write`: the caret drawn while typing. */
+    caret?: string;
+    /** Flair's label for the change, e.g. `entrance.fade＠logo`; motion primitives set it to find their changes again. */
+    tag?: string;
+    scramble?: string;
+    solo?: number;
+    view?: readonly [number, number, number, number] | string;
+}
+/** Mirrors `SvgMotion` in `@pixerate/flair/vector`. */
+interface FlairSvgMotion {
+    svg: string;
+    animate?: FlairSvgAnimation[];
+}
+/** Mirrors Flair's catalog `VectorEffect` (`@pixerate/flair/catalog`). */
+interface FlairVectorEffect {
+    kind: 'vector';
+    id: string;
+    name: string;
+    description: string;
+    category: string;
+    tags: string[];
+    motion: FlairSvgMotion;
+    /** Values are `#rrggbb` strings, or `[r, g, b]` channels from 0 to 1 (Flair's catalog writes both); imports turn them into hex. */
+    presets?: {
+        name: string;
+        values: Record<string, string | readonly number[]>;
+    }[];
+    /** Ms on the last frame before looping. */
+    hold?: number;
+    trigger?: 'hover' | 'press' | 'click' | 'scroll';
+}
+/** Mirrors Flair's `EffectDocument` (`@pixerate/flair/editor`) for a vector effect. */
+interface FlairEffectDocument {
+    version: 1;
+    name: string;
+    effect: {
+        kind: 'vector';
+        motion: FlairSvgMotion;
+        hold?: number;
+    };
+    values: Record<string, string>;
+    tracks: Record<string, never>;
+    duration: number;
+    loop: boolean;
+    presets: {
+        name: string;
+        values: Record<string, string>;
+    }[];
+}
+interface FlairMotionExport {
+    motion: FlairSvgMotion;
+    /** The scene's length (ms). */
+    duration: number;
+    /** Ms after the last change (Flair's `hold`). */
+    hold: number;
+    /** Changes sampled into linear steps. */
+    sampled: number;
+    /** What could not be carried over, in sentences. */
+    notes: string[];
+    /** How the viewer plays it: pass to Flair's `SvgPlayer` as `{ trigger }` (from the scene's `trigger`). */
+    trigger?: MotionTrigger;
+}
+interface FlairExportOptions {
+    /**
+     * Play in answer to the viewer (default: the scene's `trigger`; null for none). With `click`
+     * shot n is Flair step n + 1: nothing plays until the first click, and each click plays the next shot.
+     */
+    trigger?: MotionTrigger | null;
+    /** Sampling rate for changes Flair cannot express exactly (default: the scene's `fps`, else 30). */
+    fps?: number;
+    /** Decimal places (default 3). */
+    precision?: number;
+    /**
+     * Write cubic-bezier easings (the `ease`, `ease-in`, `ease-out`, `ease-in-out`, `ease-in-back`
+     * and `ease-out-back` presets, and `{ type: 'cubic-bezier' }` curves) as one change with
+     * `ease: [x1, y1, x2, y2]` (default true). Needs Flair 0.36 or later; set false for older
+     * Flair, and they are sampled into linear steps.
+     */
+    curves?: boolean;
+    /**
+     * Write pulses, shakes, teeters, waves, wiggles and colour pulses as one change with a Flair
+     * `behavior` (default true), so they play exactly. Needs Flair 0.38 or later; set false for
+     * older Flair, and they are sampled into linear steps.
+     */
+    behaviors?: boolean;
+    /**
+     * The Flair version the export is for (default `0.39`): it decides what is written exactly
+     * and what is sampled. 0.36 adds cubic-bezier curves, 0.38 behaviours, 0.39 springs and
+     * stepped time (`strobe`). `curves` and `behaviors` override it.
+     */
+    flair?: string;
+}
+/** The Flair version exports target by default. */
+declare const FLAIR_EXPORT_VERSION = "0.39";
+/** Whether Flair `version` is at least `min` (dotted numbers). */
+declare function flairAtLeast(version: string, min: string): boolean;
+/** The Flair easing that matches `ease` (within 1% everywhere), if any. */
+declare function flairEaseFor(ease: AnimationEasing): FlairEaseName | undefined;
+/**
+ * The Flair easing for `ease`: a Flair name when one matches within 1%, else (with `curves`,
+ * the default) the curve's `[x1, y1, x2, y2]` when it is a cubic-bezier. Undefined for curves
+ * Flair cannot play (springs, elastic, `hold`), which are sampled.
+ */
+declare function flairCurveFor(ease: AnimationEasing, curves?: boolean): FlairEase | undefined;
+/** A scene as a Flair `SvgMotion`. */
+declare function toFlairSvgMotion(scene: MotionScene, options?: FlairExportOptions): FlairMotionExport;
+interface FlairEffectOptions extends FlairExportOptions {
+    /** Kebab-case id (default: the scene's name). */
+    id?: string;
+    name?: string;
+    description?: string;
+    /** Flair catalog category (default `icon`). */
+    category?: string;
+    tags?: string[];
+}
+/** A scene as a Flair catalog vector effect, with its colour controls and presets. */
+declare function toFlairVectorEffect(scene: MotionScene, options?: FlairEffectOptions): FlairVectorEffect;
+/** A scene as a document for Flair's `EffectEditor` (`replaceDocument`). */
+declare function toFlairEffectDocument(scene: MotionScene, options?: FlairExportOptions): FlairEffectDocument;
+
+/**
+ * The effects contract: how an editor finds, describes and renders effects that live in another
+ * package. This library ships no effects of its own here, only the shapes a provider fills in;
+ * a host passes a provider to an editor (`setEffectsProvider`) and the editor degrades to its
+ * old behaviour without one.
+ *
+ * Every time is in milliseconds. Pixels are straight-alpha RGBA rows, top to bottom.
+ */
+
+/** How an effect is drawn: a pixel shader, an animated vector picture, or motion applied to someone else's vector art. */
+type EffectKind = 'shader' | 'vector' | 'motion';
+/**
+ * What an effect is for. An effect may have several uses.
+ *
+ * - `filter`: changes an input picture (`inputs.source`).
+ * - `transition`: blends `inputs.from` into `inputs.to`; `progress` runs 0 → 1.
+ * - `generator`: draws a picture from nothing (a background, a texture).
+ * - `overlay`: draws something meant to sit over other content, usually with transparency.
+ * - `title`: draws type or a graphic meant as a title.
+ * - `motion`: animates vector art (`applyVectorEffect`).
+ * - `interactive`: reacts to pointer, scroll or audio input at run time.
+ */
+type EffectUse = 'filter' | 'transition' | 'generator' | 'overlay' | 'title' | 'motion' | 'interactive';
+declare const EFFECT_KINDS: readonly EffectKind[];
+declare const EFFECT_USES: readonly EffectUse[];
+/** One entry of a provider's catalog. */
+interface EffectSummary {
+    /** Stable id, saved in documents. Never reused for a different effect. */
+    id: string;
+    name: string;
+    kind: EffectKind;
+    /** The provider's own grouping (e.g. `gradient`, `light`, `transition`). */
+    category: string;
+    uses: readonly EffectUse[];
+    description?: string;
+    tags?: readonly string[];
+    /** True when the effect's output has transparent pixels (it can sit over other content). */
+    transparent: boolean;
+    /** True when the effect loops; its `duration` is then one cycle. */
+    loop: boolean;
+    /** Length of one play (ms). Absent for effects that do not change over time. */
+    duration?: number;
+}
+interface EffectSearchOptions {
+    kind?: EffectKind;
+    category?: string;
+    use?: EffectUse;
+    /** Most results to return. */
+    limit?: number;
+}
+/** One control value: a number, a `#rrggbb` colour or other string, a switch, or a vector of numbers. */
+type EffectValue = number | string | boolean | readonly number[];
+type EffectValues = Readonly<Record<string, EffectValue>>;
+/**
+ * The controls of an effect as a strict JSON Schema: `type: 'object'`, `additionalProperties:
+ * false`, and a `description` on every property (with units and range). `checkEffectProvider`
+ * checks this.
+ */
+type EffectControlSchema = JsonSchema & {
+    type: 'object';
+    properties: {
+        readonly [control: string]: JsonSchema;
+    };
+    additionalProperties: false;
+};
+interface EffectPreset {
+    name: string;
+    /** Values to apply over the defaults. */
+    values: EffectValues;
+}
+/**
+ * A named input the effect reads. Filters read `source`, transitions `from` and `to`; a mask is
+ * passed separately (`EffectRenderRequest.mask`), not as an input.
+ */
+interface EffectInputSpec {
+    name: string;
+    kind: 'image' | 'audio';
+    description: string;
+    required: boolean;
+}
+/** Everything an editor needs to show an effect's controls and render it. */
+interface EffectDescription extends EffectSummary {
+    controls: EffectControlSchema;
+    /** A value for every control. */
+    defaults: EffectValues;
+    presets: readonly EffectPreset[];
+    inputs: readonly EffectInputSpec[];
+}
+/**
+ * Pixels in and out of a renderer, shaped like `ImageData`.
+ *
+ * `data` is 8-bit sRGB with straight alpha and is always present. `float`, when present, is the
+ * same picture as 32-bit floats in **linear light** (sRGB primaries), straight alpha, where colour
+ * may exceed 1. Renderers created with `depth` 16 or 32 return `float` when the provider
+ * `supportsFloat`; `data` is then its clamped sRGB encoding.
+ */
+interface EffectPixels {
+    width: number;
+    height: number;
+    data: Uint8ClampedArray;
+    float?: Float32Array;
+}
+/**
+ * An input picture. Always accepted as `EffectPixels`; a provider whose capabilities include
+ * `supportsHostImages` also takes the host's own image objects, which saves a read back.
+ */
+type EffectImageSource = EffectPixels | ImageBitmap | OffscreenCanvas | VideoFrame;
+interface EffectRendererOptions {
+    /** Output size in pixels. */
+    width: number;
+    height: number;
+    /** Bits per channel of the target (default 8). 16 and 32 ask for `float` output. */
+    depth?: 8 | 16 | 32;
+}
+interface EffectRenderRequest {
+    /** Effect time (ms), from the start of the effect. */
+    time: number;
+    /** Control values; missing controls take their defaults. Invalid values reject with `EffectControlError`. */
+    values?: EffectValues;
+    /** Pictures for the effect's named inputs (see `EffectDescription.inputs`). */
+    inputs?: Readonly<Record<string, EffectImageSource>>;
+    /** Coverage (alpha channel, 0 = untouched) limiting where the effect applies. Only with `supportsMask`. */
+    mask?: EffectImageSource;
+    /** Transitions: how far from `from` to `to`, 0–1. Defaults to `time / duration`. */
+    progress?: number;
+}
+/** A live renderer for one effect at one size. Not safe for concurrent `render` calls. */
+interface EffectRenderer {
+    readonly effectId: string;
+    readonly width: number;
+    readonly height: number;
+    readonly depth: 8 | 16 | 32;
+    render(request: EffectRenderRequest): Promise<EffectPixels>;
+    /** Frees GPU or worker resources. Rendering afterwards rejects. */
+    dispose(): void;
+}
+/** One change of an animated SVG (the shape of Flair's `SvgAnimation`). */
+type EffectSvgAnimation = FlairSvgAnimation;
+/** An animated SVG: markup plus changes to its elements (the shape of Flair's `SvgMotion`). */
+interface EffectVectorMotion {
+    svg: string;
+    animate?: readonly EffectSvgAnimation[];
+    /** Length of one play (ms). */
+    duration: number;
+    loop: boolean;
+    /** Ms held on the last frame before looping. */
+    hold?: number;
+}
+/** What a vector or motion effect is applied to: SVG markup, optionally with the ids of the elements to animate (default: all). */
+type EffectVectorTarget = string | {
+    svg: string;
+    nodeIds?: readonly string[];
+};
+/** What a provider can do, so editors can degrade cleanly. */
+interface EffectProviderCapabilities {
+    /** Renders off the main thread. */
+    supportsWorker: boolean;
+    /** Returns `float` pixels for depth 16 and 32 renderers. */
+    supportsFloat: boolean;
+    /** Honours `EffectRenderRequest.mask`; otherwise the editor masks the result itself. */
+    supportsMask: boolean;
+    /** Takes `ImageBitmap`, `OffscreenCanvas` or `VideoFrame` inputs, not only `EffectPixels`. */
+    supportsHostImages: boolean;
+    /** Implements `applyVectorEffect`. */
+    supportsVector: boolean;
+    /** Largest width or height a renderer accepts (px). */
+    maxSize?: number;
+}
+type MaybePromise<T> = T | Promise<T>;
+/**
+ * A source of effects. Implementations live outside this library (for example Flair's
+ * `flairEffects()`); `createFakeEffectProvider` is a small reference implementation.
+ *
+ * Unknown ids reject or throw `UnknownEffectError`, invalid values `EffectControlError`, and an
+ * operation the provider cannot do `EffectUnsupportedError`.
+ */
+interface EffectProvider {
+    /** Stable id of the provider, saved next to effect ids (e.g. `flair`). */
+    readonly id: string;
+    readonly name: string;
+    readonly version?: string;
+    readonly capabilities: EffectProviderCapabilities;
+    list(options?: EffectSearchOptions): MaybePromise<readonly EffectSummary[]>;
+    /** Effects matching every word of `query` (in name, id, category, tags or description), best first. */
+    search(query: string, options?: EffectSearchOptions): MaybePromise<readonly EffectSummary[]>;
+    describe(id: string): MaybePromise<EffectDescription>;
+    /** A pixel renderer. A `vector` effect may refuse with `EffectUnsupportedError` where it cannot lay out SVG (a Worker). */
+    createRenderer(id: string, options: EffectRendererOptions): MaybePromise<EffectRenderer>;
+    /**
+     * Vector and motion effects as an animated SVG. Present when `capabilities.supportsVector`. A
+     * `motion` effect animates the target's elements (`nodeIds`, else each top-level element with an
+     * id); a `vector` effect brings its own picture and ignores the target. Refuse a target the
+     * effect cannot use with `EffectUnsupportedError`.
+     */
+    applyVectorEffect?(id: string, target: EffectVectorTarget, values?: EffectValues): MaybePromise<EffectVectorMotion>;
+}
+
+/** An affine matrix `[a, b, c, d, e, f]`: `x' = a·x + c·y + e`, `y' = b·x + d·y + f` (SVG order). */
+type VectorMatrix = readonly [number, number, number, number, number, number];
+/** A point in document coordinates. */
+interface Vec2 {
+    x: number;
+    y: number;
+}
+/**
+ * How an anchor's handles relate:
+ * - `corner`: handles move independently (or are absent).
+ * - `smooth`: handles stay on one line through the anchor, lengths independent.
+ * - `symmetric`: handles stay on one line with equal lengths.
+ */
+type VectorAnchorType = 'corner' | 'smooth' | 'symmetric';
+/**
+ * Live corner shapes: `round` (an arc tangent to both sides), `inverted` (an arc centred on
+ * the corner, cut into the shape) and `chamfer` (a straight bevel).
+ */
+type VectorCornerKind = 'round' | 'inverted' | 'chamfer';
+declare const VECTOR_CORNER_KINDS: readonly VectorCornerKind[];
+/**
+ * A live corner: drawn rounded (or cut) at render, hit-test, bounds, boolean, outline and export
+ * time while the stored anchor stays sharp. The radius shrinks to fit when the sides are short:
+ * the cut reaches at most halfway along each side.
+ */
+interface VectorCorner {
+    radius: number;
+    /** Default `round`. */
+    kind?: VectorCornerKind;
+    /**
+     * Corner smoothing (squircle, as in Figma and iOS), 0–1, round corners between straight sides
+     * only: the cut reaches (1 + smoothing) times as far along each side and eases into a shorter arc,
+     * so curvature builds up gradually. Default 0 (a circular arc).
+     */
+    smoothing?: number;
+}
+/**
+ * One anchor of a subpath. Handles are absolute document positions; a missing (or `null`)
+ * handle sits on the anchor, so a segment with no handles at either end is a straight line.
+ */
+interface VectorAnchor {
+    x: number;
+    y: number;
+    /** Control point of the segment arriving at this anchor. */
+    in?: Vec2 | null;
+    /** Control point of the segment leaving this anchor. */
+    out?: Vec2 | null;
+    /** Default `corner`. */
+    type?: VectorAnchorType;
+    /** Live corner radius. Ignored on smooth / symmetric anchors and the ends of open subpaths. */
+    corner?: VectorCorner | null;
+    /**
+     * A stable id, unique within its path, given when a constraint refers to the anchor (see
+     * `VectorConstraint`). Edits that move or restyle the anchor keep it; edits that rebuild a path
+     * drop it, and constraints on a dropped anchor are removed.
+     */
+    id?: string;
+}
+/** A chain of anchors joined by line or cubic Bézier segments. */
+interface VectorSubpath {
+    anchors: VectorAnchor[];
+    /** 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 | VectorGradient | VectorMeshGradient | VectorFreeformGradient | CanvasGradientDef | null;
+/**
+ * A gradient mesh (Illustrator's Gradient Mesh, PDF shading types 6 and 7): a lattice of
+ * `(rows + 1) × (columns + 1)` points in the node's own space, row by row, each with a colour.
+ * Each cell is a smooth patch whose sides are curves through the lattice and whose colour blends
+ * between its four corners. Outside the patches the paint is transparent.
+ */
+interface VectorMeshGradient {
+    type: 'mesh';
+    rows: number;
+    columns: number;
+    /** Lattice points, row by row (`(rows + 1) × (columns + 1)` of them). */
+    points: Vec2[];
+    /** A CSS colour per point. */
+    colors: string[];
+    /** Opacity per point (0–1, default 1 each). */
+    opacities?: number[];
+}
+/** One colour point of a freeform gradient. */
+interface VectorFreeformPoint {
+    x: number;
+    y: number;
+    color: string;
+    /** 0–1, default 1. */
+    opacity?: number;
+    /** Radius of the disc of pure colour round the point, as a fraction of half the box's longer side (0–1, default 0). */
+    spread?: number;
+}
+/**
+ * A freeform gradient (Illustrator's Freeform Gradient): colour points placed anywhere in the
+ * node's own space, blended across the shape by distance, and optional smooth lines through some
+ * of them that carry their colours along their length.
+ */
+interface VectorFreeformGradient {
+    type: 'freeform';
+    points: VectorFreeformPoint[];
+    /** Each line runs smoothly through the points at these indices, in order. */
+    lines?: number[][];
+}
+type VectorFillRule = 'nonzero' | 'evenodd';
+type VectorLineCap = 'butt' | 'round' | 'square';
+type VectorLineJoin = 'miter' | 'round' | 'bevel';
+/**
+ * Where the stroke sits on the outline: centred on it, inside the shape or outside it. Only
+ * shapes whose subpaths are all closed have an inside; open paths always stroke centred.
+ */
+type VectorStrokeAlign = 'center' | 'inside' | 'outside';
+/** Arrowheads and end markers for the ends of open paths. */
+type VectorArrowhead = 'triangle' | 'arrow' | 'open' | 'circle' | 'square' | 'bar';
+declare const VECTOR_ARROWHEADS: readonly VectorArrowhead[];
+/**
+ * `extend`: the head's tip sits past the end point and the path keeps its length; `tip`: the
+ * tip sits on the end point and the stroke is shortened under the head.
+ */
+type VectorArrowAlign = 'extend' | 'tip';
+/**
+ * One point of a variable-width stroke profile. `t` is the position along the subpath by
+ * length (0 at its start, 1 at its end); `left` and `right` are how far the stroke reaches on
+ * each side, as multiples of half the stroke width (looking along the path on screen, y down).
+ * A uniform stroke has 1 on both sides. Two points at the same `t` make a step.
+ */
+interface VectorWidthPoint {
+    t: number;
+    left: number;
+    right: number;
+}
+/**
+ * Blend modes of paint layers and nodes: the set SVG and CSS `mix-blend-mode` draw, named as the
+ * image editor names them (`@pixerate/editor/image-editor` `BlendMode`). `linear-dodge` draws as
+ * CSS `plus-lighter`. The image editor's other modes (linear burn, vivid light, pigment, …) have
+ * no SVG equivalent and are not offered.
+ */
+type VectorBlendMode = 'normal' | 'darken' | 'multiply' | 'color-burn' | 'lighten' | 'screen' | 'color-dodge' | 'linear-dodge' | 'overlay' | 'soft-light' | 'hard-light' | 'difference' | 'exclusion' | 'hue' | 'saturation' | 'color' | 'luminosity';
+/** Every vector blend mode, in the image editor's (Photoshop's) menu order. */
+declare const VECTOR_BLEND_MODES: readonly VectorBlendMode[];
+/** One fill of a path's fill stack (`VectorStyle.fills`). */
+interface VectorPaintLayer {
+    /** A colour, a gradient, or `null` for none. */
+    paint: VectorPaint;
+    /** 0–1, default 1. Multiplies the paint's own alpha. */
+    opacity?: number;
+    /** How the layer mixes with what is under it (the layers below, then the backdrop). Default `normal`. */
+    blendMode?: VectorBlendMode;
+    /** Hidden layers are kept but not drawn or hit. Default true. */
+    visible?: boolean;
+}
+/** The settings each stroke layer has of its own (the stroke shorthand fields of `VectorStyle`). */
+type VectorStrokeSettings = Pick<VectorStyle, 'strokeWidth' | 'strokeLinecap' | 'strokeLinejoin' | 'strokeDasharray' | 'strokeAlign' | 'startArrow' | 'endArrow' | 'arrowAlign' | 'startArrowScale' | 'endArrowScale' | 'strokeWidthProfile'>;
+/**
+ * What a stroke layer draws. Only `paint` (a paint along the outline, the default) exists today.
+ * Other kinds are the extension point for strokes drawn some other way, such as a raster
+ * brushstroke from `@pixerate/editor/paint` laid along the path: a layer with an unknown kind is
+ * kept through edits, load and SVG round trips, listed to agents, and skipped when drawing and
+ * hit-testing.
+ */
+type VectorStrokeLayerKind = 'paint';
+/** One stroke of a path's stroke stack (`VectorStyle.strokes`): a paint plus its own stroke settings. */
+interface VectorStrokeLayer extends VectorPaintLayer, VectorStrokeSettings {
+    /** Default `paint`. See `VectorStrokeLayerKind`. */
+    kind?: VectorStrokeLayerKind;
+}
+/** Paint and stroke settings of a path. */
+interface VectorStyle {
+    fill?: VectorPaint;
+    stroke?: VectorPaint;
+    /** Default 1. */
+    strokeWidth?: number;
+    strokeLinecap?: VectorLineCap;
+    strokeLinejoin?: VectorLineJoin;
+    strokeDasharray?: number[];
+    /** Default `nonzero`. */
+    fillRule?: VectorFillRule;
+    /** Default `center`. */
+    strokeAlign?: VectorStrokeAlign;
+    /** Head at the start of the first subpath when it is open, or none. */
+    startArrow?: VectorArrowhead | null;
+    /** Head at the end of the last subpath when it is open, or none. */
+    endArrow?: VectorArrowhead | null;
+    /** Default `extend`. */
+    arrowAlign?: VectorArrowAlign;
+    /** Size of the start head as a multiple of the stroke width (default 1: a head 4 widths long). */
+    startArrowScale?: number;
+    /** Size of the end head (default 1). */
+    endArrowScale?: number;
+    /**
+     * Variable width: side scales along each subpath, interpolated with a monotone cubic (see
+     * `widthProfileAt`). Absent, empty or `null` strokes at a uniform width. A profiled stroke is
+     * drawn as its filled outline.
+     */
+    strokeWidthProfile?: VectorWidthPoint[] | null;
+    /**
+     * The fill stack, bottom to top. Absent: `fill` alone is the stack (one layer, or none without
+     * a paint). Present: it is the truth, and `fill` mirrors its top layer's paint. The shorthand
+     * stays writable: setting `fill` to a paint repaints the top layer, `null` clears the stack.
+     * Stacks of one plain layer (full opacity, `normal`, visible) are stored as the shorthand.
+     */
+    fills?: VectorPaintLayer[] | null;
+    /**
+     * The stroke stack, bottom to top, drawn over every fill. Like `fills`: absent, `stroke` and the
+     * stroke settings above are the one stroke; present, they mirror its top layer, and writing them
+     * edits that layer (`stroke: null` clears the stack).
+     */
+    strokes?: VectorStrokeLayer[] | null;
+}
+interface VectorNodeBase {
+    id: string;
+    name?: string;
+    /** Default true. */
+    visible?: boolean;
+    /** Locked nodes are drawn but cannot be picked or edited on the canvas. */
+    locked?: boolean;
+    /** 0–1, default 1. */
+    opacity?: number;
+    /**
+     * Placement in the parent's space: a rigid matrix (rotation + translation). Anchors and
+     * children are in the node's own space. Omitted for unrotated nodes, whose positions are
+     * stored directly. Scale and skew are never stored here — `transformVectorNode` bakes
+     * them into the geometry, so stroke widths and the rotated selection box stay exact.
+     */
+    transform?: VectorMatrix;
+    /**
+     * An in-between a blend group generated from its keys. Steps are rebuilt whenever a key or
+     * the blend options change, and are locked (clicks select the blend group).
+     */
+    blendStep?: boolean;
+    /**
+     * Live path effects, applied top to bottom: each acts on every path above it (the node's own
+     * outline, or a group's children, then the result of the effects before it), and effects after a
+     * repeater act on its copies. The stored anchors and children never change.
+     */
+    effects?: VectorEffect[] | null;
+    /**
+     * As an operand of a live boolean group: how it combines with the result of the operands below
+     * it. Absent: the group's `liveBoolean` operation.
+     */
+    booleanOperation?: VectorBooleanOperation | null;
+    /** How the whole node (all its paint, filters included) mixes with what is under it. Default `normal`. */
+    blendMode?: VectorBlendMode;
+    /**
+     * Visual filters (drop and inner shadows, glows, blurs, feather), applied to everything the
+     * node draws. Unlike path `effects` they never change geometry: bounds, hit-testing and
+     * booleans ignore them.
+     */
+    filters?: VectorFilter[] | null;
+    /**
+     * How the node follows its frame when the frame is resized (`VectorGroupNode.frame`): per
+     * axis, pinned to the start (default `left` / `top`), the end, both (it stretches), the centre,
+     * or scaled with the frame. Ignored outside frames.
+     */
+    resizing?: VectorResizing | null;
+}
+/** Horizontal resizing constraint of a frame's child (see `VectorNodeBase.resizing`). */
+type VectorHorizontalResizing = 'left' | 'right' | 'leftRight' | 'center' | 'scale';
+/** Vertical resizing constraint of a frame's child (see `VectorNodeBase.resizing`). */
+type VectorVerticalResizing = 'top' | 'bottom' | 'topBottom' | 'center' | 'scale';
+declare const VECTOR_HORIZONTAL_RESIZING: readonly VectorHorizontalResizing[];
+declare const VECTOR_VERTICAL_RESIZING: readonly VectorVerticalResizing[];
+/** A frame child's resizing constraints (Figma's "constraints"). */
+interface VectorResizing {
+    /** Default `left`. */
+    horizontal?: VectorHorizontalResizing;
+    /** Default `top`. */
+    vertical?: VectorVerticalResizing;
+}
+/**
+ * Makes a group a frame (an artboard when top-level): a rectangle in the group's own space with an
+ * optional fill drawn below the children, which by default it clips. Resizing the frame moves and
+ * resizes its children by their `resizing` constraints instead of scaling them.
+ */
+interface VectorFrame {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    /** The frame's background, drawn below its children (default none). */
+    fill?: VectorPaint;
+    /** Clip the children to the frame (default true). */
+    clip?: boolean;
+}
+/** A shape made of one or more subpaths (holes and compound shapes included). */
+interface VectorPathNode extends VectorNodeBase, VectorStyle {
+    type: 'path';
+    subpaths: VectorSubpath[];
+    /**
+     * Makes the path a connector: an open line whose ends may be glued to other objects'
+     * connection sites. Its geometry is routed again after every edit, so it follows them.
+     */
+    connector?: VectorConnector | null;
+}
+/**
+ * Where a connector end meets an object: the middle of a side of the object's own (unrotated)
+ * bounds, its centre, or `auto` (the side facing the connector's other end, chosen on every route).
+ */
+type VectorConnectorSide = 'top' | 'right' | 'bottom' | 'left' | 'center' | 'auto';
+declare const VECTOR_CONNECTOR_SIDES: readonly VectorConnectorSide[];
+/** How a connector runs between its ends: a straight line, right-angled elbows or an S-curve. */
+type VectorConnectorRoute = 'straight' | 'elbow' | 'curved';
+declare const VECTOR_CONNECTOR_ROUTES: readonly VectorConnectorRoute[];
+/** A glued connector end. */
+interface VectorConnectorEnd {
+    nodeId: string;
+    /** Default `auto`. */
+    side?: VectorConnectorSide;
+}
+/** A connector's settings (`VectorPathNode.connector`). An end that is not glued stays where it is. */
+interface VectorConnector {
+    start?: VectorConnectorEnd | null;
+    end?: VectorConnectorEnd | null;
+    /** Default `straight`. */
+    route?: VectorConnectorRoute;
+    /** Corner radius of an elbow route's bends (document units, default 0). */
+    radius?: number;
+    /** How far an elbow or curve leaves a glued end straight out of its side before turning (document units, default 16). */
+    gap?: number;
+}
+/**
+ * How a blend spaces its in-betweens: a number of `steps` between each pair of keys, a fixed
+ * `distance` between steps along the spine, or `smoothColor` (as many steps as the colours
+ * need for a smooth ramp; by distance when the colours match).
+ */
+type VectorBlendSpacing = 'steps' | 'distance' | 'smoothColor';
+declare const VECTOR_BLEND_SPACINGS: readonly VectorBlendSpacing[];
+/** Settings of a blend. */
+interface VectorBlendOptions {
+    /** Default `steps`. */
+    spacing?: VectorBlendSpacing;
+    /** Steps between each pair of keys with `steps` spacing (default 5). */
+    steps?: number;
+    /** Distance between steps along the spine with `distance` spacing (default 20). */
+    distance?: number;
+    /** Turn the steps with the spine's direction (default `false`: they keep the keys' orientation). */
+    orientToSpine?: boolean;
+    /** Move anchors in straight lines instead of the rotation-aware morph (default `false`). */
+    linear?: boolean;
+}
+/** A live blend: the group's keys plus how the in-betweens are made and laid out. */
+interface VectorBlend extends VectorBlendOptions {
+    /**
+     * A replaced spine in the group's space: the steps follow it instead of the straight lines
+     * between the keys' centres (the keys sit along it, spread evenly by arc length).
+     */
+    spine?: VectorSubpath | null;
+    /** The anchor of each key's first subpath its blend starts from, by key id (the Blend tool's clicks). */
+    starts?: Record<string, number>;
+}
+/**
+ * How a mask group's mask (its first, bottom child) hides the rest: `clip` (a clipping mask: the
+ * mask's outline, fully opaque; its paint is not drawn), `alpha` (an opacity mask by the mask's
+ * drawn alpha: soft edges, gradients and opacity count) or `luminance` (by its brightness times
+ * its alpha: white shows, black hides).
+ */
+type VectorMaskType = 'clip' | 'alpha' | 'luminance';
+declare const VECTOR_MASK_TYPES: readonly VectorMaskType[];
+/** A group's mask settings (`VectorGroupNode.mask`). */
+interface VectorMask {
+    type: VectorMaskType;
+    /** Show the contents where the mask hides them and hide them where it shows them. Default false. */
+    invert?: boolean;
+}
+/** A group of nodes that select and transform together. */
+/**
+ * A group drawn by a provider vector effect (see `@pixerate/editor/effects`): its children are the
+ * effect's picture, made again when its values change. Kept as plain shapes without a provider.
+ */
+interface VectorProviderEffect {
+    /** The provider's effect id. */
+    effect: string;
+    provider?: string;
+    name?: string;
+    /** Control values (over the effect's defaults). */
+    values: Record<string, number | string | boolean | readonly number[]>;
+}
+interface VectorGroupNode extends VectorNodeBase {
+    type: 'group';
+    children: VectorNode[];
+    /** The provider vector effect this group shows (see `VectorProviderEffect`). */
+    providerEffect?: VectorProviderEffect | null;
+    /**
+     * Makes the group a live blend: its children that are not `blendStep`s are the keys, in
+     * stacking order, and the steps between them are regenerated whenever a key changes.
+     */
+    blend?: VectorBlend | null;
+    /**
+     * Makes the group a live boolean: its children stay editable operands, folded bottom to top
+     * (each by its own `booleanOperation` or this one), and the group draws as the result in the
+     * bottom operand's style.
+     */
+    liveBoolean?: VectorBooleanOperation | null;
+    /**
+     * Makes the group a mask group: its first (bottom) child is the mask and the children above it
+     * show only where the mask lets them (see `VectorMaskType`). Hit-testing, bounds, snapping and
+     * booleans use the masked result. A hidden mask child turns the mask off (the contents draw
+     * whole). The group's own opacity, blend mode and filters apply to the masked result, and its
+     * path effects to the contents (not the mask). Ignored on blends and live booleans.
+     */
+    mask?: VectorMask | null;
+    /**
+     * Makes the group a frame (see `VectorFrame`): it draws its fill below the children, clips them,
+     * selects and snaps by its rectangle, and lays its children out by their `resizing` constraints
+     * when resized. Ignored on blends, live booleans and mask groups.
+     */
+    frame?: VectorFrame | null;
+    /**
+     * Makes the group a live symmetry group: it draws its children and their mirrored (or rotated)
+     * copies, regenerated whenever a child changes. Ignored on blends, live booleans, mask groups
+     * and frames.
+     */
+    symmetry?: VectorSymmetry | null;
+}
+/**
+ * How a symmetry group repeats its children: mirrored across a `vertical`, `horizontal` or
+ * `diagonal` axis, across both axes (`dual`: four quarters), or `radial`ly round the centre
+ * (`copies` turns, each mirrored too with `mirror`, like a kaleidoscope).
+ */
+type VectorSymmetryMode = 'vertical' | 'horizontal' | 'dual' | 'diagonal' | 'radial';
+declare const VECTOR_SYMMETRY_MODES: readonly VectorSymmetryMode[];
+/** A symmetry group's settings (`VectorGroupNode.symmetry`). */
+interface VectorSymmetry {
+    mode: VectorSymmetryMode;
+    /** Where the axes cross (the group's own space). */
+    center: Vec2;
+    /** Turn of the axes, degrees clockwise (default 0). */
+    rotation?: number;
+    /** Radial: how many turns round the circle (2–64, default 6). */
+    copies?: number;
+    /** Radial: mirror each turn too (default false). */
+    mirror?: boolean;
+}
+/**
+ * The character style of text (a font and how it is set). Sizes are document units; `tracking` is in
+ * 1/1000 em. Paint comes from the node's fills and strokes (and a run's own `fill`).
+ */
+interface VectorCharacterStyle {
+    /** Family name ("Inter"); a family the shaper lacks draws in a fallback and is listed as missing. */
+    fontFamily: string;
+    /** CSS weight, 1–1000 (400 regular, 700 bold). */
+    fontWeight: number;
+    /** Default false. */
+    italic?: boolean;
+    fontSize: number;
+    /** Letter spacing in 1/1000 em (default 0). */
+    tracking?: number;
+    /** Baseline-to-baseline distance; absent: auto (`autoLeading` × size). */
+    leading?: number;
+    /** Raises (positive) or lowers the text (default 0). */
+    baselineShift?: number;
+    underline?: boolean;
+    strikethrough?: boolean;
+}
+/** Character style fields a run can set over the node's own style, plus its own fill. */
+type VectorTextRunStyle = Partial<VectorCharacterStyle> & {
+    /** The run's fill: replaces the paint of the node's top fill for these characters. */
+    fill?: VectorPaint;
+};
+/** A style over `length` UTF-16 code units of the text, in order. */
+interface VectorTextRun {
+    length: number;
+    style: VectorTextRunStyle;
+}
+type VectorTextAlign = 'left' | 'center' | 'right' | 'justify';
+declare const VECTOR_TEXT_ALIGNS: readonly VectorTextAlign[];
+/** Paragraph settings of a text node (all its paragraphs). Lengths in document units. */
+interface VectorParagraphStyle {
+    /** Default `left`. `justify` stretches every line of area text but a paragraph's last; on a path it spreads the text over the path. */
+    align?: VectorTextAlign;
+    /** Auto leading as a multiple of the font size (default 1.2). */
+    autoLeading?: number;
+    firstLineIndent?: number;
+    startIndent?: number;
+    endIndent?: number;
+    spaceBefore?: number;
+    spaceAfter?: number;
+}
+/** Where text on a path sits across the path: its baseline, ascender, descender or centre on the line. */
+type VectorPathTextBaseline = 'baseline' | 'ascender' | 'descender' | 'center';
+declare const VECTOR_PATH_TEXT_BASELINES: readonly VectorPathTextBaseline[];
+/**
+ * Where a text node's text goes, in the node's own space:
+ * - `point`: one line per paragraph, the first baseline starting at (`x`, `y`);
+ * - `area`: lines wrapped inside the box at (`x`, `y`) of `width` × `height` (lines that do not fit
+ *   are hidden: the text overflows);
+ * - `path`: one line set along `path` (paragraph breaks become spaces), from `start` to `end`
+ *   (distances from the path's ends), turned with the path (`orientation: 'rotate'`) or upright.
+ *   `flip` runs the text the other way, on the other side.
+ */
+type VectorTextFrame = {
+    kind: 'point';
+    x: number;
+    y: number;
+} | {
+    kind: 'area';
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+} | {
+    kind: 'path';
+    path: VectorSubpath;
+    /** Margin from the path's start (default 0). */
+    start?: number;
+    /** Margin from the path's end (default 0). */
+    end?: number;
+    flip?: boolean;
+    /** Default `rotate`. */
+    orientation?: 'rotate' | 'upright';
+    /** Default `baseline`. */
+    baseline?: VectorPathTextBaseline;
+};
+/**
+ * Text: a string with a character style, optional styled runs and a paragraph style, set in a
+ * frame. It paints with the node's fills and strokes like a path. Layout and glyphs come from the
+ * editor's text shaper (`setVectorTextShaper`); with an outline shaper the text draws as glyph
+ * outlines (so path effects, envelopes, booleans and Create Outlines work), otherwise as SVG text.
+ */
+interface VectorTextNode extends VectorNodeBase, VectorStyle {
+    type: 'text';
+    text: string;
+    /** The base character style. */
+    font: VectorCharacterStyle;
+    /** Runs over the text, each overriding some fields of `font` (absent: one style throughout). */
+    runs?: VectorTextRun[] | null;
+    paragraph?: VectorParagraphStyle | null;
+    frame: VectorTextFrame;
+}
+/**
+ * Per-instance changes to a symbol's art: every fill and / or stroke of the art painted with one
+ * paint (a tint), and art nodes (by their id in the symbol) hidden.
+ */
+interface VectorInstanceOverrides {
+    fill?: VectorPaint;
+    stroke?: VectorPaint;
+    /** Ids of nodes of the symbol's art (top-level or nested) not drawn in this instance. */
+    hidden?: string[];
+}
+/**
+ * A placed copy of a symbol (`VectorDocument.symbols`): it draws the symbol's art through its
+ * `transform`, which, unlike other nodes', may scale and skew. Editing the symbol changes every
+ * instance.
+ */
+interface VectorInstanceNode extends VectorNodeBase {
+    type: 'instance';
+    symbolId: string;
+    /** Strokes (and other lengths of the art's paint) scale with the instance (default true, as in Illustrator). */
+    scaleStrokes?: boolean;
+    overrides?: VectorInstanceOverrides | null;
+    /**
+     * The symbol's art, resolved by the editor (the same array as the symbol's `nodes`). Not part of
+     * the stored document: `VectorEditorController.toJSON` and SVG export leave it out, and loading
+     * resolves it again (`resolveVectorSymbols`).
+     */
+    art?: VectorNode[];
+}
+type VectorNode = VectorPathNode | VectorGroupNode | VectorTextNode | VectorInstanceNode;
+/** A symbol: reusable art its instances draw. */
+interface VectorSymbol {
+    id: string;
+    name: string;
+    /** The art, bottom to top, in the symbol's own space (its origin is the registration point instances are placed by). */
+    nodes: VectorNode[];
+}
+/** A vector drawing: an artboard and its nodes, bottom to top. */
+interface VectorDocument {
+    width: number;
+    height: number;
+    /** Artboard colour (default: transparent). */
+    background?: string;
+    nodes: VectorNode[];
+    /** Symbols the document's instances draw (see `VectorInstanceNode`). */
+    symbols?: VectorSymbol[];
+    /** Constraints between anchors, segments and circles, solved after every edit. */
+    constraints?: VectorConstraint[];
+    /** Named values the constraints' expressions use. */
+    parameters?: VectorParameter[];
+}
+/**
+ * Constraint kinds (CAD-style parametric drawing). Geometric: `coincident` (two points, a point on
+ * a segment's line, or a point on a circle), `collinear` (two segments on one line), `concentric`
+ * (two circles, or a circle's centre on a point), `fix`, `parallel`, `perpendicular`, `horizontal`
+ * / `vertical` (a segment, or two points level), `tangent` (a segment and a circle, two circles, or
+ * G1 at an anchor: its handles in line), `smooth` (G2 at an anchor: G1 and equal curvature),
+ * `symmetric` (two points about a segment's line) and `equal` (segment lengths or radii).
+ * Dimensional (with a `value`): `distance`, `angle` (degrees), `radius` and `diameter`.
+ */
+type VectorConstraintKind = 'coincident' | 'collinear' | 'concentric' | 'fix' | 'parallel' | 'perpendicular' | 'horizontal' | 'vertical' | 'tangent' | 'smooth' | 'symmetric' | 'equal' | 'distance' | 'angle' | 'radius' | 'diameter';
+declare const VECTOR_CONSTRAINT_KINDS: readonly VectorConstraintKind[];
+/**
+ * What a constraint refers to: an anchor of a path (by its stable `id`), one of the anchor's
+ * handles, the segment from the anchor to the next one, or (no `anchor`) a whole path as a circle
+ * (its centre and radius, for closed round paths).
+ */
+interface VectorGeomRef {
+    nodeId: string;
+    /** The anchor's `id` (see `VectorAnchor.id`). */
+    anchor?: string;
+    /** With `anchor`: the handle instead of the anchor point. */
+    handle?: 'in' | 'out';
+    /** With `anchor`: the segment from it to the next anchor. */
+    segment?: boolean;
+    /** Without `anchor`: the path as a circle. */
+    circle?: boolean;
+}
+/** A constraint kept by the document and solved after every edit. */
+interface VectorConstraint {
+    id: string;
+    kind: VectorConstraintKind;
+    refs: VectorGeomRef[];
+    /** Dimensional constraints: the value as an expression (document units, degrees for angles), e.g. `"40"` or `"w / 2"`. */
+    value?: string;
+    /** Dimensional constraints: a name other expressions can use (`d1`, `ang2`). */
+    name?: string;
+    /** `distance`: measured along the line between (default), or only horizontally or vertically. */
+    axis?: 'aligned' | 'horizontal' | 'vertical';
+}
+/** A named value constraints' expressions can use. */
+interface VectorParameter {
+    name: string;
+    /** An expression (numbers, other names, `+ - * /`, parentheses, `pi`). */
+    value: string;
+    description?: string;
+}
+/** An axis-aligned rectangle. */
+interface VectorBounds {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/** Identifies one anchor of a path node. */
+interface VectorAnchorRef {
+    nodeId: string;
+    subpath: number;
+    index: number;
+}
+/** Identifies one handle of an anchor. */
+interface VectorHandleRef extends VectorAnchorRef {
+    handle: 'in' | 'out';
+}
+/**
+ * Canvas tools. `direct` edits anchors, handles and segments; the shape tools drag out a new
+ * shape; `scissors` cuts a path at a point, `knife` cuts filled shapes along a freehand stroke,
+ * `eraser` rubs out the area under one and `width` drags a stroke's width at a point.
+ * `shapeBuilder` merges (Alt: deletes) the faces the selected shapes make, and `paintBucket`
+ * fills the region the visible outlines enclose around a click with a new shape. `blend`
+ * blends the shape clicked first into the one clicked next (clicking an anchor of a closed path
+ * starts the blend there). `envelope` edits the mesh of the selection's envelope: drag its
+ * anchors and handles, or inside a patch to pull the surface. `type` adds point text (click) or
+ * area text (drag) and edits text it clicks; `typePath` sets text along the path it clicks. `frame`
+ * drags out a frame (`VectorGroupNode.frame`), taking in the top-level objects it fully encloses.
+ * `connector` drags a connector between objects, gluing each end to the side it starts or ends on.
+ */
+type VectorTool = 'select' | 'direct' | 'pen' | 'pencil' | 'rect' | 'ellipse' | 'polygon' | 'star' | 'line' | 'scissors' | 'knife' | 'eraser' | 'width' | 'shapeBuilder' | 'paintBucket' | 'blend' | 'gradient' | 'envelope' | 'type' | 'typePath' | 'frame' | 'connector';
+declare const VECTOR_TOOLS: readonly VectorTool[];
+/** Keyboard modifiers held during a pointer event. */
+interface VectorModifiers {
+    shift?: boolean;
+    alt?: boolean;
+    /** Cmd on macOS, Ctrl elsewhere. */
+    mod?: boolean;
+}
+/** The eight resize handles of a selection box and the rotation handle. */
+type VectorTransformHandle = 'nw' | 'n' | 'ne' | 'e' | 'se' | 's' | 'sw' | 'w' | 'rotate';
+declare const VECTOR_TRANSFORM_HANDLES: readonly VectorTransformHandle[];
+/** Pan and zoom of the canvas: `screen = document × zoom + (x, y)`. */
+interface VectorViewport {
+    /** Screen position of the document origin, in screen pixels. */
+    x: number;
+    y: number;
+    zoom: number;
+}
+/** What the next shape and pen path are drawn with. */
+interface VectorDefaults extends VectorStyle {
+    /** Sides of the polygon tool (default 6). */
+    polygonSides?: number;
+    /** Points of the star tool (default 5). */
+    starPoints?: number;
+    /** Inner radius of the star tool as a fraction of the outer one (default 0.5). */
+    starInnerRatio?: number;
+    /** Live corner radius the rectangle, polygon and star tools give their corners (default 0). */
+    cornerRadius?: number;
+    /** Corner kind of those tools (default `round`). */
+    cornerKind?: VectorCornerKind;
+}
+type VectorAlign = 'left' | 'center' | 'right' | 'top' | 'middle' | 'bottom';
+type VectorDistribute = 'horizontal' | 'vertical';
+type VectorBooleanOperation = 'union' | 'subtract' | 'intersect' | 'exclude';
+/**
+ * Pathfinder operations: `divide` (every face its own shape), `trim` (hidden parts removed),
+ * `merge` (Trim, then touching parts of one fill joined), `crop` (the top shape crops the others),
+ * `outline` (outlines cut into open strokes where they meet) and `minusBack` (the top shape minus
+ * everything below it).
+ */
+type VectorPathfinderOperation = 'divide' | 'trim' | 'merge' | 'crop' | 'outline' | 'minusBack';
+declare const VECTOR_PATHFINDER_OPERATIONS: readonly VectorPathfinderOperation[];
+type VectorArrange = 'front' | 'forward' | 'backward' | 'back';
+/** Average: line anchors up on a horizontal line (same y), a vertical one (same x), or both. */
+type VectorAverageAxis = 'horizontal' | 'vertical' | 'both';
+/**
+ * Live path effects (After Effects' path operators): `trim` (Trim Paths), `roundCorners`,
+ * `puckerBloat`, `twist`, `zigzag`, `wiggle` (Wiggle Paths), `offset` (Offset Paths), `merge`
+ * (Merge Paths), `repeater`, `envelope` (an envelope distortion: a warp preset or a mesh),
+ * `contour` (CorelDRAW's Contour: concentric offset steps blending toward end colours) and
+ * `blockShadow` (CorelDRAW's Block Shadow: the shape swept along a direction, under it).
+ */
+type VectorEffectType = 'trim' | 'roundCorners' | 'puckerBloat' | 'twist' | 'zigzag' | 'wiggle' | 'offset' | 'merge' | 'repeater' | 'envelope' | 'contour' | 'blockShadow';
+declare const VECTOR_EFFECT_TYPES: readonly VectorEffectType[];
+/** Warp presets (Photoshop's fifteen, in menu order); shared with the image editor (`src/geom`). */
+type VectorWarpStyle = WarpStyle;
+/**
+ * A grid of bicubic Bézier patches mapping a source box onto the plane. `us` / `vs` are the patch
+ * boundaries as fractions of the box (increasing, first 0, last 1); `points` is the
+ * `(3·(us.length − 1) + 1) × (3·(vs.length − 1) + 1)` control grid, row by row, in the node's own
+ * space. Neighbouring patches share their edge row: anchors sit where both indices are multiples
+ * of 3, handles where one is. Shared with the image editor (`src/geom`).
+ */
+type VectorWarpMesh = WarpMesh;
+/** Merge Paths modes: a compound path (no boolean), union, the first minus the others, intersection or exclusion. */
+type VectorMergeMode = 'merge' | 'add' | 'subtract' | 'intersect' | 'exclude';
+declare const VECTOR_MERGE_MODES: readonly VectorMergeMode[];
+/** Parameters of each effect type. Lengths are in the node's own units, angles in degrees, percentages 0–100. */
+interface VectorEffectParamsMap {
+    trim: {
+        /** Start and end of the kept part, percent of the length (swapped when start > end). */
+        start: number;
+        end: number;
+        /** Shifts both, in degrees (360° = once round). */
+        offset: number;
+        /**
+         * `simultaneous`: every path trimmed by the same fractions of its own length;
+         * `individual`: the paths laid end to end in stacking order and trimmed as one length.
+         */
+        mode: 'simultaneous' | 'individual';
+    };
+    roundCorners: {
+        radius: number;
+    };
+    /** Percent, −100 (pucker: spiky) to 100 (bloat: bulging). */
+    puckerBloat: {
+        amount: number;
+    };
+    twist: {
+        /** Turn at the farthest point from the centre (none at the centre). */
+        angle: number;
+        /** The centre as an offset from the middle of the paths' bounds. */
+        center: Vec2;
+    };
+    zigzag: {
+        /** How far the points move to either side. */
+        size: number;
+        /** Ridges per segment. */
+        ridges: number;
+        /** Rounded waves instead of sharp zig zags. */
+        smooth: boolean;
+    };
+    wiggle: {
+        /** Largest displacement. */
+        size: number;
+        /** Points added per segment. */
+        detail: number;
+        smooth: boolean;
+        /** Wiggles per second. */
+        speed: number;
+        /** Percent: how much neighbouring points move together. */
+        correlation: number;
+        /** Degrees (360° = one wiggle). */
+        phase: number;
+        /** The same seed (and time) always gives the same wiggle. */
+        seed: number;
+        /** Seconds: where along the wiggle's motion it is drawn. */
+        time: number;
+    };
+    offset: {
+        /** Grows (positive) or shrinks (negative) the shapes. */
+        amount: number;
+        join: VectorLineJoin;
+        miterLimit: number;
+        /** Copies, copy i offset by `amount · (i + 1 + copyOffset)`. */
+        copies: number;
+        copyOffset: number;
+    };
+    merge: {
+        mode: VectorMergeMode;
+    };
+    repeater: {
+        /** Copies, the original included; a fraction fades the last copy. */
+        copies: number;
+        /** Shifts the copies along: copy i is transformed `i + offset` times. */
+        offset: number;
+        /** Each step: move, about `anchor` turn by `rotation` and scale by `scale` percent. */
+        position: Vec2;
+        /** Offset from the middle of the paths' bounds. */
+        anchor: Vec2;
+        rotation: number;
+        scale: Vec2;
+        /** Percent opacity of the first and last copies (in between interpolated). */
+        startOpacity: number;
+        endOpacity: number;
+        /** `below`: each copy draws under the one before it; `above`: over it. */
+        composite: 'below' | 'above';
+    };
+    /**
+     * Contour: concentric copies of each shape offset `offset` apart, `steps` of them `inside`,
+     * `outside`, or `center` (inside until the shape is used up), their fill and stroke blending
+     * from the shape's own colours to `fillColor` / `strokeColor` (null keeps the colour).
+     * `acceleration` (−100…100) bunches the colour change toward the end (positive) or start.
+     */
+    contour: {
+        direction: 'inside' | 'outside' | 'center';
+        steps: number;
+        offset: number;
+        join: VectorLineJoin;
+        miterLimit: number;
+        fillColor: string | null;
+        strokeColor: string | null;
+        acceleration: number;
+    };
+    /**
+     * Block shadow (CorelDRAW's Block Shadow; a long shadow when it fades): each shape swept
+     * `distance` along `angle` (degrees, 0 right, 90 down, in the node's own space) as one solid
+     * shape under the art, in `color` (null: the shape's own solid fill) at `opacity` percent,
+     * fading to `endOpacity` percent at the far end.
+     */
+    blockShadow: {
+        angle: number;
+        distance: number;
+        color: string | null;
+        opacity: number;
+        endOpacity: number;
+    };
+    /**
+     * Envelope distortion: the paths above it are mapped from their combined bounds through a warp
+     * preset (bend and horizontal / vertical distortion in percent) or, with style `mesh`, through
+     * `mesh` (null: the flat mesh of `columns × rows` patches over the bounds). The bounds are
+     * taken afresh each time, so editing the contents keeps the envelope.
+     */
+    envelope: {
+        style: VectorWarpStyle | 'mesh';
+        bend: number;
+        horizontal: number;
+        vertical: number;
+        orientation: 'horizontal' | 'vertical';
+        /** Patches of the mesh (a preset turns into a mesh of this size when it is edited). */
+        rows: number;
+        columns: number;
+        mesh: VectorWarpMesh | null;
+    };
+}
+/** One entry of an effect stack. */
+type VectorEffect = {
+    [K in VectorEffectType]: {
+        /** Unique within the node. */
+        id: string;
+        type: K;
+        /** Disabled effects are skipped. Default true. */
+        enabled?: boolean;
+        params: VectorEffectParamsMap[K];
+    };
+}[VectorEffectType];
+/** Identifies one segment of a path node: from anchor `segment` to the next. */
+interface VectorSegmentRef {
+    nodeId: string;
+    subpath: number;
+    segment: number;
+}
+/**
+ * Visual filters: `dropShadow` (the node's silhouette, offset and blurred, under it),
+ * `innerShadow` (a shadow cast inside the edges), `outerGlow` / `innerGlow` (an unoffset glow
+ * outside or inside the edges), `layerBlur` (the whole node blurred) and `feather` (edges faded
+ * to transparent).
+ */
+type VectorFilterType = 'dropShadow' | 'innerShadow' | 'outerGlow' | 'innerGlow' | 'layerBlur' | 'feather';
+declare const VECTOR_FILTER_TYPES: readonly VectorFilterType[];
+/** A shadow or glow: colour, offset, blur and spread in the node's own units. */
+interface VectorShadowParams {
+    color: string;
+    /** 0–1: multiplies the colour's own alpha. */
+    opacity: number;
+    /** Blur radius (the SVG / CSS standard deviation is half of it). */
+    blur: number;
+    /** Grows the silhouette before blurring (inner effects: chokes it inwards). */
+    spread: number;
+}
+/** Parameters of each filter type. Lengths are in the node's own units. */
+interface VectorFilterParamsMap {
+    dropShadow: VectorShadowParams & {
+        offsetX: number;
+        offsetY: number;
+    };
+    innerShadow: VectorShadowParams & {
+        offsetX: number;
+        offsetY: number;
+    };
+    outerGlow: VectorShadowParams;
+    innerGlow: VectorShadowParams;
+    layerBlur: {
+        radius: number;
+    };
+    /** Fades the edges over `radius` inwards. */
+    feather: {
+        radius: number;
+    };
+}
+/** One entry of a node's filter stack. */
+type VectorFilter = {
+    [K in VectorFilterType]: {
+        /** Unique within the node. */
+        id: string;
+        type: K;
+        /** Disabled filters are skipped. Default true. */
+        enabled?: boolean;
+        params: VectorFilterParamsMap[K];
+    };
+}[VectorFilterType];
+
+/**
+ * A vector animation as plain JSON: a piece of vector artwork (the editor's `VectorDocument`,
+ * as the vector editor draws it) and the shots that bring it to life.
+ *
+ * Shots, not timelines: a shot frames the camera, plays its commands and holds. Timing comes
+ * from the content (each command has a sensible default length, and drawing a line takes as
+ * long as the line is long), so there are no keyframes to manage. The same scene plays the
+ * same frames every time: every frame is a pure function of time.
+ */
+interface MotionScene {
+    /** Format version (always 1). */
+    version: 1;
+    /** A short name, e.g. `logo-reveal`. */
+    name: string;
+    description?: string;
+    /** The artwork in its resting state. Commands target its node ids. */
+    artwork: VectorDocument;
+    shots: MotionShot[];
+    /** Playback past the end: stop (`none`, default), `loop` or `ping-pong`. */
+    loop?: AnimationLoopMode;
+    /**
+     * Plays in answer to the viewer instead of on its own (exported to Flair's player):
+     * - `click`: nothing plays until the viewer clicks; each click plays the next shot, and after the
+     *   last one a click plays the first again, so a last shot that puts things back makes a toggle.
+     * - `hover` / `press`: plays forward while the pointer is over (or down on) it, and back when it leaves.
+     * - `scroll`: scrubs through the scene as it scrolls through the viewport.
+     * The editor previews it played through; `loop` does not apply.
+     */
+    trigger?: MotionTrigger;
+    /** Frame rate used to sample motion that a target format cannot express exactly (default 30). */
+    fps?: number;
+    /**
+     * Stepped time for every command that gives none: changes hold on a grid of this many frames
+     * per second ("on twos" at 12), for a hand-drawn look. Default: smooth.
+     */
+    steps?: number;
+    /** A beat grid to cue shots to (`MotionShot.at.beat`): music or a voiceover's rhythm. */
+    beat?: MotionBeatGrid;
+    /** A voiceover's words with their times, to cue shots to (`MotionShot.at.word`). */
+    narration?: MotionNarration;
+    /** Wanted length in seconds `[min, max]`; `check` warns outside it. */
+    target?: [number, number];
+    /**
+     * Reusable motion: named command lists written against the target `"$"`, played on any
+     * node with a `play` command (a "pop and settle" or "attention" you use many times).
+     */
+    clips?: Record<string, MotionClip>;
+    /**
+     * Properties that follow other properties: a background moving at half the speed of the
+     * foreground (parallax), a wheel turning as it rolls. Each adds to what its target's commands do.
+     */
+    drivers?: MotionDriver[];
+    /**
+     * Motion blur on the stage and in rendered frames (not in exports): each frame averages a few
+     * moments across the shutter, more for faster motion.
+     */
+    motionBlur?: MotionBlur;
+    /** Parameters a Flair effect made from this scene exposes (see `toFlairVectorEffect`). */
+    controls?: MotionControl[];
+    /** Named sets of control values. */
+    presets?: MotionPreset[];
+}
+/** What the viewer does to play a triggered scene (see `MotionScene.trigger`). */
+type MotionTrigger = 'click' | 'hover' | 'press' | 'scroll';
+declare const MOTION_TRIGGERS: readonly MotionTrigger[];
+/** A rectangle of the artwork, in document units. */
+interface MotionRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/**
+ * Where the camera looks: a rectangle, or the id of a node to frame (with `padding` around
+ * its bounds, default 24). The camera eases there over `ms` (default 1000; the first shot cuts).
+ */
+type MotionCamera = (MotionRect | {
+    frame: string;
+    padding?: number;
+}) & {
+    ease?: AnimationEasing;
+    ms?: number;
+    /** Zoom at a steady rate (the size changes by the same factor each moment) instead of linearly. */
+    geometric?: boolean;
+};
+/** A steady beat: `bpm` beats a minute, the first at `offset` ms, `meter` beats a bar. */
+interface MotionBeatGrid {
+    bpm: number;
+    /** When beat 0 falls, ms (default 0). */
+    offset?: number;
+    /** Beats in a bar (default 4), for reading beats as bar and beat. */
+    meter?: number;
+}
+/** A voiceover: its words in order, each with when it is said (ms), from a TTS or speech-to-text word timing. */
+interface MotionNarration {
+    words: {
+        text: string;
+        start: number;
+        end?: number;
+    }[];
+}
+/** When a shot is cued to start: on a beat, on a narration word, or at a time. */
+interface MotionCue {
+    /** Beat number on the scene's beat grid, from 0 (fractions for off-beats: 2.5 is the "and" of beat 3). */
+    beat?: number;
+    /** Index of a word in the scene's narration, from 0. */
+    word?: number;
+    /** A time in ms. */
+    ms?: number;
+}
+/** One beat of the animation. */
+interface MotionShot {
+    /** Stable id (unique in the scene), e.g. `intro`. */
+    id: string;
+    /** What happens in this shot, in a few words (shown on the timeline). */
+    label?: string;
+    /** Omit to keep the current framing. */
+    camera?: MotionCamera;
+    /**
+     * Start on a cue: a beat, a narration word or a time. The shot before holds until then; a
+     * cue that comes before the shot before has ended is missed (`check` says by how much).
+     * Give one of `beat`, `word` or `ms`.
+     */
+    at?: MotionCue;
+    /** Commands, played one after another (unless a command says `with: "previous"`). */
+    run: MotionCommand[];
+    /** Milliseconds to hold after the commands finish (default 600). */
+    hold?: number;
+    /**
+     * Plays the whole shot this many times as fast (default 1): its camera move, delays,
+     * durations, staggers and hold all scale by 1 / speed. `fit_animation` sets it to fit a length.
+     */
+    speed?: number;
+}
+/** How `split` splits outlined text. */
+type MotionTextUnit = 'letter' | 'word' | 'line';
+declare const MOTION_TEXT_UNITS: readonly MotionTextUnit[];
+/** The order `split` units animate in. */
+type MotionCascade = 'forward' | 'backward' | 'center' | 'edges' | 'random';
+declare const MOTION_CASCADES: readonly MotionCascade[];
+/** Fields every command takes. */
+interface MotionCommandBase {
+    /** Node ids from the artwork (groups animate as one, unless `split` splits their text). */
+    targets: string[];
+    /**
+     * For outlined text (a group of letter paths): animate it a letter, word or line at a time,
+     * staggered in reading order (default stagger 40 ms a letter, 120 a word, 300 a line).
+     */
+    split?: MotionTextUnit;
+    /** With `split`: the order units go in (default `forward`). `random` is the same every time. */
+    cascade?: MotionCascade;
+    /** Length in ms for each target, one cycle when repeating (each type has a default; `draw` follows the path length; a spring `ease` lasts until it settles). */
+    duration?: number;
+    /** Wait this many ms before starting (default 0). */
+    delay?: number;
+    /** Start each further target this many ms after the one before (default 0). */
+    stagger?: number;
+    /** `after` (default) starts when the commands before it finish; `previous` starts with the command before. */
+    with?: 'after' | 'previous';
+    /** An easing; a spring with no `duration` lasts until it settles. */
+    ease?: AnimationEasing;
+    /** Why this command is here (for people and agents reading the scene). */
+    note?: string;
+    /**
+     * Play the change this many times (a whole number, default 1); `duration` is one cycle. Not
+     * for `enter`, `exit` or `wait`.
+     */
+    repeat?: number;
+    /**
+     * How repeats follow each other: `loop` (default) starts each cycle afresh, `mirror` plays
+     * every other one backwards, `offset` carries on from where the last ended (rotate by 90,
+     * repeat 4: a full turn). Colours and shapes offset like `loop`.
+     */
+    repeatMode?: 'loop' | 'mirror' | 'offset';
+    /** Stepped time: hold the change on a grid of this many frames per second (default: the scene's `steps`, else smooth). */
+    steps?: number;
+    /**
+     * The provider effect this command came from (see `applyMotionEffect`): commands that share a
+     * `source.instance` are one applied effect, changed or removed together. Plain commands have none.
+     */
+    source?: MotionEffectSource;
+}
+/** Where a command came from when an effects provider made it (`@pixerate/editor/effects`). */
+interface MotionEffectSource {
+    /** The applied effect's id in the scene (e.g. `fx1`), shared by all its commands. */
+    instance: string;
+    /** The provider's effect id. */
+    effect: string;
+    provider?: string;
+    name?: string;
+    /** The control values it was applied with. */
+    values?: Record<string, EffectValue>;
+}
+type MotionEnterStyle = 'fade' | 'pop' | 'grow' | 'slide' | 'draw' | 'zoom' | 'rise' | 'wipe' | 'iris' | 'split';
+type MotionExitStyle = 'fade' | 'shrink' | 'slide' | 'undraw' | 'wipe';
+type MotionDirection = 'up' | 'down' | 'left' | 'right';
+/** The opening an `iris` reveals through. */
+type MotionIrisShape = 'circle' | 'box';
+/** The line a `split` opens from. */
+type MotionSplitOrientation = 'horizontal' | 'vertical';
+/**
+ * Brings hidden targets in. Targets entered in a shot are hidden before it. Each style is a
+ * Flair motion primitive (`entrance.<style>`) with the same defaults.
+ */
+interface MotionEnterCommand extends MotionCommandBase, MotionDrawOrder {
+    type: 'enter';
+    /**
+     * Default `fade`. `draw` draws the outline on, then fades the fill in. `pop` scales up past
+     * full size and settles; `zoom` settles from larger; `rise` rises a short way with a little
+     * overshoot. `wipe`, `iris` and `split` reveal the target through a clip over its box (see
+     * `MotionFrame.clips`), reaching past it far enough to show its whole stroke.
+     */
+    style?: MotionEnterStyle;
+    /**
+     * For `slide`: the direction of travel (default `up`). For `wipe`: the way the edge travels
+     * (default `right`, which reveals from the left).
+     */
+    direction?: MotionDirection;
+    /** For `slide` (default 40) and `rise` (default 20): how far in document units. */
+    distance?: number;
+    /** For `pop` (default 0.5) and `zoom` (default 1.6): the starting scale. */
+    scale?: number;
+    /** For `iris`: open through a `circle` (default; an ellipse on a box that is not square) or a `box`. */
+    shape?: MotionIrisShape;
+    /** For `split`: open up and down from a `horizontal` line through the middle (default), or left and right from a `vertical` one. */
+    orientation?: MotionSplitOrientation;
+}
+/** Takes targets out. */
+interface MotionExitCommand extends MotionCommandBase, MotionDrawOrder {
+    type: 'exit';
+    /** Default `fade`. `wipe` hides the target behind an edge travelling `direction` (a wipe in, reversed). */
+    style?: MotionExitStyle;
+    /** For `slide`: the direction of travel (default `down`). For `wipe`: the way the edge travels (default `right`, which hides from the left). */
+    direction?: MotionDirection;
+    distance?: number;
+}
+/**
+ * How the strokes of a group (or several paths) draw on or off together. Default: all at once,
+ * each over the whole time.
+ */
+interface MotionDrawOrder {
+    /** `together` (default) or `sequence`: one stroke after another, each for a time in proportion to its length. */
+    order?: 'together' | 'sequence';
+    /** With `together`: `time` (default) gives every stroke the whole time; `speed` draws them all at one speed, so short ones take less. */
+    pace?: 'time' | 'speed';
+    /** With `pace: "speed"`: `start` (default) starts them together, `end` finishes them together. */
+    align?: 'start' | 'end';
+    /** With `sequence`: `document` (default, stacking order) or `distance` from `origin` (a radial reveal). */
+    sortBy?: 'document' | 'distance';
+    /** With `sortBy: "distance"`: the point (document units) strokes are drawn out from (default the target's centre). */
+    origin?: {
+        x: number;
+        y: number;
+    };
+}
+/** Draws a stroke on (or off) between two fractions of its length. */
+interface MotionDrawCommand extends MotionCommandBase, MotionDrawOrder {
+    type: 'draw';
+    /**
+     * A travelling stroke this fraction of the length long (0–1): it runs along the path and off
+     * the end, instead of drawing it on and leaving it.
+     */
+    comet?: number;
+    /** Fraction drawn at the end (default 1). */
+    to?: number;
+    /** Fraction drawn at the start (default: what is drawn now). */
+    from?: number;
+}
+/** Moves targets by an offset, or to a point (their centre lands there). */
+interface MotionMoveCommand extends MotionCommandBase {
+    /**
+     * `add` makes the change a layer over the pose instead of a change to it: it stacks on
+     * whatever else moves the target (a shake on a slide), and what it adds stays once it ends.
+     * Default `replace` for move, rotate and scale (the later change takes over), `add` for
+     * pulse, shake, teeter, wave and wiggle.
+     */
+    blend?: 'replace' | 'add';
+    type: 'move';
+    by?: {
+        x: number;
+        y: number;
+    };
+    to?: {
+        x: number;
+        y: number;
+    };
+    /**
+     * Points (document units) the centre passes through on the way, in order. The path is
+     * smooth (velocity carries through each point) and never overshoots a point.
+     */
+    via?: {
+        x: number;
+        y: number;
+    }[];
+    /** With `via`: `even` (default) keeps the speed steady along the path, `equal` gives each leg the same time. */
+    pacing?: 'even' | 'equal';
+}
+/** Turns targets about their centre, by or to an angle in degrees (clockwise). */
+interface MotionRotateCommand extends MotionCommandBase {
+    /**
+     * `add` makes the change a layer over the pose instead of a change to it: it stacks on
+     * whatever else moves the target (a shake on a slide), and what it adds stays once it ends.
+     * Default `replace` for move, rotate and scale (the later change takes over), `add` for
+     * pulse, shake, teeter, wave and wiggle.
+     */
+    blend?: 'replace' | 'add';
+    type: 'rotate';
+    by?: number;
+    to?: number;
+}
+/** Scales targets about their centre (1 = rest size). */
+interface MotionScaleCommand extends MotionCommandBase {
+    /**
+     * `add` makes the change a layer over the pose instead of a change to it: it stacks on
+     * whatever else moves the target (a shake on a slide), and what it adds stays once it ends.
+     * Default `replace` for move, rotate and scale (the later change takes over), `add` for
+     * pulse, shake, teeter, wave and wiggle.
+     */
+    blend?: 'replace' | 'add';
+    type: 'scale';
+    to: number | {
+        x: number;
+        y: number;
+    };
+    /** Grow at a steady rate (the same factor each moment), which reads as an even zoom. */
+    geometric?: boolean;
+}
+/** Changes opacity (0–1). */
+interface MotionFadeCommand extends MotionCommandBase {
+    type: 'fade';
+    to: number;
+}
+/** Changes solid paints and stroke width. Colours mix in OKLab. */
+interface MotionStyleCommand extends MotionCommandBase {
+    type: 'style';
+    fill?: string;
+    stroke?: string;
+    strokeWidth?: number;
+}
+/** Morphs each target into the shape of another node (`into`), which usually stays hidden. */
+interface MotionMorphCommand extends MotionCommandBase {
+    type: 'morph';
+    into: string;
+}
+/**
+ * Smart Animate: tweens a group into another group (`into`, usually hidden), part by part. Each
+ * part of the target takes the shape, paint and place of its partner in `into`, paired by name,
+ * then by id (`card-a-title` ↔ `card-b-title`), then by kind in order. Parts with no partner fade
+ * out; parts of `into` with no partner do not appear (`check` lists them).
+ */
+interface MotionMatchCommand extends MotionCommandBase {
+    type: 'match';
+    /** Id of the group (or node) to become. */
+    into: string;
+}
+/** A reusable piece of motion: commands that target `"$"` (whatever `play` names), timed as in a shot. */
+interface MotionClip {
+    description?: string;
+    /** Commands, timed as in a shot; `"$"` in `targets` stands for the node played on. Clips cannot play clips. */
+    run: MotionCommand[];
+}
+/** Motion blur: how long the shutter is open and how many moments a frame averages at most. */
+interface MotionBlur {
+    /** Shutter angle in degrees of a frame at the scene's fps (default 180: half a frame; 360 is a whole frame). */
+    shutter?: number;
+    /** Most moments a frame averages (default 8, at most 32); fewer for slower motion. */
+    samples?: number;
+}
+/** Properties a driver reads and drives: offsets (document units), turn (degrees), scales and opacity. */
+type MotionDrivenProperty = 'x' | 'y' | 'rotation' | 'scaleX' | 'scaleY' | 'opacity';
+declare const MOTION_DRIVEN_PROPERTIES: readonly MotionDrivenProperty[];
+/**
+ * One property following another. Both are read as a change from rest (offsets and turns from
+ * 0, scales and opacity from 1): the target's property changes by `source change · factor + offset`,
+ * clamped to `clamp`, on top of its own commands (added to offsets and turns, multiplied into
+ * scales and opacity as 1 + change).
+ */
+interface MotionDriver {
+    /** The node that follows. */
+    target: string;
+    property: MotionDrivenProperty;
+    /** The node and property it follows. */
+    source: {
+        node: string;
+        property: MotionDrivenProperty;
+    };
+    /** Default 1 (0.5 moves at half the speed; 360 / (2π·radius) turns a wheel by how far it rolls). */
+    factor?: number;
+    /** Added to the change (default 0). */
+    offset?: number;
+    /** Limits the change to `[min, max]`. */
+    clamp?: [number, number];
+}
+/** The placeholder target in a clip's commands. */
+declare const MOTION_CLIP_TARGET = "$";
+/** Plays a clip (`scene.clips`) on the targets: its commands, with `"$"` standing for each target. */
+interface MotionPlayCommand extends MotionCommandBase {
+    type: 'play';
+    /** The clip's name. */
+    clip: string;
+    /** Play it this many times as fast (default 1). */
+    speed?: number;
+}
+/** Moves targets along a path node, centre on the path. */
+interface MotionFollowCommand extends MotionCommandBase {
+    type: 'follow';
+    /** Id of a path node in the artwork (it can be hidden). */
+    path: string;
+    /**
+     * Turn with the path's direction (default false). Moves, shakes and wiggles made during the
+     * follow then turn with it too: they are offsets from the target's place on the path.
+     */
+    rotate?: boolean;
+    /** Fractions of the path's length to travel between (default 0 → 1). */
+    from?: number;
+    to?: number;
+}
+/** Scales up and back, `count` times (draws the eye). */
+interface MotionPulseCommand extends MotionCommandBase {
+    /**
+     * `add` makes the change a layer over the pose instead of a change to it: it stacks on
+     * whatever else moves the target (a shake on a slide), and what it adds stays once it ends.
+     * Default `replace` for move, rotate and scale (the later change takes over), `add` for
+     * pulse, shake, teeter, wave and wiggle.
+     */
+    blend?: 'replace' | 'add';
+    type: 'pulse';
+    /** Extra scale at the peak (default 0.15). */
+    amount?: number;
+    count?: number;
+}
+/** Shakes side to side (or up and down), settling. */
+interface MotionShakeCommand extends MotionCommandBase {
+    /**
+     * `add` makes the change a layer over the pose instead of a change to it: it stacks on
+     * whatever else moves the target (a shake on a slide), and what it adds stays once it ends.
+     * Default `replace` for move, rotate and scale (the later change takes over), `add` for
+     * pulse, shake, teeter, wave and wiggle.
+     */
+    blend?: 'replace' | 'add';
+    type: 'shake';
+    /** Distance in document units (default 8). */
+    amount?: number;
+    count?: number;
+    /** Default `horizontal`. */
+    axis?: 'horizontal' | 'vertical';
+}
+/** Rocks about the centre by `angle` either way, settling (Flair's `emphasis.teeter`). */
+interface MotionTeeterCommand extends MotionCommandBase {
+    /**
+     * `add` makes the change a layer over the pose instead of a change to it: it stacks on
+     * whatever else moves the target (a shake on a slide), and what it adds stays once it ends.
+     * Default `replace` for move, rotate and scale (the later change takes over), `add` for
+     * pulse, shake, teeter, wave and wiggle.
+     */
+    blend?: 'replace' | 'add';
+    type: 'teeter';
+    /** Degrees either way (default 8). */
+    angle?: number;
+    /** Rocks (default 3). */
+    count?: number;
+}
+/** Bobs up and down without settling, like something floating (Flair's `emphasis.wave`). */
+interface MotionWaveCommand extends MotionCommandBase {
+    /**
+     * `add` makes the change a layer over the pose instead of a change to it: it stacks on
+     * whatever else moves the target (a shake on a slide), and what it adds stays once it ends.
+     * Default `replace` for move, rotate and scale (the later change takes over), `add` for
+     * pulse, shake, teeter, wave and wiggle.
+     */
+    blend?: 'replace' | 'add';
+    type: 'wave';
+    /** Height in document units (default 6). */
+    amount?: number;
+    /** Bobs (default 2). */
+    count?: number;
+}
+/**
+ * Wanders about its place as smooth seeded noise, easing out of and back to rest (Flair's
+ * `emphasis.wiggle`). The same seed always wanders the same way.
+ */
+interface MotionWiggleCommand extends MotionCommandBase {
+    /**
+     * `add` makes the change a layer over the pose instead of a change to it: it stacks on
+     * whatever else moves the target (a shake on a slide), and what it adds stays once it ends.
+     * Default `replace` for move, rotate and scale (the later change takes over), `add` for
+     * pulse, shake, teeter, wave and wiggle.
+     */
+    blend?: 'replace' | 'add';
+    type: 'wiggle';
+    /** Up to about this far, in document units (default 6). */
+    amount?: number;
+    /** Wanders per second, in Hz (default 3). */
+    frequency?: number;
+    /** Layers of finer detail (default 2). */
+    octaves?: number;
+    /** Also turns about the centre by up to about this many degrees (default 0). */
+    rotate?: number;
+    /** A whole number; default: one picked from the target's id, so each target wanders its own way. */
+    seed?: number;
+}
+/** Tints solid paint toward a colour and back, `count` times (Flair's `emphasis.color-pulse`). */
+interface MotionColorPulseCommand extends MotionCommandBase {
+    type: 'color-pulse';
+    /** The tint (default `#f59e0b`). Mixes in OKLab. */
+    color?: string;
+    /** Which paint (default `fill`). On a group it tints every path in it. */
+    paint?: 'fill' | 'stroke';
+    count?: number;
+}
+/** Tweens a numeric parameter of a live path effect on the target (twist angle, wiggle time, zig zag size…). */
+interface MotionEffectCommand extends MotionCommandBase {
+    type: 'effect';
+    /** Id of an effect in the target node's `effects`. */
+    effect: string;
+    /** A numeric parameter of that effect, e.g. `angle`. */
+    param: string;
+    to: number;
+}
+/** Does nothing for `duration` ms. */
+interface MotionWaitCommand {
+    type: 'wait';
+    duration: number;
+    with?: 'after' | 'previous';
+    note?: string;
+}
+type MotionCommand = MotionEnterCommand | MotionExitCommand | MotionDrawCommand | MotionMoveCommand | MotionRotateCommand | MotionScaleCommand | MotionFadeCommand | MotionStyleCommand | MotionMorphCommand | MotionMatchCommand | MotionPlayCommand | MotionFollowCommand | MotionPulseCommand | MotionShakeCommand | MotionTeeterCommand | MotionWaveCommand | MotionWiggleCommand | MotionColorPulseCommand | MotionEffectCommand | MotionWaitCommand;
+type MotionCommandType = MotionCommand['type'];
+declare const MOTION_COMMAND_TYPES: readonly MotionCommandType[];
+declare const MOTION_ENTER_STYLES: readonly MotionEnterStyle[];
+declare const MOTION_BLENDS: readonly ["replace", "add"];
+declare const MOTION_REPEAT_MODES: readonly ["loop", "mirror", "offset"];
+declare const MOTION_EXIT_STYLES: readonly MotionExitStyle[];
+declare const MOTION_IRIS_SHAPES: readonly MotionIrisShape[];
+declare const MOTION_SPLIT_ORIENTATIONS: readonly MotionSplitOrientation[];
+declare const MOTION_DIRECTIONS: readonly MotionDirection[];
+/**
+ * A colour parameter of the effect made from the scene: it stands for every use of its
+ * `default` colour in the artwork and the commands, so recolouring it recolours them all.
+ */
+interface MotionControl {
+    /** Identifier, e.g. `accent`. */
+    name: string;
+    type: 'color';
+    /** A `#rrggbb` colour used in the scene. */
+    default: string;
+    label?: string;
+}
+interface MotionPreset {
+    name: string;
+    values: Record<string, string>;
+}
+/** Default lengths (ms) of commands that give none. */
+declare const MOTION_DEFAULT_DURATIONS: Readonly<Record<Exclude<MotionCommandType, 'wait' | 'draw'>, number>>;
+/** Default hold after a shot's commands (ms). */
+declare const MOTION_DEFAULT_HOLD = 600;
+/** Default camera move (ms). */
+declare const MOTION_CAMERA_MS = 1000;
+/** `draw` lasts `length × MOTION_DRAW_MS_PER_UNIT`, clamped to `MOTION_DRAW_RANGE`. */
+declare const MOTION_DRAW_MS_PER_UNIT = 1.5;
+declare const MOTION_DRAW_RANGE: readonly [number, number];
+/**
+ * The Flair motion primitive (`@pixerate/flair/motion`) a command plays, or undefined when
+ * Flair has none (`move`, `scale`, `fade`, `style`, `morph`, `effect`, `wait` are the editor's
+ * own). Commands and primitives of the same name take the same parameters and defaults.
+ */
+declare function motionFlairPrimitive(command: MotionCommand): string | undefined;
+
+/**
+ * Helpers for providers and editors: value validation, catalog search, pixel buffers, masking,
+ * and a provider slot editors hold.
+ */
+
+/** Problems with `values` against an effect's control schema (unknown controls, types, ranges). Partial values are fine. */
+declare function effectValueErrors(description: Pick<EffectDescription, 'controls'>, values: unknown): SchemaValidationError[];
+/**
+ * `values` over the effect's defaults, validated against its control schema. Throws
+ * `EffectControlError` naming every bad control. Providers call this in `render`; editors call
+ * it before saving values.
+ */
+declare function resolveEffectValues(description: Pick<EffectDescription, 'id' | 'controls' | 'defaults'>, values?: EffectValues): Record<string, EffectValues[string]>;
+/**
+ * Filters a catalog and ranks it against `query` (every word must appear in the id, name,
+ * category, tags or description; name matches rank first). An empty query keeps catalog order.
+ * Providers can implement `list` and `search` with it.
+ */
+declare function searchEffectSummaries<T extends EffectSummary>(catalog: readonly T[], query?: string, options?: EffectSearchOptions): T[];
+/** A transparent picture, with float samples when `float` is set. */
+declare function createEffectPixels(width: number, height: number, float?: boolean): EffectPixels;
+/** True for an `EffectPixels` (rather than a host image object). */
+declare function isEffectPixels(source: EffectImageSource | unknown): source is EffectPixels;
+/** sRGB-encoded 0–1 to linear light. */
+declare const srgbToLinear: (v: number) => number;
+/** Linear light to sRGB-encoded (clamped below at 0; may exceed 1). */
+declare const linearToSrgb: (v: number) => number;
+/** Fills `pixels.data` from `pixels.float` (linear float to clamped 8-bit sRGB). */
+declare function encodeEffectFloat(pixels: EffectPixels): EffectPixels;
+/**
+ * Blends an effect `result` back over its `source` by `mask` coverage (alpha channel), in place
+ * on `result`: where the mask is 0 the source shows, where it is 255 the result. Without a
+ * source (generators), the result's alpha is multiplied by coverage. Editors use it when the
+ * provider does not `supportsMask`. All three must have the same size.
+ */
+declare function applyEffectMask(result: EffectPixels, mask: EffectPixels, source?: EffectPixels): EffectPixels;
+/**
+ * Holds an editor's effects provider. Controllers expose it as `effectsProvider`,
+ * `setEffectsProvider(provider | null)` and `useEffects(provider)`; listeners hear every change.
+ */
+declare class EffectsSlot {
+    private current;
+    private readonly listeners;
+    get provider(): EffectProvider | null;
+    set(provider: EffectProvider | null): void;
+    /** Sets `provider` and returns a function that clears it again (if it is still the one set). */
+    use(provider: EffectProvider): () => void;
+    /** The provider, or a `NoEffectsProviderError`. */
+    require(): EffectProvider;
+    subscribe(listener: (provider: EffectProvider | null) => void): () => void;
+}
+
+export { isEffectPixels as $, type EffectProviderCapabilities as A, type EffectRenderRequest as B, type EffectValue as C, type EffectDescription as D, type EffectProvider as E, type EffectPixels as F, type EffectSummary as G, EFFECT_KINDS as H, EFFECT_USES as I, type EffectControlSchema as J, type EffectImageSource as K, type EffectInputSpec as L, type EffectKind as M, type EffectPreset as N, type EffectRenderer as O, type EffectRendererOptions as P, type EffectSearchOptions as Q, type EffectSvgAnimation as R, type EffectValues as S, type EffectVectorMotion as T, type EffectVectorTarget as U, type VectorEffectType as V, EffectsSlot as W, applyEffectMask as X, createEffectPixels as Y, effectValueErrors as Z, encodeEffectFloat as _, type EffectUse as a, type MotionExitCommand as a$, linearToSrgb as a0, resolveEffectValues as a1, searchEffectSummaries as a2, srgbToLinear as a3, type MotionCommand as a4, type MotionShot as a5, type MotionScene as a6, type MotionDirection as a7, type MotionIrisShape as a8, type MotionSplitOrientation as a9, type FlairEaseName as aA, type FlairSpringEase as aB, type FlairSvgAnimation as aC, MOTION_BLENDS as aD, MOTION_CAMERA_MS as aE, MOTION_CASCADES as aF, MOTION_CLIP_TARGET as aG, MOTION_COMMAND_TYPES as aH, MOTION_DEFAULT_DURATIONS as aI, MOTION_DEFAULT_HOLD as aJ, MOTION_DIRECTIONS as aK, MOTION_DRAW_MS_PER_UNIT as aL, MOTION_DRAW_RANGE as aM, MOTION_DRIVEN_PROPERTIES as aN, MOTION_ENTER_STYLES as aO, MOTION_EXIT_STYLES as aP, MOTION_IRIS_SHAPES as aQ, MOTION_REPEAT_MODES as aR, MOTION_SPLIT_ORIENTATIONS as aS, MOTION_TEXT_UNITS as aT, MOTION_TRIGGERS as aU, type MotionColorPulseCommand as aV, type MotionCommandBase as aW, type MotionDrawCommand as aX, type MotionDrawOrder as aY, type MotionEffectCommand as aZ, type MotionEnterCommand as a_, type MotionDriver as aa, type MotionDrivenProperty as ab, type MotionRect as ac, type MotionBeatGrid as ad, type MotionCue as ae, type MotionCamera as af, type MotionTextUnit as ag, type MotionCascade as ah, type MotionBlur as ai, type MotionControl as aj, type MotionPreset as ak, type MotionClip as al, type FlairSvgMotion as am, type FlairVectorEffect as an, type MotionEffectSource as ao, type FlairExportOptions as ap, type FlairMotionExport as aq, type FlairEffectOptions as ar, type FlairEffectDocument as as, type MotionEnterStyle as at, type MotionExitStyle as au, type MotionCommandType as av, type MotionNarration as aw, FLAIR_EASES as ax, FLAIR_EXPORT_VERSION as ay, type FlairEase as az, type VectorEffectParamsMap as b, type VectorHorizontalResizing as b$, type MotionFadeCommand as b0, type MotionFollowCommand as b1, type MotionMatchCommand as b2, type MotionMorphCommand as b3, type MotionMoveCommand as b4, type MotionPlayCommand as b5, type MotionPulseCommand as b6, type MotionRotateCommand as b7, type MotionScaleCommand as b8, type MotionShakeCommand as b9, type VectorParagraphStyle as bA, type VectorTextFrame as bB, type VectorTransformHandle as bC, type VectorAnchorRef as bD, type VectorPathfinderOperation as bE, type VectorTool as bF, type VectorDefaults as bG, type VectorTextAlign as bH, type VectorStyle as bI, type VectorHandleRef as bJ, type VectorSegmentRef as bK, type VectorBlendOptions as bL, type VectorModifiers as bM, type VectorProviderEffect as bN, type VectorBlendMode as bO, type VectorAlign as bP, type VectorDistribute as bQ, type VectorArrange as bR, type VectorMaskType as bS, type VectorSymmetryMode as bT, type VectorSymmetry as bU, type VectorFreeformPoint as bV, type VectorMeshGradient as bW, type VectorFreeformGradient as bX, type VectorArrowhead as bY, type VectorResizing as bZ, type VectorFrame as b_, type MotionStyleCommand as ba, type MotionTeeterCommand as bb, type MotionTrigger as bc, type MotionWaitCommand as bd, type MotionWaveCommand as be, type MotionWiggleCommand as bf, flairAtLeast as bg, flairCurveFor as bh, flairEaseFor as bi, motionFlairPrimitive as bj, toFlairEffectDocument as bk, toFlairSvgMotion as bl, toFlairVectorEffect as bm, type VectorAnchor as bn, type VectorTextNode as bo, type VectorAnchorType as bp, type VectorCornerKind as bq, type VectorViewport as br, type VectorConnectorRoute as bs, type VectorConnectorSide as bt, type VectorConnectorEnd as bu, type VectorConnector as bv, type VectorConstraintKind as bw, type VectorConstraint as bx, type VectorCharacterStyle as by, type VectorTextRun as bz, type VectorPathNode as c, type VectorVerticalResizing as c0, type VectorMask as c1, type VectorAverageAxis as c2, type VectorSymbol as c3, type VectorParameter as c4, type VectorBlendSpacing as c5, type VectorGradientInterpolation as c6, type VectorStrokeGradientMode as c7, type VectorArrowAlign as c8, type VectorPaintLayer as c9, VECTOR_TOOLS as cA, VECTOR_TRANSFORM_HANDLES as cB, VECTOR_VERTICAL_RESIZING as cC, type VectorCorner as cD, type VectorGeomRef as cE, type VectorLineCap as cF, type VectorPathTextBaseline as cG, type VectorStrokeLayerKind as cH, type VectorTextRunStyle as cI, type VectorWarpStyle as cJ, type VectorStrokeLayer as ca, type VectorBlend as cb, type VectorMergeMode as cc, type VectorLineJoin as cd, type VectorStrokeSettings as ce, type VectorInstanceOverrides as cf, VECTOR_ARROWHEADS as cg, VECTOR_BLEND_MODES as ch, VECTOR_BLEND_SPACINGS as ci, VECTOR_CONNECTOR_ROUTES as cj, VECTOR_CONNECTOR_SIDES as ck, VECTOR_CONSTRAINT_KINDS as cl, VECTOR_CORNER_KINDS as cm, VECTOR_EFFECT_TYPES as cn, VECTOR_FILTER_TYPES as co, VECTOR_GRADIENT_INTERPOLATIONS as cp, VECTOR_GRADIENT_SPREADS as cq, VECTOR_GRADIENT_TYPES as cr, VECTOR_HORIZONTAL_RESIZING as cs, VECTOR_MASK_TYPES as ct, VECTOR_MERGE_MODES as cu, VECTOR_PATHFINDER_OPERATIONS as cv, VECTOR_PATH_TEXT_BASELINES as cw, VECTOR_STROKE_GRADIENT_MODES as cx, VECTOR_SYMMETRY_MODES as cy, VECTOR_TEXT_ALIGNS as cz, type VectorFillRule as d, type VectorBooleanOperation as e, type VectorNode as f, type VectorEffect as g, type VectorGroupNode as h, type VectorBounds as i, type VectorWarpMesh as j, type VectorInstanceNode as k, type VectorFilterType as l, type VectorFilterParamsMap as m, type VectorFilter as n, type VectorGradient as o, type Vec2 as p, type VectorGradientUnits as q, type VectorGradientSpread as r, type VectorGradientType as s, type VectorPaint as t, type VectorMatrix as u, type VectorGradientStop as v, type VectorStrokeAlign as w, type VectorSubpath as x, type VectorDocument as y, type VectorWidthPoint as z };