@nikkory/vibe-engine 4.0.0

package/dist/ui-studio/granularity/GranularityGenerator.d.ts

@@ -0,0 +1,266 @@
+/**
+ * GranularityGenerator - Base abstract class for granularity-based generation
+ *
+ * This is the foundation for the Unified Granularity Architecture's recursive
+ * generation pipeline. All granularity-specific generators extend this base class.
+ *
+ * Key Features:
+ * - Generic type parameter G for type-safe granularity level
+ * - Abstract generate() method for level-specific implementation
+ * - Common utility methods shared across all generators
+ * - Factor resolution support
+ *
+ * @packageDocumentation
+ * @module generators
+ * @since 4.0.0
+ *
+ * Powered by Nikkory
+ */
+import type { DesignSystem } from '../types';
+import type { GranularityLevel, GranularityConfig, GranularityFactorValues, GranularityFactorDefinition } from '../../types/granularity';
+/**
+ * Output from a granularity generation operation
+ *
+ * @category types
+ * @since 4.0.0
+ *
+ * @example
+ * ```typescript
+ * const output: GeneratedOutput = {
+ *   code: '<Section>...</Section>',
+ *   styles: 'section { ... }',
+ *   metadata: { granularity: 'section', childCount: 3 },
+ *   children: [...childOutputs]
+ * };
+ * ```
+ *
+ * Powered by Nikkory
+ */
+export interface GeneratedOutput {
+    /** Generated code (JSX/TSX) */
+    readonly code: string;
+    /** Generated styles (CSS/Tailwind classes) */
+    readonly styles?: string;
+    /** Generation metadata */
+    readonly metadata: GenerationMetadata;
+    /** Child outputs (for recursive generation) */
+    readonly children?: readonly GeneratedOutput[];
+}
+/**
+ * Metadata about the generation operation
+ *
+ * @category types
+ * @since 4.0.0
+ *
+ * Powered by Nikkory
+ */
+export interface GenerationMetadata {
+    /** Config ID that was generated */
+    readonly configId: string;
+    /** Granularity level of the generated output */
+    readonly granularity: GranularityLevel;
+    /** Design system used */
+    readonly designSystem: DesignSystem;
+    /** Number of children generated */
+    readonly childCount: number;
+    /** Factors applied at this level */
+    readonly appliedFactors: readonly string[];
+    /** Generation timestamp */
+    readonly generatedAt: Date;
+    /** Generation duration in milliseconds */
+    readonly durationMs?: number;
+}
+/**
+ * Options for granularity generation
+ *
+ * @category types
+ * @since 4.0.0
+ *
+ * Powered by Nikkory
+ */
+export interface GranularityGeneratorOptions {
+    /** Whether to include children in generation */
+    readonly includeChildren?: boolean;
+    /** Maximum depth for recursive generation */
+    readonly maxDepth?: number;
+    /** Whether to enable verbose logging */
+    readonly verbose?: boolean;
+    /** Custom factor overrides */
+    readonly factorOverrides?: GranularityFactorValues;
+    /** Config lookup function for resolving references */
+    readonly configLookup?: (id: string) => GranularityConfig<GranularityLevel> | undefined;
+}
+/**
+ * GranularityGenerator - Abstract base class for all granularity generators
+ *
+ * This class provides the foundation for the recursive generation pipeline.
+ * Concrete implementations must implement the generate() method for their
+ * specific granularity level.
+ *
+ * @category generators
+ * @since 4.0.0
+ *
+ * @typeParam G - The granularity level this generator handles
+ *
+ * @example
+ * ```typescript
+ * class SectionGranularityGenerator extends GranularityGenerator<'section'> {
+ *   async generate(
+ *     config: GranularityConfig<'section'>
+ *   ): Promise<GeneratedOutput> {
+ *     // Section-specific generation logic
+ *     const factors = this.getFactorsForLevel('section');
+ *     const resolvedFactors = this.resolveFactors(factors, config);
+ *     // ...generate code
+ *   }
+ * }
+ * ```
+ *
+ * Powered by Nikkory
+ */
+export declare abstract class GranularityGenerator<G extends GranularityLevel> {
+    /** Generator options */
+    protected readonly options: GranularityGeneratorOptions;
+    /**
+     * Create a new GranularityGenerator
+     *
+     * @param options - Generator options
+     */
+    constructor(options?: GranularityGeneratorOptions);
+    /**
+     * Generate output for a granularity config
+     *
+     * This is the main generation method that subclasses must implement.
+     * It takes a config and produces the generated output (code, styles, metadata).
+     *
+     * @param config - The granularity config to generate from
+     * @param parentFactors - Factors inherited from parent (for cascade)
+     * @returns Promise resolving to generated output
+     *
+     * @example
+     * ```typescript
+     * const output = await generator.generate(sectionConfig, { spacing: 'lg' });
+     * console.log(output.code);
+     * ```
+     */
+    abstract generate(config: GranularityConfig<G>, parentFactors?: GranularityFactorValues): Promise<GeneratedOutput>;
+    /**
+     * Get all factors applicable at a given granularity level
+     *
+     * Includes factors defined at this level AND factors from higher
+     * levels that have cascadeDown enabled.
+     *
+     * @param level - The granularity level to query
+     * @returns Array of factor definitions applicable at this level
+     *
+     * @example
+     * ```typescript
+     * const pageFactors = this.getFactorsForLevel('page');
+     * // Returns factors from template (cascaded) + page level
+     * ```
+     *
+     * Powered by Nikkory
+     */
+    protected getFactorsForLevel(level: GranularityLevel): readonly GranularityFactorDefinition[];
+    /**
+     * Resolve factor values for a config
+     *
+     * Priority order (highest to lowest):
+     * 1. Config's explicit factors
+     * 2. Parent's cascading factors
+     * 3. Design system defaults
+     *
+     * @param factors - Factor definitions to resolve
+     * @param config - The config containing factor values
+     * @param parentFactors - Factors from parent (optional)
+     * @returns Resolved factor values
+     *
+     * @example
+     * ```typescript
+     * const factors = this.getFactorsForLevel('section');
+     * const resolved = this.resolveFactors(factors, sectionConfig, parentFactors);
+     * console.log(resolved.spacing); // 'lg'
+     * ```
+     *
+     * Powered by Nikkory
+     */
+    protected resolveFactors(factors: readonly GranularityFactorDefinition[], config: GranularityConfig<G>, parentFactors?: GranularityFactorValues): GranularityFactorValues;
+    /**
+     * Get factor definition by ID
+     *
+     * @param factorId - The factor ID
+     * @returns Factor definition or undefined
+     *
+     * Powered by Nikkory
+     */
+    protected getFactorDefinition(factorId: string): GranularityFactorDefinition | undefined;
+    /**
+     * Check if one granularity level is higher than another
+     *
+     * @param a - First level
+     * @param b - Second level
+     * @returns True if a is higher than b
+     *
+     * @example
+     * ```typescript
+     * this.isHigherGranularity('page', 'section'); // true
+     * this.isHigherGranularity('atom', 'component'); // false
+     * ```
+     *
+     * Powered by Nikkory
+     */
+    protected isHigherGranularity(a: GranularityLevel, b: GranularityLevel): boolean;
+    /**
+     * Get child granularity levels for a given level
+     *
+     * @param level - The parent level
+     * @returns Array of valid child levels
+     *
+     * @example
+     * ```typescript
+     * this.getChildGranularities('page'); // ['section', 'component', 'atom']
+     * this.getChildGranularities('atom'); // []
+     * ```
+     *
+     * Powered by Nikkory
+     */
+    protected getChildGranularities(level: GranularityLevel): readonly GranularityLevel[];
+    /**
+     * Check if a child granularity is valid for a parent
+     *
+     * @param parent - Parent granularity level
+     * @param child - Child granularity level
+     * @returns True if child can be nested in parent
+     *
+     * @example
+     * ```typescript
+     * this.isValidChildGranularity('page', 'section'); // true
+     * this.isValidChildGranularity('component', 'page'); // false
+     * ```
+     *
+     * Powered by Nikkory
+     */
+    protected isValidChildGranularity(parent: GranularityLevel, child: GranularityLevel): boolean;
+    /**
+     * Create generation metadata
+     *
+     * @param config - The config being generated
+     * @param appliedFactors - IDs of factors applied
+     * @param childCount - Number of children generated
+     * @param durationMs - Generation duration
+     * @returns Generation metadata object
+     *
+     * Powered by Nikkory
+     */
+    protected createMetadata(config: GranularityConfig<G>, appliedFactors: readonly string[], childCount: number, durationMs?: number): GenerationMetadata;
+    /**
+     * Log message if verbose mode is enabled
+     *
+     * @param message - Message to log
+     * @param data - Optional data to include
+     *
+     * Powered by Nikkory
+     */
+    protected log(message: string, data?: unknown): void;
+}
+//# sourceMappingURL=GranularityGenerator.d.ts.map

package/dist/ui-studio/granularity/RecursiveGenerator.d.ts

@@ -0,0 +1,328 @@
+/**
+ * RecursiveGenerator - Recursive generation pipeline implementation
+ *
+ * This generator implements the recursive generation pipeline for the
+ * Unified Granularity Architecture. It generates parent configs by
+ * recursively generating their children.
+ *
+ * Key Features:
+ * - Recursive generation: Page → Sections → Components → Atoms
+ * - Factor cascade: Parent factors cascade down to children
+ * - Enterprise safeguards: Circular reference detection, max depth check
+ * - Factor override priority: Child overrides > Parent cascade > Defaults
+ *
+ * Enterprise Safeguards:
+ * 1. CircularReferenceError - Detects A → B → A cycles
+ * 2. MaxDepthExceededError - Prevents stack overflow (MAX_DEPTH = 10)
+ * 3. try/finally cleanup - Ensures visited set is cleaned up
+ *
+ * @packageDocumentation
+ * @module generators
+ * @since 4.0.0
+ *
+ * Powered by Nikkory
+ */
+import { GranularityGenerator } from './GranularityGenerator';
+import type { GeneratedOutput, GranularityGeneratorOptions } from './GranularityGenerator';
+import type { GranularityLevel, GranularityConfig, GranularityFactorValues } from '../../types/granularity';
+import type { ChildReference } from '../../types/granularity/config.types';
+/**
+ * Error thrown when a circular reference is detected in the config hierarchy
+ *
+ * This prevents infinite recursion when configs reference each other in a cycle.
+ * For example: Page A → Section B → Page A
+ *
+ * @category errors
+ * @since 4.0.0
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await generator.generate(circularConfig);
+ * } catch (error) {
+ *   if (error instanceof CircularReferenceError) {
+ *     console.log(`Circular at: ${error.configId}`);
+ *     console.log(`Path: ${error.visitedPath.join(' → ')}`);
+ *   }
+ * }
+ * ```
+ *
+ * Powered by Nikkory
+ */
+export declare class CircularReferenceError extends Error {
+    /** The config ID that caused the circular reference */
+    readonly configId: string;
+    /** The path of visited configs leading to the circular reference */
+    readonly visitedPath: readonly string[];
+    constructor(configId: string, visitedPath: readonly string[]);
+}
+/**
+ * Error thrown when the maximum recursion depth is exceeded
+ *
+ * This prevents stack overflow from deeply nested configs.
+ * Default MAX_DEPTH is 10 levels.
+ *
+ * @category errors
+ * @since 4.0.0
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await generator.generate(deeplyNestedConfig);
+ * } catch (error) {
+ *   if (error instanceof MaxDepthExceededError) {
+ *     console.log(`Depth ${error.currentDepth} > ${error.maxDepth}`);
+ *     console.log(`At config: ${error.configId}`);
+ *   }
+ * }
+ * ```
+ *
+ * Powered by Nikkory
+ */
+export declare class MaxDepthExceededError extends Error {
+    /** Current recursion depth */
+    readonly currentDepth: number;
+    /** Maximum allowed depth */
+    readonly maxDepth: number;
+    /** Config ID where depth was exceeded */
+    readonly configId: string;
+    constructor(currentDepth: number, maxDepth: number, configId: string);
+}
+/**
+ * Options for RecursiveGenerator
+ *
+ * @category types
+ * @since 4.0.0
+ *
+ * Powered by Nikkory
+ */
+export interface RecursiveGeneratorOptions extends GranularityGeneratorOptions {
+    /** Custom code composer function */
+    readonly codeComposer?: (parent: string, children: readonly string[]) => string;
+    /** Custom style composer function */
+    readonly styleComposer?: (parent: string, children: readonly string[]) => string;
+}
+/**
+ * Maximum recursion depth to prevent stack overflow
+ *
+ * Template(1) → Layout(2) → Page(3) → Section(4) → Component(5) → Atom(6)
+ * Buffer of 4 levels for nested components = 10 total
+ *
+ * @category constants
+ * @since 4.0.0
+ *
+ * Powered by Nikkory
+ */
+export declare const MAX_DEPTH = 10;
+/**
+ * RecursiveGenerator - Generates configs recursively with factor cascade
+ *
+ * This is the main generator for the Unified Granularity Architecture.
+ * It handles recursive generation of parent configs through their children,
+ * with proper factor cascade and enterprise safeguards.
+ *
+ * @category generators
+ * @since 4.0.0
+ *
+ * @example
+ * ```typescript
+ * const generator = new RecursiveGenerator({
+ *   configLookup: (id) => configRegistry.get(id),
+ *   verbose: true,
+ * });
+ *
+ * const output = await generator.generate(pageConfig);
+ * console.log(output.code);
+ * console.log(output.children?.length); // Section outputs
+ * ```
+ *
+ * Powered by Nikkory
+ */
+export declare class RecursiveGenerator extends GranularityGenerator<GranularityLevel> {
+    protected readonly options: RecursiveGeneratorOptions;
+    constructor(options?: RecursiveGeneratorOptions);
+    /**
+     * Generate output for a granularity config recursively
+     *
+     * This method implements the recursive generation pipeline with
+     * enterprise safeguards for circular references and max depth.
+     *
+     * @param config - The granularity config to generate
+     * @param parentFactors - Factors inherited from parent (for cascade)
+     * @param visited - Set of visited config IDs (for circular detection)
+     * @param depth - Current recursion depth (for max depth check)
+     * @returns Promise resolving to generated output with children
+     *
+     * @throws CircularReferenceError - When same config is visited twice in path
+     * @throws MaxDepthExceededError - When recursion exceeds MAX_DEPTH
+     *
+     * @example
+     * ```typescript
+     * const generator = new RecursiveGenerator();
+     *
+     * // Simple usage - safeguards handled internally
+     * const output = await generator.generate(pageConfig);
+     *
+     * // With explicit tracking (for debugging)
+     * const output = await generator.generate(pageConfig, {}, new Set(), 0);
+     * ```
+     *
+     * Powered by Nikkory
+     */
+    generate(config: GranularityConfig<GranularityLevel>, parentFactors?: GranularityFactorValues, visited?: Set<string>, depth?: number): Promise<GeneratedOutput>;
+    /**
+     * Resolve child reference to full config with cascaded factors
+     *
+     * This method handles both string references (ID lookups) and inline configs.
+     * It also applies factor cascade with proper priority:
+     * 1. Child's explicit factorOverrides (HIGHEST - always wins)
+     * 2. Parent's cascading factors (filtered by cascadeDown=true)
+     * 3. Design system defaults (LOWEST - fallback)
+     *
+     * @param child - Child reference to resolve
+     * @param parentFactors - Factors from parent to cascade
+     * @returns Full child config with cascaded factors
+     *
+     * @example
+     * ```typescript
+     * const childConfig = this.resolveChild(
+     *   { childGranularity: 'section', ref: 'hero-section', slot: 'main' },
+     *   { spacing: 'lg', colorPrimary: '#3B82F6' }
+     * );
+     * ```
+     *
+     * Powered by Nikkory
+     */
+    protected resolveChild(child: ChildReference<GranularityLevel>, parentFactors: GranularityFactorValues): GranularityConfig<GranularityLevel>;
+    /**
+     * Filter factors that should cascade to child level
+     *
+     * Only factors with cascadeDown=true that are defined at or above
+     * the child's level are included.
+     *
+     * @param factors - Parent's resolved factors
+     * @param childLevel - Target child granularity level
+     * @returns Factors that cascade to the child level
+     *
+     * Powered by Nikkory
+     */
+    protected filterCascadingFactors(factors: GranularityFactorValues, childLevel: GranularityLevel): GranularityFactorValues;
+    /**
+     * Compose parent output with child outputs
+     *
+     * This method creates the final GeneratedOutput by combining the
+     * parent's code/styles with all children's code/styles.
+     *
+     * @param config - Parent config being composed
+     * @param factors - Resolved factors for this level
+     * @param children - Array of child GeneratedOutputs
+     * @returns Composed GeneratedOutput
+     *
+     * @example
+     * ```typescript
+     * const output = this.compose(pageConfig, resolvedFactors, sectionOutputs);
+     * console.log(output.code); // Page code with sections
+     * ```
+     *
+     * Powered by Nikkory
+     */
+    protected compose(config: GranularityConfig<GranularityLevel>, factors: GranularityFactorValues, children: readonly GeneratedOutput[]): GeneratedOutput;
+    /**
+     * Default code composer - wraps children in parent container
+     *
+     * @param parentCode - Parent's generated code
+     * @param childCodes - Children's generated codes
+     * @param config - Parent config for context
+     * @returns Composed code string
+     *
+     * Powered by Nikkory
+     */
+    protected defaultCodeComposer(parentCode: string, childCodes: readonly string[], config: GranularityConfig<GranularityLevel>): string;
+    /**
+     * Default style composer - concatenates styles
+     *
+     * @param parentStyles - Parent's generated styles
+     * @param childStyles - Children's generated styles
+     * @returns Composed styles string
+     *
+     * Powered by Nikkory
+     */
+    protected defaultStyleComposer(parentStyles: string, childStyles: readonly string[]): string;
+    /**
+     * Generate code for a config (simplified implementation)
+     *
+     * @param config - Config to generate code for
+     * @param factors - Resolved factors
+     * @returns Generated code string
+     *
+     * Powered by Nikkory
+     */
+    protected generateCode(config: GranularityConfig<GranularityLevel>, factors: GranularityFactorValues): string;
+    /**
+     * Generate styles for a config (simplified implementation)
+     *
+     * @param config - Config to generate styles for
+     * @param factors - Resolved factors
+     * @returns Generated styles string
+     *
+     * Powered by Nikkory
+     */
+    protected generateStyles(config: GranularityConfig<GranularityLevel>, factors: GranularityFactorValues): string;
+    /**
+     * Get component name from config
+     *
+     * @param config - Config to get name from
+     * @returns PascalCase component name
+     *
+     * Powered by Nikkory
+     */
+    protected getComponentName(config: GranularityConfig<GranularityLevel>): string;
+    /**
+     * Get CSS class name from config
+     *
+     * @param config - Config to get class from
+     * @returns kebab-case class name
+     *
+     * Powered by Nikkory
+     */
+    protected getClassName(config: GranularityConfig<GranularityLevel>): string;
+    /**
+     * Generate props string from factors
+     *
+     * @param factors - Resolved factors
+     * @returns Props string for JSX
+     *
+     * Powered by Nikkory
+     */
+    protected generateProps(factors: GranularityFactorValues): string;
+    /**
+     * Generate CSS variables from factors
+     *
+     * @param factors - Resolved factors
+     * @returns CSS variables string
+     *
+     * Powered by Nikkory
+     */
+    protected generateCssVariables(factors: GranularityFactorValues): string;
+}
+/**
+ * Create a new RecursiveGenerator instance
+ *
+ * @param options - Generator options
+ * @returns RecursiveGenerator instance
+ *
+ * @example
+ * ```typescript
+ * const generator = createRecursiveGenerator({
+ *   configLookup: (id) => configRegistry.get(id),
+ *   maxDepth: 5,
+ *   verbose: true,
+ * });
+ *
+ * const output = await generator.generate(pageConfig);
+ * ```
+ *
+ * Powered by Nikkory
+ */
+export declare function createRecursiveGenerator(options?: RecursiveGeneratorOptions): RecursiveGenerator;
+//# sourceMappingURL=RecursiveGenerator.d.ts.map

package/dist/ui-studio/index.d.ts

@@ -0,0 +1,94 @@
+/**
+ * UI Studio - Nikkory Component Generation Engine
+ * Single entry point for all code generation functionality
+ *
+ * @packageDocumentation
+ * @module ui-studio
+ * @since 5.0.0
+ *
+ * Powered by Nikkory
+ */
+/**
+ * ComponentGenerator - Main orchestrator for component generation
+ */
+export { ComponentGenerator, createComponentGenerator, generateComponent, generateComponentOutput, } from './ComponentGenerator';
+export type { StyleOutput, CodeOutput, ComponentGenerationResult, } from './ComponentGenerator';
+/**
+ * Factor resolution system - resolves factor values
+ */
+export { FactorResolver, createFactorResolver, resolveFactors, getTailwindClassesForComponent, getCssVariablesForComponent, } from './resolution/FactorResolver';
+/**
+ * Matrix multiplication system - class mapping and configuration resolution
+ */
+export { MatrixResolver } from './matrix/MatrixResolver';
+export { ClassMapper } from './matrix/ClassMapper';
+export type * from './matrix/types';
+/**
+ * Tier-based template generation
+ */
+export { TierGenerator } from './templates/TierGenerator';
+/**
+ * Section and page composition system
+ */
+export { SectionGenerator } from './composition/SectionGenerator';
+export { PageGenerator } from './composition/PageGenerator';
+export { SlotResolver, createSlotResolver, resolveSlot, resolveSlots, isComponentAllowedInSlot, } from './composition/SlotResolver';
+export { FactorPropagator, createFactorPropagator, propagateFactors, getFactorTailwindClasses as getSectionFactorTailwindClasses, getFactorCssVariables as getSectionFactorCssVariables, mapFactorsToProps, SECTION_FACTOR_MAPPINGS, } from './composition/FactorPropagator';
+export { SectionGenerator as SectionOrchestratorGenerator, createSectionGenerator, generateSectionComponents, } from './composition/section-orchestrator';
+/**
+ * Granularity-based generation system
+ */
+export { GranularityGenerator } from './granularity/GranularityGenerator';
+export { RecursiveGenerator } from './granularity/RecursiveGenerator';
+export { FactorCascade } from './granularity/FactorCascade';
+/**
+ * Algorithm Engine registries - tier, factors, components, design systems
+ *
+ * @example
+ * ```typescript
+ * import { TIER_REGISTRY, getTierEntry } from '@nikkory/vibe-engine/ui-studio';
+ *
+ * const entry = getTierEntry('enterprise');
+ * ```
+ */
+export { TIER_REGISTRY, getTierEntry, getFactorsForTier, getCodeFeaturesForTier, getLocRangeForTier, isFactorEnabledForTier, getMinimumTierForFactor, getTiersSupportingFactor, compareTierLevels, getAllTiers, getTierDisplayName, } from './registries/tiers-registry';
+export { FACTOR_REGISTRY as ALGORITHM_FACTOR_REGISTRY, getFactorDefinition, getAllFactorDefinitions, getFactorsByGroup, getFactorIdsByGroup, getFactorName, getFactorDefaultValue, getFactorPossibleValues, isValidFactorValue, getFactorCssProperty, getFactorDataAttribute, getAllFactorGroups, getFactorCountByGroup, getFactorsInRange, searchFactors, } from './registries/factors-registry';
+export { COMPONENT_REGISTRY as ALGORITHM_COMPONENT_REGISTRY, getComponentEntry, getAllComponentTypes, getComponentsByCategory, getComponentIdsByCategory, getAllComponentCategories, getComponentCountByCategory, getApplicableFactors, getSkippedFactors, getFactorApplicability, isFactorApplicable, getFactorOverride, getComponentsSupportingFactor, getComponentsForDesignSystem, getComponentsForTier, componentSupportsDesignSystem, componentSupportsTier, searchComponents, getTotalComponentCount, getComponentElementType, } from './registries/components-registry';
+export { DESIGN_SYSTEM_REGISTRY, getDesignSystemEntry, getAllDesignSystems, getFactorValue, getAllFactorValues, getFactorTailwindClasses, getFactorCssVariables, getDesignSystemCssVariables, getDesignSystemName, getDesignSystemDescription, searchDesignSystems, getTotalDesignSystemCount, hasFactorValue, getDesignSystemsWithFactor, generateThemeCss, mergeFactorValues, } from './registries/design-systems-registry';
+/**
+ * Presets - granularity factors, component registry, sections, pages, etc.
+ *
+ * @example
+ * ```typescript
+ * import { ALL_COMPONENTS, getComponent } from '@nikkory/vibe-engine/ui-studio';
+ *
+ * const button = getComponent('button');
+ * ```
+ */
+export { FACTOR_REGISTRY as GRANULARITY_FACTOR_REGISTRY, colorPrimaryFactor, colorSecondaryFactor, typographyScaleFactor, borderRadiusFactor, shadowStyleFactor, themeModeFactor, iconStyleFactor, surfaceStyleFactor, spacingScaleFactor, containerWidthFactor, gridColumnsFactor, gapSizeFactor, alignmentFactor, layoutTypeFactor, aspectRatioFactor, animationDurationFactor, animationEasingFactor, hoverEffectFactor, loadingStyleFactor, breakpointStrategyFactor, mobileBehaviorFactor, touchTargetSizeFactor, focusStyleFactor, reducedMotionFactor, getFactorById, getFactorsByCategory as getGranularityFactorsByCategory, getAllFactorIds, isValidFactorId, getFactorRegistryStats, } from './presets/factor-registry';
+export { getRegistryFor, getDefinitionById, getDefinitionIds, isValidDefinitionId, filterByCategory, filterByStatus, searchDefinitions, getRegistryStats as getGranularityRegistryStats, getAllRegistryStats, getDefinitionCounts, getTotalDefinitionCount, } from './presets/granularity-registry';
+export type { RegistryDefinition, RegistryForLevel } from './presets/granularity-registry';
+export { ALL_COMPONENTS as UI_COMPONENTS, COMPONENT_REGISTRY as UI_COMPONENT_REGISTRY, getAllComponentIds, getComponent, isValidComponentId, getComponentsByCategory as getUIComponentsByCategory, getComponentsByStatus, getComponentsByPhase, getStableComponents, getPlannedComponents, searchComponents as searchUIComponents, getComponentDependencies, getComponentDependents, getRegistryStats, getPopularComponents, getNewComponents, getComponentsByDesignSystem, getComponentsByTier, getComponentsByIcon, getAllIcons, getAllEmojis, getComponentsGroupedByCategory, getUIStats, } from './presets/component-registry';
+export type { ComponentId, ComponentCategory, ComponentComplexity, ComponentStatus, RegistryComponentDefinition, ComponentDefinition, } from './presets/component-registry';
+export type { BaseSectionDefinition, SectionCategoryDefaults } from './presets/section-registry.types';
+export { SECTION_CATEGORY_ICONS, SECTION_CATEGORY_EMOJIS, SECTION_CATEGORY_DEFAULTS, getCategoryDefaults, getCategoryIcon, getCategoryEmoji, getAllSectionCategories, } from './presets/section-registry.defaults';
+export { withSectionDefaults, withSectionDefaultsArray, validateBaseSectionDefinition, validateBaseSectionDefinitions, isBaseSectionDefinition, isRegistrySectionDefinition, } from './presets/section-registry.helpers';
+export { ALL_SECTIONS } from './presets/section-registry';
+export { ALL_LAYOUTS } from './presets/layout-registry';
+export { ALL_PAGES } from './presets/page-registry';
+export { ALL_TEMPLATES } from './presets/template-registry';
+export * from './presets/registry.types';
+export * from './presets/registry.constants';
+export { INDUSTRY_PRESETS, getIndustryIds, getIndustryPreset, getPresetsByCategory, getPresetsByTier, getPresetsByDesignSystem, financePreset, healthcarePreset, ecommercePreset, saasPreset, educationPreset, gamingPreset, socialPreset, governmentPreset, creativePreset, realEstatePreset, travelPreset, foodPreset, fitnessPreset, newsPreset, nonprofitPreset, } from './presets/industries';
+export type { IndustryCategory, DesignSystemId, ColorPaletteId, TierRecommendation, IndustryPreset, } from './presets/industries';
+export { IndustryDetector, detectIndustry, detectMultipleIndustries, getIndustryRecommendation, getRecommendationFromInput, getAvailableIndustries, getIndustriesByCategory, searchIndustries as searchIndustryPresets, isValidIndustry, getAggregatedDesignSystems, } from './presets/IndustryDetector';
+export type { DetectionConfidence, DetectionResult, AlternativeMatch, IndustryRecommendation, } from './presets/IndustryDetector';
+export { MATRIX_GROUPS, getMatrixGroupIds, getMatrixGroup, getGroupsByCategory as getMatrixGroupsByCategory, getCommonBundles, getGroupsByComponent, calculateBundleSize, getRecommendedGroupsForIndustry, validateMatrixGroup, validateAllMatrixGroups, getStableComponentsInGroup, getAvailableComponentsInGroup, createMatrixGroup, formGroup, feedbackGroup, navigationGroup, dataDisplayGroup, overlayGroup, actionGroup, dateTimeGroup, mediaGroup, utilityGroup, starterBundle, dashboardBundle, ecommerceBundle, formHeavyBundle, contentRichBundle, mobileFirstBundle, } from './presets/matrix-groups';
+export type { MatrixGroup, MatrixGroupCategory } from './presets/matrix-groups';
+export * from './presets/variants';
+export * from './presets/section-defaults';
+/**
+ * Shared type definitions for UI Studio
+ */
+export type * from './types';
+//# sourceMappingURL=index.d.ts.map