@directededges/specs-from-figma 0.21.0 → 0.22.0

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

@@ -0,0 +1,16 @@
+/** Per-variant binding co-occurrence detected on a single element */
+export interface PropPairCandidate {
+    elementName: string;
+    visiblePropName: string;
+    contentKey: 'mainComponent' | 'characters' | 'slotContentId';
+    contentPropName: string;
+}
+/** Cross-variant validated binding pair */
+export interface PropPair {
+    elementName: string;
+    booleanPropName: string;
+    contentKey: 'mainComponent' | 'characters' | 'slotContentId';
+    contentPropName: string;
+    contentType: 'glyph' | 'string' | 'slot';
+    booleanDefault: boolean;
+}

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

@@ -0,0 +1,89 @@
+import type { FigmaElementNode } from '../Nodes/types.js';
+import type { SpecableNode } from '../Nodes/types.js';
+import type { AnyProp as AnovaAnyProp, ResolvedConfig } from '@directededges/specs-schema';
+import type { PropPairCandidate, PropPair } from './PropPair.js';
+import { ConditionalStyle } from '../Styles/Primitives/ConditionalStyle.js';
+/**
+ * Variant type subset used by from(). Avoids importing Variant directly
+ * to prevent circular dependencies.
+ */
+interface PairableVariant {
+    invalid: boolean;
+    bindingPairCandidates: PropPairCandidate[];
+    full: {
+        get(name: string): {
+            node: FigmaElementNode;
+        } | undefined;
+    };
+}
+/**
+ * PropPairings — collection class for validated prop pairs.
+ *
+ * Follows the _items + method pattern of Elements, Variants, and Styles.
+ * Owns detection, cross-variant validation, active-pair orchestration,
+ * and prop enrichment.
+ */
+export declare class PropPairings {
+    private _items;
+    private _byElement;
+    private static _active?;
+    constructor(items: PropPair[]);
+    /**
+     * Scan nodes for visible + content binding co-occurrence.
+     * Called per-variant during construction. Returns candidates (not yet validated).
+     */
+    static scan(nodes: FigmaElementNode[]): PropPairCandidate[];
+    /**
+     * Cross-variant validation of binding pair candidates.
+     * Applies validation rules (FR-002 through FR-005) and resolves content type and boolean default.
+     */
+    static from(variants: PairableVariant[], node: SpecableNode): PropPairings;
+    /**
+     * Activate the pair for a given element name.
+     * Called during element evaluation so Style can read the active pair.
+     */
+    activate(elementName: string): void;
+    /**
+     * Clear the active pair after element evaluation.
+     */
+    deactivate(): void;
+    /**
+     * Evaluate whether the current element's visible binding should become
+     * a ConditionalStyle. Returns the ConditionalStyle if paired, undefined otherwise.
+     */
+    static evaluateVisible(node: FigmaElementNode): ConditionalStyle | undefined;
+    /**
+     * Returns the set of boolean prop names that are paired and should be
+     * excluded from prop output.
+     */
+    pairedBooleans(): Set<string>;
+    /**
+     * Build a lookup from content prop name to its validated pair.
+     * Used by Props.process() to apply nullable pairing during prop iteration.
+     */
+    pairsByProp(): Map<string, PropPair>;
+    /**
+     * Apply binding pair merging to a content prop: set nullable, default, and metadata.
+     */
+    static apply(item: AnovaAnyProp, pair: PropPair, keyFormat: ResolvedConfig['format']['keys']): void;
+    get items(): readonly PropPair[];
+    get size(): number;
+    isEmpty(): boolean;
+    /**
+     * Group binding pair candidates by boolean prop name across all variants.
+     */
+    private static groupCandidatesByBoolean;
+    /**
+     * Track content-only bindings (no visible co-occurrence) for subset rule.
+     */
+    private static trackContentOnlyBindings;
+    /**
+     * Resolve the default value of a boolean component property definition.
+     */
+    private static resolveBooleanDefault;
+    /**
+     * Set nullable and default on a content prop based on the pair's content type.
+     */
+    private static setNullable;
+}
+export {};

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

@@ -0,0 +1,93 @@
+import { SpecableNode, FigmaElementNode } from '../Nodes/types.js';
+import { Props as AnovaProps } from '@directededges/specs-schema';
+import { Utilities } from "../../Utilities/Utilities.js";
+import type { ProcessingContext } from '../../Runtime/Context/interfaces.js';
+import { ResolvedConfig } from '@directededges/specs-schema';
+import { PropPairings } from './PropPairings.js';
+export type PropDefinition = ComponentPropertyDefinitions[string];
+export type VariantPropDefinition = PropDefinition & {
+    type: 'VARIANT';
+    defaultValue: string;
+    variantOptions?: string[];
+};
+export declare class Props {
+    private _component;
+    private _items;
+    private _definitions;
+    private _validDefinition;
+    get validDefinition(): boolean;
+    get props(): AnovaProps;
+    private config;
+    constructor(component: SpecableNode, config: ResolvedConfig);
+    process(context?: ProcessingContext, pairings?: PropPairings, codeOnlyContainer?: FigmaElementNode): Promise<void>;
+    /**
+     * Resolve INSTANCE_SWAP component ID to human-readable component name
+     * @param componentId - Component node ID (e.g., "1:1")
+     * @param context - Processing context with node resolver
+     * @returns ComponentSet name, Component name, or null if not found
+     */
+    private resolveInstanceSwapDefault;
+    /**
+     * Numeric inference guard (ADR 029).
+     * Returns true only when the value is a finite number with no leading zeros.
+     */
+    static isNumericValue(value: string): boolean;
+    data(): AnovaProps | undefined;
+    static propNameWithoutId(key: string): string;
+    static getDefinitions(component: InstanceNode | ComponentNode | ComponentSetNode): Promise<ComponentPropertyDefinitions | 'exception'>;
+    static exception(component: InstanceNode | ComponentNode | ComponentSetNode): boolean;
+    /**
+     * Check if component has any properties
+     */
+    hasProperties(): boolean;
+    /**
+     * Get raw property definitions, optionally filtered by type
+     */
+    getDefinitions(): Awaited<ReturnType<typeof Utilities.getPropertyDefinitions>> | undefined;
+    getDefinitions(type: 'VARIANT'): Record<string, VariantPropDefinition> | undefined;
+    getDefinitions(type: 'BOOLEAN' | 'TEXT' | 'INSTANCE_SWAP' | 'SLOT'): Record<string, PropDefinition> | undefined;
+    /**
+     * Returns an iterator over [propName, definition] entries.
+     * @example
+     * for (const [name, definition] of props.entries()) {
+     *   console.log(name, definition.type);
+     * }
+     */
+    entries(): IterableIterator<[string, PropDefinition]>;
+    /**
+     * Returns an iterator over property definition values.
+     * @example
+     * for (const definition of props.values()) {
+     *   console.log(definition.type);
+     * }
+     */
+    values(): IterableIterator<PropDefinition>;
+    /**
+     * Returns an iterator over property names.
+     * @example
+     * for (const name of props.keys()) {
+     *   console.log(name);
+     * }
+     */
+    keys(): IterableIterator<string>;
+    /**
+     * Makes Props directly iterable (defaults to entries).
+     * @example
+     * for (const [name, definition] of props) {
+     *   console.log(name, definition);
+     * }
+     */
+    [Symbol.iterator](): IterableIterator<[string, PropDefinition]>;
+    /**
+     * Returns the number of property definitions.
+     */
+    get size(): number;
+    /**
+     * Checks if there are no property definitions.
+     * @example
+     * if (props.isEmpty()) {
+     *   return;
+     * }
+     */
+    isEmpty(): boolean;
+}

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

@@ -0,0 +1,37 @@
+import type { AnyProp } from '@directededges/specs-schema';
+export declare class SlotConstraints {
+    /**
+     * Post-process the merged props map to promote slot constraint code-only props
+     * onto their matching SlotProp fields.
+     *
+     * Scans for code-only props whose names match `{existingSlotName} minItems|maxItems|anyOf`.
+     * When a match is found against an existing slot prop, the constraint value is promoted
+     * onto the SlotProp and the constraint prop is removed from the map.
+     *
+     * Follows the StylesProcessor.postProcess() pattern.
+     */
+    static postProcess(props: Record<string, AnyProp>): void;
+    /**
+     * Parse a prop key to see if it matches the pattern `{slotName} {constraintType}`.
+     * Keys are raw (unformatted), so "Children minItems" matches slot "Children" + suffix "minItems".
+     */
+    private static parseConstraintKey;
+    /**
+     * True if a raw prop key is a slot constraint (`{slotName} minItems|maxItems|anyOf`)
+     * for one of the given slot names. Used to keep instance propConfigurations symmetric
+     * with the component side, which promotes these onto the SlotProp and removes them.
+     */
+    static isConstraintKey(key: string, slotNames: Set<string>): boolean;
+    /**
+     * Extract the constraint value from a code-only prop.
+     * The value lives in examples[0] (preferred) or default. Both string and number
+     * props are supported: with inferNumberProps enabled, minItems/maxItems constraint
+     * props are inferred as number, so their value must be coerced to string here.
+     */
+    private static getConstraintValue;
+    /**
+     * Promote a constraint value onto a SlotProp.
+     * Returns true if promotion succeeded, false if value is invalid.
+     */
+    private static promote;
+}

package/dist/Component/SlotContent/SlotCandidate.d.ts

@@ -0,0 +1,42 @@
+import type { ResolvedConfig } from '@directededges/specs-schema';
+import type { SlotItem } from './SlotItem.js';
+/**
+ * One candidate slot fill, produced by SlotDetector and consumed by SlotRegistry.
+ * Transient: carries the resolved SlotItem payload, a derived key candidate, and
+ * the wiring coordinates (element name + variant) needed to attach the example
+ * reference back onto the slot binding after de-duplication. Discarded once the
+ * registry emits.
+ */
+export declare class SlotCandidate {
+    /** Proposed key (may be superseded by an existing entry after de-dup). */
+    readonly keyCandidate: string;
+    /** The resolved slot fill payload — provides layout/anatomy/elements data. */
+    readonly item: SlotItem;
+    /** Figma layer name of the slot element — used to wire the example reference. */
+    readonly elementName: string;
+    /** Variant configuration string used in key derivation and wiring. */
+    readonly variantKey: string;
+    /** True if this slot was found inside an instance (nested), not directly in the component tree. */
+    readonly nested: boolean;
+    /**
+     * Figma node id of the slot. Collision-proof wiring identity for nested slots —
+     * slot *names* repeat across sibling instances (e.g. two "Slot" layers), node ids
+     * do not. The human-readable spec key (`keyCandidate`) stays name-derived and is
+     * disambiguated only at registry emission.
+     */
+    readonly slotNodeId: string;
+    constructor(elementName: string, variantKey: string, hostComponentName: string, item: SlotItem, config: ResolvedConfig, nested?: boolean, keyPrefix?: string, slotNodeId?: string);
+    /**
+     * Canonical string for layout-only de-duplication.
+     * Depth-first traversal of the layout tree.
+     */
+    layoutKey(): string;
+    /**
+     * Compound key for layout + anatomy de-duplication.
+     */
+    layoutAnatomyKey(): string;
+    /**
+     * Compound key for full de-duplication (layout + anatomy + elements).
+     */
+    fullKey(): string;
+}

package/dist/Component/SlotContent/SlotContent.d.ts

@@ -0,0 +1,84 @@
+import { SlotRegistry } from './SlotRegistry.js';
+import type { NestedSlotRelation } from './SlotDetector.js';
+import type { ResolvedConfig, SlotContent as AnovaSlotContent } from '@directededges/specs-schema';
+import type { Variant } from '../Variants/Variant.js';
+import { type ProcessingContext } from '../../Runtime/Context/interfaces.js';
+export interface SlotContentOptions {
+    /** Component (or subcomponent) name that hosts the slots — used in entry keys. */
+    hostComponentName: string;
+    /** JSON Pointer base for example references (e.g. `#/components/egdsAlert`). */
+    basePath: string;
+    /** Output field this content serializes under. */
+    outputKey: 'slotContentExamples' | 'slotContent';
+    config: ResolvedConfig;
+    /**
+     * Shared slot registry. Component creates one registry and passes it to both
+     * SlotContent and InstanceExamples so identical fills dedup to a single entry
+     * regardless of source. When omitted, a private registry is created (legacy /
+     * standalone behavior).
+     */
+    registry?: SlotRegistry;
+    /**
+     * Whether to stamp `$slotContent` references onto the component's own slot
+     * bindings (and thereby mark those registry entries referenced for emission).
+     * Maps to `include.defaultSlotContent`. When false, fills are still detected
+     * and contributed to the shared registry, but no component-side pointers are
+     * emitted and no entries are marked referenced by this collaborator.
+     */
+    stampReferences?: boolean;
+}
+/**
+ * Top-level collaborator for slot content — sibling to Variants, Props, Anatomy,
+ * Subcomponents. Detects (SlotDetector) the component's own slot fills,
+ * contributes them to a (shared) SlotRegistry for de-duplication, and — when
+ * stamping is enabled — wires example references onto slot bindings and marks
+ * the referenced entries for emission. Parameterized so it serves both Component
+ * (`slotContentExamples`) and the future Composition (`slotContent`).
+ */
+export declare class SlotContent {
+    private _detector;
+    private _hostComponentName;
+    private _basePath;
+    private _outputKey;
+    private _config;
+    private _registry;
+    private _stampReferences;
+    private _nestedRelations;
+    constructor(options: SlotContentOptions);
+    /**
+     * Detect slot fills across variants, contribute them to the shared registry,
+     * and (when stamping is enabled) stamp example references onto each variant's
+     * `full` slot bindings, marking the referenced entries for emission. Must run
+     * after variants are evaluated but BEFORE variants.layer(), so differencing
+     * captures the example references.
+     */
+    process(variants: Variant[], context?: ProcessingContext): Promise<void>;
+    /**
+     * The serialized slot content record (keyed by final key), referenced entries
+     * only. When this collaborator owns its registry (standalone use) this is the
+     * full picture; when the registry is shared, the Component reads the registry
+     * directly so all sources contribute.
+     */
+    data(): Record<string, AnovaSlotContent>;
+    get outputKey(): 'slotContentExamples' | 'slotContent';
+    /** True when this collaborator's own registry has emitted nothing. */
+    get isEmpty(): boolean;
+    /**
+     * Stamp the example reference for each de-duplicated entry onto the matching
+     * slot-bound Children in each variant's `full` element map, and mark the
+     * referenced registry entries for emission.
+     */
+    private _wireExamples;
+    private _injectNestedPointers;
+    /**
+     * Inject SlotContentRef into instance elements nested inside slot content entries.
+     * For each relation (containingSlot → instance → childSlot), resolve both final
+     * keys (parent from top-level wiring, child from nested wiring — they may share a
+     * Figma name like "Children"), and add propConfigurations.<childSlotName>:
+     * { $slotContent } to the instance element in the parent entry. Marks both
+     * entries referenced. Shared by component slot content and instance examples.
+     */
+    static injectNestedPointers(nestedRelations: NestedSlotRelation[], registry: SlotRegistry, basePath: string, outputKey: 'slotContentExamples' | 'slotContent', config: ResolvedConfig): void;
+    /** Variant suffix used as the wiring key — must match SlotDetector's derivation. */
+    private _variantKey;
+}

package/dist/Component/SlotContent/SlotDetector.d.ts

@@ -0,0 +1,85 @@
+import { SlotCandidate } from './SlotCandidate.js';
+import type { ResolvedConfig } from '@directededges/specs-schema';
+import type { FigmaElementNode } from '../Nodes/types.js';
+import type { Variant } from '../Variants/Variant.js';
+import type { ProcessingContext } from '../../Runtime/Context/interfaces.js';
+/**
+ * Describes a slot nested inside an instance element within a slot content space.
+ * Used to inject SlotContentRef into the parent slot content's elements after registry finalization.
+ *
+ * Structure: ContainingSlot → (slot content) → InstanceNode → ChildSlot
+ */
+export interface NestedSlotRelation {
+    /** Element name of the slot whose content contains the instance. */
+    containingSlotElementName: string;
+    containingVariantKey: string;
+    /**
+     * Figma node id of the containing slot. Used as the wiring identity (node ids are
+     * unique; slot *names* collide across sibling instances). Resolves the parent
+     * entry when the containing slot is itself nested.
+     */
+    containingSlotId: string;
+    /** Figma node name of the instance element (must be present in containingSlot's elements). */
+    instanceNodeName: string;
+    /** Element name of the slot found inside the instance. */
+    childSlotElementName: string;
+    childVariantKey: string;
+    /** Figma node id of the child slot — the collision-proof wiring identity. */
+    childSlotId: string;
+    /**
+     * Instance names crossed BELOW the anchor instance (`instanceNodeName`) down to
+     * the instance that owns the child slot. Empty for the single-hop case
+     * (slot → instance → childSlot); non-empty for deeper chains, where it becomes
+     * the `path` of a `$nested` entry on the anchor instance (ADR-052).
+     */
+    nestedInstancePath: string[];
+}
+/**
+ * Walks all variants of a component, finds slot layers with authored content,
+ * and produces SlotCandidate instances for SlotRegistry.
+ *
+ * Walk rule:
+ *   - Walk the variant node's children recursively
+ *   - When a SLOT node is found, check if it has authored content (non-empty children)
+ *   - If it does, build a SlotCandidate for it
+ *   - INSTANCE children: recurse into them to find nested slots
+ *     - Guard against cycles using the instance's componentId
+ *     - Each slot found inside an instance produces its own SlotCandidate
+ */
+export declare class SlotDetector {
+    private config;
+    constructor(config: ResolvedConfig);
+    /**
+     * Traverse all variants and produce slot fill candidates.
+     * Returns candidates (one per filled slot × variant) and nestedRelations
+     * (instance-within-slot relationships needed for SlotContentRef injection).
+     */
+    traverse(variants: Variant[], hostComponentName: string, context?: ProcessingContext): Promise<{
+        candidates: SlotCandidate[];
+        nestedRelations: NestedSlotRelation[];
+    }>;
+    /**
+     * Traverse a single node (e.g. an instance-example node) with the same recursive
+     * slot/nesting rules as {@link traverse}. `variantSuffix` is the disambiguated
+     * example key (used as the wiring coordinate); `keyPrefix` (the base example key,
+     * un-disambiguated) prefixes every produced slot-content key at all nesting depths,
+     * so the registry entries an instance example contributes all begin with the
+     * instance name and any `__N` disambiguator lands at the end of the final key.
+     */
+    traverseNode(node: FigmaElementNode, variantSuffix: string, hostComponentName: string, context?: ProcessingContext, keyPrefix?: string): Promise<{
+        candidates: SlotCandidate[];
+        nestedRelations: NestedSlotRelation[];
+    }>;
+    /**
+     * Recursively walk a node's children looking for SLOT nodes with authored content.
+     * Recurses into INSTANCE children to find nested slots, guarded by componentId.
+     *
+     * containingSlotName: the Figma name of the nearest ancestor slot node (if any).
+     * containingInstanceName: the Figma name of the nearest instance node within that slot's content.
+     * When a slot is found inside an instance that is inside a slot, a NestedSlotRelation is recorded.
+     */
+    private _visit;
+    private _processSlotNode;
+    /** Derive the variant suffix portion of the entry key. */
+    private _variantSuffix;
+}

package/dist/Component/SlotContent/SlotItem.d.ts

@@ -0,0 +1,44 @@
+import type { ResolvedConfig, SlotContent as AnovaSlotContent } from '@directededges/specs-schema';
+import type { ProcessingContext } from '../../Runtime/Context/interfaces.js';
+/**
+ * The resolved payload for a single Figma slot layer — the anatomy + elements + layout triplet.
+ *
+ * Each slot's content is its own "space" — traversed independently from the component anatomy.
+ * Traversal starts at the slot's children (not the slot node itself), stops at instances.
+ * Mirrors the Variant lifecycle (evaluate → postProcess → data) but never calls difference().
+ * Stored as a value in the output `slotContentExamples` / `slotContent` record.
+ */
+export declare class SlotItem {
+    private _elements;
+    private _anatomy;
+    private _layout?;
+    private _config;
+    readonly isEmpty: boolean;
+    constructor(slotNode: SlotNode, config: ResolvedConfig);
+    evaluate(context?: ProcessingContext): Promise<void>;
+    postProcess(context?: ProcessingContext): Promise<void>;
+    data(): AnovaSlotContent;
+    /**
+     * Canonical string for the layout tree.
+     * Serializes the slot content children (the synthetic root's children),
+     * so two structurally identical content trees produce the same key
+     * regardless of which slot hosts them.
+     */
+    layoutKey(): string;
+    anatomyKey(): string;
+    layoutAnatomyKey(): string;
+    /** Elements equality key: SHA-256 of canonicalized elements (fixed-length Map key). */
+    elementsKey(): string;
+    private static _canonicalize;
+    /**
+     * Emit elements keyed by actual Figma node name (not Elements map key, which uses 'root'
+     * for the first element). Keeps anatomy, layout, and elements names consistent.
+     */
+    private _elementsData;
+    /**
+     * The synthetic root holds the slot's content children. Layout.data() returns [{ root: [...] }].
+     * Unwrap to return the children array directly as the slot content's layout.
+     */
+    private _fillLayout;
+    private _serializeLayoutNode;
+}

package/dist/Component/SlotContent/SlotRegistry.d.ts

@@ -0,0 +1,61 @@
+import type { SlotContent as AnovaSlotContent } from '@directededges/specs-schema';
+import type { SlotCandidate } from './SlotCandidate.js';
+/**
+ * De-duplicates SlotCandidate instances and assigns stable keys.
+ *
+ * De-dup is slot-agnostic: two candidates that produce identical structure
+ * (regardless of which slot element or variant they came from) share one entry.
+ * The same registry is shared between a component's own slot fills (via
+ * SlotContent) and the slot fills found inside instanceExamples, so identical
+ * fills from either source collapse to a single `slotContentExamples` entry with
+ * one reused key.
+ *
+ * De-dup fingerprint: layout + anatomy + elements (the candidate's fullKey).
+ *
+ * Emission is reference-gated: an entry is only serialized by `data()` if a
+ * consumer has marked its finalKey as referenced (`markReferenced`). This keeps
+ * the registry free of dangling entries when a consumer's `include.*` flag is
+ * off and avoids emitting fills that nothing points at.
+ */
+export declare class SlotRegistry {
+    /** finalKey → SlotContent data */
+    private _items;
+    /** fingerprint → finalKey (de-dup index) */
+    private _fingerprintIndex;
+    /** (elementName + variantKey) → finalKey for top-level slots (setExample wiring) */
+    private _topLevelWiring;
+    /** (elementName + variantKey) → finalKey for slots nested inside instances (Phase 5 wiring) */
+    private _nestedWiring;
+    /** finalKeys that an emitted consumer actually references — only these are serialized. */
+    private _referenced;
+    /**
+     * Register a candidate, de-duplicating against existing entries.
+     * Returns the finalKey assigned (existing key on a fingerprint match, else a
+     * freshly-resolved key). Registration alone does NOT emit the entry — call
+     * `markReferenced(finalKey)` once a consumer stamps a pointer to it.
+     */
+    add(candidate: SlotCandidate): string;
+    /** Mark a finalKey as referenced by an emitted consumer so `data()` serializes it. */
+    markReferenced(finalKey: string): void;
+    /** The live SlotContent entry for a finalKey (mutable), or undefined. */
+    entry(finalKey: string): AnovaSlotContent | undefined;
+    /** Top-level wiring lookup: (elementName + '|' + variantKey) → finalKey. */
+    topLevelKey(wiringKey: string): string | undefined;
+    /** Nested wiring lookup: (elementName + '|' + variantKey) → finalKey. */
+    nestedKey(wiringKey: string): string | undefined;
+    /**
+     * Returns the slotContentExamples record (referenced entries only) and the
+     * wiring maps. Each wiring map: (elementName + '|' + variantKey) → finalKey.
+     */
+    data(): {
+        slotContentExamples: Record<string, AnovaSlotContent>;
+        topLevelWiring: Map<string, string>;
+        nestedWiring: Map<string, string>;
+    };
+    /** True when no candidates have been registered. */
+    get isEmpty(): boolean;
+    /** True when nothing has been marked referenced (so `data()` would be empty). */
+    get hasReferences(): boolean;
+    /** Produce a unique final key, avoiding collisions with already-registered keys. */
+    private _resolveCollision;
+}

package/dist/Component/Styles/Composites/BiaxialComposite.d.ts

@@ -0,0 +1,64 @@
+import type { ResolvedConfig } from '@directededges/specs-schema';
+import { FigmaVariableReference } from '../References/index.js';
+import type { FigmaElementNode } from '../../Nodes/types.js';
+/** Per-field value: raw number or variable reference */
+export type BiaxialFieldValue = number | FigmaVariableReference;
+export type BiaxialValue = number | FigmaVariableReference | BiaxialComposite;
+/**
+ * Bi-axial composite for `{ horizontal, vertical }` spacing values.
+ * Used for `itemSpacing` when wrap is enabled and axes differ.
+ * Direction-aware: maps Figma primary/counter-axis to absolute horizontal/vertical
+ * based on layoutMode.
+ */
+export declare class BiaxialComposite {
+    private _fields;
+    constructor(fields: {
+        horizontal?: BiaxialFieldValue;
+        vertical?: BiaxialFieldValue;
+    });
+    /**
+     * Factory: read itemSpacing + counterAxisSpacing from a Figma node and produce
+     * a BiaxialComposite with direction-aware axis mapping.
+     * Picks up variable bindings when present and licensed.
+     */
+    static fromNode(node: FigmaElementNode, layoutMode: 'HORIZONTAL' | 'VERTICAL', licensed?: boolean): BiaxialComposite;
+    /**
+     * Resolve a bound variable for a Figma node property key.
+     */
+    private static getVariableForKey;
+    /**
+     * Compare against a baseline. Returns a sparse composite with only changed fields,
+     * or null if no fields differ.
+     */
+    difference(baseline: BiaxialValue): BiaxialValue | null;
+    /**
+     * Style-level union router (like QuadComposite.differenceValues).
+     * Returns undefined when biaxial semantics do not apply.
+     */
+    static differenceValues(current: unknown, baseline: unknown): BiaxialValue | null | undefined;
+    /**
+     * Merge a layered variant composite onto a baseline.
+     * Layer wins on overlapping axes.
+     */
+    static merge(base: BiaxialValue, layer: BiaxialComposite | null): BiaxialValue;
+    clone(): BiaxialComposite;
+    data(config: ResolvedConfig): Record<string, unknown>;
+    /** Resolve variable names for all FigmaVariableReference fields */
+    resolveVariables(foundations: import('../../../Runtime/Foundations/interfaces.js').FigmaFoundations | undefined): Promise<void>;
+    /** True when all fields are plain numbers equal to the given scalar (for default removal) */
+    isEqualToScalar(scalar: number): boolean;
+    /** Get a field value by axis name */
+    get(field: 'horizontal' | 'vertical'): BiaxialFieldValue | undefined;
+    /** Returns axis names that have values */
+    fields(): string[];
+    private fieldValue;
+    private static resolveField;
+    private static fieldDiffers;
+    private static cloneField;
+    private static cloneValue;
+    /**
+     * Normalize: always preserve composite form (never collapse to scalar).
+     * Bi-axial values remain explicit even when both axes are equal.
+     */
+    private static normalize;
+}