@directededges/specs-from-figma 0.22.0 → 0.23.0

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

@@ -1,21 +0,0 @@
-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;
-}

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

@@ -1,24 +0,0 @@
-import { BaseElement } from "../BaseElement.js";
-import { ResolvedConfig } from '@directededges/specs-schema';
-import { type ProcessingContext } from '../../../Runtime/Context/interfaces.js';
-export declare class InstanceElement extends BaseElement {
-    resolvedInstanceName?: string;
-    constructor(node: InstanceNode, config: ResolvedConfig);
-    protected extendedEvaluate(): Promise<void>;
-    /**
-     * Resolve the main component name for an instance node.
-     * Returns the component set name if the main component belongs to a set,
-     * otherwise returns the component name directly.
-     */
-    static resolveMainComponentName(node: InstanceNode): Promise<string>;
-    /**
-     * Determine the main component reference asynchronously.
-     * Uses cached resolvedInstanceName from detect() if available.
-     */
-    private instanceName;
-    /**
-     * Post-process for InstanceElement.
-     * With unified bindings, instanceOf already contains the binding info.
-     */
-    protected extendedPostProcess(context?: ProcessingContext): Promise<void>;
-}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,12 +0,0 @@
-export { BaseElement } from "./BaseElement.js";
-export { ElementFactory } from "./ElementFactory.js";
-export { ComponentElement } from "./Primitives/ComponentElement.js";
-export { FrameElement } from "./Primitives/FrameElement.js";
-export { InstanceElement } from "./Primitives/InstanceElement.js";
-export { TextElement } from "./Primitives/TextElement.js";
-export { VectorElement } from "./Primitives/VectorElement.js";
-export { LineElement } from "./Primitives/LineElement.js";
-export { StarElement } from "./Primitives/StarElement.js";
-export { PolygonElement } from "./Primitives/PolygonElement.js";
-export { RectangleElement } from "./Primitives/RectangleElement.js";
-export { EllipseElement } from "./Primitives/EllipseElement.js";

package/dist/Component/Gradient/Gradient.d.ts

@@ -1,73 +0,0 @@
-import type { GradientValue, GradientStop, ResolvedConfig } from '@directededges/specs-schema';
-import { type ProcessingContext } from '../../Runtime/Context/interfaces.js';
-/**
- * Type guard for gradient paints
- */
-type GradientPaint = Extract<Paint, {
-    type: 'GRADIENT_LINEAR' | 'GRADIENT_RADIAL' | 'GRADIENT_ANGULAR' | 'GRADIENT_DIAMOND';
-}>;
-/**
- * Gradient — first-class component for Figma gradient fills
- *
- * Instance-based class (peer to Shadow/Blur/Effects) that wraps a GradientValue.
- * Provides lifecycle methods (difference, clone, data) and handles conversion
- * from Figma gradient paints to structured gradient values.
- *
- * Usage:
- *   const gradient = new Gradient();
- *   gradient.evaluate(paint);
- */
-export declare class Gradient {
-    private _value;
-    constructor(value?: GradientValue);
-    get value(): GradientValue;
-    get type(): 'LINEAR' | 'RADIAL' | 'ANGULAR';
-    get stops(): GradientStop[];
-    /**
-     * Returns true if this Gradient differs from base.
-     * Compares gradient type, geometry (angle/center), and all stops.
-     */
-    difference(base: Gradient): boolean;
-    /**
-     * Serialize this Gradient for output, respecting config.format.tokens.
-     * FigmaVariableReference stop colors are converted per config profile.
-     * Color instances serialize via .data(config.format.color).
-     */
-    data(config: ResolvedConfig): GradientValue;
-    /**
-     * Create a deep clone of this Gradient instance.
-     */
-    clone(): Gradient;
-    /**
-     * Populate gradient value from a Figma gradient paint.
-     * Returns true if evaluation succeeded, false if paint is unsupported/invalid.
-     *
-     * @param paint - Figma gradient paint (GRADIENT_LINEAR, GRADIENT_RADIAL, GRADIENT_ANGULAR)
-     */
-    evaluate(paint: GradientPaint, context?: ProcessingContext): boolean;
-    /**
-     * Static factory: construct and evaluate in one call.
-     * Returns Gradient instance or null if evaluation failed.
-     *
-     * @param paint - Figma gradient paint
-     */
-    static fromPaint(paint: GradientPaint, context?: ProcessingContext): Gradient | null;
-    /**
-     * Check if a paint is a gradient type (LINEAR, RADIAL, ANGULAR, or DIAMOND)
-     */
-    static isGradientPaint(paint: Paint | undefined): boolean;
-    /**
-     * Extract CSS-equivalent angle from Figma linear gradient transform
-     */
-    private static evaluateAngle;
-    /**
-     * Extract center position from Figma radial/angular gradient transform
-     */
-    private static evaluateCenter;
-    /**
-     * Convert Figma gradient stops to GradientStop array.
-     * Returns null if < 2 stops (Figma requires at least 2).
-     */
-    private static evaluateStops;
-}
-export {};

package/dist/Component/Gradient/GradientProcessor.d.ts

@@ -1,18 +0,0 @@
-import { Gradient } from './Gradient.js';
-import type { ProcessingContext } from '../../Runtime/Context/interfaces.js';
-/**
- * GradientProcessor — post-processing logic for Gradient instances
- *
- * Handles variable name resolution for gradient stop colors.
- * Peer to EffectsProcessor.
- */
-export declare class GradientProcessor {
-    /**
-     * Performs post-processing on a Gradient instance.
-     * Resolves variable names for any FigmaVariableReference stop colors.
-     *
-     * @param gradient The Gradient instance to process
-     * @param context Optional processing context with foundations loader
-     */
-    static postProcess(gradient: Gradient | null, context?: ProcessingContext): Promise<void>;
-}

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

@@ -1,2 +0,0 @@
-export { Gradient } from './Gradient.js';
-export { GradientProcessor } from './GradientProcessor.js';

package/dist/Component/InstanceExamples/InstanceExample.d.ts

@@ -1,35 +0,0 @@
-import type { InstanceExample as AnovaInstanceExample, ResolvedConfig, SlotContentRef } from '@directededges/specs-schema';
-import type { ProcessingContext } from '../../Runtime/Context/interfaces.js';
-/**
- * Per-example builder (ADR-048 / ADR-050). Maps one detected INSTANCE node into an
- * `InstanceExample` — `{ title, propConfigurations? }`.
- *
- * Scalar prop configuration (TEXT/BOOLEAN/VARIANT/INSTANCE_SWAP coercion, key
- * formatting, instance-swap name resolution, and slot-constraint folding) is
- * delegated to `PropConfigurations` — the same machinery instance elements use —
- * so an example serializes a configured instance identically to the rest of the
- * spec. Slot props are supplied as pre-resolved `SlotContentRef`s by the owning
- * `InstanceExamples` collaborator (which performs slot detection and owns the
- * shared registry); the example holds no slot content of its own.
- *
- * `PropBinding` is never emitted — an instance example is a documented configuration,
- * not a live data binding (ADR-048).
- *
- * Construction mirrors sibling per-item builders (`Subcomponent`, `PropConfigurations`):
- * `(node, config)`; per-call context arrives via `resolve()` / `data()`.
- */
-export declare class InstanceExample {
-    private _node;
-    private _props;
-    constructor(node: InstanceNode, config: ResolvedConfig);
-    /** The original node name, used as the human-readable title. */
-    get title(): string;
-    /** Resolve scalar prop configurations (incl. INSTANCE_SWAP names). Run before `data()`. */
-    resolve(context?: ProcessingContext): Promise<void>;
-    /**
-     * Build the `InstanceExample`. `slotRefs` are the example's resolved slot-prop
-     * references (keyed by slot prop key), supplied by `InstanceExamples`.
-     * `propConfigurations` is omitted when the example exposes no configurable props.
-     */
-    data(slotRefs: Record<string, SlotContentRef>): AnovaInstanceExample;
-}

package/dist/Component/InstanceExamples/InstanceExamples.d.ts

@@ -1,49 +0,0 @@
-import type { InstanceExamples as AnovaInstanceExamples, ResolvedConfig } from '@directededges/specs-schema';
-import type { SlotRegistry } from '../SlotContent/SlotRegistry.js';
-import { type ProcessingContext } from '../../Runtime/Context/interfaces.js';
-/**
- * Top-level collaborator for instance examples (ADR-048 + ADR-050) — sibling to
- * Subcomponents and SlotContent. Reads `processing.instanceExamples`, gathers
- * candidate nodes by scope (PAGE | FILE), applies match/exclude/parentNames
- * filtering, and builds keyed `InstanceExample` entries.
- *
- * Detection mirrors `processing.subcomponents`. Output gating
- * (`include.instanceExamples`) is applied by the caller in `Component.data()`.
- */
-export declare class InstanceExamples {
-    /** example key → builder + its resolved slot-prop refs */
-    private _items;
-    private config;
-    constructor(config: ResolvedConfig);
-    /**
-     * Compile an example name pattern (with `{C}` and `*`) into a RegExp and test it.
-     * `{C}` expands to the (escaped) component name; `*` becomes `.*`.
-     * Independent of `Subcomponents.matchesPatterns` (which uses `{S}` capture semantics).
-     */
-    static matchesExamplePattern(name: string, patterns: string[], componentName: string): boolean;
-    /**
-     * Detect instance examples for the given host component and contribute their
-     * slot fills to the shared registry.
-     *
-     * Candidates are INSTANCE nodes only (FRAME nodes are rejected), found via a
-     * boundary-respecting walk (the runtime's getPageSiblings / getAllPagesNodes,
-     * which stop at COMPONENT/COMPONENT_SET/INSTANCE). Applies for both PAGE and
-     * FILE scope. No-op when `processing.instanceExamples` is absent.
-     *
-     * `stampReferences` (= include.instanceExamples) controls whether slot refs are
-     * stamped and registry entries marked referenced. Detection always runs so the
-     * shared registry is populated regardless of the include flag.
-     */
-    evaluate(componentName: string, basePath: string, registry: SlotRegistry, stampReferences: boolean, acceptableComponentIds: Set<string>, context?: ProcessingContext, rootNodeId?: string): Promise<void>;
-    /**
-     * Detect filled slots inside an example instance (recursively, incl. slot ›
-     * instance › slot nesting) via the shared SlotDetector, contribute every level
-     * to the shared registry (deduped, example-key-prefixed), and — when stamping —
-     * mark referenced and wire nested refs. Returns the top-level slot-prop refs.
-     */
-    private _contributeSlots;
-    /** Serialize to the keyed `InstanceExamples` record, sorted by key for determinism. */
-    data(): AnovaInstanceExamples;
-    get size(): number;
-    get isEmpty(): boolean;
-}

package/dist/Component/Layout/Layout.d.ts

@@ -1,26 +0,0 @@
-import { ResolvedConfig } from '@directededges/specs-schema';
-import type { LayoutTree, LayoutSerializedNode } from './types.js';
-/**
- * Layout: builds and compares per-variant element hierarchy as a nested tree.
- * Primary construction is via constructor with a provided node list.
- */
-export declare class Layout {
-    private _tree;
-    private _config;
-    constructor(config: ResolvedConfig, tree: LayoutTree);
-    /**
-     * Get the internal layout tree.
-     */
-    get tree(): LayoutTree;
-    /**
-     * Compare the current layout tree against a baseline.
-     * Follows BaseElement.compare pattern: returns undefined if equal,
-     * otherwise returns a new Layout instance with the current tree when different.
-     */
-    compare(baseline: Layout | undefined): Layout | undefined;
-    /**
-     * Return nested array representation suitable for serialization.
-     */
-    data(): LayoutSerializedNode[];
-    private serialize;
-}

package/dist/Component/Layout/types.d.ts

@@ -1,61 +0,0 @@
-/**
- * Nested layout tree node used internally.
- */
-export interface LayoutNode {
-    name: string;
-    children: LayoutNode[];
-}
-/**
- * Rooted layout tree container.
- */
-export interface LayoutTree {
-    root: LayoutNode;
-}
-/**
- * Serialized tree representation returned by data().
- * Format: Array containing the root node object.
- * Leaf nodes are strings, parent nodes are { [nodeName]: children[] }.
- * Example:
- * [
- *   {
- *     "root": [
- *       {
- *         "labelContainer": [
- *           "requiredIndicator",
- *           "label",
- *           "secondaryDescription"
- *         ]
- *       },
- *       {
- *         "control": [
- *           "value",
- *           "placeholder",
- *           "startIcon"
- *         ]
- *       }
- *     ]
- *   }
- * ]
- */
-export type LayoutSerializedNode = string | {
-    [nodeName: string]: LayoutSerializedNode[];
-};
-export type LayoutData = LayoutSerializedNode[];
-/**
- * Whole-tree comparison result.
- */
-export interface LayoutComparison {
-    equal: boolean;
-    added: string[];
-    removed: string[];
-    moved: Array<{
-        name: string;
-        fromPath: string[];
-        toPath: string[];
-    }>;
-    orderChanges: Array<{
-        parent: string;
-        previousOrder: string[];
-        currentOrder: string[];
-    }>;
-}

package/dist/Component/Metadata/Metadata.d.ts

@@ -1,13 +0,0 @@
-import { Metadata as AnovaMetadata } from '@directededges/specs-schema';
-import { SpecableNode } from "../Nodes/types";
-import { ResolvedConfig } from '@directededges/specs-schema';
-import type { ProcessingContext } from "../../Runtime/Context/interfaces";
-export declare class Metadata {
-    /**
-     * Find the page ID by traversing up the parent chain
-     * Handles both Plugin and REST contexts
-     * Note: Plugin API uses 'PAGE' type, REST API uses 'CANVAS' type for pages
-     */
-    private static findPageId;
-    static create(node: SpecableNode, config: ResolvedConfig, context?: ProcessingContext): AnovaMetadata;
-}

package/dist/Component/Metadata/constants.d.ts

@@ -1,8 +0,0 @@
-export declare const METADATA: {
-    PLUGIN_VERSION: string;
-    PLUGIN_NAME: string;
-    PLUGIN_URL: string;
-    SCHEMA_VERSION: string;
-    SCHEMA_URL: string;
-    SCHEMA_LATEST_URL: string;
-};

package/dist/Component/Nodes/types.d.ts

@@ -1,4 +0,0 @@
-export type SpecableNode = ComponentNode | ComponentSetNode | FrameNode;
-export type FigmaElementNode = ComponentNode | FrameNode | InstanceNode | TextNode | VectorNode | LineNode | StarNode | PolygonNode | RectangleNode | EllipseNode | SlotNode;
-export type FigmaContainerNode = ComponentNode | FrameNode | InstanceNode;
-export type FigmaCorneredNode = ComponentNode | InstanceNode | FrameNode | RectangleNode;

package/dist/Component/PropConfigurations/PropConfiguration.d.ts

@@ -1,15 +0,0 @@
-import type { PropConfigurationValue } from './PropConfigurations';
-/**
- * PropConfiguration
- *
- * Represents a single component property configuration value.
- * Wrapper class to enable type-safe iteration and Output rendering.
- *
- * Pattern: Singular wrapper (like Style.ts) for individual entries
- * Used by: PropConfigurations.entries() → Attribute → Value
- */
-export declare class PropConfiguration {
-    readonly key: string;
-    readonly value: PropConfigurationValue;
-    constructor(key: string, value: PropConfigurationValue);
-}

package/dist/Component/PropConfigurations/PropConfigurations.d.ts

@@ -1,55 +0,0 @@
-import type { PropConfigurations as AnovaPropConfigurations } from '@directededges/specs-schema';
-import { ResolvedConfig } from '@directededges/specs-schema';
-import type { ProcessingContext } from '../../Runtime/Context/interfaces.js';
-import { PropConfiguration } from './PropConfiguration.js';
-export type PropConfigurationValue = string | number | boolean;
-export declare class PropConfigurations {
-    private _items;
-    private _types;
-    private _node;
-    private config;
-    constructor(node: InstanceNode, config: ResolvedConfig);
-    /**
-     * Evaluate component properties. Stores raw values (including component IDs
-     * for INSTANCE_SWAP) so that merge/compare operate on cheap identity checks.
-     * Name resolution for INSTANCE_SWAP happens lazily at data() time.
-     */
-    evaluate(): void;
-    /**
-     * Merge another PropConfigurations instance onto this one.
-     * Layer properties take precedence over base properties.
-     * Performs property-level merge: base properties are preserved unless layer overrides them.
-     *
-     * @param layer - The PropConfigurations to merge onto this one
-     * @returns A new PropConfigurations instance with merged values
-     */
-    merge(layer: PropConfigurations): PropConfigurations;
-    /**
-     * Compare this PropConfigurations against a baseline to identify differences.
-     * Returns a new PropConfigurations instance containing only differences.
-     *
-     * @param baseline - The PropConfigurations to compare against
-     * @returns A new PropConfigurations instance with differences, or empty if no differences
-     */
-    compare(baseline: PropConfigurations): PropConfigurations;
-    /**
-     * Resolve INSTANCE_SWAP component IDs to human-readable names.
-     * Called during postProcess (after merge/compare) so that evaluate/compare
-     * operate on cheap raw IDs and name lookup only happens for the final output set.
-     * Writes resolved names back into _items so that entries()/get() return
-     * resolved values without dual-state — before postProcess they hold raw IDs,
-     * after postProcess they hold resolved names.
-     */
-    postProcess(context?: ProcessingContext): Promise<void>;
-    data(): AnovaPropConfigurations | undefined;
-    get(name: string): PropConfigurationValue | undefined;
-    set(name: string, value: PropConfigurationValue | PropConfiguration): void;
-    [Symbol.iterator](): IterableIterator<[string, PropConfiguration]>;
-    entries(): IterableIterator<[string, PropConfiguration]>;
-    values(): IterableIterator<PropConfigurationValue>;
-    keys(): IterableIterator<string>;
-    get size(): number;
-    isEmpty(): boolean;
-    copy(source: PropConfigurations, keys?: Set<string> | string[]): void;
-    clone(): PropConfigurations;
-}

package/dist/Component/Props/CodeOnlyProps/BooleanCodeOnlyProp.d.ts

@@ -1,11 +0,0 @@
-import type { BooleanProp } from '@directededges/specs-schema';
-import type { FigmaElementNode } from '../../Nodes/types.js';
-/**
- * Extracts BooleanProp from a node whose visibility is bound to a BOOLEAN prop.
- */
-export declare class BooleanCodeOnlyProp {
-    /** A node is extractable if it has a 'visible' binding. */
-    static canExtract(node: FigmaElementNode): boolean;
-    /** Extract a BooleanProp. The current visible state becomes the default. */
-    static extract(node: FigmaElementNode): BooleanProp;
-}

package/dist/Component/Props/CodeOnlyProps/CodeOnlyProps.d.ts

@@ -1,36 +0,0 @@
-import type { AnyProp, ResolvedConfig, Props as AnovaProps } from '@directededges/specs-schema';
-import type { FigmaElementNode } from '../../Nodes/types.js';
-/**
- * Orchestrator for code-only prop extraction.
- * Routes descendant nodes to specialized extractors (Text, Boolean, Instance)
- * and merges results into the native props map.
- */
-export declare class CodeOnlyProps {
-    /**
-     * Full code-only props pipeline: extract, merge with native props,
-     * and post-process slot constraints.
-     *
-     * Keys are stored raw (unformatted). Props.data() handles formatting and sorting.
-     * Mutates nativeProps in place.
-     */
-    static process(container: FigmaElementNode, nativeProps: AnovaProps, processing: ResolvedConfig['processing']): Promise<void>;
-    /**
-     * Returns the set of raw (unformatted) prop names that will be extracted from the container.
-     * Used by Props.process() to pre-exclude these from native prop extraction.
-     */
-    static getCodeOnlyPropNames(container: FigmaElementNode): Set<string>;
-    /**
-     * Extract code-only props from a container node by routing each descendant
-     * to the appropriate specialized extractor.
-     */
-    static extract(container: FigmaElementNode, existingProps: Record<string, AnyProp>, processing: ResolvedConfig['processing']): Promise<Map<string, AnyProp>>;
-    /**
-     * Extract the component property name from a node's componentPropertyReferences.
-     * Ref values are formatted as "PropName#nodeId" — returns the part before '#'.
-     */
-    private static getPropNameFromRefs;
-    /**
-     * Recursively collect all descendant nodes from a container.
-     */
-    private static descendants;
-}

package/dist/Component/Props/CodeOnlyProps/InstanceCodeOnlyProp.d.ts

@@ -1,19 +0,0 @@
-import type { BooleanProp, EnumProp } from '@directededges/specs-schema';
-import type { FigmaElementNode } from '../../Nodes/types.js';
-/**
- * Extracts BooleanProp or EnumProp from an INSTANCE node used as a code-only prop picker.
- * The instance's component must have exactly one VARIANT property in componentPropertyDefinitions.
- */
-export declare class InstanceCodeOnlyProp {
-    /** An INSTANCE node is extractable if it has type 'INSTANCE'. */
-    static canExtract(node: FigmaElementNode): boolean;
-    /**
-     * Extract a BooleanProp or EnumProp from the instance's variant definition.
-     * Returns null if the instance does not meet the single-VARIANT contract.
-     * Returns `propName` derived from the VARIANT key (not the node name).
-     */
-    static extract(node: FigmaElementNode): Promise<{
-        prop: BooleanProp | EnumProp;
-        propName: string;
-    } | null>;
-}

package/dist/Component/Props/CodeOnlyProps/TextCodeOnlyProp.d.ts

@@ -1,18 +0,0 @@
-import type { StringProp, NumberProp } from '@directededges/specs-schema';
-import type { FigmaElementNode } from '../../Nodes/types.js';
-/**
- * Extracts StringProp or NumberProp from a TEXT layer bound to a characters prop.
- */
-export declare class TextCodeOnlyProp {
-    /** A TEXT node is extractable if it has a 'characters' binding. */
-    static canExtract(node: FigmaElementNode): boolean;
-    /**
-     * Extract a StringProp or NumberProp from a text layer.
-     * When `inferNumber` is true and the text content passes the numeric guard,
-     * emits NumberProp instead of StringProp (ADR 029).
-     */
-    static extract(node: FigmaElementNode, inferNumber?: boolean): StringProp | NumberProp;
-    private static buildStringProp;
-    private static buildNumberProp;
-    private static extensions;
-}

package/dist/Component/Props/CodeOnlyProps/index.d.ts

@@ -1,4 +0,0 @@
-export { CodeOnlyProps } from './CodeOnlyProps.js';
-export { TextCodeOnlyProp } from './TextCodeOnlyProp.js';
-export { BooleanCodeOnlyProp } from './BooleanCodeOnlyProp.js';
-export { InstanceCodeOnlyProp } from './InstanceCodeOnlyProp.js';