@directededges/specs-from-figma 0.20.0 → 0.22.0

package/dist/Component/Children/Children.d.ts

@@ -0,0 +1,96 @@
+import { ResolvedConfig } from '@directededges/specs-schema';
+import { Children as AnovaChildren, PropBinding as AnovaPropBinding } from "@directededges/specs-schema";
+import { FigmaElementNode } from "../Nodes/types.js";
+import { type ProcessingContext } from '../../Runtime/Context/interfaces.js';
+export declare class Children {
+    private _items;
+    private _binding;
+    private _examples;
+    private config;
+    constructor(config: ResolvedConfig);
+    /**
+     * Populate children from a Figma node's children or slot reference.
+     * Clears any binding reference since items and binding are mutually exclusive.
+     * @param node A Figma node to extract children from
+     */
+    evaluate(node: FigmaElementNode, propRefs?: Record<string, string>, context?: ProcessingContext): void;
+    /**
+     * Set the children value - either items array or binding reference.
+     * Items and binding are mutually exclusive; setting one clears the other.
+     * @param value Array of child names or a AnovaPropBinding binding
+     */
+    set(value: string[] | AnovaPropBinding): void;
+    /**
+     * Check if this children property is bound to a prop.
+     * @returns true if bound, false otherwise
+     */
+    isBound(): boolean;
+    /**
+     * Check if children is empty (no items, not bound, no example fills).
+     * An example reference alone is a meaningful difference and is not empty.
+     * @returns true if empty, false otherwise
+     */
+    empty(): boolean;
+    /**
+     * @param layer - The Children to merge onto this one
+     * @returns A new Children instance with merged values
+     */
+    merge(layer: Children): Children;
+    /**
+     * @param baseline - The Children to compare against
+     * @returns A new Children instance with differences, or empty if no differences
+     */
+    compare(baseline: Children): Children;
+    private static _examplesEqual;
+    /**
+     * Set the slot fill example reference (ADR-047) for this slot binding.
+     * Called before data() is invoked; data() emits `examples` when set.
+     * Currently a single reference — Figma's default fill for the slot layer.
+     */
+    setExample(pointer: string): void;
+    /**
+     * Get the children data formatted according to settings.
+     * Returns a SlotBinding (with optional `examples`) if bound,
+     * otherwise formatted children array.
+     */
+    data(): AnovaChildren | undefined;
+    /**
+     * Get the children value - binding, items array, or null if empty.
+     * @returns AnovaPropBinding if bound, array if items exist, null if empty
+     */
+    get(): string[] | AnovaPropBinding | null;
+    /**
+     * Returns an iterator over child names.
+     * @example
+     * for (const childName of children.values()) {
+     *   console.log(childName);
+     * }
+     */
+    values(): IterableIterator<string>;
+    /**
+     * Makes Children directly iterable.
+     * @example
+     * for (const childName of children) {
+     *   console.log(childName);
+     * }
+     */
+    [Symbol.iterator](): IterableIterator<string>;
+    /**
+     * Returns the number of children.
+     */
+    get size(): number;
+    /**
+     * Checks if there are no children.
+     * @example
+     * if (children.isEmpty()) {
+     *   return;
+     * }
+     */
+    isEmpty(): boolean;
+    /**
+     * Create a deep clone of this Children instance.
+     *
+     * @returns A new Children instance with copied child names and binding
+     */
+    clone(): Children;
+}

package/dist/Component/Color/Color.d.ts

@@ -0,0 +1,63 @@
+import type { ColorObject, ColorFormat } from '@directededges/specs-schema';
+/**
+ * Color — first-class wrapper for DTCG ColorObject objects.
+ *
+ * Provides lifecycle methods (difference, clone, data) consistent with
+ * peer value types (Gradient, Shadow, Effects, Typography).
+ * Public readonly fields preserve `toMatchObject` compatibility in tests.
+ */
+export declare class Color {
+    readonly colorSpace: string;
+    readonly components: (number | 'none')[];
+    readonly alpha?: number;
+    readonly hex: string;
+    constructor(value: ColorObject);
+    /**
+     * Returns true if this Color differs from base.
+     * Compares hex (encodes all three RGB channels) and alpha.
+     */
+    difference(base: Color): boolean;
+    /**
+     * Deep copy returning a new independent instance.
+     */
+    clone(): Color;
+    /**
+     * Serialize to the specs-schema ColorObject interface, or to a formatted
+     * color string when a non-OBJECT ColorFormat is specified.
+     */
+    data(format?: ColorFormat): ColorObject | string;
+    /** 6-digit sRGB hex: `#FF6600` */
+    toHex(): string;
+    /** 8-digit sRGB hex with alpha: `#FF6600FF` */
+    toHexa(): string;
+    /** CSS `rgb()` functional notation: `rgb(255, 102, 0)` */
+    toRgb(): string;
+    /** CSS `rgba()` functional notation: `rgba(255, 102, 0, 1)` */
+    toRgba(): string;
+    /** CSS `hsla()` functional notation: `hsla(24, 100%, 50%, 1)` */
+    toHsla(): string;
+    /** Figma HSB/HSV notation: `hsb(24, 100%, 100%)` */
+    toHsb(): string;
+    /** CSS Color Level 4 `oklch()`: `oklch(0.7 0.15 50 / 1)` */
+    toOklch(): string;
+    /** CSS Color Level 4 `oklab()`: `oklab(0.7 0.1 0.1 / 1)` */
+    toOklab(): string;
+    /** Resolved alpha rounded to 4dp: 1 when omitted. */
+    private alphaValue;
+    /** sRGB components as 0–255 integers. */
+    private rgb255;
+    /** sRGB 0–1 components, coercing 'none' to 0. */
+    private srgbComponents;
+    /** sRGB → HSL. Returns [h (0–360), s (0–100), l (0–100)] rounded. */
+    private hsl;
+    /** sRGB → HSB/HSV. Returns [h (0–360), s (0–100), b (0–100)] rounded. */
+    private hsb;
+    /** sRGB → OKLab. Returns [L, a, b] rounded to 4 decimal places. */
+    private oklab;
+    /** sRGB → OKLCh. Returns [L, C, h] with L/C rounded to 4dp, h to 2dp. */
+    private oklch;
+    /** sRGB gamma → linear. */
+    private static srgbToLinear;
+    /** Round to 4 decimal places. */
+    private static round4;
+}

package/dist/Component/Component.d.ts

@@ -0,0 +1,71 @@
+import { Anatomy } from './Anatomy/Anatomy.js';
+import type { Component as AnovaComponent } from '@directededges/specs-schema';
+import { SpecableNode } from './Nodes/types.js';
+import { ResolvedConfig } from '@directededges/specs-schema';
+import { ProgressCoordinator } from '../Progress/ProgressCoordinator.js';
+import type { ProcessingContext } from '../Runtime/Context/interfaces.js';
+import type { StylesMap, VariablesMap, CollectionsMap } from '../Runtime/Foundations/FigmaRESTMaps.js';
+import type { RestLicenseInput } from '../License/types.js';
+/**
+ * Options for REST/CLI environment
+ * Internal interface - not exported
+ */
+interface RestOptions {
+    coordinator?: ProgressCoordinator;
+    styles: StylesMap;
+    variables: VariablesMap;
+    collections: CollectionsMap;
+    author?: string;
+}
+export declare class Component {
+    private _anatomy;
+    private props;
+    private variants;
+    private subcomponents;
+    private instanceExamples;
+    private _slotContent?;
+    /** Shared slot-fill registry: component's own fills AND instanceExamples' fills dedup here. */
+    private _slotRegistry;
+    protected config: ResolvedConfig;
+    private context?;
+    private node;
+    private _name;
+    private options?;
+    get name(): () => string;
+    protected get anatomy(): Anatomy;
+    /**
+     * Create Component from REST API JSON
+     * Returns fully-processed Component ready for .yaml() output
+     *
+     * @param libraryJson - Raw REST API JSON data
+     * @param componentId - Component name or ID to extract
+     * @param config - Component configuration
+     * @param options - Required: styles, variables, collections Maps; Optional: coordinator, author
+     * @throws Error if JSON is invalid or component not found
+     */
+    static fromRestApi(libraryJson: any, componentId: string, config: ResolvedConfig, options: RestOptions, licenseInput?: RestLicenseInput): Promise<Component>;
+    constructor(node: SpecableNode, config: ResolvedConfig, options?: RestOptions);
+    /**
+     * Internal processing method
+     * Called by factory methods and subclasses
+     */
+    protected _process(coordinator?: ProgressCoordinator, context?: ProcessingContext): Promise<void>;
+    /** JSON Pointer base for this host's slot content references. Overridden by Subcomponent. */
+    protected _slotBasePath(): string;
+    /**
+     * Component ids an instance example may resolve to — used to confirm a candidate
+     * is genuinely an instance of THIS component before treating it as an example
+     * (ADR-048). Computed by node kind, since a COMPONENT may or may not live inside
+     * a COMPONENT_SET:
+     *  - COMPONENT_SET → its variant child COMPONENT ids (a variant instance's
+     *    mainComponent points at a child variant, never at the set itself).
+     *  - standalone COMPONENT → its own id (instances point directly at it).
+     */
+    protected _acceptableComponentIds(): Set<string>;
+    protected _processSlots(context?: ProcessingContext): Promise<void>;
+    protected data(): AnovaComponent;
+    yaml(): string;
+    json(): AnovaComponent;
+    static componentRootNode(node: SpecableNode, variantName: string): ComponentNode | undefined;
+}
+export {};

package/dist/Component/Effects/Blur.d.ts

@@ -0,0 +1,41 @@
+import type { Blur as AnovaBlur } from '@directededges/specs-schema';
+import type { ResolvedConfig } from '@directededges/specs-schema';
+import { FigmaVariableReference } from '../Styles/Style.js';
+/**
+ * Represents one evaluated LAYER_BLUR or BACKGROUND_BLUR effect item.
+ * Singular per role — the containing `Effects` key (`layerBlur` vs
+ * `backgroundBlur`) determines render role.
+ * Peer to `Shadow` in the Effects class hierarchy.
+ */
+export declare class Blur {
+    visible: boolean;
+    radius: number | FigmaVariableReference;
+    /**
+     * Populate fields from a Figma LAYER_BLUR or BACKGROUND_BLUR effect object.
+     * `boundVariables.radius` carries variable binding when the radius field is
+     * bound to a Figma variable.
+     */
+    evaluate(effect: BlurEffect): void;
+    /**
+     * Returns true if any field differs from the base Blur.
+     * Type-mismatch rule: primitive vs FigmaVariableReference is always different.
+     */
+    difference(base: Blur): boolean;
+    /**
+     * Deep clone: primitive fields by value, FigmaVariableReference instances cloned.
+     */
+    clone(): Blur;
+    /**
+     * Returns null if identical to baseline, otherwise returns this.clone().
+     */
+    compare(baseline: Blur): Blur | null;
+    /**
+     * Blur merge is whole-object replacement: returns layer.clone().
+     */
+    merge(layer: Blur): Blur;
+    /**
+     * Serialize to the anova output shape, applying config.format settings.
+     * Returns a shape compatible with the `Blur` interface from `@directededges/specs-schema`.
+     */
+    data(config: ResolvedConfig): AnovaBlur;
+}

package/dist/Component/Effects/Effects.d.ts

@@ -0,0 +1,51 @@
+import type { Effects as AnovaEffects } from '@directededges/specs-schema';
+import type { ResolvedConfig } from '@directededges/specs-schema';
+import { Shadow } from './Shadow.js';
+import { Blur } from './Blur.js';
+/**
+ * Named-key container for all four Figma effect roles.
+ *
+ * Each key is optional; a key is omitted when no effects of that type are
+ * present on the node. `Shadow` is used for both drop and inner shadows —
+ * `Shadow.inset` distinguishes them (absent/false = drop, true = inner).
+ *
+ * Maps directly to platform properties:
+ * - `shadows` (inset=false/absent) → `box-shadow` / `.shadow()`
+ * - `shadows` (inset=true)         → `inset box-shadow`
+ * - `layerBlur`                    → `filter: blur()`
+ * - `backgroundBlur`               → `backdrop-filter: blur()`
+ */
+export declare class Effects {
+    shadows?: Shadow[];
+    layerBlur?: Blur;
+    backgroundBlur?: Blur;
+    pushShadow(shadow: Shadow): void;
+    /**
+     * Returns true when no effect of any type has been set.
+     */
+    isEmpty(): boolean;
+    /**
+     * Returns true if this Effects instance differs from base.
+     * Shadow arrays are compared positionally within each key (independent groups).
+     * Blur fields differ when one is present and the other absent, or when their
+     * values differ.
+     */
+    difference(base: Effects): boolean;
+    /**
+     * Deep clone: each Shadow copied via Shadow.clone(); each Blur via Blur.clone().
+     */
+    clone(): Effects;
+    /**
+     * Returns null if identical to baseline, otherwise returns this.clone().
+     */
+    compare(baseline: Effects): Effects | null;
+    /**
+     * Whole-group replacement: returns layer.clone().
+     */
+    merge(layer: Effects): Effects;
+    /**
+     * Serialize to the anova output shape.
+     * Only keys with values are included in the result.
+     */
+    data(config: ResolvedConfig): AnovaEffects;
+}

package/dist/Component/Effects/EffectsProcessor.d.ts

@@ -0,0 +1,15 @@
+import { Style } from '../Styles/Style.js';
+import type { ProcessingContext } from '../../Runtime/Context/interfaces.js';
+/**
+ * Post-processes an `effects` Style after initial evaluation.
+ *
+ * Handles two paths:
+ * 1. FigmaStyleReference: resolves the `.name` field via resolveName().
+ * 2. Effects: iterates Shadow arrays and Blur fields; resolves any
+ *    FigmaVariableReference instances to named variables.
+ *
+ * Called from `StylesProcessor.postProcess()` for the `effects` style key.
+ */
+export declare class EffectsProcessor {
+    static postProcess(style: Style | undefined, context?: ProcessingContext): Promise<void>;
+}

package/dist/Component/Effects/Shadow.d.ts

@@ -0,0 +1,51 @@
+import type { Shadow as AnovaShadow } from '@directededges/specs-schema';
+import type { ResolvedConfig } from '@directededges/specs-schema';
+import { FigmaVariableReference } from '../Styles/Style.js';
+import { Color } from '../Color/Color.js';
+import { type ProcessingContext } from '../../Runtime/Context/interfaces.js';
+export type ShadowFieldValue = number | string | boolean | Color | FigmaVariableReference;
+/**
+ * Represents one evaluated DROP_SHADOW effect item.
+ * Peer to `Style` in the class hierarchy.
+ */
+export declare class Shadow {
+    visible: boolean;
+    inset?: boolean;
+    offsetX: number | FigmaVariableReference;
+    offsetY: number | FigmaVariableReference;
+    blur: number | FigmaVariableReference;
+    spread: number | FigmaVariableReference;
+    color: Color | FigmaVariableReference;
+    /**
+     * Populate fields from a Figma DROP_SHADOW effect object.
+     *
+     * ⚠️ boundVariables key names for numeric fields (`offsetX`, `offsetY`, `radius`, `spread`)
+     * are unconfirmed against live Plugin API data. `color` is confirmed. Verify in Plugin
+     * console before relying on variable binding for numeric fields (T008).
+     */
+    evaluate(effect: DropShadowEffect, context?: ProcessingContext): void;
+    /**
+     * Returns true if any field differs from the base Shadow.
+     * Type-mismatch rule: primitive vs FigmaVariableReference is always different.
+     */
+    difference(base: Shadow): boolean;
+    /**
+     * Deep clone: primitive fields by value, FigmaVariableReference instances cloned.
+     */
+    clone(): Shadow;
+    /**
+     * Returns null if identical to baseline, otherwise returns this.clone().
+     */
+    compare(baseline: Shadow): Shadow | null;
+    /**
+     * Shadow merge is whole-object replacement: returns layer.clone().
+     */
+    merge(layer: Shadow): Shadow;
+    /**
+     * Serialize to the anova output shape, applying config.format settings.
+     */
+    data(config: ResolvedConfig): AnovaShadow;
+    private static fieldDiffers;
+    private static cloneField;
+    private static serializeField;
+}

package/dist/Component/Effects/index.d.ts

@@ -0,0 +1,4 @@
+export { Shadow } from './Shadow.js';
+export { Blur } from './Blur.js';
+export { Effects } from './Effects.js';
+export { EffectsProcessor } from './EffectsProcessor.js';

package/dist/Component/Elements/BaseElement.d.ts

@@ -0,0 +1,87 @@
+import { Element as AnovaElement } from '@directededges/specs-schema';
+import { Styles } from "../Styles/Styles.js";
+import { FigmaContainerNode, FigmaElementNode } from '../Nodes/types.js';
+import { PropConfigurations } from "../PropConfigurations/PropConfigurations.js";
+import { ResolvedConfig } from '@directededges/specs-schema';
+import { Children } from "../Children/Children.js";
+import { PropBinding } from "../Props/PropBinding.js";
+import type { ProcessingContext } from "../../Runtime/Context/interfaces.js";
+export type ContainerElement = BaseElement & {
+    node: FigmaContainerNode;
+};
+export type ElementType = 'text' | 'glyph' | 'vector' | 'container' | 'slot' | 'instance' | 'line' | 'ellipse' | 'rectangle' | 'polygon' | 'star';
+export declare abstract class BaseElement {
+    node: FigmaElementNode;
+    parent: string | null;
+    children: Children;
+    propConfigurations: PropConfigurations;
+    styles: Styles;
+    type: ElementType;
+    instanceOf: PropBinding | null;
+    content: PropBinding | null;
+    config: ResolvedConfig;
+    protected context?: ProcessingContext;
+    constructor(node: FigmaElementNode, config: ResolvedConfig);
+    /**
+     * Evaluate element attributes (Template Method Pattern)
+     * Delegates to subclass-specific logic for binding evaluation
+     */
+    evaluate(context?: ProcessingContext): Promise<void>;
+    /**
+     * Subclass-specific evaluation logic - to be implemented by subclasses
+     */
+    protected abstract extendedEvaluate(): Promise<void>;
+    /**
+     * Get the element's name (computed from node)
+     */
+    get name(): string;
+    /**
+     * Get the component property references from the node.
+     * Used by subclasses to detect property bindings.
+     */
+    protected get propRefs(): Record<string, string> | undefined;
+    /**
+     * Relates raw Figma properties into semantic spec properties.
+     * Runs after evaluate() and before layer()/compare().
+     */
+    postEvaluate(): void;
+    postProcess(removeDefaults: boolean, fullElement?: BaseElement | undefined, context?: ProcessingContext): Promise<void>;
+    protected abstract extendedPostProcess(context?: ProcessingContext): Promise<void>;
+    /**
+     * Type guard to check if this element can be a layout parent (has auto-layout)
+     * Only ComponentNode and FrameNode support layoutMode
+     */
+    isLayoutParent(): this is BaseElement & {
+        node: ComponentNode | FrameNode | InstanceNode;
+    };
+    data(config: ResolvedConfig, subcomponentRefs?: Map<string, string>): AnovaElement | undefined;
+    evaluateParent(node: FigmaElementNode): string | null;
+    empty(): boolean;
+    /**
+     * Create a deep clone of this BaseElement.
+     * All nested properties (children, styles, props) are also cloned.
+     * Used to prevent shared references when compositing Elements.
+     *
+     * @returns A new BaseElement that is a deep copy of this one
+     */
+    clone(): BaseElement;
+    /**
+     * Merge another BaseElement onto this one, with the layer's properties taking precedence.
+     * Used for accumulating predecessor .layered changes onto a baseline element.
+     * Performs deep property-level merging for styles, props, children.
+     * Does not mutate either input - returns a new BaseElement.
+     *
+     * @param layer - The BaseElement to merge onto this one
+     * @returns A new BaseElement with merged properties
+     */
+    merge(layer: BaseElement): BaseElement;
+    /**
+     * Compare this BaseElement against a baseline to identify differences.
+     * Returns a new BaseElement containing only the properties that differ.
+     * Used for computing .layered output after accumulating predecessors.
+     *
+     * @param baseline - The BaseElement to compare against (or undefined if element is new)
+     * @returns A new BaseElement with only differences, or undefined if no differences
+     */
+    compare(baseline: BaseElement | undefined): BaseElement | undefined;
+}

package/dist/Component/Elements/ElementFactory.d.ts

@@ -0,0 +1,7 @@
+import { BaseElement } from "./BaseElement.js";
+import { FigmaElementNode } from '../Nodes/types.js';
+import { ResolvedConfig } from '@directededges/specs-schema';
+export declare class ElementFactory {
+    static create(node: FigmaElementNode, config: ResolvedConfig): BaseElement;
+    static createFrom(element: BaseElement): BaseElement;
+}

package/dist/Component/Elements/ElementFactoryRegistry.d.ts

@@ -0,0 +1,21 @@
+import type { ResolvedConfig } from '@directededges/specs-schema';
+import type { FigmaElementNode } from '../Nodes/types.js';
+import type { BaseElement } from './BaseElement.js';
+/**
+ * Indirection that breaks the `BaseElement` ↔ `ElementFactory` import cycle.
+ *
+ * `BaseElement.clone()/merge()/compare()` need `ElementFactory.create()`, but
+ * `ElementFactory` (transitively, via its concrete element subclasses) extends
+ * `BaseElement` — a static `BaseElement → ElementFactory` import makes the class
+ * a subclass-evaluates-before-base hazard ("Class extends value undefined").
+ *
+ * This module imports nothing at runtime (types only), so it is a graph leaf.
+ * `ElementFactory` registers its `create` on load; `BaseElement` calls through
+ * `createElement`, never importing `ElementFactory` directly.
+ */
+type ElementFactoryFn = (node: FigmaElementNode, config: ResolvedConfig) => BaseElement;
+/** Called once by `ElementFactory` at module load. */
+export declare function registerElementFactory(fn: ElementFactoryFn): void;
+/** Create an element via the registered `ElementFactory`. */
+export declare function createElement(node: FigmaElementNode, config: ResolvedConfig): BaseElement;
+export {};

package/dist/Component/Elements/Elements.d.ts

@@ -0,0 +1,86 @@
+import { BaseElement } from './BaseElement.js';
+import { Elements as AnovaElements } from '@directededges/specs-schema';
+import { ResolvedConfig } from '@directededges/specs-schema';
+import type { FigmaElementNode } from '../Nodes/types.js';
+import type { ProcessingContext } from '../../Runtime/Context/interfaces.js';
+import { PropPairings } from '../Props/PropPairings.js';
+export declare class Elements {
+    private _items;
+    private config;
+    private _nodes;
+    constructor(config: ResolvedConfig, nodes?: FigmaElementNode[]);
+    /**
+     * Create element instances for all nodes. Resolves main component names
+     * for INSTANCE nodes and applies glyph detection when glyphNamePattern is configured.
+     */
+    detect(): Promise<void>;
+    /**
+     * Evaluate properties for all previously-detected elements.
+     * When validatedPairs are provided, sets the active pair on Style
+     * before each element evaluates so the visible binding can emit a Conditional.
+     */
+    evaluate(context?: ProcessingContext, pairings?: PropPairings): Promise<void>;
+    /**
+     * Relates raw Figma properties into semantic spec properties for all elements.
+     * Runs after evaluate() and before layer()/compare().
+     */
+    postEvaluate(): void;
+    /**
+     * Apply (merge) another Elements tree onto this one.
+     *
+     * @param layer - The Elements tree to merge onto this one
+     * @returns A new Elements instance with the merged result
+     */
+    applyLayer(layer: Elements): Elements;
+    /**
+     * Compare this Elements tree against a baseline to identify differences.
+     *
+     * @param baseline - The Elements tree to compare against
+     * @returns A new Elements instance containing only differences
+     */
+    compare(baseline: Elements): Elements;
+    postProcess(removeDefaults?: boolean, fullElements?: Elements | null, context?: ProcessingContext): Promise<void>;
+    data(config: ResolvedConfig, subcomponentRefs?: Map<string, string>): AnovaElements | undefined;
+    get(name: string): BaseElement | undefined;
+    set(name: string, el: BaseElement): void;
+    has(name: string): boolean;
+    delete(name: string): void;
+    /**
+     * Makes Elements directly iterable (defaults to entries).
+     * @example
+     * for (const [name, element] of elements) { ... }
+     */
+    [Symbol.iterator](): IterableIterator<[string, BaseElement]>;
+    /**
+     * Returns an iterator over [name, element] entries.
+     * @example
+     * for (const [name, element] of elements.entries()) { ... }
+     */
+    entries(): IterableIterator<[string, BaseElement]>;
+    /**
+     * Returns an iterator over element values.
+     * @example
+     * for (const element of elements.values()) { ... }
+     */
+    values(): IterableIterator<BaseElement>;
+    /**
+     * Returns an iterator over element names.
+     * @example
+     * for (const name of elements.keys()) {
+     *   console.log(name);
+     * }
+     */
+    keys(): IterableIterator<string>;
+    /**
+     * Returns the number of elements in the collection.
+     */
+    get size(): number;
+    /**
+     * Checks if the collection is empty.
+     * @example
+     * if (elements.isEmpty()) {
+     *   return new Elements(this._node, this.config);
+     * }
+     */
+    isEmpty(): boolean;
+}

package/dist/Component/Elements/Primitives/ComponentElement.d.ts

@@ -0,0 +1,8 @@
+import { BaseElement } from "../BaseElement.js";
+import { ResolvedConfig } from '@directededges/specs-schema';
+import type { ProcessingContext } from '../../../Runtime/Context/interfaces.js';
+export declare class ComponentElement extends BaseElement {
+    constructor(node: ComponentNode, config: ResolvedConfig);
+    protected extendedEvaluate(): Promise<void>;
+    protected extendedPostProcess(_context?: ProcessingContext): Promise<void>;
+}

package/dist/Component/Elements/Primitives/EllipseElement.d.ts

@@ -0,0 +1,8 @@
+import { BaseElement } from "../BaseElement.js";
+import { ResolvedConfig } from '@directededges/specs-schema';
+import type { ProcessingContext } from '../../../Runtime/Context/interfaces.js';
+export declare class EllipseElement extends BaseElement {
+    constructor(node: EllipseNode, config: ResolvedConfig);
+    protected extendedEvaluate(): Promise<void>;
+    protected extendedPostProcess(_context?: ProcessingContext): Promise<void>;
+}

package/dist/Component/Elements/Primitives/FrameElement.d.ts

@@ -0,0 +1,8 @@
+import { BaseElement } from "../BaseElement.js";
+import { ResolvedConfig } from '@directededges/specs-schema';
+import type { ProcessingContext } from '../../../Runtime/Context/interfaces.js';
+export declare class FrameElement extends BaseElement {
+    constructor(node: FrameNode, config: ResolvedConfig);
+    protected extendedEvaluate(): Promise<void>;
+    protected extendedPostProcess(_context?: ProcessingContext): Promise<void>;
+}

package/dist/Component/Elements/Primitives/GlyphElement.d.ts

@@ -0,0 +1,21 @@
+import { BaseElement } from "../BaseElement.js";
+import { ResolvedConfig, Element as AnovaElement } from '@directededges/specs-schema';
+import type { FigmaElementNode } from '../../Nodes/types.js';
+import type { ProcessingContext } from '../../../Runtime/Context/interfaces.js';
+export declare class GlyphElement extends BaseElement {
+    private _glyphName;
+    constructor(node: FigmaElementNode, config: ResolvedConfig, glyphName: string);
+    get glyphName(): string;
+    /**
+     * Match a resolved component name against a glyph name pattern.
+     * Returns the extracted glyph name if matched, or null if no match.
+     * The pattern uses {i} as a placeholder for the glyph name portion.
+     */
+    static patternMatch(resolvedName: string, pattern: string): string | null;
+    protected extendedEvaluate(): Promise<void>;
+    data(config: ResolvedConfig, subcomponentRefs?: Map<string, string>): AnovaElement | undefined;
+    protected extendedPostProcess(_context?: ProcessingContext): Promise<void>;
+    clone(): BaseElement;
+    merge(layer: BaseElement): BaseElement;
+    compare(baseline: BaseElement | undefined): BaseElement | undefined;
+}