@forgespace/siza-gen 0.2.0

package/dist/index.d.ts

@@ -0,0 +1,2369 @@
+import Database from 'better-sqlite3';
+import * as pino from 'pino';
+import pino__default, { Logger } from 'pino';
+import { z } from 'zod';
+
+/**
+ * Type definitions for the ML subsystem.
+ */
+
+/** A vector embedding with its source metadata. */
+interface IEmbedding {
+    /** The source entity ID (e.g., component snippet ID or prompt hash). */
+    sourceId: string;
+    /** The source type. */
+    sourceType: 'component' | 'prompt' | 'description' | 'rule' | 'token' | 'pattern' | 'example';
+    /** The text that was embedded. */
+    text: string;
+    /** The embedding vector (Float32). */
+    vector: Float32Array;
+    /** Dimensionality of the vector. */
+    dimensions: number;
+    /** Timestamp of creation. */
+    createdAt: number;
+}
+/** Cosine similarity search result. */
+interface ISimilarityResult {
+    /** The matched entity ID. */
+    id: string;
+    /** Cosine similarity score (0-1). */
+    similarity: number;
+    /** The original text that was embedded. */
+    text: string;
+}
+/** Configuration for the embedding model. */
+interface IEmbeddingConfig {
+    /** HuggingFace model identifier. */
+    modelId: string;
+    /** Local cache directory for the downloaded model. */
+    cacheDir: string;
+    /** Expected dimensionality of embeddings. */
+    dimensions: number;
+}
+/** A training example for LoRA fine-tuning. */
+interface ITrainingExample {
+    /** The user prompt that triggered generation. */
+    prompt: string;
+    /** The generated code. */
+    code: string;
+    /** Feedback score (-1 to 2, where >0 = accepted). */
+    score: number;
+    /** Generation parameters used. */
+    params: Record<string, string>;
+}
+/** Configuration for LoRA training. */
+interface ILoRAConfig {
+    /** LoRA rank (lower = smaller adapter). */
+    rank: number;
+    /** Number of training epochs. */
+    epochs: number;
+    /** Batch size (CPU-friendly). */
+    batchSize: number;
+    /** Learning rate. */
+    learningRate: number;
+}
+/** Adapter types for the sidecar model. */
+type AdapterType = 'quality-scorer' | 'prompt-enhancer' | 'style-recommender';
+/** Status of a training job. */
+interface ITrainingStatus {
+    adapter: AdapterType;
+    status: 'idle' | 'preparing' | 'training' | 'complete' | 'failed';
+    progress: number;
+    error?: string;
+    startedAt?: number;
+    completedAt?: number;
+}
+
+/**
+ * Sentence embeddings using Transformers.js (ONNX runtime).
+ *
+ * Downloads `all-MiniLM-L6-v2` on first use (~80MB), cached in `.uiforge/models/`.
+ * Runs entirely on CPU — ~50-100ms per embedding on modern hardware.
+ */
+
+/**
+ * Override default embedding configuration.
+ */
+declare function configureEmbeddings(overrides: Partial<IEmbeddingConfig>): void;
+/**
+ * Get the embedding configuration.
+ */
+declare function getEmbeddingConfig(): IEmbeddingConfig;
+/**
+ * Generate an embedding vector for a single text string.
+ */
+declare function embed(text: string): Promise<Float32Array>;
+/**
+ * Generate embeddings for multiple texts in batch.
+ * More efficient than calling embed() in a loop.
+ */
+declare function embedBatch(texts: string[]): Promise<Float32Array[]>;
+/**
+ * Create a full IEmbedding object from text.
+ */
+declare function createEmbedding(sourceId: string, sourceType: IEmbedding['sourceType'], text: string): Promise<IEmbedding>;
+/**
+ * Compute cosine similarity between two vectors.
+ * Assumes both vectors are already normalized (which they are from the pipeline).
+ */
+declare function cosineSimilarity(a: Float32Array, b: Float32Array): number;
+/**
+ * Find the most similar embeddings to a query vector.
+ */
+declare function findSimilar(queryVector: Float32Array, candidates: IEmbedding[], topK?: number, threshold?: number): ISimilarityResult[];
+/**
+ * Check if the embedding model is loaded.
+ */
+declare function isModelLoaded(): boolean;
+/**
+ * Unload the model to free memory.
+ */
+declare function unloadModel(): void;
+
+/**
+ * Persistent embedding store backed by SQLite.
+ * Stores and retrieves vector embeddings for semantic search.
+ * Uses sqlite-vss HNSW index when available, brute-force fallback otherwise.
+ */
+
+/**
+ * Store an embedding in the database.
+ */
+declare function storeEmbedding(embedding: IEmbedding, db: Database.Database): void;
+/**
+ * Store multiple embeddings in a single transaction.
+ */
+declare function storeEmbeddings(embeddings: IEmbedding[], db: Database.Database): void;
+/**
+ * Load all embeddings of a given source type.
+ */
+declare function loadEmbeddings(sourceType: IEmbedding['sourceType'], db: Database.Database): IEmbedding[];
+/**
+ * Get a single embedding by source ID and type.
+ */
+declare function getEmbedding(sourceId: string, sourceType: IEmbedding['sourceType'], db: Database.Database): IEmbedding | undefined;
+/**
+ * Semantic search: find the most similar embeddings to a query vector.
+ * Uses sqlite-vss HNSW index when available (O(log n)), falls back to
+ * in-memory brute-force cosine similarity otherwise.
+ */
+declare function semanticSearch(queryVector: Float32Array, sourceType: IEmbedding['sourceType'], db: Database.Database, topK?: number, threshold?: number): ISimilarityResult[];
+/**
+ * Get the count of stored embeddings by type.
+ */
+declare function getEmbeddingCount(sourceType: IEmbedding['sourceType'], db: Database.Database): number;
+/**
+ * Delete embeddings by source type.
+ */
+declare function deleteEmbeddings(sourceType: IEmbedding['sourceType'], db: Database.Database): number;
+
+/**
+ * Training data exporter — extracts feedback data from SQLite
+ * and writes JSONL files suitable for LoRA fine-tuning.
+ *
+ * Produces adapter-specific datasets:
+ * - quality-scorer: prompt + code → score (regression)
+ * - prompt-enhancer: original prompt → improved prompt (text-to-text)
+ * - style-recommender: prompt → style label (classification)
+ */
+
+/** A single JSONL row for quality-scorer training. */
+interface IQualityScorerRow {
+    instruction: string;
+    input: string;
+    output: string;
+}
+/** A single JSONL row for prompt-enhancer training. */
+interface IPromptEnhancerRow {
+    instruction: string;
+    input: string;
+    output: string;
+}
+/** A single JSONL row for style-recommender training. */
+interface IStyleRecommenderRow {
+    instruction: string;
+    input: string;
+    output: string;
+}
+/**
+ * Export raw training examples from the feedback table.
+ * Returns scored feedback entries with all available metadata.
+ */
+declare function exportRawExamples(db: Database.Database, opts?: {
+    minAbsScore?: number;
+    limit?: number;
+}): ITrainingExample[];
+/**
+ * Build quality-scorer training data.
+ * Format: instruction-following where the model predicts acceptance score.
+ */
+declare function buildQualityScorerData(examples: ITrainingExample[]): IQualityScorerRow[];
+/**
+ * Build prompt-enhancer training data.
+ * Pairs low-scored prompts with high-scored prompts for the same component type.
+ */
+declare function buildPromptEnhancerData(examples: ITrainingExample[]): IPromptEnhancerRow[];
+/**
+ * Build style-recommender training data.
+ * Format: prompt → recommended style name.
+ */
+declare function buildStyleRecommenderData(examples: ITrainingExample[]): IStyleRecommenderRow[];
+/**
+ * Write training data to a JSONL file.
+ * Creates parent directories if needed.
+ */
+declare function writeJsonl<T extends object>(rows: T[], filePath: string): number;
+/**
+ * Export adapter-specific training data to JSONL files.
+ * Returns the count of examples written per adapter.
+ */
+declare function exportForAdapter(adapter: AdapterType, db: Database.Database, outputDir: string): {
+    path: string;
+    count: number;
+};
+/**
+ * Check if enough training data is available for a given adapter.
+ */
+declare function hasEnoughData(adapter: AdapterType, db: Database.Database, includeSynthetic?: boolean): {
+    ready: boolean;
+    count: number;
+    required: number;
+};
+
+/**
+ * Model manager — handles model/adapter paths, directory setup,
+ * and model availability checks for the sidecar model system.
+ *
+ * All models and adapters are stored in `.uiforge/` (gitignored).
+ * Models are downloaded on first use and cached locally.
+ */
+
+/** Model registry — known models and their download URLs. */
+declare const MODEL_REGISTRY: {
+    readonly 'qwen2.5-0.5b': {
+        readonly filename: "qwen2.5-0.5b-instruct-q4_k_m.gguf";
+        readonly size: "~350MB";
+        readonly url: "https://huggingface.co/Qwen/Qwen2.5-0.5B-Instruct-GGUF/resolve/main/qwen2.5-0.5b-instruct-q4_k_m.gguf";
+    };
+};
+type ModelId = keyof typeof MODEL_REGISTRY;
+/** Paths configuration for the ML subsystem. */
+interface IModelPaths {
+    base: string;
+    models: string;
+    adapters: string;
+    trainingData: string;
+    embeddings: string;
+}
+/**
+ * Configure the base directory for all ML artifacts.
+ * Must be called before any other model-manager function.
+ */
+declare function configureModelDir(baseDir: string): void;
+/**
+ * Get the current base directory.
+ */
+declare function getBaseDir(): string;
+/**
+ * Get all standard paths for the ML subsystem.
+ */
+declare function getModelPaths(): IModelPaths;
+/**
+ * Ensure all required directories exist.
+ * Creates them recursively if missing.
+ */
+declare function ensureDirectories(): IModelPaths;
+/**
+ * Get the full path to a base model GGUF file.
+ */
+declare function getModelPath(modelId: ModelId): string;
+/**
+ * Get the full path to a LoRA adapter file.
+ */
+declare function getAdapterPath(adapter: AdapterType): string;
+/**
+ * Get the full path to a training data JSONL file.
+ */
+declare function getTrainingDataPath(adapter: AdapterType): string;
+/**
+ * Check if a base model is available locally.
+ */
+declare function isModelAvailable(modelId: ModelId): boolean;
+/**
+ * Check if a LoRA adapter is available locally.
+ */
+declare function isAdapterAvailable(adapter: AdapterType): boolean;
+/**
+ * Get the download URL for a model.
+ */
+declare function getModelDownloadUrl(modelId: ModelId): string;
+/**
+ * Get info about all available adapters.
+ */
+declare function listAdapters(): Array<{
+    adapter: AdapterType;
+    available: boolean;
+    path: string;
+    sizeBytes: number;
+}>;
+/**
+ * Get info about all available models.
+ */
+declare function listModels(): Array<{
+    modelId: ModelId;
+    available: boolean;
+    path: string;
+    sizeBytes: number;
+}>;
+/**
+ * Get total disk usage of all ML artifacts.
+ * Recursively calculates directory sizes.
+ */
+declare function getDiskUsage(): {
+    totalBytes: number;
+    breakdown: Record<string, number>;
+};
+
+/**
+ * Training pipeline — orchestrates LoRA fine-tuning jobs.
+ *
+ * Flow: check readiness → export data → spawn training → track status → save adapter.
+ *
+ * Training runs as a background process via child_process so the MCP server
+ * stays responsive. Status is tracked in the SQLite training_jobs table.
+ *
+ * Note: Actual LoRA training requires the llama.cpp `finetune` binary
+ * or a Python training script. This module manages the orchestration layer.
+ */
+
+/** Default LoRA configuration optimized for N100 CPU. */
+declare const DEFAULT_LORA_CONFIG: ILoRAConfig;
+/**
+ * Create a new training job record in the database.
+ */
+declare function createTrainingJob(adapter: AdapterType, examplesCount: number, db: Database.Database): number;
+/**
+ * Update training job status.
+ */
+declare function updateJobStatus(jobId: number, status: ITrainingStatus['status'], progress: number, db: Database.Database, error?: string): void;
+/**
+ * Get the latest training job status for an adapter.
+ */
+declare function getLatestJobStatus(adapter: AdapterType, db: Database.Database): ITrainingStatus | null;
+/**
+ * Get status of all training jobs.
+ */
+declare function getAllJobStatuses(db: Database.Database): ITrainingStatus[];
+/**
+ * Check if a training job is currently running for an adapter.
+ */
+declare function isTraining(adapter: AdapterType): boolean;
+/**
+ * Pre-flight check: verify all prerequisites for training.
+ */
+declare function checkTrainingReadiness(adapter: AdapterType, modelId: ModelId, db: Database.Database): {
+    ready: boolean;
+    issues: string[];
+};
+/**
+ * Start a LoRA training job for the specified adapter.
+ *
+ * This exports training data, then spawns an external training process.
+ * The process can be:
+ * 1. llama.cpp `finetune` binary (if available)
+ * 2. A Python training script (if Python + PEFT are available)
+ * 3. A mock/stub for testing
+ *
+ * Returns the job ID for status tracking.
+ */
+declare function startTrainingJob(adapter: AdapterType, modelId: ModelId, db: Database.Database, config?: ILoRAConfig, trainingCommand?: string): {
+    jobId: number;
+    status: ITrainingStatus;
+};
+/**
+ * Cancel a running training job.
+ */
+declare function cancelTrainingJob(adapter: AdapterType, db: Database.Database): boolean;
+/**
+ * Get a summary of the training pipeline state.
+ */
+declare function getTrainingSummary(db: Database.Database): {
+    jobs: ITrainingStatus[];
+    dataReadiness: Record<AdapterType, {
+        ready: boolean;
+        count: number;
+        required: number;
+    }>;
+    activeCount: number;
+};
+
+/**
+ * Quality scorer — predicts whether generated code will be accepted by the user.
+ *
+ * Uses the sidecar model when available, otherwise falls back to
+ * heuristic scoring based on code structure analysis.
+ *
+ * Score range: 0-10 (0 = likely rejected, 10 = likely accepted).
+ */
+/** Quality score result. */
+interface IQualityScore {
+    /** Score from 0-10. */
+    score: number;
+    /** Confidence in the score (0-1). */
+    confidence: number;
+    /** Whether the score came from the model or heuristics. */
+    source: 'model' | 'heuristic';
+    /** Breakdown of heuristic factors (when source is 'heuristic'). */
+    factors?: Record<string, number>;
+    /** Inference latency in ms. */
+    latencyMs: number;
+}
+declare function scoreQuality(prompt: string, generatedCode: string, params?: {
+    componentType?: string;
+    framework?: string;
+    style?: string;
+}): Promise<IQualityScore>;
+/**
+ * Enhanced quality scoring with RAG-based a11y compliance checks.
+ * Retrieves relevant axe-core rules and checks violations against them.
+ */
+declare function scoreQualityWithRAG(prompt: string, generatedCode: string, params?: {
+    componentType?: string;
+    framework?: string;
+    style?: string;
+}): Promise<IQualityScore>;
+/**
+ * Quick check: is the code likely acceptable? (score >= 6)
+ */
+declare function isLikelyAccepted(prompt: string, generatedCode: string, params?: {
+    componentType?: string;
+    framework?: string;
+    style?: string;
+}): Promise<boolean>;
+
+/**
+ * Prompt enhancer — improves user prompts before sending to the host LLM.
+ *
+ * Uses the sidecar model when available, otherwise applies rule-based
+ * enhancement to add specificity, style hints, and structure guidance.
+ *
+ * Enhancement strategies:
+ * 1. Add missing context (framework, style, accessibility)
+ * 2. Expand vague terms into specific design tokens
+ * 3. Inject best-practice hints based on component type
+ */
+/** Enhancement result. */
+interface IEnhancedPrompt {
+    /** The enhanced prompt text. */
+    enhanced: string;
+    /** The original prompt text. */
+    original: string;
+    /** Whether the enhancement came from the model or rules. */
+    source: 'model' | 'rules';
+    /** What was added/changed. */
+    additions: string[];
+    /** Latency in ms. */
+    latencyMs: number;
+}
+/** Context for prompt enhancement. */
+interface IEnhancementContext {
+    componentType?: string;
+    framework?: string;
+    style?: string;
+    mood?: string;
+    industry?: string;
+}
+/**
+ * Enhance a user prompt for better generation results.
+ */
+declare function enhancePrompt(prompt: string, context?: IEnhancementContext): Promise<IEnhancedPrompt>;
+/**
+ * Enhance using rule-based strategies.
+ */
+declare function enhanceWithRules(prompt: string, context?: IEnhancementContext, start?: number): IEnhancedPrompt;
+/**
+ * Async RAG-enhanced prompt enhancement.
+ * Retrieves relevant ARIA patterns and a11y rules to enrich the prompt.
+ */
+declare function enhancePromptWithRAG(prompt: string, context?: IEnhancementContext): Promise<IEnhancedPrompt>;
+/**
+ * Check if a prompt would benefit from enhancement.
+ */
+declare function needsEnhancement(prompt: string): boolean;
+
+/**
+ * Style recommender — suggests design tokens based on prompt context.
+ *
+ * Uses RAG retrieval from ingested design tokens (Material Design 3, Primer)
+ * to recommend appropriate styling. Falls back to heuristic industry/mood
+ * lookup when no embeddings are available.
+ */
+
+interface IStyleRecommendation {
+    primaryColor: string;
+    secondaryColor: string;
+    fontFamily: string;
+    spacing: string;
+    borderRadius: string;
+    designSystem: string;
+    confidence: number;
+    source: 'rag' | 'heuristic';
+    matchedTokens: ISimilarityResult[];
+}
+interface IStyleContext {
+    industry?: string;
+    mood?: string;
+}
+declare function recommendStyle(prompt: string, context?: IStyleContext): Promise<IStyleRecommendation>;
+
+type ComponentCategory = 'atom' | 'molecule' | 'organism';
+type MoodTag = 'bold' | 'calm' | 'playful' | 'professional' | 'premium' | 'energetic' | 'minimal' | 'editorial' | 'futuristic' | 'warm' | 'corporate' | 'creative';
+type IndustryTag = 'saas' | 'fintech' | 'ecommerce' | 'healthcare' | 'education' | 'startup' | 'agency' | 'media' | 'devtools' | 'general';
+type VisualStyleId = 'glassmorphism' | 'neubrutalism' | 'soft-depth' | 'bento-grid' | 'gradient-mesh' | 'dark-premium' | 'minimal-editorial' | 'linear-modern' | 'retro-playful' | 'corporate-trust';
+interface IComponentA11y {
+    roles: string[];
+    ariaAttributes: string[];
+    htmlAttributes?: string[];
+    keyboardNav: string;
+    contrastRatio: string;
+    focusVisible: boolean;
+    reducedMotion: boolean;
+}
+interface IComponentSeo {
+    semanticElement: string;
+    headingLevel?: string;
+    landmark?: string;
+}
+interface IComponentResponsive {
+    strategy: 'mobile-first' | 'container-query';
+    breakpoints: string[];
+}
+interface IComponentQuality {
+    antiGeneric: string[];
+    inspirationSource: string;
+    craftDetails: string[];
+}
+interface IComponentSnippet {
+    id: string;
+    name: string;
+    category: ComponentCategory;
+    type: string;
+    variant: string;
+    tags: string[];
+    mood: MoodTag[];
+    industry: IndustryTag[];
+    visualStyles: VisualStyleId[];
+    jsx: string;
+    tailwindClasses: Record<string, string>;
+    css?: string;
+    animations?: string[];
+    dependencies?: string[];
+    a11y: IComponentA11y;
+    seo?: IComponentSeo;
+    responsive: IComponentResponsive;
+    quality: IComponentQuality;
+}
+type AnimationCategory = 'entrance' | 'hover' | 'scroll' | 'loading' | 'text' | 'transition' | 'feedback' | 'background' | 'button' | 'card' | 'list' | 'modal' | 'navigation' | 'chart';
+type AnimationPurpose = 'user-feedback' | 'attention' | 'delight' | 'confirmation' | 'orientation' | 'progress';
+interface IMicroInteraction {
+    id: string;
+    name: string;
+    category: AnimationCategory;
+    purpose: AnimationPurpose[];
+    tailwindClasses: string;
+    css?: string;
+    keyframes?: string;
+    reducedMotionFallback: string;
+    duration: string;
+    description: string;
+}
+interface IComponentQuery {
+    type?: string;
+    variant?: string;
+    mood?: MoodTag;
+    industry?: IndustryTag;
+    style?: VisualStyleId;
+    category?: ComponentCategory;
+    tags?: string[];
+}
+interface ISearchResult {
+    snippet: IComponentSnippet;
+    score: number;
+}
+
+/**
+ * Image Design Analyzer
+ *
+ * Extracts structured design patterns from UI screenshots/mockups for ML training.
+ * Does NOT store images - only extracts and stores structured design data.
+ */
+
+interface IDesignAnalysis {
+    /** Detected color palette */
+    colors: {
+        primary: string[];
+        secondary: string[];
+        accent: string[];
+        background: string[];
+        text: string[];
+    };
+    /** Typography information */
+    typography: {
+        fontFamilies: string[];
+        headingSizes: string[];
+        bodySizes: string[];
+        weights: string[];
+    };
+    /** Spacing and layout */
+    spacing: {
+        system: string;
+        padding: string[];
+        margin: string[];
+        gap: string[];
+    };
+    /** Detected UI components */
+    components: Array<{
+        type: string;
+        variant?: string;
+        description: string;
+    }>;
+    /** Layout patterns */
+    layout: {
+        type: string;
+        structure: string;
+        responsive: boolean;
+    };
+    /** Visual style classification */
+    visualStyle: {
+        primary: VisualStyleId;
+        characteristics: string[];
+    };
+    /** Inferred mood and industry */
+    mood: MoodTag[];
+    industry: IndustryTag[];
+    /** Overall design quality score (0-1) */
+    qualityScore: number;
+    /** Additional metadata */
+    metadata: {
+        complexity: 'simple' | 'moderate' | 'complex';
+        modernityScore: number;
+        accessibilityNotes: string[];
+    };
+}
+/**
+ * Analyze an image description and generated code to extract design patterns.
+ * This function processes the output from image_to_component to extract structured design data.
+ */
+declare function extractDesignPatterns(imageDescription: string, generatedCode: string, componentTypes: string[]): IDesignAnalysis;
+
+/**
+ * Design-to-Training-Data Converter
+ *
+ * Converts extracted design patterns into ML training data format.
+ * Integrates with existing feedback system and pattern detection.
+ */
+
+interface ITrainingDataResult {
+    snippetsCreated: number;
+    feedbackEntriesCreated: number;
+    patternsDetected: number;
+    summary: string;
+}
+/**
+ * Convert design analysis into training data and store in database.
+ * This is the main entry point for the image-to-training-data pipeline.
+ */
+declare function storeDesignLearning(analysis: IDesignAnalysis, generatedCode: string, componentName: string, framework: string, db: Database.Database): ITrainingDataResult;
+
+interface IDesignContext {
+    typography: {
+        fontFamily: string;
+        headingFont?: string;
+        fontSize: {
+            xs: string;
+            sm: string;
+            base: string;
+            lg: string;
+            xl: string;
+            '2xl': string;
+            '3xl': string;
+        };
+        fontWeight: {
+            normal: string;
+            medium: string;
+            semibold: string;
+            bold: string;
+        };
+        lineHeight: {
+            tight: string;
+            normal: string;
+            relaxed: string;
+        };
+    };
+    colorPalette: {
+        primary: string;
+        primaryForeground: string;
+        secondary: string;
+        secondaryForeground: string;
+        accent: string;
+        accentForeground: string;
+        background: string;
+        foreground: string;
+        muted: string;
+        mutedForeground: string;
+        border: string;
+        destructive: string;
+        destructiveForeground: string;
+    };
+    spacing: {
+        unit: number;
+        scale: number[];
+    };
+    borderRadius: {
+        sm: string;
+        md: string;
+        lg: string;
+        full: string;
+    };
+    shadows: {
+        sm: string;
+        md: string;
+        lg: string;
+    };
+    iconSet?: string;
+    animationLib?: string;
+    buttonVariants?: IButtonVariant[];
+}
+interface IButtonVariant {
+    name: string;
+    className: string;
+    styles: Record<string, string>;
+}
+interface IGeneratedFile {
+    path: string;
+    content: string;
+    encoding?: 'utf-8' | 'base64';
+}
+interface IScreenElement {
+    id: string;
+    type: 'heading' | 'text' | 'button' | 'input' | 'image' | 'card' | 'nav' | 'list' | 'container' | 'icon' | 'divider';
+    label?: string;
+    placeholder?: string;
+    children?: IScreenElement[];
+    styles?: Record<string, string>;
+    action?: string;
+}
+interface ITransition {
+    from: string;
+    to: string;
+    trigger: 'click' | 'tap' | 'hover' | 'auto';
+    animation?: 'fade' | 'slide-left' | 'slide-right' | 'slide-up' | 'none';
+    targetElement?: string;
+}
+interface IFigmaVariable {
+    name: string;
+    type: 'COLOR' | 'FLOAT' | 'STRING';
+    value: string | number;
+    collection?: string;
+}
+interface IFigmaDesignToken {
+    name: string;
+    type: string;
+    value: string | number;
+    category: 'color' | 'spacing' | 'typography' | 'borderRadius' | 'shadow';
+}
+interface ITailwindMapping {
+    className: string;
+    cssProperty: string;
+    value: string;
+}
+type Framework = 'react' | 'nextjs' | 'vue' | 'angular' | 'svelte' | 'html';
+type Architecture = 'flat' | 'feature-based' | 'atomic';
+type StateManagement$1 = 'useState' | 'zustand' | 'pinia' | 'signals' | 'stores' | 'none';
+type ImageType = 'wireframe' | 'mockup' | 'component_preview';
+type ComponentLibraryId = 'shadcn' | 'radix' | 'headlessui' | 'primevue' | 'material' | 'none';
+type PageTemplateType = 'landing' | 'dashboard' | 'auth_login' | 'auth_signup' | 'pricing' | 'settings' | 'crud_table' | 'blog_list' | 'onboarding' | 'error_404' | 'ecommerce_plp' | 'ecommerce_pdp' | 'ecommerce_cart' | 'ecommerce_checkout' | 'ai_chat' | 'changelog' | 'team_members' | 'settings_billing' | 'api_keys' | 'analytics' | 'profile' | 'file_manager' | 'kanban' | 'calendar' | 'docs' | 'faq' | 'blog_post';
+type AccessibilitySeverity = 'error' | 'warning' | 'info';
+interface IAccessibilityIssue {
+    rule: string;
+    severity: AccessibilitySeverity;
+    message: string;
+    element?: string;
+    suggestion: string;
+    wcagCriteria?: string;
+}
+interface IAccessibilityReport {
+    score: number;
+    issues: IAccessibilityIssue[];
+    summary: {
+        errors: number;
+        warnings: number;
+        info: number;
+    };
+    passed: string[];
+}
+interface IFontPairing {
+    name: string;
+    heading: {
+        family: string;
+        weights: number[];
+        googleFontsUrl: string;
+    };
+    body: {
+        family: string;
+        weights: number[];
+        googleFontsUrl: string;
+    };
+    accent?: {
+        family: string;
+        weights: number[];
+        googleFontsUrl: string;
+    };
+    mood: string[];
+    bestFor: string[];
+    cssImport: string;
+}
+interface IColorSystem {
+    name: string;
+    description: string;
+    mood: string[];
+    light: Record<string, string>;
+    dark: Record<string, string>;
+    tailwindExtend: Record<string, Record<string, string>>;
+}
+interface ISpacingSystem {
+    baseUnit: number;
+    scale: Record<string, string>;
+    breakpoints: Record<string, string>;
+    containers: Record<string, string>;
+    borderRadius: Record<string, string>;
+    shadows: Record<string, string>;
+}
+interface IIconLibrary {
+    name: string;
+    style: string;
+    count: string;
+    importPackage: Record<string, string>;
+    cdnUrl?: string;
+    recommended: string[];
+}
+interface IAnimationPreset {
+    name: string;
+    category: 'transition' | 'micro-interaction' | 'loading' | 'scroll';
+    css: string;
+    tailwindClass?: string;
+    duration: string;
+}
+interface ILayoutPattern {
+    name: string;
+    description: string;
+    components: string[];
+    useCase: string[];
+    responsiveBehavior: string;
+    tailwindClasses: Record<string, string>;
+}
+interface IComponentLibrary {
+    name: string;
+    description: string;
+    frameworks: string[];
+    installPackage: Record<string, string>;
+    docsUrl: string;
+    features: string[];
+    recommended: boolean;
+}
+interface IInspirationSource {
+    name: string;
+    url: string;
+    category: 'gallery' | 'design-system' | 'typography' | 'color' | 'icons';
+    description: string;
+    priority: number;
+}
+interface IScrapedPage {
+    url: string;
+    title: string;
+    screenshot?: Buffer;
+    colors: string[];
+    fonts: string[];
+    fontSizes: string[];
+    spacing: string[];
+    layoutPatterns: string[];
+    componentTypes: string[];
+    meta: Record<string, string>;
+}
+interface IImageAnalysis {
+    label: string;
+    dominantColors: Array<{
+        hex: string;
+        percentage: number;
+    }>;
+    layoutRegions: Array<{
+        role: string;
+        bounds: {
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+        };
+    }>;
+    detectedComponents: string[];
+    dimensions: {
+        width: number;
+        height: number;
+    };
+}
+interface IPatternMatch {
+    category: 'color' | 'typography' | 'layout' | 'component' | 'spacing';
+    pattern: string;
+    confidence: number;
+    sources: string[];
+}
+interface IDesignAnalysisResult {
+    references: Array<{
+        source: string;
+        colors: string[];
+        fonts: string[];
+        layouts: string[];
+        components: string[];
+    }>;
+    commonPatterns: IPatternMatch[];
+    suggestedContext: Partial<IDesignContext>;
+    screenshots: Array<{
+        source: string;
+        data: string;
+    }>;
+}
+
+/**
+ * Component library types supported by UIForge
+ */
+type ComponentLibrary = 'shadcn' | 'radix' | 'headlessui' | 'primevue' | 'material' | 'none';
+/**
+ * Abstract base class for all framework generators
+ * Provides common functionality and enforces consistent interface
+ */
+declare abstract class BaseGenerator {
+    protected readonly framework: Framework;
+    protected readonly logger: pino.Logger;
+    constructor(framework: Framework);
+    /**
+     * Generate a complete project
+     * @param projectName Project name
+     * @param architecture Architecture pattern
+     * @param stateManagement State management approach
+     * @param designContext Design context
+     * @returns Array of generated files
+     */
+    abstract generateProject(projectName: string, architecture: Architecture, stateManagement: StateManagement$1, designContext: IDesignContext): IGeneratedFile[];
+    /**
+     * Generate a UI component
+     * @param componentType Component type
+     * @param props Component props
+     * @param designContext Design context
+     * @param componentLibrary Component library to use
+     * @returns Array of generated files
+     */
+    abstract generateComponent(componentType: string, props: Record<string, unknown>, designContext: IDesignContext, componentLibrary?: ComponentLibrary): IGeneratedFile[];
+    /**
+     * Get the framework this generator handles
+     * @returns Framework type
+     */
+    getFramework(): Framework;
+    /**
+     * Get component library dependencies for the current framework
+     * @param componentLibrary Component library type
+     * @returns Array of dependency names
+     */
+    protected getComponentLibraryDependencies(componentLibrary: ComponentLibrary): string[];
+    /**
+     * Get component library imports for the current framework
+     * @param componentLibrary Component library type
+     * @returns Array of import statements
+     */
+    protected getComponentLibraryImports(componentLibrary: ComponentLibrary): string[];
+    /**
+     * Generate component library-specific component code
+     * @param componentType Component type
+     * @param props Component props
+     * @param componentLibrary Component library type
+     * @returns Generated component code
+     */
+    protected generateComponentLibraryCode(componentType: string, props: Record<string, unknown>, componentLibrary: ComponentLibrary): string;
+    protected abstract getShadcnDependencies(): string[];
+    protected abstract getRadixDependencies(): string[];
+    protected abstract getHeadlessUIDependencies(): string[];
+    protected abstract getPrimeVueDependencies(): string[];
+    protected abstract getMaterialDependencies(): string[];
+    protected abstract getShadcnImports(): string[];
+    protected abstract getRadixImports(): string[];
+    protected abstract getHeadlessUIImports(): string[];
+    protected abstract getPrimeVueImports(): string[];
+    protected abstract getMaterialImports(): string[];
+    protected abstract generateShadcnComponent(componentType: string, props: Record<string, unknown>): string;
+    protected abstract generateRadixComponent(componentType: string, props: Record<string, unknown>): string;
+    protected abstract generateHeadlessUIComponent(componentType: string, props: Record<string, unknown>): string;
+    protected abstract generatePrimeVueComponent(componentType: string, props: Record<string, unknown>): string;
+    protected abstract generateMaterialComponent(componentType: string, props: Record<string, unknown>): string;
+    protected abstract generateTailwindComponent(componentType: string, props: Record<string, unknown>): string;
+    /**
+     * Validate generation parameters
+     * @param params Parameters to validate
+     * @returns Validation result
+     */
+    protected validateParams(params: {
+        projectName?: string;
+        componentType?: string;
+        architecture?: Architecture;
+        stateManagement?: StateManagement$1;
+    }): {
+        valid: boolean;
+        errors: string[];
+    };
+    /**
+     * Format component name based on framework conventions
+     * @param componentType Component type
+     * @returns Formatted component name
+     */
+    protected formatComponentName(componentType: string): string;
+    /**
+     * Get file extension for this framework
+     * @returns File extension
+     */
+    protected getFileExtension(): string;
+    /**
+     * Create a basic package.json for the project
+     * @param projectName Project name
+     * @param dependencies Project dependencies
+     * @param devDependencies Development dependencies
+     * @returns Package.json content
+     */
+    protected createPackageJson(projectName: string, dependencies: Record<string, string>, devDependencies: Record<string, string>): string;
+    /**
+     * Get default scripts for package.json
+     * @returns Default scripts object
+     */
+    protected getDefaultScripts(): Record<string, string>;
+    /**
+     * Create TypeScript configuration
+     * @returns TypeScript config content
+     */
+    protected createTsConfig(): string;
+    /**
+     * Create Vite configuration
+     * @returns Vite config content
+     */
+    protected createViteConfig(): string;
+    /**
+     * Get Vite plugin import statement
+     * @returns Import statement
+     */
+    protected getVitePluginImport(): string;
+    /**
+     * Get Vite plugin package
+     * @returns Package name
+     */
+    protected getVitePluginPackage(): string;
+    /**
+     * Get Vite plugin configuration
+     * @returns Plugin configuration
+     */
+    protected getVitePluginConfig(): string;
+    /**
+     * Create README.md content
+     * @param projectName Project name
+     * @returns README content
+     */
+    protected createReadme(projectName: string): string;
+    /**
+     * Get framework documentation URL
+     * @returns Documentation URL
+     */
+    protected getFrameworkDocsUrl(): string;
+    /**
+     * Log generation start
+     * @param type Generation type
+     * @param target Target name
+     */
+    protected logStart(type: 'project' | 'component', target: string): void;
+    /**
+     * Log generation completion
+     * @param type Generation type
+     * @param target Target name
+     * @param fileCount Number of files generated
+     */
+    protected logComplete(type: 'project' | 'component', target: string, fileCount: number): void;
+}
+
+type GeneratorConstructor = new (framework: Framework) => BaseGenerator;
+/**
+ * Generator Factory - Creates and manages framework generators
+ * Provides a unified interface for creating generators and ensures consistent behavior
+ */
+declare class GeneratorFactory {
+    private static instance;
+    private generators;
+    private instances;
+    private constructor();
+    /**
+     * Get singleton instance
+     * @returns GeneratorFactory instance
+     */
+    static getInstance(): GeneratorFactory;
+    /**
+     * Register a generator class for a framework
+     * @param framework Framework type
+     * @param generatorClass Generator class constructor
+     */
+    registerGenerator(framework: Framework, generatorClass: GeneratorConstructor): void;
+    /**
+     * Create a generator instance for the specified framework
+     * @param framework Framework type
+     * @returns Generator instance
+     */
+    createGenerator(framework: Framework): BaseGenerator;
+    /**
+     * Generate a project using the specified framework
+     * @param framework Framework type
+     * @param projectName Project name
+     * @param architecture Architecture pattern
+     * @param stateManagement State management approach
+     * @param designContext Design context
+     * @returns Array of generated files
+     */
+    generateProject(framework: Framework, projectName: string, architecture: Architecture, stateManagement: StateManagement$1, designContext?: IDesignContext): IGeneratedFile[];
+    /**
+     * Generate a UI component
+     * @param framework Target framework
+     * @param componentType Component type
+     * @param props Component props
+     * @param designContext Design context
+     * @param componentLibrary Component library to use
+     * @returns Array of generated files
+     */
+    generateComponent(framework: Framework, componentType: string, props: Record<string, unknown>, designContext?: IDesignContext, componentLibrary?: ComponentLibrary): IGeneratedFile[];
+    /**
+     * Get list of supported frameworks
+     * @returns Array of supported framework types
+     */
+    getSupportedFrameworks(): Framework[];
+    /**
+     * Check if a framework is supported
+     * @param framework Framework to check
+     * @returns True if supported
+     */
+    isFrameworkSupported(framework: string): framework is Framework;
+    /**
+     * Get generator information for all supported frameworks
+     * @returns Array of generator information
+     */
+    getGeneratorInfo(): Array<{
+        framework: Framework;
+        className: string;
+        isInstantiated: boolean;
+    }>;
+    /**
+     * Clear all cached instances
+     */
+    clearInstances(): void;
+    /**
+     * Clear instance for a specific framework
+     * @param framework Framework to clear
+     */
+    clearInstance(framework: Framework): void;
+    /**
+     * Unregister a generator
+     * @param framework Framework to unregister
+     */
+    unregisterGenerator(framework: Framework): void;
+    /**
+     * Get default design context
+     * @returns Default design context
+     */
+    private getDefaultContext;
+    /**
+     * Register default generators for all supported frameworks
+     */
+    private registerDefaultGenerators;
+}
+/**
+ * Convenience function to generate a component
+ * @param framework Framework type
+ * @param componentType Component type
+ * @param props Component props
+ * @param designContext Design context
+ * @param componentLibrary Component library to use
+ * @returns Array of generated files
+ */
+declare function generateComponent(framework: Framework, componentType: string, props: Record<string, unknown>, designContext?: IDesignContext, componentLibrary?: ComponentLibrary): IGeneratedFile[];
+
+/**
+ * Default design context constant
+ * Shared across the application for consistent default values
+ */
+declare const DEFAULT_DESIGN_CONTEXT: IDesignContext;
+
+/**
+ * React Generator - Generates React components and projects
+ */
+declare class ReactGenerator extends BaseGenerator {
+    constructor(framework: Framework);
+    /**
+     * Generate a complete React project
+     */
+    generateProject(projectName: string, architecture: Architecture, stateManagement: StateManagement$1, designContext: IDesignContext): IGeneratedFile[];
+    /**
+     * Generate a React component
+     */
+    generateComponent(componentType: string, props: Record<string, unknown>, designContext: IDesignContext, componentLibrary?: ComponentLibrary): IGeneratedFile[];
+    private createPackageJsonFile;
+    private createTsConfigFile;
+    private createViteConfigFile;
+    private createReadmeFile;
+    private createAppComponent;
+    private createIndexHtmlFile;
+    private createTailwindConfig;
+    private createStateManagementFiles;
+    private createComponentFile;
+    private createStorybookFile;
+    private createTestFile;
+    protected getShadcnDependencies(): string[];
+    protected getRadixDependencies(): string[];
+    protected getHeadlessUIDependencies(): string[];
+    protected getPrimeVueDependencies(): string[];
+    protected getMaterialDependencies(): string[];
+    protected getShadcnImports(): string[];
+    protected getRadixImports(): string[];
+    protected getHeadlessUIImports(): string[];
+    protected getPrimeVueImports(): string[];
+    protected getMaterialImports(): string[];
+    protected generateShadcnComponent(componentType: string, props: Record<string, unknown>): string;
+    protected generateRadixComponent(componentType: string, props: Record<string, unknown>): string;
+    protected generateHeadlessUIComponent(componentType: string, props: Record<string, unknown>): string;
+    protected generatePrimeVueComponent(componentType: string, props: Record<string, unknown>): string;
+    protected generateMaterialComponent(componentType: string, props: Record<string, unknown>): string;
+    protected generateTailwindComponent(componentType: string, props: Record<string, unknown>): string;
+    private generatePropsInterface;
+    private getHtmlElementForComponentType;
+    private getTailwindClassesForComponentType;
+}
+
+/**
+ * Vue Generator - Generates Vue components and projects
+ */
+declare class VueGenerator extends BaseGenerator {
+    constructor(framework: Framework);
+    generateProject(projectName: string, _architecture: Architecture, _stateManagement: StateManagement$1, _designContext: IDesignContext): IGeneratedFile[];
+    generateComponent(componentType: string, props: Record<string, unknown>, designContext: IDesignContext, componentLibrary?: ComponentLibrary): IGeneratedFile[];
+    protected getShadcnDependencies(): string[];
+    protected getRadixDependencies(): string[];
+    protected getHeadlessUIDependencies(): string[];
+    protected getPrimeVueDependencies(): string[];
+    protected getMaterialDependencies(): string[];
+    protected getShadcnImports(): string[];
+    protected getRadixImports(): string[];
+    protected getHeadlessUIImports(): string[];
+    protected getPrimeVueImports(): string[];
+    protected getMaterialImports(): string[];
+    protected generateShadcnComponent(componentType: string, _props: Record<string, unknown>): string;
+    protected generateRadixComponent(componentType: string, _props: Record<string, unknown>): string;
+    protected generateHeadlessUIComponent(componentType: string, _props: Record<string, unknown>): string;
+    protected generatePrimeVueComponent(componentType: string, _props: Record<string, unknown>): string;
+    protected generateMaterialComponent(componentType: string, _props: Record<string, unknown>): string;
+    protected generateTailwindComponent(componentType: string, _props: Record<string, unknown>): string;
+    private createComponentFile;
+    private createTestFile;
+}
+
+/**
+ * Angular Generator - Generates Angular components and projects
+ */
+declare class AngularGenerator extends BaseGenerator {
+    constructor(framework: Framework);
+    generateProject(projectName: string, _architecture: Architecture, _stateManagement: StateManagement$1, _designContext: IDesignContext): IGeneratedFile[];
+    generateComponent(componentType: string, props: Record<string, unknown>, designContext: IDesignContext, componentLibrary?: ComponentLibrary): IGeneratedFile[];
+    protected getShadcnDependencies(): string[];
+    protected getRadixDependencies(): string[];
+    protected getHeadlessUIDependencies(): string[];
+    protected getPrimeVueDependencies(): string[];
+    protected getMaterialDependencies(): string[];
+    protected getShadcnImports(): string[];
+    protected getRadixImports(): string[];
+    protected getHeadlessUIImports(): string[];
+    protected getPrimeVueImports(): string[];
+    protected getMaterialImports(): string[];
+    protected generateShadcnComponent(componentType: string, _props: Record<string, unknown>): string;
+    protected generateRadixComponent(componentType: string, _props: Record<string, unknown>): string;
+    protected generateHeadlessUIComponent(componentType: string, _props: Record<string, unknown>): string;
+    protected generatePrimeVueComponent(componentType: string, _props: Record<string, unknown>): string;
+    protected generateMaterialComponent(componentType: string, _props: Record<string, unknown>): string;
+    protected generateTailwindComponent(componentType: string, _props: Record<string, unknown>): string;
+    private createComponentFile;
+    private createTestFile;
+}
+
+/**
+ * Svelte Generator - Generates Svelte components and projects
+ */
+declare class SvelteGenerator extends BaseGenerator {
+    constructor(framework: Framework);
+    generateProject(projectName: string, _architecture: Architecture, _stateManagement: StateManagement$1, _designContext: IDesignContext): IGeneratedFile[];
+    generateComponent(componentType: string, props: Record<string, unknown>, designContext: IDesignContext, componentLibrary?: ComponentLibrary): IGeneratedFile[];
+    protected getShadcnDependencies(): string[];
+    protected getRadixDependencies(): string[];
+    protected getHeadlessUIDependencies(): string[];
+    protected getPrimeVueDependencies(): string[];
+    protected getMaterialDependencies(): string[];
+    protected getShadcnImports(): string[];
+    protected getRadixImports(): string[];
+    protected getHeadlessUIImports(): string[];
+    protected getPrimeVueImports(): string[];
+    protected getMaterialImports(): string[];
+    protected generateShadcnComponent(componentType: string, _props: Record<string, unknown>): string;
+    protected generateRadixComponent(componentType: string, _props: Record<string, unknown>): string;
+    protected generateHeadlessUIComponent(componentType: string, _props: Record<string, unknown>): string;
+    protected generatePrimeVueComponent(componentType: string, _props: Record<string, unknown>): string;
+    protected generateMaterialComponent(componentType: string, _props: Record<string, unknown>): string;
+    protected generateTailwindComponent(componentType: string, _props: Record<string, unknown>): string;
+    private createComponentFile;
+    private createTestFile;
+}
+
+/**
+ * HTML Generator - Generates HTML components and projects
+ */
+declare class HtmlGenerator extends BaseGenerator {
+    constructor(framework: Framework);
+    generateProject(projectName: string, _architecture: Architecture, _stateManagement: StateManagement$1, _designContext: IDesignContext): IGeneratedFile[];
+    generateComponent(componentType: string, props: Record<string, unknown>, designContext: IDesignContext, componentLibrary?: ComponentLibrary): IGeneratedFile[];
+    protected getShadcnDependencies(): string[];
+    protected getRadixDependencies(): string[];
+    protected getHeadlessUIDependencies(): string[];
+    protected getPrimeVueDependencies(): string[];
+    protected getMaterialDependencies(): string[];
+    protected getShadcnImports(): string[];
+    protected getRadixImports(): string[];
+    protected getHeadlessUIImports(): string[];
+    protected getPrimeVueImports(): string[];
+    protected getMaterialImports(): string[];
+    protected generateShadcnComponent(componentType: string, _props: Record<string, unknown>): string;
+    protected generateRadixComponent(componentType: string, _props: Record<string, unknown>): string;
+    protected generateHeadlessUIComponent(componentType: string, _props: Record<string, unknown>): string;
+    protected generatePrimeVueComponent(componentType: string, _props: Record<string, unknown>): string;
+    protected generateMaterialComponent(componentType: string, _props: Record<string, unknown>): string;
+    protected generateTailwindComponent(componentType: string, _props: Record<string, unknown>): string;
+    private createComponentFile;
+}
+
+/**
+ * Register a component snippet into the knowledge base.
+ * Validates input and normalizes fields for consistent searching.
+ */
+declare function registerSnippet(snippet: IComponentSnippet): void;
+/**
+ * Clear the registry (for testing).
+ */
+declare function clearRegistry(): void;
+/**
+ * Register multiple snippets at once.
+ */
+declare function registerSnippets(snippets: IComponentSnippet[]): void;
+/**
+ * Get a snippet by exact ID.
+ */
+declare function getSnippetById(id: string): IComponentSnippet | undefined;
+/**
+ * Get all registered snippets count.
+ */
+declare function getRegistrySize(): number;
+/**
+ * Get a shallow copy of all registered snippets.
+ */
+declare function getAllSnippets(): IComponentSnippet[];
+/**
+ * Search components using tag-based fuzzy scoring.
+ * Scores are computed by matching mood, industry, style, type, tags, and category.
+ */
+declare function searchComponents(query: IComponentQuery): ISearchResult[];
+/**
+ * Get all variants for a given component type.
+ */
+declare function getVariants(type: string): IComponentSnippet[];
+/**
+ * Get all component types available in the registry.
+ */
+declare function getAvailableTypes(): string[];
+/**
+ * Get all snippets for a given category.
+ */
+declare function getByCategory(category: ComponentCategory): IComponentSnippet[];
+/**
+ * Get snippets matching a mood.
+ */
+declare function getByMood(mood: MoodTag): IComponentSnippet[];
+/**
+ * Get snippets matching an industry.
+ */
+declare function getByIndustry(industry: IndustryTag): IComponentSnippet[];
+/**
+ * Apply a visual style layer onto a component snippet.
+ * Returns a new snippet with modified tailwind classes.
+ */
+declare function applyVisualStyle(snippet: IComponentSnippet, styleId: VisualStyleId): IComponentSnippet;
+/**
+ * Inject micro-interaction animations into a snippet.
+ * Returns a new snippet with animation classes added.
+ */
+declare function injectAnimations(snippet: IComponentSnippet, animationIds: string[]): IComponentSnippet;
+/**
+ * Compose a full section by searching for an organism and optionally applying style + animations.
+ */
+declare function composeSection(sectionType: string, options?: {
+    style?: VisualStyleId;
+    mood?: MoodTag;
+    industry?: IndustryTag;
+}): IComponentSnippet | undefined;
+/**
+ * Get the best matching snippet for a component type, falling back gracefully.
+ * This is the main entry point for the generation tools.
+ */
+declare function getBestMatch(type: string, options?: {
+    variant?: string;
+    mood?: MoodTag;
+    industry?: IndustryTag;
+    style?: VisualStyleId;
+}): IComponentSnippet | undefined;
+/**
+ * Get the best matching snippet with feedback boosting.
+ * Uses feedback data to re-rank search results based on user acceptance patterns.
+ */
+declare function getBestMatchWithFeedback(type: string, options?: {
+    variant?: string;
+    mood?: MoodTag;
+    industry?: IndustryTag;
+    style?: VisualStyleId;
+}, db?: Database.Database): IComponentSnippet | undefined;
+/**
+ * Trigger pattern promotion cycle.
+ * Promotes high-performing code patterns from feedback to the registry.
+ */
+declare function triggerPatternPromotion(db: Database.Database): number;
+
+/**
+ * Initialize the full component registry with all atoms, molecules, organisms,
+ * visual styles, and micro-interactions.
+ *
+ * Call this once at startup before using any registry search/retrieval functions.
+ */
+declare function initializeRegistry(): void;
+
+type BackendCategory = 'api-route' | 'middleware' | 'architecture' | 'database' | 'security' | 'observability' | 'performance' | 'documentation';
+type BackendFramework = 'express' | 'nextjs-api' | 'nextjs-server-actions' | 'hono' | 'fastify' | 'framework-agnostic';
+type BackendPattern = 'clean-architecture' | 'service-layer' | 'repository' | 'middleware-chain' | 'event-driven' | 'cqrs' | 'factory' | 'strategy' | 'observer' | 'decorator' | 'singleton';
+interface IBackendQuality {
+    securityChecks: string[];
+    performanceConsiderations: string[];
+    antiPatterns: string[];
+    inspirationSource: string;
+}
+interface IBackendSnippet {
+    id: string;
+    name: string;
+    category: BackendCategory;
+    type: string;
+    variant: string;
+    tags: string[];
+    framework: BackendFramework[];
+    patterns: BackendPattern[];
+    typescript: string;
+    dependencies: string[];
+    envVars?: string[];
+    quality: IBackendQuality;
+    testHint: string;
+}
+
+declare function searchBackendSnippets(query: {
+    category?: BackendCategory;
+    framework?: BackendFramework;
+    tags?: string[];
+    type?: string;
+}): IBackendSnippet[];
+declare function initializeBackendRegistry(): Promise<void>;
+
+/**
+ * SQLite-backed graph store for the RAG component registry.
+ * Uses better-sqlite3 for embedded, zero-cost persistence.
+ *
+ * Static TypeScript files remain the source of truth.
+ * The DB is a runtime index rebuilt from static files when missing.
+ */
+
+/**
+ * Get or create the SQLite database connection.
+ * Defaults to `.uiforge/rag.sqlite` in the project root.
+ */
+declare function getDatabase(customPath?: string): Database.Database;
+/**
+ * Close the database connection.
+ */
+declare function closeDatabase(): void;
+
+declare const FONT_PAIRINGS: readonly IFontPairing[];
+declare const DEFAULT_FONT_PAIRING = "manrope-inter";
+declare function getFontPairing(name: string): IFontPairing | undefined;
+declare function getFontPairingsByMood(mood: string): IFontPairing[];
+declare const TYPE_SCALE: Record<string, string>;
+
+declare const COLOR_SYSTEMS: readonly IColorSystem[];
+declare const DEFAULT_COLOR_SYSTEM = "zinc";
+declare function getColorSystem(name: string): IColorSystem | undefined;
+declare function getColorSystemsByMood(mood: string): IColorSystem[];
+
+declare const SPACING_SYSTEM: ISpacingSystem;
+
+declare const ICON_LIBRARIES: readonly IIconLibrary[];
+declare function getDefaultIconLibrary(framework: string): IIconLibrary;
+
+declare const ANIMATION_PRESETS: readonly IAnimationPreset[];
+declare function getAnimationsByCategory(category: IAnimationPreset['category']): IAnimationPreset[];
+
+declare const LAYOUT_PATTERNS: readonly ILayoutPattern[];
+declare function getLayoutPattern(name: string): ILayoutPattern | undefined;
+declare function getLayoutPatternsByUseCase(useCase: string): ILayoutPattern[];
+
+declare const INSPIRATION_SOURCES: readonly IInspirationSource[];
+declare function getInspirationByCategory(category: IInspirationSource['category']): IInspirationSource[];
+declare function getInspirationByPriority(maxPriority?: number): IInspirationSource[];
+declare function getPrimaryDesignReference(): IInspirationSource;
+declare function getFallbackDesignReference(): IInspirationSource;
+
+declare const COMPONENT_LIBRARIES: readonly IComponentLibrary[];
+declare function getComponentLibrariesForFramework(framework: string): IComponentLibrary[];
+declare function getRecommendedLibrary(framework: string): IComponentLibrary | undefined;
+
+declare const DEFAULT_PRESET = "zinc-manrope";
+interface IPresetConfig {
+    colorSystem: string;
+    fontPairing: string;
+}
+declare const PRESETS: Record<string, IPresetConfig>;
+declare function getPreset(name?: string): IDesignContext;
+declare function listPresets(): string[];
+
+interface IPageSection {
+    id: string;
+    name: string;
+    query: IComponentQuery;
+    fallbackSnippetId?: string;
+    containerClasses: string;
+    darkModeClasses?: string;
+}
+interface IPageComposition {
+    id: string;
+    name: string;
+    description: string;
+    templateType: PageTemplateType;
+    sections: IPageSection[];
+    layout: 'single-column' | 'sidebar-left' | 'sidebar-right' | 'split';
+    layoutClasses: string;
+    mood: MoodTag[];
+    industry: IndustryTag[];
+    visualStyles: VisualStyleId[];
+    quality: {
+        antiGeneric: string[];
+        inspirationSource: string;
+        designPhilosophy: string;
+    };
+}
+
+declare function registerComposition(comp: IPageComposition): void;
+declare function getComposition(id: string): IPageComposition | undefined;
+interface IFindOptions {
+    mood?: MoodTag[];
+    industry?: IndustryTag[];
+    visualStyle?: VisualStyleId;
+}
+declare function findBestComposition(templateType: PageTemplateType, options?: IFindOptions): IPageComposition | undefined;
+interface IComposeOptions {
+    mood?: MoodTag[];
+    industry?: IndustryTag[];
+    visualStyle?: VisualStyleId;
+}
+interface IComposedSection {
+    id: string;
+    name: string;
+    jsx: string;
+    snippetId?: string;
+}
+interface IComposedPage {
+    jsx: string;
+    sections: IComposedSection[];
+    metadata: {
+        compositionId: string;
+        compositionName: string;
+        layout: string;
+        mood: MoodTag[];
+        industry: IndustryTag[];
+        visualStyles: VisualStyleId[];
+    };
+}
+declare function composePageFromTemplate(compositionId: string, options?: IComposeOptions): IComposedPage | null;
+declare function clearCompositions(): void;
+declare function getAllCompositions(): IPageComposition[];
+
+interface ITemplatePack {
+    id: string;
+    name: string;
+    description: string;
+    appType: string;
+    pages: {
+        path: string;
+        compositionId: string;
+        title: string;
+        isIndex: boolean;
+    }[];
+    theme: {
+        colorSystemId: string;
+        fontPairingId: string;
+        visualStyle: VisualStyleId;
+        mood: MoodTag;
+    };
+    sharedComponents: string[];
+    quality: {
+        antiGeneric: string[];
+        designPhilosophy: string;
+        inspirationSources: string[];
+    };
+}
+
+declare function registerPack(pack: ITemplatePack): void;
+declare function getPack(id: string): ITemplatePack | undefined;
+declare function getAllPacks(): ITemplatePack[];
+declare function searchPacks(appType?: string): ITemplatePack[];
+
+declare function registerInteraction(interaction: IMicroInteraction): void;
+declare function registerInteractions(items: IMicroInteraction[]): void;
+declare function getMicroInteraction(id: string): IMicroInteraction | undefined;
+declare function getInteractionsByCategory(category: AnimationCategory): IMicroInteraction[];
+/**
+ * Get all registered micro-interactions as a frozen shallow copy.
+ * Note: This is a shallow freeze - nested objects within interactions are not frozen.
+ * For deep immutability, consider using a deep freeze utility or immutable data structures.
+ */
+declare function getAllInteractions(): readonly IMicroInteraction[];
+/**
+ * Clear all registered interactions (for testing).
+ */
+declare function clearAllMicroInteractions(): void;
+declare function initializeInteractions(): void;
+
+type ProjectType = 'next-saas' | 'next-app' | 'express-api' | 'fullstack-mono' | 'react-spa';
+type AppType = 'saas' | 'ecommerce' | 'dashboard' | 'landing' | 'api';
+type Scale = 'solo' | 'team' | 'enterprise';
+type DeployTarget = 'vercel' | 'cloudflare' | 'docker' | 'aws';
+type StateManagement = 'zustand' | 'redux-toolkit' | 'tanstack-query' | 'jotai';
+interface IProjectTemplate {
+    id: ProjectType;
+    name: string;
+    description: string;
+    appTypes: AppType[];
+    scales: Scale[];
+    structure: IDirectoryStructure;
+    dependencies: Record<string, string>;
+    devDependencies: Record<string, string>;
+    scripts: Record<string, string>;
+    configFiles: IConfigFile[];
+    features: string[];
+}
+interface IDirectoryStructure {
+    [path: string]: 'file' | 'directory' | IDirectoryStructure;
+}
+interface IConfigFile {
+    path: string;
+    content: string;
+}
+interface IScaffoldOptions {
+    projectName: string;
+    projectType: ProjectType;
+    appType?: AppType;
+    scale?: Scale;
+    deployTarget?: DeployTarget;
+    stateManagement?: StateManagement;
+    features?: string[];
+}
+
+declare function getTemplate(projectType: ProjectType): IProjectTemplate;
+declare function getAllTemplates(): IProjectTemplate[];
+interface ITemplateSelectionCriteria {
+    appType?: AppType;
+    scale?: Scale;
+    features?: string[];
+    needsMonorepo?: boolean;
+    needsBackend?: boolean;
+}
+declare function selectTemplate(criteria: ITemplateSelectionCriteria): ProjectType;
+declare function customizeTemplate(template: IProjectTemplate, options: IScaffoldOptions): IProjectTemplate;
+declare function getRecommendations(criteria: ITemplateSelectionCriteria): {
+    primary: ProjectType;
+    alternatives: ProjectType[];
+    reasoning: string;
+};
+
+declare const zustandPatterns: {
+    basic: {
+        name: string;
+        description: string;
+        code: string;
+    };
+    withSelectors: {
+        name: string;
+        description: string;
+        code: string;
+    };
+    withMiddleware: {
+        name: string;
+        description: string;
+        code: string;
+    };
+    async: {
+        name: string;
+        description: string;
+        code: string;
+    };
+    slices: {
+        name: string;
+        description: string;
+        code: string;
+    };
+};
+
+declare const reduxToolkitPattern: {
+    id: string;
+    name: string;
+    code: string;
+};
+
+declare const tanstackQueryPattern: {
+    id: string;
+    name: string;
+    code: string;
+};
+
+declare const stateManagementPatterns: {
+    zustand: {
+        name: string;
+        description: string;
+        pros: string[];
+        cons: string[];
+        bestFor: string[];
+    };
+    'redux-toolkit': {
+        name: string;
+        description: string;
+        pros: string[];
+        cons: string[];
+        bestFor: string[];
+    };
+    'tanstack-query': {
+        name: string;
+        description: string;
+        pros: string[];
+        cons: string[];
+        bestFor: string[];
+    };
+    jotai: {
+        name: string;
+        description: string;
+        pros: string[];
+        cons: string[];
+        bestFor: string[];
+    };
+};
+
+declare const nextSaasTemplate: IProjectTemplate;
+
+declare const nextAppTemplate: IProjectTemplate;
+
+declare const expressApiTemplate: IProjectTemplate;
+
+declare const fullstackMonoTemplate: IProjectTemplate;
+
+declare const reactSpaTemplate: IProjectTemplate;
+
+declare const templates: Record<ProjectType, IProjectTemplate>;
+declare const templateList: IProjectTemplate[];
+
+/**
+ * Type definitions for the feedback & self-learning system.
+ */
+/** A recorded generation event. */
+interface IGeneration {
+    id: string;
+    tool: 'generate_ui_component' | 'generate_page_template';
+    params: Record<string, string>;
+    componentType: string;
+    framework: string;
+    outputHash: string;
+    timestamp: number;
+    sessionId: string;
+    prompt?: string;
+    variant?: string;
+    mood?: string;
+    industry?: string;
+    style?: string;
+    codeHash?: string;
+}
+/** Feedback for a generation (explicit or implicit). */
+interface IFeedback {
+    id: string;
+    generationId: string;
+    rating: 'positive' | 'negative' | 'neutral';
+    source: 'explicit' | 'implicit';
+    score: number;
+    confidence: number;
+    comment?: string;
+    timestamp: number;
+}
+/** A detected code pattern from generated outputs. */
+interface ICodePattern {
+    id: string;
+    skeletonHash: string;
+    skeleton: string;
+    snippet: string;
+    frequency: number;
+    avgScore: number;
+    promoted: boolean;
+}
+/** Implicit signal derived from analyzing the next prompt. */
+interface IImplicitSignal {
+    type: 'new_task' | 'minor_tweak' | 'major_redo' | 'praise' | 'time_gap' | 'rapid_followup';
+    score: number;
+    confidence: number;
+    reason: string;
+}
+/** Input for the submit_feedback MCP tool. */
+interface IExplicitFeedbackInput {
+    generationId: string;
+    rating: 'positive' | 'negative';
+    comment?: string;
+}
+/** Result of classifying a prompt pair. */
+interface IPromptClassification {
+    signals: IImplicitSignal[];
+    combinedScore: number;
+    combinedConfidence: number;
+}
+
+/**
+ * Feedback tracker — records generation events and manages the implicit feedback loop.
+ *
+ * Stores generation history in SQLite and uses the prompt classifier
+ * to derive implicit feedback scores from consecutive generations.
+ */
+
+/**
+ * Record a generation event.
+ * If a previous generation exists for this session, implicit feedback is derived.
+ */
+declare function recordGeneration$1(gen: IGeneration, generatedCode: string, db: Database.Database, promptContext?: string): {
+    implicitFeedback?: IFeedback;
+};
+/**
+ * Record explicit user feedback for a generation.
+ */
+declare function recordExplicitFeedback(generationId: string, rating: 'positive' | 'negative', db: Database.Database, comment?: string): IFeedback;
+/**
+ * Get the aggregate feedback score for a component snippet or pattern.
+ * Returns a value between -1 and 2, or 0 if no feedback exists.
+ */
+declare function getAggregateScore(componentType: string, db: Database.Database): number;
+/**
+ * Get feedback count (useful for determining training readiness).
+ */
+declare function getFeedbackCount(db: Database.Database): number;
+/**
+ * Get feedback statistics.
+ */
+declare function getFeedbackStats(db: Database.Database): {
+    total: number;
+    explicit: number;
+    implicit: number;
+    avgScore: number;
+    positive: number;
+    negative: number;
+    neutral: number;
+};
+/**
+ * Export training data as JSONL-style array for LoRA fine-tuning.
+ */
+declare function exportTrainingData(db: Database.Database, minScore?: number): Array<{
+    prompt: string;
+    score: number;
+    componentType: string | null;
+    style: string | null;
+}>;
+/**
+ * Clear the in-memory session cache (useful for testing).
+ */
+declare function clearSessionCache(): void;
+
+/**
+ * Feedback-boosted search — merges feedback scores into registry search results.
+ *
+ * Replaces raw `searchComponents()` with a version that boosts results
+ * based on accumulated user feedback, so the RAG system learns over time.
+ */
+
+/**
+ * Search components with feedback-based score boosting.
+ *
+ * 1. Runs the base registry search (in-memory scoring).
+ * 2. Looks up aggregate feedback scores per component type from SQLite.
+ * 3. Boosts/penalizes results by up to ±30% based on feedback history.
+ */
+declare function feedbackBoostedSearch(query: IComponentQuery, db: Database.Database): ISearchResult[];
+/**
+ * Get the feedback boost factor for a specific component type.
+ * Returns a multiplier between 0.7 and 1.3 (±30%).
+ */
+declare function getFeedbackBoost(componentType: string, db: Database.Database): number;
+
+/**
+ * Pattern promotion — auto-expand the registry from proven user-accepted patterns.
+ *
+ * When a code pattern is generated frequently with high feedback scores,
+ * it gets promoted to a first-class registry snippet so the RAG system
+ * returns it directly in future searches.
+ */
+
+/**
+ * Ensure the patterns table exists in the database.
+ */
+declare function ensurePatternsTable(db: Database.Database): void;
+/**
+ * Record or update a code pattern from a generation.
+ */
+declare function recordPattern(skeletonHash: string, skeleton: string, code: string, componentType: string | undefined, category: ComponentCategory | undefined, feedbackScore: number, db: Database.Database): ICodePattern;
+/**
+ * Get all patterns eligible for promotion.
+ */
+declare function getPromotablePatternsFromDb(db: Database.Database): ICodePattern[];
+/**
+ * Promote a pattern to a registry snippet.
+ * Creates a new IComponentSnippet from the pattern and registers it.
+ */
+declare function promotePattern(pattern: ICodePattern, componentType: string, category: ComponentCategory, db: Database.Database): IComponentSnippet | null;
+/**
+ * Run the promotion cycle: find eligible patterns and promote them.
+ * Returns the count of newly promoted patterns.
+ */
+declare function runPromotionCycle(db: Database.Database): number;
+/**
+ * Get pattern statistics.
+ */
+declare function getPatternStats(db: Database.Database): {
+    total: number;
+    promoted: number;
+    eligible: number;
+    avgFrequency: number;
+    avgScore: number;
+};
+
+/**
+ * Rule-based prompt classifier for implicit feedback.
+ *
+ * Analyzes consecutive generation calls to infer user satisfaction
+ * without requiring any external ML model or API.
+ */
+
+/**
+ * Classify a pair of consecutive generation events to produce implicit feedback
+ * for the previous generation.
+ *
+ * @param prev The previous generation event
+ * @param curr The current generation event
+ * @param promptContext Optional text context from the current prompt/description
+ */
+declare function classifyPromptPair(prev: IGeneration, curr: IGeneration, promptContext?: string): IPromptClassification;
+/**
+ * Classify a single keyword context without a previous generation.
+ * Useful for explicit prompt analysis.
+ */
+declare function classifyPromptText(promptContext: string): IPromptClassification;
+
+/**
+ * Code pattern detection — extracts structural skeletons from generated code
+ * and hashes them for cross-session pattern recognition.
+ */
+
+/**
+ * Extract a structural skeleton from JSX/HTML code.
+ *
+ * Strips class names, text content, and attribute values,
+ * keeping only the element hierarchy and semantic roles.
+ *
+ * Example:
+ *   Input:  <div className="flex gap-4"><h2 className="text-2xl">Title</h2><button>CTA</button></div>
+ *   Output: div>h2+button
+ */
+declare function extractSkeleton(code: string): string;
+/**
+ * Hash a skeleton string to create a consistent fingerprint.
+ */
+declare function hashSkeleton(skeleton: string): string;
+/**
+ * Extract skeleton and hash from code in one step.
+ */
+declare function fingerprint(code: string): {
+    skeleton: string;
+    hash: string;
+};
+/**
+ * Check if a pattern meets promotion criteria.
+ */
+declare function isPromotable(pattern: ICodePattern): boolean;
+
+interface IValidationResult {
+    valid: boolean;
+    errors: string[];
+    warnings: string[];
+}
+declare function validateSnippet(snippet: IComponentSnippet): IValidationResult;
+declare function validateSnippetStrict(snippet: IComponentSnippet): IValidationResult;
+
+declare function recordGeneration(snippet: IComponentSnippet): void;
+declare function isDuplicateConsecutive(type: string, variant: string): boolean;
+declare function suggestDiverseVariant(type: string, available: string[]): string | undefined;
+declare function clearHistory(): void;
+
+type ArtifactType = 'component' | 'page' | 'module' | 'api-route' | 'project';
+interface IComponentStructure {
+    component: string;
+    category: 'atom' | 'molecule' | 'organism';
+    children?: IComponentStructure[];
+    props?: Record<string, unknown>;
+    layout?: string;
+    tokens?: Record<string, string>;
+}
+interface IGeneratedArtifact {
+    id: string;
+    type: ArtifactType;
+    category?: string;
+    prompt: string;
+    code: string;
+    structure?: IComponentStructure;
+    metadata?: Record<string, unknown>;
+    qualityScore?: number;
+    feedbackScore?: number;
+    inspirationSources?: string[];
+    createdAt: number;
+}
+interface IArtifactQuery {
+    type?: ArtifactType;
+    category?: string;
+    minQualityScore?: number;
+    minFeedbackScore?: number;
+    limit?: number;
+}
+interface ILearningStats {
+    totalArtifacts: number;
+    avgQualityScore: number;
+    avgFeedbackScore: number;
+    topPatterns: Array<{
+        category: string;
+        count: number;
+    }>;
+    promotionCandidates: number;
+}
+
+declare function resetSchemaInit(): void;
+declare function generateArtifactId(prompt: string, type: ArtifactType): string;
+declare function storeArtifact(artifact: IGeneratedArtifact, db: Database.Database): void;
+declare function getArtifact(id: string, db: Database.Database): IGeneratedArtifact | undefined;
+declare function queryArtifacts(query: IArtifactQuery, db: Database.Database): IGeneratedArtifact[];
+declare function updateFeedbackScore(id: string, score: number, db: Database.Database): boolean;
+declare function updateQualityScore(id: string, score: number, db: Database.Database): boolean;
+declare function getArtifactCount(db: Database.Database, type?: ArtifactType): number;
+declare function getTopArtifacts(db: Database.Database, limit?: number): IGeneratedArtifact[];
+declare function deleteArtifact(id: string, db: Database.Database): boolean;
+
+declare function recordGeneratedArtifact(prompt: string, code: string, type: IGeneratedArtifact['type'], db: Database.Database, options?: {
+    category?: string;
+    qualityScore?: number;
+    structure?: IGeneratedArtifact['structure'];
+    metadata?: Record<string, unknown>;
+    inspirationSources?: string[];
+}): IGeneratedArtifact;
+declare function getPromotionCandidates(db: Database.Database): IGeneratedArtifact[];
+declare function getLearningStats(db: Database.Database): ILearningStats;
+declare function getRecentArtifacts(db: Database.Database, limit?: number): IGeneratedArtifact[];
+declare function getSimilarArtifacts(type: IGeneratedArtifact['type'], category: string, db: Database.Database, limit?: number): IGeneratedArtifact[];
+
+declare const DEFAULT_CONTEXT: IDesignContext;
+declare class DesignContextStore {
+    private context;
+    constructor();
+    get(): IDesignContext;
+    set(ctx: IDesignContext): void;
+    update(partial: Partial<IDesignContext>): void;
+    selectPreset(name: string): IDesignContext;
+    listPresets(): string[];
+    reset(): void;
+}
+declare const designContextStore: DesignContextStore;
+
+/**
+ * Component Libraries Integration
+ *
+ * Centralized access to all component library integrations including:
+ * - shadcn/ui
+ * - Radix UI
+ * - Headless UI
+ * - Material-UI
+ */
+
+/**
+ * Component library interface
+ */
+interface ComponentLibraryIntegration {
+    name: string;
+    id: ComponentLibraryId;
+    description: string;
+    setupProject(options: ComponentLibrarySetupOptions): IGeneratedFile[];
+    generateComponent(name: string, designContext: IDesignContext, customizations?: Record<string, unknown>): IGeneratedFile[];
+    getAvailableComponents(): string[];
+    getAvailablePatterns(): string[];
+}
+/**
+ * Component library setup options
+ */
+interface ComponentLibrarySetupOptions {
+    framework: Framework;
+    projectName: string;
+    components?: string[];
+    patterns?: string[];
+    designContext?: IDesignContext;
+    customizations?: Record<string, unknown>;
+}
+/**
+ * Get component library integration by ID
+ */
+declare function getComponentLibrary(libraryId: ComponentLibraryId): ComponentLibraryIntegration | undefined;
+/**
+ * Get all available component libraries
+ */
+declare function getAvailableComponentLibraries(): ComponentLibraryIntegration[];
+/**
+ * Setup component library project
+ */
+declare function setupComponentLibraryProject(libraryId: ComponentLibraryId, options: ComponentLibrarySetupOptions): IGeneratedFile[];
+/**
+ * Generate component from library
+ */
+declare function generateComponentFromLibrary(libraryId: ComponentLibraryId, componentName: string, designContext: IDesignContext, customizations?: Record<string, unknown>): IGeneratedFile[];
+/**
+ * Get available components for library
+ */
+declare function getAvailableComponentsForLibrary(libraryId: ComponentLibraryId): string[];
+/**
+ * Get available patterns for library
+ */
+declare function getAvailablePatternsForLibrary(libraryId: ComponentLibraryId): string[];
+
+declare const configSchema: z.ZodObject<{
+    NODE_ENV: z.ZodDefault<z.ZodEnum<{
+        production: "production";
+        development: "development";
+        test: "test";
+    }>>;
+    FIGMA_ACCESS_TOKEN: z.ZodOptional<z.ZodString>;
+    LOG_LEVEL: z.ZodDefault<z.ZodEnum<{
+        error: "error";
+        warn: "warn";
+        info: "info";
+        debug: "debug";
+    }>>;
+}, z.core.$strip>;
+type Config = z.infer<typeof configSchema>;
+declare function loadConfig(): Config;
+declare function getConfig(): Config;
+/**
+ * Safely parse JSON with fallback.
+ * @param jsonString - JSON string to parse
+ * @param defaultValue - Fallback value if parsing fails
+ */
+declare function safeJSONParse<T>(jsonString: string | null | undefined, defaultValue: T): T;
+declare function safeJSONParse<T extends Record<string, unknown>>(jsonString: string | null | undefined): T;
+
+declare const logger: pino__default.Logger;
+declare function createLogger(name: string): Logger;
+
+/**
+ * Consolidated utility functions for UIForge MCP
+ * Removes duplication and provides a clean, organized interface
+ */
+/**
+ * Convert string to PascalCase (e.g., "button" → "Button", "nav-bar" → "NavBar")
+ */
+declare function toPascalCase(str: string): string;
+/**
+ * Convert string to kebab-case (e.g., "NavBar" → "nav-bar", "Button" → "button")
+ */
+declare function toKebabCase(str: string): string;
+/**
+ * Convert string to camelCase (e.g., "nav-bar" → "navBar", "Button" → "button")
+ */
+declare function toCamelCase(str: string): string;
+/**
+ * Convert string to snake_case (e.g., "NavBar" → "nav_bar", "button" → "button")
+ */
+declare function toSnakeCase(str: string): string;
+/**
+ * Capitalize first letter of string
+ */
+declare function capitalize(str: string): string;
+/**
+ * Simple pluralization for common English words
+ */
+declare function pluralize(str: string): string;
+/**
+ * Sanitize string for CSS class names
+ */
+declare function sanitizeClassName(str: string): string;
+/**
+ * Generate random ID with optional prefix
+ */
+declare function generateRandomId(prefix?: string): string;
+/**
+ * Truncate string to specified length with ellipsis
+ */
+declare function truncate(str: string, maxLength: number, suffix?: string): string;
+/**
+ * Escape HTML special characters
+ */
+declare function escapeHtml(str: string): string;
+/**
+ * Convert JSX attributes to HTML attributes
+ */
+declare function jsxToHtmlAttributes(jsxCode: string): string;
+/**
+ * Convert React event handlers to HTML event attributes
+ */
+declare function reactEventsToHtml(jsxCode: string): string;
+/**
+ * Convert React event handlers to Svelte event syntax
+ */
+declare function reactEventsToSvelte(jsxCode: string): string;
+/**
+ * Remove JSX-specific syntax
+ */
+declare function cleanJsxSyntax(jsxCode: string): string;
+/**
+ * Full JSX to HTML conversion
+ */
+declare function jsxToHtml(jsxCode: string): string;
+/**
+ * Full JSX to Svelte conversion
+ */
+declare function jsxToSvelte(jsxCode: string): string;
+/**
+ * Convert HTML attributes object to JSX attributes string
+ */
+declare function htmlToJsxAttributes(attributes: Record<string, string>): string;
+/**
+ * Convert style object to CSS string
+ */
+declare function convertStyleObjectToString(styleObject: Record<string, string | number>): string;
+/**
+ * Parse CSS style string to object
+ */
+declare function parseStyleString(styleString: string): Record<string, string>;
+/**
+ * Merge multiple style objects
+ */
+declare function mergeStyles(...styles: (Record<string, string | number> | undefined)[]): Record<string, string | number>;
+/**
+ * Validate email format
+ */
+declare function isValidEmail(email: string): boolean;
+/**
+ * Validate URL format
+ */
+declare function isValidUrl(url: string): boolean;
+/**
+ * Validate hex color format
+ */
+declare function isValidHexColor(color: string): boolean;
+/**
+ * Validate component name (kebab-case)
+ */
+declare function isValidComponentName(name: string): boolean;
+/**
+ * Validate project name
+ */
+declare function isValidProjectName(name: string): boolean;
+/**
+ * Get file extension from path
+ */
+declare function getFileExtension(path: string): string;
+/**
+ * Get filename without extension
+ */
+declare function getFileName(path: string): string;
+/**
+ * Convert file path to different framework conventions
+ */
+declare function convertPathForFramework(path: string, framework: string): string;
+/**
+ * Remove duplicates from array
+ */
+declare function unique<T>(array: T[]): T[];
+/**
+ * Group array items by key
+ */
+declare function groupBy<T>(array: T[], key: keyof T): Record<string, T[]>;
+/**
+ * Sort array of objects by key
+ */
+declare function sortBy<T>(array: T[], key: keyof T, direction?: 'asc' | 'desc'): T[];
+/**
+ * Check if array includes value (case-insensitive for strings)
+ */
+declare function includesCaseInsensitive<T>(array: T[], value: T): boolean;
+/**
+ * Type guard for strings
+ */
+declare function isString(value: unknown): value is string;
+/**
+ * Type guard for numbers
+ */
+declare function isNumber(value: unknown): value is number;
+/**
+ * Type guard for objects
+ */
+declare function isObject(value: unknown): value is Record<string, unknown>;
+/**
+ * Type guard for arrays
+ */
+declare function isArray<T>(value: unknown): value is T[];
+/**
+ * Type guard for functions
+ */
+declare function isFunction(value: unknown): value is (...args: unknown[]) => unknown;
+/**
+ * Create standardized error object
+ */
+declare function createError(message: string, code?: string, details?: Record<string, unknown>): {
+    message: string;
+    code: string;
+    details: Record<string, unknown>;
+    timestamp: string;
+};
+/**
+ * Check if error is a network error
+ */
+declare function isNetworkError(error: unknown): boolean;
+/**
+ * Retry function with exponential backoff
+ */
+declare function retry<T>(fn: () => Promise<T>, maxAttempts?: number, delay?: number): Promise<T>;
+
+export { ANIMATION_PRESETS, type AdapterType, AngularGenerator, type AppType, type Architecture, type ArtifactType, type BackendCategory, type BackendFramework, BaseGenerator, COLOR_SYSTEMS, COMPONENT_LIBRARIES, type ComponentCategory, type ComponentLibrary, type ComponentLibraryId, type ComponentLibraryIntegration, type ComponentLibrarySetupOptions, type Config, DEFAULT_COLOR_SYSTEM, DEFAULT_CONTEXT, DEFAULT_DESIGN_CONTEXT, DEFAULT_FONT_PAIRING, DEFAULT_LORA_CONFIG, DEFAULT_PRESET, type DeployTarget, FONT_PAIRINGS, type Framework, GeneratorFactory, HtmlGenerator, type IAccessibilityIssue, type IAccessibilityReport, type IArtifactQuery, type IBackendSnippet, ICON_LIBRARIES, type ICodePattern, type IComponentLibrary, type IComponentQuery, type IComponentSnippet, type IComponentStructure, type IConfigFile, type IDesignAnalysisResult, type IDesignContext, type IDirectoryStructure, type IEmbedding, type IEmbeddingConfig, type IEnhancedPrompt, type IEnhancementContext, type IExplicitFeedbackInput, type IFeedback, type IFigmaDesignToken, type IFigmaVariable, type IGeneratedArtifact, type IGeneratedFile, type IGeneration, type IImageAnalysis, type IImplicitSignal, type ILearningStats, type ILoRAConfig, type IModelPaths, INSPIRATION_SOURCES, type IPatternMatch, type IPresetConfig, type IProjectTemplate, type IPromptClassification, type IQualityScore, type IScaffoldOptions, type IScrapedPage, type IScreenElement, type ISearchResult, type ISimilarityResult, type IStyleContext, type IStyleRecommendation, type ITailwindMapping, type ITemplateSelectionCriteria, type ITrainingExample, type ITrainingStatus, type ITransition, type IValidationResult, type ImageType, type IndustryTag, LAYOUT_PATTERNS, type ModelId, type MoodTag, PRESETS, type PageTemplateType, type ProjectType, ReactGenerator, SPACING_SYSTEM, type Scale, type StateManagement$1 as StateManagement, SvelteGenerator, TYPE_SCALE, type VisualStyleId, VueGenerator, applyVisualStyle, buildPromptEnhancerData, buildQualityScorerData, buildStyleRecommenderData, cancelTrainingJob, capitalize, checkTrainingReadiness, classifyPromptPair, classifyPromptText, cleanJsxSyntax, clearAllMicroInteractions, clearCompositions, clearHistory as clearDiversityHistory, clearRegistry, clearSessionCache, closeDatabase, composePageFromTemplate, composeSection, configureEmbeddings, configureModelDir, convertPathForFramework, convertStyleObjectToString, cosineSimilarity, createEmbedding, createError, createLogger, createTrainingJob, customizeTemplate, deleteArtifact, deleteEmbeddings, designContextStore, embed, embedBatch, enhancePrompt, enhancePromptWithRAG, enhanceWithRules, ensureDirectories, ensurePatternsTable, escapeHtml, exportForAdapter, exportRawExamples, exportTrainingData, expressApiTemplate, extractDesignPatterns, extractSkeleton, feedbackBoostedSearch, findBestComposition, findSimilar, fingerprint, fullstackMonoTemplate, generateArtifactId, generateComponent, generateComponentFromLibrary, generateRandomId, getAdapterPath, getAggregateScore, getAllCompositions, getAllInteractions, getAllJobStatuses, getAllPacks, getAllSnippets, getAllTemplates, getAnimationsByCategory, getArtifact, getArtifactCount, getAvailableComponentLibraries, getAvailableComponentsForLibrary, getAvailablePatternsForLibrary, getAvailableTypes, getBaseDir, getBestMatch, getBestMatchWithFeedback, getByCategory, getByIndustry, getByMood, getColorSystem, getColorSystemsByMood, getComponentLibrariesForFramework, getComponentLibrary, getComposition, getConfig, getDatabase, getDefaultIconLibrary, getDiskUsage, getEmbedding, getEmbeddingConfig, getEmbeddingCount, getFallbackDesignReference, getFeedbackBoost, getFeedbackCount, getFeedbackStats, getFileExtension, getFileName, getFontPairing, getFontPairingsByMood, getInspirationByCategory, getInspirationByPriority, getInteractionsByCategory, getLatestJobStatus, getLayoutPattern, getLayoutPatternsByUseCase, getLearningStats, getMicroInteraction, getModelDownloadUrl, getModelPath, getModelPaths, getPack, getPatternStats, getPreset, getPrimaryDesignReference, getPromotablePatternsFromDb, getPromotionCandidates, getRecentArtifacts, getRecommendations, getRecommendedLibrary, getRegistrySize, getSimilarArtifacts, getSnippetById, getTemplate, getTopArtifacts, getTrainingDataPath, getTrainingSummary, getVariants, groupBy, hasEnoughData, hashSkeleton, htmlToJsxAttributes, includesCaseInsensitive, initializeBackendRegistry, initializeInteractions, initializeRegistry, injectAnimations, isAdapterAvailable, isArray, isDuplicateConsecutive, isFunction, isLikelyAccepted, isModelAvailable, isModelLoaded, isNetworkError, isNumber, isObject, isPromotable, isString, isTraining, isValidComponentName, isValidEmail, isValidHexColor, isValidProjectName, isValidUrl, jsxToHtml, jsxToHtmlAttributes, jsxToSvelte, listAdapters, listModels, listPresets, loadConfig, loadEmbeddings, logger, mergeStyles, needsEnhancement, nextAppTemplate, nextSaasTemplate, parseStyleString, pluralize, promotePattern, queryArtifacts, reactEventsToHtml, reactEventsToSvelte, reactSpaTemplate, recommendStyle, recordGeneration as recordDiversityGeneration, recordExplicitFeedback, recordGeneratedArtifact, recordGeneration$1 as recordGeneration, recordPattern, reduxToolkitPattern as reduxToolkitPatterns, registerComposition, registerInteraction, registerInteractions, registerPack, registerSnippet, registerSnippets, resetSchemaInit, retry, runPromotionCycle, safeJSONParse, sanitizeClassName, scoreQuality, scoreQualityWithRAG, searchBackendSnippets, searchComponents, searchPacks, selectTemplate, semanticSearch, setupComponentLibraryProject, sortBy, startTrainingJob, stateManagementPatterns, storeArtifact, storeDesignLearning, storeEmbedding, storeEmbeddings, suggestDiverseVariant, tanstackQueryPattern as tanstackQueryPatterns, templateList, templates, toCamelCase, toKebabCase, toPascalCase, toSnakeCase, triggerPatternPromotion, truncate, unique, unloadModel, updateFeedbackScore, updateJobStatus, updateQualityScore, validateSnippet, validateSnippetStrict, writeJsonl, zustandPatterns };