@directededges/specs-from-figma 0.21.0 → 0.22.0

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

@@ -0,0 +1,108 @@
+import type { Styles as AnovaStyles } from "@directededges/specs-schema";
+import { FigmaElementNode } from '../Nodes/types.js';
+import { StyleKey } from './keys.js';
+import { Style } from './Style.js';
+import { ResolvedConfig } from '@directededges/specs-schema';
+import type { ProcessingContext } from '../../Runtime/Context/interfaces.js';
+export declare class Styles {
+    private _items;
+    private _node;
+    private _context?;
+    constructor(node: FigmaElementNode, context?: ProcessingContext);
+    /**
+     * Get the source Figma node
+     * Used by Output classes to access node properties (e.g., fills, strokes for color swatches)
+     */
+    get node(): FigmaElementNode;
+    get context(): ProcessingContext | undefined;
+    evaluate(context?: ProcessingContext, keys?: readonly string[]): void;
+    /**
+     * Merge another Styles instance onto this one.
+     * Layer styles take precedence over base styles.
+     * Performs property-level merge: base styles are preserved unless layer overrides them.
+     *
+     * @param layer - The Styles to merge onto this one
+     * @returns A new Styles instance with merged values
+     */
+    merge(layer: Styles): Styles;
+    /**
+     * Compare this Styles against a baseline to identify differences.
+     * Returns a new Styles instance containing only styles that differ.
+     * For composite values (Sides/Corners), produces sparse diffs with only changed fields.
+     *
+     * @param baseline - The Styles to compare against
+     * @returns A new Styles instance with differences, or empty if no differences
+     */
+    compare(baseline: Styles): Styles;
+    /**
+     * Relates raw Figma properties into semantic spec properties.
+     * Runs after evaluate() and before compare()/layer().
+     */
+    postEvaluate(): void;
+    postProcess(removeDefaults: boolean, fullStyles: Styles | undefined, context?: ProcessingContext): Promise<void>;
+    data(config: ResolvedConfig): AnovaStyles | undefined;
+    /**
+     * Removes a style by its key.
+     * @param key The key of the style to remove.
+     */
+    remove(key: string): void;
+    /**
+     * Copy styles from another Styles instance
+     * @param source Source Styles instance to copy from
+     * @param keys Optional set of keys to copy. If omitted, copies all styles.
+     */
+    copy(source: Styles, keys?: Set<string> | string[]): void;
+    /**
+     * Create a deep clone of this Styles instance.
+     *
+     * @returns A new Styles instance with cloned style objects
+     */
+    clone(): Styles;
+    get(key: StyleKey): Style | undefined;
+    set(key: StyleKey, style: Style): void;
+    has(key: StyleKey): boolean;
+    /**
+     * Returns an iterator over [styleKey, style] entries.
+     * @example
+     * for (const [key, style] of styles.entries()) {
+     *   console.log(key, style);
+     * }
+     */
+    entries(): IterableIterator<[StyleKey, Style]>;
+    /**
+     * Returns an iterator over style values.
+     * @example
+     * for (const style of styles.values()) {
+     *   await style.process();
+     * }
+     */
+    values(): IterableIterator<Style>;
+    /**
+     * Returns an iterator over style keys.
+     * @example
+     * for (const key of styles.keys()) {
+     *   console.log(key);
+     * }
+     */
+    keys(): IterableIterator<StyleKey>;
+    /**
+     * Makes Styles directly iterable (defaults to entries).
+     * @example
+     * for (const [key, style] of styles) {
+     *   console.log(key, style);
+     * }
+     */
+    [Symbol.iterator](): IterableIterator<[StyleKey, Style]>;
+    /**
+     * Returns the number of styles in the collection.
+     */
+    get size(): number;
+    /**
+     * Checks if the collection is empty.
+     * @example
+     * if (styles.isEmpty()) {
+     *   return;
+     * }
+     */
+    isEmpty(): boolean;
+}

package/dist/Component/Styles/StylesProcessor.d.ts

@@ -0,0 +1,96 @@
+import { Styles } from './Styles';
+import type { ProcessingContext } from '../../Runtime/Context/interfaces.js';
+export declare class StylesProcessor {
+    /**
+     * Relates raw Figma properties into semantic spec properties.
+     * Runs after evaluate() and before layer() so computed values
+     * are available for variant differencing.
+     */
+    static postEvaluate(styles: Styles): void;
+    /**
+     * Performs all post-processing steps on the given Styles instance.
+     * Runs after layer() — handles name resolution, defaults removal,
+     * and text-style/typography relationships.
+     * @param styles The Styles object to process.
+     * @param removeDefaults Whether to remove default styles.
+     * @param fullStyles The full styles for comparison.
+     * @param context Optional processing context with dataLoader
+     */
+    static postProcess(styles: Styles, removeDefaults: boolean, fullStyles: Styles | undefined, context?: ProcessingContext): Promise<void>;
+    /**
+     * Removes default styles from the given Styles object.
+     * @param styles The Styles object to process.
+     */
+    private static removeDefaults;
+    /**
+     * Resolves variable names within SidesQuadComposite and CornersQuadComposite values.
+     * @param styles The Styles object to process.
+     * @param context Optional processing context
+     */
+    private static lookupQuadCompositeVariables;
+    /**
+     * Resolves variable names within BiaxialComposite values.
+     * @param styles The Styles object to process.
+     * @param context Optional processing context
+     */
+    private static lookupBiaxialCompositeVariables;
+    /**
+     *
+     * Relates layout sizing and auto-layout styles.
+     * @param styles The Styles object to process.
+     */
+    private static relateLayoutSizingAndAutoLayout;
+    /**
+     * Maps Figma constraints to directional positioning properties (ADR-041).
+     *
+     * Reads the parent's layout mode and the child's positioning context to determine
+     * which offset properties to emit. Each axis is mapped independently (FR-013).
+     *
+     * Context rules (FR-012):
+     * - Parent layoutMode NONE (regular frame): offsets + position null
+     * - Auto-layout + ABSOLUTE child: offsets + position "ABSOLUTE"
+     * - Auto-layout + AUTO child: position "AUTO", no offsets
+     * - Top-level (no parent) or COMPONENT root: position null, no offsets
+     */
+    private static relateAutoVsAbsoluteLayout;
+    /**
+     * Maps a single-axis constraint to the appropriate offset property/properties.
+     */
+    private static mapAxisConstraint;
+    /**
+     * Creates a Style for an offset key and sets a computed value on it.
+     * Accepts null to explicitly mark a key as "no value" (needed for variant differencing).
+     */
+    private static setOffsetStyle;
+    /**
+     * Removes wrapAlignment when wrap is not active — it's a dead property otherwise.
+     */
+    private static relateWrapAndWrapAlignment;
+    private static relateTextStyleAndTextProperties;
+    /**
+     * Looks up and updates a Figma style name (text or effect) for the given Styles instance.
+     * @param styles The Styles object to process.
+     * @param styleKey The style key to look up ('textStyleId').
+     * @param context Optional processing context
+     */
+    private static lookupFigmaStyleName;
+    /**
+     * Looks up and updates color style names for fills and strokes.
+     * Only performs lookup if the style type is 'STYLE'.
+     * @param styles The Styles object to process.
+     * @param context Optional processing context
+     */
+    private static lookupColorStyleNames;
+    /**
+     * Looks up and updates variables for the given Styles instance.
+     * @param styles The Styles object to process.
+     * @param context Optional processing context
+     */
+    private static lookupVariables;
+    /**
+     * Looks up and updates gradient stop variables for any gradient styles.
+     * @param styles The Styles object to process.
+     * @param context Optional processing context
+     */
+    private static lookupGradientVariables;
+}

package/dist/Component/Styles/defaults.d.ts

@@ -0,0 +1,2 @@
+import { StyleKey } from "./keys.js";
+export declare const STYLE_DEFAULTS: Record<StyleKey, string | number | boolean | null>;

package/dist/Component/Styles/figmaKeyMap.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Maps transformer spec output keys to their corresponding Figma node property keys.
+ * Only keys that differ need an entry — all others fall through to identity.
+ *
+ * This is the single source of truth for any transformer output key that diverges
+ * from its Figma node property name. Add new entries here as more semantic renames land.
+ */
+export declare const SPEC_TO_FIGMA_KEY_MAP: Readonly<Record<string, string>>;
+/** Resolve a spec-layer output key to the Figma node property key to read from. */
+export declare function toFigmaKey(specKey: string): string;
+/** All spec keys that map to `node.fills`. */
+export declare const FILL_SPEC_KEYS: ReadonlyArray<string>;

package/dist/Component/Styles/keys.d.ts

@@ -0,0 +1,20 @@
+export declare const STYLE_KEYS: {
+    ALL: string[];
+    STROKE_SIDES: string[];
+    CORNERS: string[];
+    PADDING_SIDES: string[];
+    COMPONENT: string[];
+    FRAME: string[];
+    SLOT: string[];
+    INSTANCE: string[];
+    GLYPH: string[];
+    TEXT: string[];
+    VECTOR: string[];
+    RECTANGLE: string[];
+    LINE: string[];
+    STAR: string[];
+    POLYGON: string[];
+    ELLIPSE: string[];
+};
+export type StyleKey = typeof STYLE_KEYS.ALL[number];
+export type Side = 'TOP' | 'BOTTOM' | 'LEFT' | 'RIGHT';

package/dist/Component/Subcomponents/Subcomponent.d.ts

@@ -0,0 +1,20 @@
+import { Component } from "../Component.js";
+import { SpecableNode } from '../Nodes/types.js';
+import { ResolvedConfig } from '@directededges/specs-schema';
+import { Subcomponent as AnovaSubcomponent } from '@directededges/specs-schema';
+import { Anatomy } from '../Anatomy/Anatomy.js';
+import type { ProcessingContext } from '../../Runtime/Context/interfaces.js';
+export declare class Subcomponent extends Component {
+    private _parentComponentName?;
+    private _subcomponentKey?;
+    constructor(node: SpecableNode, config: ResolvedConfig);
+    /** Called by Subcomponents before process() to set path context for $extensions pointers. */
+    setPathContext(parentComponentName: string, subcomponentKey: string): void;
+    process(context?: ProcessingContext): Promise<void>;
+    protected _slotBasePath(): string;
+    /**
+     * Get the anatomy for this subcomponent (internal use only)
+     */
+    getAnatomy(): Anatomy;
+    data(): AnovaSubcomponent;
+}

package/dist/Component/Subcomponents/Subcomponents.d.ts

@@ -0,0 +1,83 @@
+import { ResolvedConfig, Subcomponents as AnovaSubcomponents } from "@directededges/specs-schema";
+import { Anatomy } from '../Anatomy/Anatomy.js';
+import type { Subcomponent } from './Subcomponent.js';
+import type { ProcessingContext } from '../../Runtime/Context/interfaces.js';
+export declare class Subcomponents {
+    private _items;
+    private _refMap;
+    private config;
+    constructor(config: ResolvedConfig);
+    private createSubcomponent;
+    /**
+     * Check if a name matches any of the given template patterns.
+     * Patterns use {C} (component name) and {S} (subcomponent name) placeholders.
+     * Short-circuits on first match, returning the captured subcomponent name or null.
+     */
+    static matchesPatterns(name: string, patterns: string[], componentName: string): string | null;
+    /**
+     * Check if a name matches any exclude pattern.
+     * Returns true if the name should be excluded.
+     */
+    private matchesExclude;
+    private evaluateAnatomy;
+    /**
+     * Scan page-level COMPONENT/COMPONENT_SET nodes for additional subcomponents.
+     * Only called when scope is PAGE. Additive — never replaces anatomy-detected subcomponents.
+     */
+    private evaluatePage;
+    evaluate(componentName: string, anatomy: Anatomy, context?: ProcessingContext, rootNodeId?: string): Promise<void>;
+    data(_config: ResolvedConfig, _removeExcludedMembers?: boolean, _defaultVariant?: boolean): AnovaSubcomponents | undefined;
+    /**
+     * Build a formatted ref map: formatted instanceOf → formatted subcomponent key.
+     * Used by data serialization to emit `{ $ref: '#/subcomponents/{key}' }`.
+     */
+    refMap(keyFormat: ResolvedConfig['format']['keys']): Map<string, string>;
+    get(name: string): Subcomponent | undefined;
+    set(name: string, subcomponent: Subcomponent): void;
+    has(name: string): boolean;
+    delete(name: string): void;
+    /**
+     * Returns an iterator over [name, subcomponent] entries.
+     * @example
+     * for (const [name, subcomponent] of subcomponents.entries()) {
+     *   console.log(name, subcomponent);
+     * }
+     */
+    entries(): IterableIterator<[string, Subcomponent]>;
+    /**
+     * Returns an iterator over subcomponent values.
+     * @example
+     * for (const subcomponent of subcomponents.values()) {
+     *   await subcomponent.process();
+     * }
+     */
+    values(): IterableIterator<Subcomponent>;
+    /**
+     * Returns an iterator over subcomponent names.
+     * @example
+     * for (const name of subcomponents.keys()) {
+     *   console.log(name);
+     * }
+     */
+    keys(): IterableIterator<string>;
+    /**
+     * Makes Subcomponents directly iterable (defaults to entries).
+     * @example
+     * for (const [name, subcomponent] of subcomponents) {
+     *   console.log(name, subcomponent);
+     * }
+     */
+    [Symbol.iterator](): IterableIterator<[string, Subcomponent]>;
+    /**
+     * Returns the number of subcomponents in the collection.
+     */
+    get size(): number;
+    /**
+     * Checks if the collection is empty.
+     * @example
+     * if (subcomponents.isEmpty()) {
+     *   return;
+     * }
+     */
+    isEmpty(): boolean;
+}

package/dist/Component/Typography/FontStyle.d.ts

@@ -0,0 +1,6 @@
+import { StyleKey } from '../Styles/keys.js';
+import { RawStyle } from '../Styles/Style.js';
+import { FigmaElementNode } from '../Nodes/types.js';
+export declare class FontStyle {
+    static value(node: FigmaElementNode, key: StyleKey): RawStyle | null;
+}

package/dist/Component/Typography/LetterSpacingStyle.d.ts

@@ -0,0 +1,4 @@
+import { RawStyle } from '../Styles/Style.js';
+export declare class LetterSpacingStyle {
+    static value(node: TextNode): RawStyle | null;
+}

package/dist/Component/Typography/LineHeightStyle.d.ts

@@ -0,0 +1,4 @@
+import { RawStyle } from '../Styles/Style.js';
+export declare class LineHeightStyle {
+    static value(node: TextNode): RawStyle | null;
+}

package/dist/Component/Typography/Typography.d.ts

@@ -0,0 +1,105 @@
+import type { Typography as AnovaTypography, ResolvedConfig } from '@directededges/specs-schema';
+import { FigmaVariableReference } from '../Styles/References/index.js';
+import { type ProcessingContext } from '../../Runtime/Context/interfaces.js';
+/**
+ * Typography - First-class component representing all typography-related properties.
+ *
+ * Consolidates 13 individual typography properties into a single composite entity,
+ * matching the Effects and Gradient pattern. Typography instances can represent:
+ * - Inline typography (13 individual properties evaluated from node)
+ * - Mixed values (when text runs have different values)
+ * - Variable bindings (fontSize, lineHeight, letterSpacing, paragraphSpacing)
+ * - Explicit null (property removed/unset in variant)
+ *
+ * @see Effects for similar pattern (composite component with property-level diffing)
+ */
+export declare class Typography {
+    fontSize?: number | FigmaVariableReference | 'Figma mixed' | null;
+    fontFamily?: string | FigmaVariableReference | 'Figma mixed' | null;
+    fontStyle?: string | FigmaVariableReference | 'Figma mixed' | null;
+    lineHeight?: number | FigmaVariableReference | 'Figma mixed' | null;
+    letterSpacing?: number | FigmaVariableReference | 'Figma mixed' | null;
+    textCase?: string | 'Figma mixed' | null;
+    textDecoration?: string | 'Figma mixed' | null;
+    paragraphIndent?: number | FigmaVariableReference | 'Figma mixed' | null;
+    paragraphSpacing?: number | FigmaVariableReference | 'Figma mixed' | null;
+    leadingTrim?: string | 'Figma mixed' | null;
+    listSpacing?: number | 'Figma mixed' | null;
+    hangingPunctuation?: boolean | 'Figma mixed' | null;
+    hangingList?: boolean | 'Figma mixed' | null;
+    /**
+     * Evaluate typography properties from a TextNode.
+     *
+     * Delegates to existing style primitives (FontStyle, NumberStyle, LineHeightStyle,
+     * MixedStyle, BooleanStyle) to evaluate each property. Checks for variable bindings
+     * on VARIABLE_PROPERTIES before calling primitives. Returns null if all properties
+     * are undefined (no typography data present).
+     *
+     * @param node - Figma TextNode to evaluate
+     * @returns Typography instance or null if empty
+     */
+    static evaluate(node: TextNode, context?: ProcessingContext): Typography | null;
+    /**
+     * Returns true when no typography property has been set.
+     * Used to determine if Typography key should be omitted from output.
+     */
+    isEmpty(): boolean;
+    /**
+     * Serialize Typography to output format.
+     *
+     * - Omits undefined properties
+     * - Includes null properties explicitly as null
+     * - Calls instance.data(config) for FigmaVariableReference properties
+     * - Returns partial object (only includes defined properties)
+     *
+     * @param config - Transformation configuration
+     * @returns Typography object (using AnovaTypography from @directededges/specs-schema)
+     */
+    data(config: ResolvedConfig): AnovaTypography;
+    /**
+     * Serialize a property value, calling instance.data(config) for FigmaVariableReference.
+     *
+     * @param value - Property value to serialize
+     * @param config - Transformation configuration
+     * @returns Serialized value
+     */
+    private serializeProperty;
+    /**
+     * Create a deep copy of this Typography instance.
+     *
+     * - Calls instance.clone() for FigmaVariableReference instances
+     * - Preserves null vs undefined distinction
+     *
+     * @returns New Typography instance
+     */
+    clone(): Typography;
+    /**
+     * Clone a field value, calling instance.clone() for FigmaVariableReference.
+     */
+    private cloneField;
+    /**
+     * Property-level comparison with base Typography.
+     *
+     * Returns true if ANY property differs. Compares:
+     * - Existence first (!!this.prop !== !!base.prop)
+     * - Calls instance.difference() for FigmaVariableReference instances
+     * - null ≠ undefined, null ≠ any value, undefined ≠ any defined value
+     *
+     * @param base - Base Typography to compare against
+     * @returns true if any property differs
+     */
+    difference(base: Typography): boolean;
+    /**
+     * Compare two field values for difference.
+     * Handles existence, primitives, FigmaVariableReference instances, 'Figma mixed', and null.
+     */
+    private differField;
+    /**
+     * Whole-group replacement: returns typography.clone().
+     * When merging two Typography objects, the typography completely replaces the base with no property inheritance.
+     *
+     * @param typography - The Typography instance to merge onto this one
+     * @returns A cloned copy of the typography Typography
+     */
+    merge(typography: Typography): Typography;
+}

package/dist/Component/Typography/TypographyProcessor.d.ts

@@ -0,0 +1,33 @@
+import { Style } from '../Styles/Style.js';
+import type { ProcessingContext } from '../../Runtime/Context/interfaces.js';
+/**
+ * Post-processes a `typography` Style after initial evaluation.
+ *
+ * Handles two paths:
+ * 1. FigmaStyleReference: resolves the `.name` field via resolveName().
+ * 2. Typography: resolves FigmaVariableReference fields and optionally removes defaults.
+ *
+ * Called from `StylesProcessor.postProcess()` for the `typography` style key.
+ */
+export declare class TypographyProcessor {
+    /**
+     * Performs all post-processing steps on a typography Style.
+     * @param style The typography Style to process
+     * @param context Optional processing context with foundations
+     * @param removeDefaults Whether to remove default values
+     */
+    static postProcess(style: Style | undefined, context?: ProcessingContext, removeDefaults?: boolean): Promise<void>;
+    /**
+     * Resolves FigmaVariableReference fields to named variables.
+     * Processes fontSize, lineHeight, letterSpacing, paragraphSpacing.
+     * @param typography The Typography instance to process
+     * @param context Optional processing context with foundations
+     */
+    private static lookupVariables;
+    /**
+     * Removes typography properties that match their default values.
+     * Properties matching TYPOGRAPHY_DEFAULTS are set to undefined.
+     * @param typography The Typography instance to process
+     */
+    private static removeDefaults;
+}

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

@@ -0,0 +1,20 @@
+/**
+ * Typography properties that support variable bindings.
+ *
+ * These properties can be bound to Figma variables:
+ * - fontSize - Font size in pixels (number variable)
+ * - fontFamily - Font family name (string variable)
+ * - fontStyle - Font style/weight (string variable)
+ * - lineHeight - Line height (pixels or %) (number variable)
+ * - letterSpacing - Letter spacing (pixels or %) (number variable)
+ * - paragraphIndent - First line indent in pixels (number variable)
+ * - paragraphSpacing - Space between paragraphs in pixels (number variable)
+ * - listSpacing - Space between list items in pixels (number variable)
+ *
+ * Used by TypographyProcessor.postProcess() to resolve FigmaVariableReference.id
+ * to FigmaVariableReference.name via instance.resolveName().
+ *
+ * @see TypographyProcessor for variable name resolution
+ * @see Typography for property types (string|number | FigmaVariableReference | 'Figma mixed' | null)
+ */
+export declare const VARIABLE_PROPERTIES: readonly ["fontSize", "fontFamily", "fontStyle", "lineHeight", "letterSpacing", "paragraphIndent", "paragraphSpacing"];

package/dist/Component/Typography/defaults.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Default values for Typography properties.
+ *
+ * Used for default removal logic during evaluation of the default variant.
+ * When a property's evaluated value matches its default, it's omitted from
+ * output to keep the base component minimal (existing transformer behavior).
+ *
+ * Note: textStyleId (now handled as FigmaStyleReferenceData reference) is not included here.
+ * TypographyStyle.value() checks for textStyleId separately before delegating
+ * to Typography.evaluate().
+ *
+ * @see Typography.evaluate() for default removal implementation
+ * @see data-model.md for null vs undefined semantics
+ */
+export declare const TYPOGRAPHY_DEFAULTS: {
+    readonly fontSize: 16;
+    readonly fontFamily: null;
+    readonly fontStyle: null;
+    readonly textCase: "ORIGINAL";
+    readonly textDecoration: "NONE";
+    readonly letterSpacing: 0;
+    readonly lineHeight: "AUTO";
+    readonly paragraphIndent: 0;
+    readonly paragraphSpacing: 0;
+    readonly leadingTrim: "NONE";
+    readonly listSpacing: 0;
+    readonly hangingPunctuation: false;
+    readonly hangingList: false;
+};
+export type TypographyProperty = keyof typeof TYPOGRAPHY_DEFAULTS;

package/dist/Component/Typography/keys.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Typography property keys (internal to Typography component).
+ *
+ * This constant lists all 13 typography properties for iteration in:
+ * - Typography.isEmpty() - checking if all properties are undefined
+ * - Typography.data() - serializing defined properties
+ * - Typography.difference() - comparing properties with base
+ *
+ * These are internal to the Typography component and separate from the
+ * central STYLE_KEYS (which contains 'typography' as a single key).
+ */
+export declare const TYPOGRAPHY_KEYS: readonly ["fontSize", "fontFamily", "fontStyle", "lineHeight", "letterSpacing", "textCase", "textDecoration", "paragraphIndent", "paragraphSpacing", "leadingTrim", "listSpacing", "hangingPunctuation", "hangingList"];

package/dist/Component/Variants/Differencer.d.ts

@@ -0,0 +1,47 @@
+import { Variant } from './Variant.js';
+import { Elements } from '../Elements/Elements.js';
+import { BaseElement } from '../Elements/BaseElement.js';
+import type { ProcessingContext } from '../../Runtime/Context/interfaces.js';
+/**
+ * Utility class for establishing element parity between variants during the difference operation.
+ * Ensures that baseline and current variants have matching element sets before comparison.
+ */
+export declare class Differencer {
+    constructor();
+    /**
+     * Ensures the baseline variant has all elements present in the current variant.
+     * For any element in the current variant missing from the baseline, adds a fallback
+     * element to the baseline to enable proper comparison.
+     *
+     * @param baseVariantFull - The baseline variant's full element collection to modify
+     * @param currentVariant - The current variant being differenced
+     * @param layeredMatches - Array of layeredMatches to search for fallback elements (DEFAULT is [0])
+     * @param context - Processing context for license-aware evaluation
+     * @returns Promise that resolves when all missing elements have been added
+     */
+    static establishBaselineParity(baseVariantFull: Elements, currentVariant: Variant, layeredMatches: Variant[], context?: ProcessingContext): Promise<void>;
+    /**
+     * Finds a fallback element for baseline parity by searching layeredMatches.
+     * Instead of traversing baseline chain, searches through all provided layeredMatches.
+     * If not found in any layeredMatch, adds to default variant (layeredMatches[0]).
+     *
+     * @param currentVariant - The current variant needing the fallback element
+     * @param elementName - The name of the element to find
+     * @param layeredMatches - Array of layeredMatches to search (DEFAULT is [0])
+     * @param context - Processing context for license-aware evaluation
+     * @returns Promise resolving to the fallback BaseElement
+     */
+    static baseFallbackElement(currentVariant: Variant, elementName: string, layeredMatches: Variant[], context?: ProcessingContext): Promise<BaseElement>;
+    /**
+     * Adds an element to the default variant's element collection.
+     * Used when an element doesn't exist in any baseline variant and must be
+     * added to the default variant to maintain parity.
+     *
+     * @param variant - The variant containing the element to add
+     * @param elementName - The name of the element to add to default
+     * @param defaultVariant - The default variant to receive the new element
+     * @param context - Processing context for license-aware evaluation
+     * @returns Promise resolving to the newly created BaseElement
+     */
+    static addElementToDefault(variant: Variant, elementName: string, defaultVariant: Variant, context?: ProcessingContext): Promise<BaseElement>;
+}