@directededges/specs-from-figma 0.22.0 → 0.23.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@directededges/specs-from-figma",
-  "version": "0.22.0",
+  "version": "0.23.0",
   "description": "Core data transformation model for Specs design specification tools",
   "type": "module",
   "main": "./dist/index.js",
@@ -31,7 +31,7 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@directededges/specs-schema": "^0.24.0",
+    "@directededges/specs-schema": "^0.25.0",
     "fs-extra": "^11.3.3",
     "yaml": "^2.8.0"
   },

package/dist/Adapters/RestApi/NodeIndexer.d.ts

@@ -1,118 +0,0 @@
-/**
- * NodeIndexer - Efficient node lookup and indexing for REST API data
- *
- * Purpose: Provide O(1) lookups for nodes, components, parents, and relationships
- * Status: Enhanced from inline PoC parent mapping (2026-01-10)
- *
- * Features:
- * - ID-based node lookup
- * - Parent relationship tracking
- * - Component indexing by ID and name
- * - Type-based node filtering
- *
- * Phase 1 Enhancements:
- * - T009: Component name lookup for instanceOf resolution
- * - T015: Main component lookup for dimension inheritance
- */
-/**
- * Minimal interface for REST API node data
- * This is the raw JSON structure from Figma REST API
- */
-interface RestApiNode {
-    id: string;
-    name: string;
-    type: string;
-    children?: RestApiNode[];
-    componentPropertyDefinitions?: Record<string, unknown>;
-    [key: string]: unknown;
-}
-export declare class NodeIndexer {
-    private nodeById;
-    private parentById;
-    private componentById;
-    private componentByName;
-    private nodesByType;
-    private componentNameById;
-    private componentSetIdById;
-    private root;
-    constructor(rootNode: RestApiNode, components?: Record<string, RestApiNode>, componentSets?: Record<string, RestApiNode>);
-    /**
-     * Recursively index all nodes in the tree
-     */
-    private indexTree;
-    /**
-     * Get node by ID
-     */
-    getById(id: string): RestApiNode | null;
-    /**
-     * Get parent of node by ID
-     */
-    getParent(id: string): RestApiNode | null;
-    /**
-     * Get component by ID
-     */
-    getComponentById(id: string): RestApiNode | null;
-    /**
-     * Get component by name
-     */
-    getComponentByName(name: string): RestApiNode | null;
-    /**
-     * Get component name by ID
-     * Returns null if component not found
-     *
-     * Phase 1 T009: Used to resolve instanceOf for RestInstanceNode
-     * Returns COMPONENT_SET name if the component is part of a set,
-     * otherwise returns the COMPONENT name
-     */
-    getComponentName(componentId: string): string | null;
-    /**
-     * Get component property definitions by ID
-     * Returns empty object if component not found
-     *
-     * Phase 1 T015: Used for dimension inheritance
-     */
-    getComponentPropertyDefinitions(componentId: string): Record<string, unknown>;
-    /**
-     * Get the component set ID for a variant component
-     * Returns null if the component has no parent set
-     */
-    getComponentSetId(componentId: string): string | null;
-    /** The indexed document root node. */
-    getRoot(): RestApiNode;
-    /** All page nodes in the document. REST API pages are type CANVAS; PAGE is included for plugin-shaped data. */
-    getPages(): RestApiNode[];
-    /**
-     * Boundary-respecting recursive walk for example/subcomponent discovery.
-     *
-     * Starting from a containment root (a PAGE, SECTION, FRAME, or GROUP), descend
-     * through SECTION/FRAME/GROUP containers collecting nodes whose type matches.
-     * The walk STOPS at COMPONENT, COMPONENT_SET, and INSTANCE boundaries — it
-     * never descends into them — so instances nested inside other instances,
-     * components, or sets are NOT returned. The boundary node itself is collected
-     * if its own type matches, but its children are not traversed.
-     *
-     * Each result carries its immediate-parent node so callers can filter on
-     * `parentName`.
-     */
-    walkBoundary(roots: RestApiNode[], types: string[]): Array<{
-        node: RestApiNode;
-        parent: RestApiNode | null;
-    }>;
-    /**
-     * Find nodes by type(s)
-     */
-    findAllByType(...types: string[]): RestApiNode[];
-    /**
-     * Find node by name or ID, optionally filtered by type(s)
-     */
-    findByNameOrId(nameOrId: string, ...types: string[]): RestApiNode | null;
-    /**
-     * Get statistics about indexed data
-     */
-    getStats(): {
-        totalNodes: number;
-        components: number;
-        types: Record<string, number>;
-    };
-}
-export {};

package/dist/Adapters/RestApi/RestBaseNode.d.ts

@@ -1,271 +0,0 @@
-/**
- * RestBaseNode - Base adapter implementing Figma Plugin API BaseNode interface for REST API data
- *
- * Purpose: Wrap REST API JSON nodes to provide Plugin API-compatible interface
- * Status: Production migration from validated PoC (2026-01-10)
- *
- * This adapter allows existing Model classes to work with Figma REST API data
- * without modification by implementing the minimal Plugin API surface needed.
- *
- * Type Safety: Uses official @figma/rest-api-spec types for improved autocomplete,
- * linting, and compatibility with Figma's REST API schema.
- */
-import type { Paint as FigmaRestPaint, VariableAlias as FigmaRestVariableAlias, Rectangle as FigmaRestRectangle, TypeStyle as FigmaRestTypeStyle, Vector as FigmaRestVector, Transform as FigmaRestTransform, IsLayerTrait as FigmaRestIsLayerTrait, StrokeWeights as FigmaRestStrokeWeights, HasFramePropertiesTrait as FigmaRestHasFramePropertiesTrait, MinimalStrokesTrait as FigmaRestMinimalStrokesTrait, HasGeometryTrait as FigmaRestHasGeometryTrait } from '@figma/rest-api-spec';
-import type { NodeIndexer } from './NodeIndexer';
-/**
- * Minimal interface for REST API node data
- * This is the raw JSON structure from Figma REST API
- */
-type VariableBinding = FigmaRestVariableAlias;
-type FigmaRestBoundVariables = NonNullable<FigmaRestIsLayerTrait['boundVariables']>;
-/**
- * Extended BoundVariables type combining official REST API spec with Plugin API mappings
- *
- * Official REST API bindings (from FigmaRestBoundVariables):
- * - size: { x, y } → Transformed to width/height in boundVariables getter
- * - rectangleCornerRadii: { RECTANGLE_TOP_LEFT_CORNER_RADIUS, ... } → Transformed to topLeftRadius, etc.
- *
- * Plugin API custom properties added during transformation (see boundVariables getter):
- * - width, height (from size.x, size.y)
- * - topLeftRadius, topRightRadius, bottomRightRadius, bottomLeftRadius (from rectangleCornerRadii)
- *
- * The boundVariables getter performs these transformations to match Plugin API expectations.
- */
-type BoundVariables = FigmaRestBoundVariables & {
-    width?: VariableBinding;
-    height?: VariableBinding;
-    [key: string]: unknown;
-};
-interface RestNodeStyles {
-    text?: string;
-    effect?: string;
-    fill?: string;
-    stroke?: string;
-    grid?: string;
-}
-export interface RestApiNodeData {
-    id: string;
-    name: string;
-    type: string;
-    children?: RestApiNodeData[];
-    absoluteBoundingBox?: FigmaRestRectangle;
-    size?: FigmaRestVector;
-    relativeTransform?: FigmaRestTransform;
-    fills?: FigmaRestPaint[];
-    strokes?: FigmaRestPaint[];
-    effects?: FigmaRestPaint[];
-    styles?: RestNodeStyles;
-    boundVariables?: BoundVariables;
-    visible?: boolean;
-    layoutMode?: NonNullable<FigmaRestHasFramePropertiesTrait['layoutMode']>;
-    primaryAxisSizingMode?: NonNullable<FigmaRestHasFramePropertiesTrait['primaryAxisSizingMode']>;
-    counterAxisSizingMode?: NonNullable<FigmaRestHasFramePropertiesTrait['counterAxisSizingMode']>;
-    primaryAxisAlignItems?: NonNullable<FigmaRestHasFramePropertiesTrait['primaryAxisAlignItems']>;
-    counterAxisAlignItems?: NonNullable<FigmaRestHasFramePropertiesTrait['counterAxisAlignItems']>;
-    paddingLeft?: number;
-    paddingRight?: number;
-    paddingTop?: number;
-    paddingBottom?: number;
-    itemSpacing?: number;
-    layoutWrap?: NonNullable<FigmaRestHasFramePropertiesTrait['layoutWrap']>;
-    layoutPositioning?: string;
-    layoutSizingHorizontal?: string;
-    layoutSizingVertical?: string;
-    itemReverseZIndex?: boolean;
-    counterAxisAlignContent?: NonNullable<FigmaRestHasFramePropertiesTrait['counterAxisAlignContent']>;
-    counterAxisSpacing?: number;
-    constraints?: {
-        horizontal: string;
-        vertical: string;
-    };
-    minWidth?: number;
-    maxWidth?: number;
-    minHeight?: number;
-    maxHeight?: number;
-    rotation?: number;
-    opacity?: number;
-    clipContent?: boolean;
-    locked?: boolean;
-    strokeWeight?: number;
-    strokeAlign?: NonNullable<FigmaRestMinimalStrokesTrait['strokeAlign']>;
-    strokeCap?: NonNullable<FigmaRestHasGeometryTrait['strokeCap']>;
-    strokeJoin?: NonNullable<FigmaRestMinimalStrokesTrait['strokeJoin']>;
-    individualStrokeWeights?: FigmaRestStrokeWeights;
-    cornerRadius?: number;
-    rectangleCornerRadii?: number[];
-    characters?: string;
-    componentPropertyReferences?: {
-        [key: string]: string;
-    };
-    [key: string]: unknown;
-}
-/**
- * Base adapter class for all REST API nodes
- * Implements core BaseNode interface properties and methods
- */
-export declare class RestBaseNode {
-    protected _data: RestApiNodeData;
-    protected _parent: RestBaseNode | null;
-    protected _indexer: NodeIndexer | null;
-    protected _childrenCache: RestBaseNode[] | null;
-    constructor(data: RestApiNodeData, parent?: RestBaseNode | null);
-    /**
-     * Set the indexer for this node and propagate to children
-     * Called by RestApiFileDocument after tree construction
-     */
-    setIndexer(indexer: NodeIndexer): void;
-    get id(): string;
-    get name(): string;
-    get type(): string;
-    get parent(): RestBaseNode | null;
-    get removed(): boolean;
-    get styles(): RestNodeStyles | undefined;
-    get style(): FigmaRestTypeStyle | undefined;
-    /**
-     * Find first child matching callback
-     * Returns null if no match or node has no children
-     */
-    findChild(callback: (node: RestBaseNode) => boolean): RestBaseNode | null;
-    /**
-     * Find all children matching callback (or all if no callback)
-     * Returns empty array if no matches or node has no children
-     */
-    findAll(callback?: (node: RestBaseNode) => boolean): RestBaseNode[];
-    /**
-     * Factory method to wrap child data in appropriate adapter class
-     *
-     * Base implementation routes INSTANCE types to RestInstanceNode.
-     * Child classes (RestComponentNode) can override this for additional routing.
-     */
-    protected wrapChild(childData: RestApiNodeData): RestBaseNode;
-    /**
-     * Set plugin data - no-op in REST mode (data is read-only)
-     */
-    setPluginData(_key: string, _value: string): void;
-    /**
-     * Get plugin data - returns empty string (REST data doesn't include plugin data)
-     */
-    getPluginData(_key: string): string;
-    get fills(): readonly FigmaRestPaint[];
-    get strokes(): readonly FigmaRestPaint[];
-    get effects(): readonly FigmaRestPaint[];
-    /**
-     * Extract boundVariables from fills/strokes/effects
-     * In REST API, boundVariables are nested inside each paint object, not at node level
-     * This getter reconstructs the Plugin API format: { fills: [{id, type}], strokes: [...], ... }
-     *
-     * Note: Only SolidPaint has boundVariables in the official Figma REST API spec
-     */
-    get boundVariables(): BoundVariables | undefined;
-    get fillStyleId(): string | typeof figma.mixed;
-    get strokeStyleId(): string;
-    get textStyleId(): string | typeof figma.mixed;
-    get effectStyleId(): string;
-    get gridStyleId(): string;
-    get layoutMode(): NonNullable<FigmaRestHasFramePropertiesTrait['layoutMode']>;
-    get primaryAxisSizingMode(): NonNullable<FigmaRestHasFramePropertiesTrait['primaryAxisSizingMode']>;
-    get counterAxisSizingMode(): NonNullable<FigmaRestHasFramePropertiesTrait['counterAxisSizingMode']>;
-    get primaryAxisAlignItems(): NonNullable<FigmaRestHasFramePropertiesTrait['primaryAxisAlignItems']>;
-    get counterAxisAlignItems(): NonNullable<FigmaRestHasFramePropertiesTrait['counterAxisAlignItems']>;
-    get paddingLeft(): number;
-    get paddingRight(): number;
-    get paddingTop(): number;
-    get paddingBottom(): number;
-    get itemSpacing(): number;
-    get layoutWrap(): NonNullable<FigmaRestHasFramePropertiesTrait['layoutWrap']>;
-    get layoutPositioning(): string;
-    get layoutSizingHorizontal(): string;
-    get layoutSizingVertical(): string;
-    get itemReverseZIndex(): boolean;
-    get counterAxisAlignContent(): NonNullable<FigmaRestHasFramePropertiesTrait['counterAxisAlignContent']>;
-    get counterAxisSpacing(): number;
-    /**
-     * Normalizes REST API constraint enum names to Plugin API equivalents.
-     * REST uses directional names (LEFT, RIGHT, TOP, BOTTOM, LEFT_RIGHT, TOP_BOTTOM);
-     * Plugin API uses abstract names (MIN, MAX, STRETCH). CENTER and SCALE are identical.
-     */
-    get constraints(): {
-        horizontal: string;
-        vertical: string;
-    };
-    get minWidth(): number | null;
-    get maxWidth(): number | null;
-    get minHeight(): number | null;
-    get maxHeight(): number | null;
-    get clipContent(): boolean;
-    get locked(): boolean;
-    get opacity(): number;
-    get cornerSmoothing(): number;
-    get rotation(): number;
-    get strokeWeight(): number;
-    get strokeAlign(): NonNullable<FigmaRestMinimalStrokesTrait['strokeAlign']>;
-    get strokeCap(): NonNullable<FigmaRestHasGeometryTrait['strokeCap']>;
-    get strokeJoin(): NonNullable<FigmaRestMinimalStrokesTrait['strokeJoin']>;
-    get strokeTopWeight(): number;
-    get strokeBottomWeight(): number;
-    get strokeLeftWeight(): number;
-    get strokeRightWeight(): number;
-    get cornerRadius(): number | typeof figma.mixed;
-    get topLeftRadius(): number;
-    get topRightRadius(): number;
-    get bottomRightRadius(): number;
-    get bottomLeftRadius(): number;
-    get textAlignHorizontal(): string;
-    get textAlignVertical(): string;
-    get characters(): string;
-    get characterStyleOverrides(): number[] | undefined;
-    get styleOverrideTable(): Record<string, Record<string, unknown>> | undefined;
-    get componentPropertyReferences(): {
-        [key: string]: string;
-    } | null;
-    get width(): number;
-    get height(): number;
-    get x(): number;
-    get y(): number;
-    get absoluteBoundingBox(): RestApiNodeData['absoluteBoundingBox'] | null;
-    get visible(): boolean;
-    /**
-     * Get main component asynchronously
-     * Base implementation returns null - only RestInstanceNode has actual implementation
-     */
-    getMainComponentAsync(): Promise<RestBaseNode | null>;
-    /**
-     * Get children as wrapped adapter instances
-     * Cached for performance - only built once
-     *
-     * CRITICAL: This getter is required for Anatomy.traverse() to work correctly.
-     * Without it, traverse() sees raw JSON children instead of wrapped adapter nodes,
-     * causing shallow anatomy extraction (only 2 elements instead of 14).
-     */
-    get children(): RestBaseNode[];
-    /**
-     * Build children array from raw data, wrapping each in appropriate adapter
-     */
-    protected _buildChildren(): RestBaseNode[];
-    /**
-     * Adapt a REST API paint to Plugin API format.
-     * - Defaults `visible` to true
-     * - Converts `gradientHandlePositions` → `gradientTransform` for gradient paints
-     */
-    private static adaptPaint;
-    /**
-     * Convert REST API `gradientHandlePositions` (3 vectors: start, end, width)
-     * to Plugin API `gradientTransform` (2×3 affine matrix).
-     *
-     * REST handle positions use Y-down screen coordinates; the Plugin API
-     * `gradientTransform` uses Y-up.
-     *
-     * LINEAR gradients: p0=start, p1=end, p2=perpendicular width handle.
-     *   Gradient-space mapping: p0→(0,0.5), p1→(1,0.5), p2→(0,0)
-     *   a = p1.x−p0.x   b = 2·(p0.x−p2.x)   tx = p2.x
-     *   c = p1.y−p0.y   d = 2·(p0.y−p2.y)   ty = p2.y
-     *
-     * RADIAL/ANGULAR gradients: p0=center, p1=horiz radius, p2=vert radius.
-     *   Gradient-space mapping: p0→(0,0), p1→(1,0), p2→(0,1)
-     *   a = p1.x−p0.x   b = p2.x−p0.x   tx = p0.x
-     *   c = p1.y−p0.y   d = p2.y−p0.y   ty = p0.y
-     */
-    private static handlePositionsToTransform;
-    toString(): string;
-}
-export {};

package/dist/Adapters/RestApi/RestComponentNode.d.ts

@@ -1,30 +0,0 @@
-/**
- * RestComponentNode - Adapter for COMPONENT and COMPONENT_SET nodes
- *
- * Purpose: Extends RestBaseNode to add component-specific properties
- * Status: Production migration from validated PoC (2026-01-10)
- *
- * Key Features:
- * - Property-definition-based default variant resolution
- * - Component property definitions exposure
- * - Children caching for performance
- */
-import { RestBaseNode, type RestApiNodeData } from './RestBaseNode';
-export declare class RestComponentNode extends RestBaseNode {
-    get componentPropertyDefinitions(): Record<string, unknown>;
-    /**
-     * For COMPONENT_SET, returns the default variant child.
-     *
-     * Resolves the default by building the expected child name from
-     * componentPropertyDefinitions VARIANT entries and their defaultValues
-     * (e.g. "Appearance=On surface, Size=M"). Falls back to first child
-     * if no property-based match is found.
-     */
-    get defaultVariant(): RestComponentNode | null;
-    _buildChildren(): RestBaseNode[];
-    /**
-     * Override wrapChild to route by type
-     * Ensures children get wrapped in appropriate adapter classes
-     */
-    protected wrapChild(childData: RestApiNodeData): RestBaseNode;
-}

package/dist/Adapters/RestApi/RestInstanceNode.d.ts

@@ -1,50 +0,0 @@
-/**
- * RestInstanceNode - Adapter for INSTANCE nodes
- *
- * Purpose: Extends RestBaseNode to add instance-specific properties
- * Status: Production migration from validated PoC (2026-01-10)
- *
- * Key Features:
- * - Component ID resolution
- * - Component properties exposure
- * - Main component lookup (requires indexer - Phase 1)
- * - Component property references (Phase 1 enhancement)
- */
-import { RestBaseNode, type RestApiNodeData } from './RestBaseNode';
-export declare class RestInstanceNode extends RestBaseNode {
-    get componentId(): string;
-    get componentProperties(): Record<string, unknown>;
-    /**
-     * Component property references (binding information)
-     * Maps property IDs to bound node IDs for instance property bindings
-     *
-     * TODO: Phase 1 Task T012 - Extract from REST data and map to Plugin API format
-     */
-    get componentPropertyReferences(): {
-        [key: string]: string;
-    };
-    /**
-     * Get main component asynchronously
-     *
-     * Uses NodeIndexer to look up component by componentId
-     * Returns null if indexer not set or component not found
-     */
-    getMainComponentAsync(): Promise<RestBaseNode | null>;
-    /**
-     * Get instanceOf name (the component this is an instance of)
-     * Used by Model classes to display instance relationships
-     *
-     * Phase 1 T010: Uses indexer to resolve component name
-     */
-    get instanceOf(): string | null;
-    /**
-     * Synchronous main component getter (legacy support)
-     * Delegates to async method - may return Promise in REST mode
-     */
-    get mainComponent(): Promise<RestBaseNode | null>;
-    _buildChildren(): RestBaseNode[];
-    /**
-     * Override wrapChild to route by type
-     */
-    protected wrapChild(childData: RestApiNodeData): RestBaseNode;
-}

package/dist/Adapters/RestApi/RestLibraryFile.d.ts

@@ -1,51 +0,0 @@
-/**
- * RestLibraryFile - Wrapper for Figma REST API JSON library data
- *
- * Purpose: Provide validated access to component library JSON structure
- * Scope: Internal to specs-from-figma, not exported in public API
- *
- * Features:
- * - Basic schema validation
- * - Component lookup by name or ID
- * - Node indexing for O(1) lookups
- * - Component wrapping in adapter classes
- *
- * Note: File I/O removed - CLI/Plugin passes pre-loaded JSON
- */
-import { RestComponentNode } from '../RestApi/RestComponentNode.js';
-import { NodeIndexer } from '../RestApi/NodeIndexer.js';
-export interface RestApiFileData {
-    document: any;
-    components?: Record<string, any>;
-    componentSets?: Record<string, any>;
-    styles?: Record<string, any>;
-    variables?: Record<string, any>;
-    schemaVersion?: number;
-    name?: string;
-}
-/**
- * Represents a Figma REST API library file (internal to transformer)
- */
-export declare class RestLibraryFile {
-    private _data;
-    private _indexer;
-    constructor(data: RestApiFileData);
-    /**
-     * Validate required structure
-     */
-    private validate;
-    /**
-     * Get or create the node indexer
-     * Indexer provides O(1) lookups for components, parents, etc.
-     */
-    getIndexer(): NodeIndexer;
-    /**
-     * Find a component by name or ID
-     * Returns null if not found
-     */
-    findComponent(nameOrId: string): RestComponentNode | null;
-    /**
-     * Find all components in the file
-     */
-    findAllComponents(): RestComponentNode[];
-}

package/dist/Adapters/RestApi/RestTextNode.d.ts

@@ -1,41 +0,0 @@
-/**
- * REST API text nodes have typography properties nested under style.*
- * Unlike Plugin API where they're at the top level (node.fontSize, node.fontName, etc.)
- * Also includes styles object for text style and effect style references
- */
-export interface RESTTextStyleOverride {
-    fontFamily?: string;
-    fontStyle?: string;
-    fontSize?: number;
-    letterSpacing?: number;
-    lineHeightUnit?: string;
-    lineHeightPercentFontSize?: number;
-    lineHeightPx?: number;
-}
-export interface RESTTextNode extends TextNode {
-    style?: {
-        fontSize?: number;
-        fontFamily?: string;
-        fontStyle?: string;
-        letterSpacing?: number;
-        lineHeightUnit?: string;
-        lineHeightPercentFontSize?: number;
-        lineHeightPx?: number;
-        textCase?: string;
-        textDecoration?: string;
-        leadingTrim?: string;
-        paragraphIndent?: number;
-        paragraphSpacing?: number;
-        listSpacing?: number;
-        hangingPunctuation?: boolean;
-        hangingList?: boolean;
-    };
-    styles?: {
-        text?: string;
-        effect?: string;
-        fill?: string;
-        stroke?: string;
-    };
-    characterStyleOverrides?: number[];
-    styleOverrideTable?: Record<string, RESTTextStyleOverride>;
-}

package/dist/Component/Anatomy/Anatomy.d.ts

@@ -1,97 +0,0 @@
-import { ResolvedConfig } from '@directededges/specs-schema';
-import { FigmaElementNode, FigmaContainerNode } from '../Nodes/types.js';
-import type { LayoutTree } from '../Layout/types.js';
-import type { Anatomy as AnovaAnatomy } from '@directededges/specs-schema';
-import { ProcessingContext } from '../../Runtime/Context/interfaces.js';
-import { Variant } from '../Variants/Variant.js';
-import { AnatomyElement } from './AnatomyElement.js';
-import type { Elements } from '../Elements/Elements.js';
-export type AnatomyItems = Record<string, AnatomyElement>;
-export declare class Anatomy {
-    private _items;
-    private config;
-    constructor(config: ResolvedConfig);
-    /**
-     * Get the anatomy element name for a node.
-     * Root nodes (when isRoot is true) are named 'root', all others use their Figma name.
-     */
-    static getAnatomyElementName(node: FigmaElementNode, isRoot?: boolean): string;
-    addNewElementsFromVariant(variant: Variant): void;
-    /**
-     * Populate anatomy from a slot content Elements set (no variant context).
-     * All elements keep their Figma names — none is renamed to 'root'.
-     */
-    addFromElements(elements: Elements): void;
-    add(elementNode: FigmaElementNode, elementName: string, variant: Variant | null): void;
-    resolveInstanceNames(context?: ProcessingContext): Promise<void>;
-    data(subcomponentRefs?: Map<string, string>): AnovaAnatomy;
-    get(name: string): AnatomyElement | undefined;
-    has(name: string): boolean;
-    /**
-     * Returns an iterator over [name, element] entries.
-     * @example
-     * for (const [name, element] of anatomy.entries()) {
-     *   console.log(name, element);
-     * }
-     */
-    entries(): IterableIterator<[string, AnatomyElement]>;
-    /**
-     * Returns an iterator over anatomy element values.
-     * @example
-     * for (const element of anatomy.values()) {
-     *   await element.postProcess();
-     * }
-     */
-    values(): IterableIterator<AnatomyElement>;
-    /**
-     * Returns an iterator over anatomy element names.
-     * @example
-     * for (const name of anatomy.keys()) {
-     *   console.log(name);
-     * }
-     */
-    keys(): IterableIterator<string>;
-    /**
-     * Makes Anatomy directly iterable (defaults to entries).
-     * @example
-     * for (const [name, element] of anatomy) {
-     *   console.log(name, element);
-     * }
-     */
-    [Symbol.iterator](): IterableIterator<[string, AnatomyElement]>;
-    /**
-     * Returns the number of anatomy elements in the collection.
-     */
-    get size(): number;
-    /**
-     * Checks if the collection is empty.
-     * @example
-     * if (anatomy.isEmpty()) {
-     *   return;
-     * }
-     */
-    isEmpty(): boolean;
-    /**
-     * Detect the code-only props container among direct children of a root node.
-     * Returns the first matching container and the set of matching child names
-     * for anatomy exclusion during traverse().
-     */
-    static exclusions(rootNode: FigmaElementNode, pattern?: string): {
-        container?: FigmaElementNode;
-        excludeNames?: Set<string>;
-    };
-    static traverse(componentNode: FigmaContainerNode, excludeRootChildren?: Set<string>): {
-        nodes: FigmaElementNode[];
-        tree: LayoutTree;
-    };
-    /**
-     * Traverse the children of a slot node as a slot content space.
-     * Unlike traverse(), no node is renamed to 'root' — all nodes keep their Figma names.
-     * Traversal stops at INSTANCE children (each instance's slots are their own spaces).
-     * Returns collected nodes and a synthetic LayoutTree whose root holds the slot's content children.
-     */
-    static traverseSlotContent(slotNode: FigmaContainerNode): {
-        nodes: FigmaElementNode[];
-        tree: LayoutTree;
-    };
-}