@praxisui/visual-builder 4.0.0-beta.0 → 6.0.0-beta.0

package/index.d.ts

@@ -1,30 +1,49 @@
 import * as i0 from '@angular/core';
 import { EventEmitter, OnInit, OnDestroy, OnChanges, AfterViewInit, ElementRef, ChangeDetectorRef, SimpleChanges } from '@angular/core';
-import { ContextProvider, FunctionRegistry, ExportOptions as ExportOptions$1, ContextualSpecification, ValidationIssue as ValidationIssue$1 } from '@praxisui/specification';
-import { SpecificationMetadata, Specification } from '@praxisui/specification-core';
-export { SpecificationMetadata } from '@praxisui/specification-core';
+import { JsonLogicExpression, FormLayoutRule, RulePropertySchema, PraxisI18nService } from '@praxisui/core';
 import { Observable } from 'rxjs';
-import { FormLayoutRule, RulePropertySchema, PraxisI18nService } from '@praxisui/core';
-import { DslParsingConfig, DslParsingResult, DslParsingService, AiResponseValidatorService, AiRuleResponse } from '@praxisui/ai';
 import { MatDialog, MatDialogRef } from '@angular/material/dialog';
 import { MatSnackBar } from '@angular/material/snack-bar';
+import { AiResponseValidatorService, AiRuleResponse } from '@praxisui/ai';
 import { FormBuilder, FormGroup, FormControl, FormArray } from '@angular/forms';
 import { MatSelectChange } from '@angular/material/select';
 import { CdkDragDrop } from '@angular/cdk/drag-drop';
 import { MatButtonToggleChange } from '@angular/material/button-toggle';
-import { MatSlideToggleChange } from '@angular/material/slide-toggle';
 import { MatChipInputEvent } from '@angular/material/chips';
 
 /**
  * Models for the Visual Rule Builder
  */
 
+interface RuleContextProvider {
+    hasValue(path: string): boolean;
+    getValue<T = unknown>(path: string): T | undefined;
+}
+type RuleFunctionRegistry<T = unknown> = Record<string, T>;
+interface DocumentationLink {
+    title?: string;
+    url?: string;
+}
+interface SpecificationMetadata {
+    code?: string;
+    message?: string;
+    tag?: string;
+    description?: string;
+    priority?: string;
+    uiConfig?: Record<string, unknown>;
+    customProperties?: Record<string, unknown>;
+    conditionExpression?: JsonLogicExpression | null;
+    fallbackMetadata?: SpecificationMetadata;
+    internalNotes?: string;
+    documentationLinks?: DocumentationLink[];
+    [key: string]: unknown;
+}
 /**
  * Value types for rule configuration
  */
 type ValueType = 'literal' | 'field' | 'context' | 'function';
 /**
- * Valid comparison operators (aligned with @praxisui/specification)
+ * Valid comparison operators supported by the visual builder
  */
 type ValidComparisonOperator = 'eq' | 'neq' | 'lt' | 'lte' | 'gt' | 'gte' | 'contains' | 'startsWith' | 'endsWith' | 'in' | 'notIn' | 'matches' | 'notMatches' | 'isNull' | 'isNotNull' | 'isEmpty' | 'isNotEmpty';
 interface RuleNode {
@@ -80,12 +99,12 @@ declare enum RuleNodeType {
  * String literal type for rule node types (for flexibility)
  */
 type RuleNodeTypeString = 'fieldCondition' | 'propertyRule' | 'andGroup' | 'orGroup' | 'notGroup' | 'xorGroup' | 'impliesGroup' | 'requiredIf' | 'visibleIf' | 'disabledIf' | 'readonlyIf' | 'forEach' | 'uniqueBy' | 'minLength' | 'maxLength' | 'ifDefined' | 'ifNotNull' | 'ifExists' | 'withDefault' | 'functionCall' | 'fieldToField' | 'contextual' | 'atLeast' | 'exactly' | 'expression' | 'contextualTemplate' | 'custom';
-type RuleNodeConfig = FieldConditionConfig | PropertyRuleConfig | BooleanGroupConfig | ConditionalValidatorConfig | CollectionValidationConfig | CollectionValidatorConfig | OptionalFieldConfig | FunctionCallConfig | FieldToFieldConfig | ContextualConfig$1 | CardinalityConfig | ExpressionConfig | ContextualTemplateConfig | CustomConfig;
+type RuleNodeConfig = FieldConditionConfig | PropertyRuleConfig | BooleanGroupConfig | ConditionalValidatorConfig | CollectionValidationConfig | CollectionValidatorConfig | OptionalFieldConfig | FunctionCallConfig | FieldToFieldConfig | ContextualConfig | CardinalityConfig | ExpressionConfig | ContextualTemplateConfig | CustomConfig;
 interface FieldConditionConfig {
     type: 'fieldCondition';
     /** Primary field name */
     fieldName: string;
-    /** Comparison operator aligned with @praxisui/specification */
+    /** Comparison operator supported by the visual builder */
     operator: ValidComparisonOperator | string;
     /** Comparison value */
     value?: unknown;
@@ -109,8 +128,8 @@ interface PropertyRuleConfig {
     properties?: Record<string, any>;
     /** Properties applied when condition is false */
     propertiesWhenFalse?: Record<string, any>;
-    /** Optional condition node or inline DSL string */
-    condition?: RuleNode | string;
+    /** Optional condition node or inline condition expression */
+    condition?: RuleNode | JsonLogicExpression | null;
     /** Optional reference to a condition node inside the graph */
     conditionNodeId?: string;
     /** Metadata for UI/description */
@@ -169,7 +188,7 @@ interface ConditionalValidatorConfig {
     readonlyStyle?: string;
     /** Show readonly indicator */
     showReadonlyIndicator?: boolean;
-    /** Metadata aligned with @praxisui/specification */
+    /** Optional metadata for validation messages and UI hints */
     metadata?: SpecificationMetadata;
 }
 interface CollectionValidationConfig {
@@ -189,7 +208,6 @@ interface CollectionValidationConfig {
 }
 /**
  * Enhanced collection validator configuration (Phase 2 Implementation)
- * Aligned with @praxisui/specification collection validation patterns
  */
 interface CollectionValidatorConfig {
     type: 'forEach' | 'uniqueBy' | 'minLength' | 'maxLength';
@@ -282,14 +300,14 @@ interface FieldToFieldConfig {
     /** Optional metadata for validation */
     metadata?: SpecificationMetadata;
 }
-interface ContextualConfig$1 {
+interface ContextualConfig {
     type: 'contextual';
     /** Template string with context placeholders */
     template: string;
     /** Available context variables */
     contextVariables: Record<string, unknown>;
     /** Optional context provider for dynamic values */
-    contextProvider?: ContextProvider;
+    contextProvider?: RuleContextProvider;
     /** Strict validation of context tokens */
     strictContextValidation?: boolean;
     /** Optional metadata */
@@ -350,14 +368,12 @@ interface RuleBuilderState {
     rootNodes: string[];
     /** Currently selected node ID */
     selectedNodeId?: string;
-    /** Current DSL representation */
-    currentDSL?: string;
     /** Current JSON representation */
     currentJSON?: unknown;
     /** Validation errors */
     validationErrors: ValidationError$1[];
     /** Build mode */
-    mode: 'visual' | 'dsl' | 'json';
+    mode: 'visual' | 'json';
     /** Whether the rule is dirty (has unsaved changes) */
     isDirty: boolean;
     /** Undo/redo history */
@@ -389,10 +405,9 @@ interface RuleBuilderSnapshot {
         nodes: Record<string, RuleNode>;
         rootNodes: string[];
         selectedNodeId?: string;
-        currentDSL?: string;
         currentJSON?: any;
         validationErrors?: ValidationError$1[];
-        mode?: 'visual' | 'dsl' | 'json';
+        mode?: 'visual' | 'json';
         isDirty?: boolean;
     };
 }
@@ -461,15 +476,11 @@ interface TemplateMetadata {
  */
 interface ExportOptions {
     /** Export format */
-    format: 'json' | 'dsl' | 'typescript' | 'form-config';
+    format: 'json' | 'typescript' | 'form-config';
     /** Include metadata in export */
     includeMetadata?: boolean;
-    /** Pretty print JSON/DSL */
+    /** Pretty print JSON */
     prettyPrint?: boolean;
-    /** Include comments in DSL */
-    includeComments?: boolean;
-    /** Metadata position in DSL */
-    metadataPosition?: 'before' | 'after' | 'inline';
     /** TypeScript interface name (for TS export) */
     interfaceName?: string;
     /** Additional export configuration */
@@ -480,7 +491,7 @@ interface ExportOptions {
  */
 interface ImportOptions {
     /** Source format */
-    format: 'json' | 'dsl' | 'form-config';
+    format: 'json' | 'form-config';
     /** Whether to merge with existing rules */
     merge?: boolean;
     /** Whether to preserve existing metadata */
@@ -529,8 +540,6 @@ interface RuleBuilderConfig {
         showAdvanced?: boolean;
         /** Enable drag and drop */
         enableDragDrop?: boolean;
-        /** Show DSL preview */
-        showDSLPreview?: boolean;
         /** Show validation errors inline */
         showInlineErrors?: boolean;
         /** Auto-save interval (ms) */
@@ -548,7 +557,7 @@ interface RuleBuilderConfig {
     /** Export/import configuration */
     exportImport?: {
         /** Default export format */
-        defaultExportFormat?: 'json' | 'dsl' | 'typescript';
+        defaultExportFormat?: 'json' | 'typescript';
         /** Supported formats */
         supportedFormats?: string[];
         /** Include metadata by default */
@@ -572,27 +581,27 @@ interface OptionalFieldConfig {
     metadata?: SpecificationMetadata;
 }
 /**
- * Configuration for expression specifications (aligned with @praxisui/specification)
+ * Configuration for legacy expression authoring support
  */
 interface ExpressionConfig {
     type: 'expression';
-    /** DSL expression string */
+    /** Legacy textual expression string */
     expression: string;
     /** Function registry for validation */
-    functionRegistry?: FunctionRegistry<unknown>;
+    functionRegistry?: RuleFunctionRegistry<unknown>;
     /** Context provider for variable resolution */
-    contextProvider?: ContextProvider;
+    contextProvider?: RuleContextProvider;
     /** Known field names for validation */
     knownFields?: string[];
     /** Enable performance warnings */
     enablePerformanceWarnings?: boolean;
     /** Maximum expression complexity */
     maxComplexity?: number;
-    /** Metadata aligned with @praxisui/specification */
+    /** Optional metadata for UI/description */
     metadata?: SpecificationMetadata;
 }
 /**
- * Configuration for contextual template specifications (aligned with @praxisui/specification)
+ * Configuration for contextual template authoring
  */
 interface ContextualTemplateConfig {
     type: 'contextualTemplate';
@@ -601,10 +610,10 @@ interface ContextualTemplateConfig {
     /** Available context variables */
     contextVariables?: Record<string, unknown>;
     /** Context provider instance */
-    contextProvider?: ContextProvider;
+    contextProvider?: RuleContextProvider;
     /** Enable strict validation of context tokens */
     strictContextValidation?: boolean;
-    /** Metadata aligned with @praxisui/specification */
+    /** Optional metadata for UI/description */
     metadata?: SpecificationMetadata;
 }
 
@@ -984,20 +993,6 @@ interface ValidationResult {
     errors: string[];
 }
 
-type DslContextScope = 'user' | 'session' | 'env' | 'global' | string;
-interface DslContextVariable {
-    /** Variable name */
-    name: string;
-    /** Variable type */
-    type: 'string' | 'number' | 'boolean' | 'date' | 'object' | 'array';
-    /** Variable scope */
-    scope: DslContextScope;
-    /** Description */
-    description?: string;
-    /** Example value */
-    example?: string;
-}
-
 /**
  * Registry service for managing RuleNode instances and their relationships.
  * Solves the core problem of resolving string IDs to actual RuleNode objects.
@@ -1187,479 +1182,18 @@ interface CleanupResult {
     memoryFreed: number;
 }
 
-/**
- * Context interface for rule conversion operations
- * Eliminates circular dependencies between converters and factory
- */
-interface ConversionContext {
-    /**
-     * Convert a child node to a specification
-     * This method is provided by the factory to avoid circular dependencies
-     */
-    convertChild<T extends object = any>(node: RuleNode): Specification<T>;
-    /**
-     * Convert multiple child nodes to specifications
-     */
-    convertChildren<T extends object = any>(nodes: RuleNode[]): Specification<T>[];
-    /**
-     * Check if a node type is supported
-     */
-    isSupported(nodeType: string): boolean;
-    /**
-     * Validate that a node can be converted
-     */
-    validateNode(node: RuleNode): {
-        isValid: boolean;
-        errors: string[];
-    };
-}
-
-/**
- * Interface for rule converters that transform RuleNodes to Specifications
- */
-interface RuleConverter {
-    /**
-     * Convert a RuleNode to a Specification
-     * @param node The node to convert
-     * @param context Context providing access to child conversion capabilities
-     */
-    convert<T extends object = any>(node: RuleNode, context?: ConversionContext): Specification<T>;
-    /**
-     * Check if this converter can handle the given node type
-     */
-    canConvert(nodeType: string): boolean;
-    /**
-     * Get the supported node types
-     */
-    getSupportedTypes(): string[];
-    /**
-     * Set the conversion context (called by factory during initialization)
-     */
-    setContext?(context: ConversionContext): void;
-}
-/**
- * Base abstract class for rule converters
- */
-declare abstract class BaseRuleConverter implements RuleConverter {
-    protected abstract supportedTypes: string[];
-    protected context?: ConversionContext;
-    abstract convert<T extends object = any>(node: RuleNode, context?: ConversionContext): Specification<T>;
-    /**
-     * Set the conversion context
-     */
-    setContext(context: ConversionContext): void;
-    canConvert(nodeType: string): boolean;
-    getSupportedTypes(): string[];
-    protected validateNode(node: RuleNode, expectedType?: string): void;
-}
-
-/**
- * Converter for field condition rules to field specifications
- */
-declare class FieldConditionConverter extends BaseRuleConverter {
-    protected supportedTypes: string[];
-    convert<T extends object>(node: RuleNode, context?: ConversionContext): Specification<T>;
-    private mapOperator;
-    private convertValue;
-    private inferAndConvertValue;
-    private operatorRequiresValue;
-    private defaultValueForOperator;
-    private getImpliedValue;
-    static ɵfac: i0.ɵɵFactoryDeclaration<FieldConditionConverter, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<FieldConditionConverter>;
-}
-
-/**
- * Converter for boolean group rules (AND, OR, NOT, XOR, IMPLIES)
- */
-declare class BooleanGroupConverter extends BaseRuleConverter {
-    private nodeRegistry;
-    protected supportedTypes: string[];
-    constructor(nodeRegistry: RuleNodeRegistryService);
-    convert<T extends object>(node: RuleNode, context?: ConversionContext): Specification<T>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<BooleanGroupConverter, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<BooleanGroupConverter>;
-}
-
-/**
- * Converter for cardinality rules (atLeast, exactly)
- */
-declare class CardinalityConverter extends BaseRuleConverter {
-    private nodeRegistry;
-    protected supportedTypes: string[];
-    constructor(nodeRegistry: RuleNodeRegistryService);
-    convert<T extends object>(node: RuleNode, context?: ConversionContext): Specification<T>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<CardinalityConverter, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<CardinalityConverter>;
-}
-
-/**
- * Factory service for converting RuleNodes to Specifications
- * Uses Strategy pattern to delegate to appropriate converters
- */
-declare class ConverterFactoryService {
-    private fieldConditionConverter;
-    private booleanGroupConverter;
-    private cardinalityConverter;
-    private converters;
-    private context;
-    constructor(fieldConditionConverter: FieldConditionConverter, booleanGroupConverter: BooleanGroupConverter, cardinalityConverter: CardinalityConverter);
-    /**
-     * Convert a RuleNode to a Specification
-     */
-    convert<T extends object = any>(node: RuleNode): Specification<T>;
-    /**
-     * Get converter for a specific node type
-     */
-    getConverter(nodeType: string): RuleConverter | undefined;
-    /**
-     * Register a new converter
-     */
-    registerConverter(name: string, converter: RuleConverter): void;
-    /**
-     * Unregister a converter
-     */
-    unregisterConverter(name: string): boolean;
-    /**
-     * Get all supported node types
-     */
-    getSupportedTypes(): string[];
-    /**
-     * Check if a node type is supported
-     */
-    isSupported(nodeType: string): boolean;
-    private initializeContext;
-    /**
-     * Internal convert method that bypasses context to avoid recursion
-     */
-    private convertInternal;
-    private initializeConverters;
-    /**
-     * Convert multiple nodes to specifications
-     */
-    convertMultiple<T extends object = any>(nodes: RuleNode[]): Specification<T>[];
-    /**
-     * Validate that a node can be converted
-     */
-    validateNode(node: RuleNode): {
-        isValid: boolean;
-        errors: string[];
-    };
-    /**
-     * Get statistics about converter usage
-     */
-    getStatistics(): ConverterStatistics;
-    static ɵfac: i0.ɵɵFactoryDeclaration<ConverterFactoryService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<ConverterFactoryService>;
-}
-/**
- * Statistics about the converter factory
- */
-interface ConverterStatistics {
-    converterCount: number;
-    supportedTypeCount: number;
-    supportedTypes: string[];
-    converterNames: string[];
-}
-
-/**
- * Configuration for contextual specification support
- */
-interface SpecificationContextualConfig {
-    /** Context variables available for token resolution */
-    contextVariables?: DslContextVariable[];
-    /** Context provider instance */
-    contextProvider?: ContextProvider;
-    /** Enable strict validation of context tokens */
-    strictContextValidation?: boolean;
-}
-declare class SpecificationBridgeService {
-    private nodeRegistry;
-    private converterFactory;
-    private dslExporter;
-    private dslParser;
-    private dslValidator;
-    private contextProvider?;
-    constructor(nodeRegistry: RuleNodeRegistryService, converterFactory: ConverterFactoryService);
-    /**
-     * Converts a RuleNode tree to a Specification instance
-     */
-    ruleNodeToSpecification<T extends object = any>(node: RuleNode): Specification<T>;
-    private registerSubtree;
-    /**
-     * Converts a Specification instance to a RuleNode tree
-     */
-    specificationToRuleNode<T extends object = any>(spec: Specification<T>): RuleNode;
-    /**
-     * Exports a RuleNode tree to DSL format
-     */
-    exportToDsl<T extends object = any>(node: RuleNode, options?: Partial<ExportOptions$1>): string;
-    /**
-     * Exports a RuleNode tree to DSL format with metadata
-     */
-    exportToDslWithMetadata<T extends object = any>(node: RuleNode): string;
-    /**
-     * Validates that a RuleNode can be successfully round-tripped
-     */
-    validateRoundTrip<T extends object = any>(node: RuleNode): {
-        success: boolean;
-        errors: string[];
-        warnings: string[];
-    };
-    /**
-     * Performs deep validation between original and reconstructed nodes
-     */
-    private deepValidateRoundTrip;
-    /**
-     * Compares two configuration objects
-     */
-    private compareConfigs;
-    /**
-     * Validates DSL round-trip conversion
-     */
-    private validateDslRoundTrip;
-    /**
-     * Parses a DSL expression string into a Specification
-     */
-    parseDslExpression<T extends object = any>(expression: string, config?: DslParsingConfig): DslParsingResult<T>;
-    /**
-     * Creates a ContextualSpecification with token resolution
-     */
-    createContextualSpecification<T extends object = any>(template: string, config?: SpecificationContextualConfig): ContextualSpecification<T>;
-    /**
-     * Resolves context tokens in a template using provided variables
-     */
-    resolveContextTokens(template: string, contextVariables: DslContextVariable[]): string;
-    /**
-     * Extracts all context tokens from a template
-     */
-    extractContextTokens(template: string): string[];
-    /**
-     * Validates that all context tokens in a template have corresponding variables
-     */
-    validateContextTokens(template: string, contextVariables: DslContextVariable[]): ValidationIssue$1[];
-    /**
-     * Converts a DSL expression to a ContextualSpecification
-     */
-    dslToContextualSpecification<T extends object = any>(dslExpression: string, config?: SpecificationContextualConfig): ContextualSpecification<T>;
-    /**
-     * Converts a ContextualSpecification back to DSL template
-     */
-    contextualSpecificationToDsl<T extends object = any>(spec: ContextualSpecification<T>): string;
-    /**
-     * Performs round-trip validation for expression specifications
-     */
-    validateExpressionRoundTrip<T extends object = any>(originalExpression: string, config?: DslParsingConfig): {
-        success: boolean;
-        errors: string[];
-        warnings: string[];
-        reconstructedExpression?: string;
-    };
-    /**
-     * Updates the context provider for contextual specifications
-     */
-    updateContextProvider(contextProvider: ContextProvider): void;
-    /**
-     * Gets the current context provider
-     */
-    getContextProvider(): ContextProvider | undefined;
-    /**
-     * Gets expected DSL keywords for a given node type
-     */
-    private getExpectedDslKeywords;
-    private createFieldSpecification;
-    private createBooleanGroupSpecification;
-    private createFunctionSpecification;
-    private createFieldToFieldSpecification;
-    private createCardinalitySpecification;
-    /**
-     * Creates conditional validator specifications (Phase 1 implementation)
-     */
-    private createConditionalValidatorSpecification;
-    /**
-     * Creates collection validator specifications (Phase 2 implementation)
-     */
-    private createCollectionValidatorSpecification;
-    /**
-     * Creates expression specification from DSL (Phase 4 implementation)
-     */
-    private createExpressionSpecification;
-    /**
-     * Creates contextual specification (Phase 4 implementation)
-     */
-    private createContextualSpecificationFromNode;
-    private convertToComparisonOperator;
-    private convertValue;
-    private comparisonExpectsValue;
-    private defaultValueForOperator;
-    private getImpliedValueForOperator;
-    private jsonToRuleNode;
-    private mapSpecificationTypeToNodeType;
-    private mapComparisonOperator;
-    private inferValueType;
-    private generateNodeId;
-    private generateNodeLabel;
-    /**
-     * Creates a context provider from context variables
-     */
-    private createContextProviderFromVariables;
-    /**
-     * Calculates complexity of a DSL expression
-     */
-    private calculateComplexity;
-    /**
-     * Finds the position of a token in a template
-     */
-    private findTokenPosition;
-    /**
-     * Suggests similar variable names using Levenshtein distance
-     */
-    private suggestSimilarVariable;
-    /**
-     * Calculates Levenshtein distance between two strings
-     */
-    private levenshteinDistance;
-    /**
-     * Parses a value expression. Phase 1 shim: accepts strings starting with '=' or { expr } objects.
-     * Returns success when the shape is acceptable; full DSL parsing will be integrated in Phase 2.
-     */
-    parseDslExpressionValue(expression: string | {
-        expr: string;
-    } | null | undefined, _config?: DslParsingConfig): {
-        success: boolean;
-        issues: string[];
-    };
-    /**
-     * Evaluates a value expression with a row context. Phase 1 shim: executes simple '=' expressions in a sandboxed Function.
-     * In Phase 2, this will use the real DSL evaluator from @praxisui/specification.
-     */
-    evaluateValue(expression: string | {
-        expr: string;
-    }, ctx: {
-        row: any;
-    }): any;
-    static ɵfac: i0.ɵɵFactoryDeclaration<SpecificationBridgeService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<SpecificationBridgeService>;
-}
-
-interface RoundTripValidationResult {
-    success: boolean;
-    errors: ValidationError$1[];
-    warnings: ValidationError$1[];
-    stages: {
-        visualToSpecification: {
-            success: boolean;
-            error?: string;
-        };
-        specificationToDsl: {
-            success: boolean;
-            error?: string;
-            dsl?: string;
-        };
-        dslToSpecification: {
-            success: boolean;
-            error?: string;
-        };
-        specificationToVisual: {
-            success: boolean;
-            error?: string;
-        };
-    };
-    dataIntegrity: {
-        nodeCountMatch: boolean;
-        structureMatch: boolean;
-        metadataPreserved: boolean;
-        logicPreserved: boolean;
-    };
-    performance: {
-        totalTime: number;
-        stageTimings: Record<string, number>;
-    };
-}
-interface RoundTripTestCase {
-    id: string;
-    name: string;
-    description: string;
-    visualRule: RuleNode;
-    expectedDsl?: string;
-    expectedValidation?: {
-        shouldSucceed: boolean;
-        expectedErrors?: string[];
-        expectedWarnings?: string[];
-    };
-    relatedNodes?: RuleNode[];
-}
-declare class RoundTripValidatorService {
-    private specificationBridge;
-    private nodeRegistry;
-    private dslParser;
-    constructor(specificationBridge: SpecificationBridgeService, nodeRegistry: RuleNodeRegistryService);
-    /**
-     * Validates complete round-trip conversion: Visual → DSL → Visual
-     */
-    validateRoundTrip(visualRule: RuleNode, relatedNodes?: RuleNode[]): RoundTripValidationResult;
-    /**
-     * Validates data integrity between original and reconstructed visual rules
-     */
-    private validateDataIntegrity;
-    /**
-     * Validates that the logical structure is preserved
-     */
-    private validateStructureMatch;
-    /**
-     * Validates that metadata is preserved through the round-trip
-     */
-    private validateMetadataPreservation;
-    /**
-     * Validates that the logical meaning is preserved
-     */
-    private validateLogicPreservation;
-    /**
-     * Counts total number of nodes in a rule tree
-     */
-    private countNodes;
-    /**
-     * Runs a comprehensive test suite for round-trip validation
-     */
-    runTestSuite(testCases: RoundTripTestCase[]): {
-        totalTests: number;
-        passed: number;
-        failed: number;
-        results: Array<{
-            testCase: RoundTripTestCase;
-            result: RoundTripValidationResult;
-        }>;
-    };
-    /**
-     * Validates test expectations against results
-     */
-    private validateExpectations;
-    /**
-     * Creates default test cases for common rule patterns
-     */
-    createDefaultTestCases(): RoundTripTestCase[];
-    private generateErrorId;
-    static ɵfac: i0.ɵɵFactoryDeclaration<RoundTripValidatorService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<RoundTripValidatorService>;
-}
-
 declare class RuleBuilderService {
-    private specificationBridge;
-    private roundTripValidator;
     private nodeRegistry;
     private readonly _state;
     private readonly _validationErrors;
     private readonly _nodeSelected;
     private readonly _stateChanged;
     private config;
-    private dslExporter;
-    private dslValidator;
-    private dslParser;
     readonly state$: Observable<RuleBuilderState>;
     readonly validationErrors$: Observable<ValidationError$1[]>;
     readonly nodeSelected$: Observable<string>;
     readonly stateChanged$: Observable<void>;
-    constructor(specificationBridge: SpecificationBridgeService, roundTripValidator: RoundTripValidatorService, nodeRegistry: RuleNodeRegistryService);
+    constructor(nodeRegistry: RuleNodeRegistryService);
     /**
      * Initialize the rule builder with configuration
      */
@@ -1716,37 +1250,28 @@ declare class RuleBuilderService {
      * Export rules to JSON payload
      */
     export(options: ExportOptions): string;
-    /**
-     * Convert current builder state to Specification (best-effort)
-     */
-    toSpecification(): Specification<any> | null;
+    toSpecification(): null;
     private updateState;
     /**
      * Validate current rules (lightweight placeholder)
      */
     validateRules(): void;
-    /**
-     * Replace builder state with a parsed DSL graph without reinitializing the service.
-     */
-    loadFromParsedDsl(nodes: Record<string, RuleNode>, rootNodes: string[], description?: string): void;
-    /**
-     * Update builder state with a parsed DSL graph while preserving history.
-     */
-    updateFromParsedDsl(nodes: Record<string, RuleNode>, rootNodes: string[], description?: string): void;
+    loadFromConditionExpression(condition: JsonLogicExpression, description?: string): void;
+    buildConditionExpressionFromGraph(nodes: Record<string, RuleNode>, rootNodes: string[]): JsonLogicExpression | null;
     private saveSnapshot;
     private generateNodeLabel;
     private withRuleTimestamps;
     private isPropertyRuleNode;
     private containsPropertyRule;
     /**
-     * Constrói um array de FormLayoutRule a partir do estado atual do builder,
-     * focando em nós propertyRule ou nós com propriedades/targets definidos.
+     * Constrói um array de FormLayoutRule a partir do estado atual do builder,
+     * focando em nós propertyRule ou nós com propriedades/targets definidos.
      */
     private exportFormRulesFromState;
     private toFormLayoutRule;
     private normalizeTargets;
-    private buildDslFromCondition;
-    private buildDslFromState;
+    private buildJsonLogicFromCondition;
+    private buildJsonLogicFromState;
     private applyBuilderState;
     private extractFormRules;
     private isFormRuleCandidate;
@@ -1756,8 +1281,18 @@ declare class RuleBuilderService {
     private sanitizeStructuredValue;
     private formRulesToBuilderState;
     private inferRuleTypeFromFormRule;
-    private parseSimpleCondition;
+    private parseConditionExpression;
+    private normalizeJsonLogicCondition;
+    private parseJsonLogicCondition;
+    private parseJsonLogicChild;
     private normalizeOperator;
+    private builderOperatorToJsonLogicOperator;
+    private jsonLogicOperatorToBuilderOperator;
+    private normalizeConditionValue;
+    private isJsonLogicExpressionCandidate;
+    private isVarExpression;
+    private extractVarPath;
+    private flattenConditionNodes;
     private prefixTarget;
     private buildRuleNodeTree;
     private flattenRuleNodeTree;
@@ -1827,10 +1362,9 @@ interface ExternalSystemConfig {
 }
 declare class ExportIntegrationService {
     private ruleBuilderService;
-    private specificationBridge;
     private readonly SUPPORTED_FORMATS;
     private externalSystems;
-    constructor(ruleBuilderService: RuleBuilderService, specificationBridge: SpecificationBridgeService);
+    constructor(ruleBuilderService: RuleBuilderService);
     /**
      * Gets all supported export formats
      */
@@ -1906,7 +1440,6 @@ declare class ExportIntegrationService {
     private generateContent;
     private generateJson;
     private generateJsonSchema;
-    private generateDsl;
     private generateYaml;
     private generateXml;
     private generateTypeScript;
@@ -2131,7 +1664,6 @@ interface TemplateStats {
     popularTags: string[];
 }
 declare class RuleTemplateService {
-    private bridgeService;
     private readonly STORAGE_KEY;
     private readonly VERSION_KEY;
     private readonly CURRENT_VERSION;
@@ -2141,7 +1673,7 @@ declare class RuleTemplateService {
     templates$: Observable<RuleTemplate[]>;
     categories$: Observable<TemplateCategory[]>;
     recentlyUsed$: Observable<RuleTemplate[]>;
-    constructor(bridgeService: SpecificationBridgeService);
+    constructor();
     /**
      * Get all templates
      */
@@ -2359,17 +1891,6 @@ interface ContextEntry {
     /** Optional type hint for validation */
     type?: string;
 }
-/**
- * Configuration for contextual specification support
- */
-interface ContextualConfig {
-    /** Context variables available for token resolution */
-    contextVariables?: ContextEntry[];
-    /** Context provider instance */
-    contextProvider?: ContextProvider;
-    /** Enable strict validation of context tokens */
-    strictContextValidation?: boolean;
-}
 /**
  * Context variable value with metadata
  */
@@ -2398,7 +1919,7 @@ interface ContextScope {
 }
 /**
  * Dedicated service for context management and variable resolution
- * Extracted from SpecificationBridgeService to follow SRP
+ * Extracted from the old bridge-oriented implementation to follow SRP
  */
 declare class ContextManagementService {
     private scopes;
@@ -2407,7 +1928,7 @@ declare class ContextManagementService {
     /**
      * Create a context provider from context variables
      */
-    createContextProvider(contextVariables: ContextEntry[]): ContextProvider;
+    createContextProvider(contextVariables: ContextEntry[]): RuleContextProvider;
     /**
      * Create a new context scope
      */
@@ -2434,11 +1955,11 @@ declare class ContextManagementService {
     /**
      * Create a scoped context provider
      */
-    createScopedProvider(scopeId: string): ContextProvider;
+    createScopedProvider(scopeId: string): RuleContextProvider;
     /**
      * Merge multiple context providers
      */
-    mergeProviders(...providers: ContextProvider[]): ContextProvider;
+    mergeProviders(...providers: RuleContextProvider[]): RuleContextProvider;
     /**
      * Get context statistics
      */
@@ -2462,69 +1983,6 @@ declare class ContextManagementService {
     static ɵprov: i0.ɵɵInjectableDeclaration<ContextManagementService>;
 }
 
-/**
- * Simplified service for core rule conversion operations
- * Replaces the God Service anti-pattern from SpecificationBridgeService
- * Focuses only on conversion between RuleNodes and Specifications
- */
-declare class RuleConversionService {
-    private converterFactory;
-    private dslParsingService;
-    private contextManagementService;
-    private dslExporter;
-    constructor(converterFactory: ConverterFactoryService, dslParsingService: DslParsingService, contextManagementService: ContextManagementService);
-    /**
-     * Convert a RuleNode tree to a Specification instance
-     * Core conversion functionality with clean error handling
-     */
-    convertRuleToSpecification<T extends object = any>(node: RuleNode): Specification<T>;
-    /**
-     * Convert a Specification back to a RuleNode tree
-     * Simplified reverse conversion
-     */
-    convertSpecificationToRule<T extends object = any>(spec: Specification<T>): RuleNode;
-    /**
-     * Export a RuleNode tree to DSL format
-     */
-    exportRuleToDsl<T extends object = any>(node: RuleNode, options?: Partial<ExportOptions$1>): string;
-    /**
-     * Import a RuleNode tree from DSL format
-     */
-    importRuleFromDsl<T extends object = any>(dslExpression: string, config?: DslParsingConfig): DslParsingResult<T>;
-    /**
-     * Create a contextual specification from a RuleNode
-     */
-    createContextualSpecification<T extends object = any>(node: RuleNode, contextConfig: ContextualConfig): Specification<T>;
-    /**
-     * Validate that a rule can be converted
-     */
-    validateConversion(node: RuleNode): ConversionValidationResult;
-    /**
-     * Get conversion statistics
-     */
-    getConversionStatistics(): ConversionStatistics;
-    private jsonToRuleNode;
-    static ɵfac: i0.ɵɵFactoryDeclaration<RuleConversionService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<RuleConversionService>;
-}
-/**
- * Result of conversion validation
- */
-interface ConversionValidationResult {
-    isValid: boolean;
-    errors: string[];
-    warnings: string[];
-}
-/**
- * Statistics about conversion capabilities
- */
-interface ConversionStatistics {
-    supportedNodeTypes: number;
-    registeredConverters: number;
-    availableNodeTypes: string[];
-    converterNames: string[];
-}
-
 /**
  * Typed error system for Visual Builder operations
  * Provides structured error handling with codes, categories, and context
@@ -2536,7 +1994,7 @@ declare enum ErrorCategory {
     VALIDATION = "validation",
     CONVERSION = "conversion",
     REGISTRY = "registry",
-    DSL = "dsl",
+    EXPRESSION = "expression",
     CONTEXT = "context",
     CONFIGURATION = "configuration",
     NETWORK = "network",
@@ -2599,16 +2057,16 @@ declare class RegistryError extends VisualBuilderError {
     constructor(operation: string, message: string, nodeId?: string | undefined, context?: Record<string, any>);
 }
 /**
- * DSL parsing and processing errors
+ * Expression parsing and processing errors
  */
-declare class DslError extends VisualBuilderError {
+declare class ExpressionError extends VisualBuilderError {
     readonly expression?: string | undefined;
     readonly position?: {
         start: number;
         end: number;
     } | undefined;
     readonly code: string;
-    readonly category = ErrorCategory.DSL;
+    readonly category = ErrorCategory.EXPRESSION;
     readonly severity = ErrorSeverity.HIGH;
     constructor(type: 'PARSING' | 'VALIDATION' | 'EXPORT' | 'IMPORT', message: string, expression?: string | undefined, position?: {
         start: number;
@@ -2715,7 +2173,7 @@ declare const createError: {
     validation: (message: string, nodeId?: string, rules?: string[]) => ValidationError;
     conversion: (code: string, message: string, nodeId?: string) => ConversionError;
     registry: (operation: string, message: string, nodeId?: string) => RegistryError;
-    dsl: (type: "PARSING" | "VALIDATION" | "EXPORT" | "IMPORT", message: string, expression?: string) => DslError;
+    expression: (type: "PARSING" | "VALIDATION" | "EXPORT" | "IMPORT", message: string, expression?: string) => ExpressionError;
     context: (operation: string, message: string, scopeId?: string, variablePath?: string) => ContextError;
     configuration: (message: string, configPath?: string, expectedType?: string) => ConfigurationError;
     internal: (message: string, cause?: Error) => InternalError;
@@ -2727,7 +2185,7 @@ type RuleNodeConfigExtended = RuleNodeConfig & {
     properties?: Record<string, any>;
     propertiesWhenFalse?: Record<string, any>;
     targets?: string[];
-    condition?: RuleNode | string | null;
+    condition?: RuleNode | JsonLogicExpression | null;
 };
 declare class RuleEditorComponent implements OnInit, OnDestroy, OnChanges, AfterViewInit {
     private readonly ruleBuilderService;
@@ -3134,77 +2592,13 @@ declare class MetadataEditorComponent implements OnInit, OnChanges {
     removeCustomProperty(index: number): void;
     addDocumentationLink(): void;
     removeDocumentationLink(index: number): void;
+    private stringifyJsonEditorValue;
+    private parseJsonEditorObject;
+    private static readonly invalidJsonEditorValue;
     static ɵfac: i0.ɵɵFactoryDeclaration<MetadataEditorComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<MetadataEditorComponent, "praxis-metadata-editor", never, { "selectedNode": { "alias": "selectedNode"; "required": false; }; }, { "metadataUpdated": "metadataUpdated"; }, never, never, true, never>;
 }
 
-declare class DslViewerComponent implements OnInit, OnChanges, AfterViewInit {
-    private snackBar;
-    dsl: string;
-    editable: boolean;
-    language: string;
-    theme: string;
-    dslChanged: EventEmitter<string>;
-    validationChanged: EventEmitter<{
-        valid: boolean;
-        errors: any[];
-        warnings: any[];
-    }>;
-    editorTextarea?: ElementRef<HTMLTextAreaElement>;
-    syntaxOverlay?: ElementRef<HTMLDivElement>;
-    private originalDsl;
-    private parser;
-    private validator;
-    hasChanges: boolean;
-    showErrors: boolean;
-    syntaxErrors: any[];
-    warnings: any[];
-    cursorPosition: {
-        line: number;
-        column: number;
-    } | null;
-    currentDsl: string;
-    showLineNumbers: boolean;
-    wordWrap: boolean;
-    showMinimap: boolean;
-    highlightedDsl: string;
-    constructor(snackBar: MatSnackBar);
-    ngOnInit(): void;
-    ngAfterViewInit(): void;
-    ngOnChanges(changes: SimpleChanges): void;
-    ngOnDestroy(): void;
-    get themeClass(): string;
-    private setEditorValue;
-    getEditorValue(): string;
-    onEditorInput(event: Event): void;
-    private updateEditorOptions;
-    syncScroll(): void;
-    updateCursorPosition(): void;
-    private validateSyntaxDebounced;
-    private debounce;
-    getValidationStatusClass(): string;
-    getValidationIcon(): string;
-    getValidationText(): string;
-    getEditorInfo(): string;
-    formatCode(): void;
-    validateSyntax(): void;
-    applyChanges(): void;
-    discardChanges(): void;
-    copyToClipboard(): void;
-    downloadDsl(): void;
-    toggleLineNumbers(): void;
-    toggleWordWrap(): void;
-    toggleMinimap(): void;
-    showErrorDetails(): void;
-    hideErrorDetails(): void;
-    goToError(error: any): void;
-    private formatDslCode;
-    private validateDslSyntax;
-    private updateSyntaxHighlighting;
-    static ɵfac: i0.ɵɵFactoryDeclaration<DslViewerComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<DslViewerComponent, "praxis-dsl-viewer", never, { "dsl": { "alias": "dsl"; "required": false; }; "editable": { "alias": "editable"; "required": false; }; "language": { "alias": "language"; "required": false; }; "theme": { "alias": "theme"; "required": false; }; }, { "dslChanged": "dslChanged"; "validationChanged": "validationChanged"; }, never, never, true, never>;
-}
-
 declare class JsonViewerComponent implements OnInit, OnChanges {
     private snackBar;
     json: any;
@@ -3239,40 +2633,6 @@ declare class JsonViewerComponent implements OnInit, OnChanges {
     static ɵcmp: i0.ɵɵComponentDeclaration<JsonViewerComponent, "praxis-json-viewer", never, { "json": { "alias": "json"; "required": false; }; "editable": { "alias": "editable"; "required": false; }; }, { "jsonChanged": "jsonChanged"; }, never, never, true, never>;
 }
 
-declare class RoundTripTesterComponent implements OnInit {
-    private roundTripValidator;
-    private ruleBuilderService;
-    private snackBar;
-    private cdr;
-    private nodeRegistry;
-    isRunning: boolean;
-    showTestCases: boolean;
-    lastTestResult: RoundTripValidationResult | null;
-    testSuiteResults: any;
-    defaultTestCases: RoundTripTestCase[];
-    hasCurrentRule: boolean;
-    constructor(roundTripValidator: RoundTripValidatorService, ruleBuilderService: RuleBuilderService, snackBar: MatSnackBar, cdr: ChangeDetectorRef, nodeRegistry: RuleNodeRegistryService);
-    ngOnInit(): void;
-    private loadDefaultTestCases;
-    private checkCurrentRule;
-    runCurrentRuleTest(): void;
-    runTestSuite(): void;
-    clearResults(): void;
-    private buildCompleteRuleTree;
-    getCurrentRuleType(): string;
-    getCurrentRuleLabel(): string;
-    getTestCaseColor(testCase: RoundTripTestCase): 'primary' | 'accent' | 'warn';
-    getResultSummary(): string;
-    getStatusClass(result: RoundTripValidationResult): string;
-    getStatusIcon(result: RoundTripValidationResult): string;
-    getStages(result: RoundTripValidationResult): any[];
-    getIntegrityChecks(result: RoundTripValidationResult): any[];
-    getSuccessRate(): number;
-    getSuccessRateClass(): string;
-    static ɵfac: i0.ɵɵFactoryDeclaration<RoundTripTesterComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<RoundTripTesterComponent, "praxis-round-trip-tester", never, {}, {}, never, never, true, never>;
-}
-
 interface ExportDialogData {
     title?: string;
     allowMultipleFormats?: boolean;
@@ -3329,121 +2689,6 @@ declare class ExportDialogComponent implements OnInit {
     static ɵcmp: i0.ɵɵComponentDeclaration<ExportDialogComponent, "praxis-export-dialog", never, {}, {}, never, never, true, never>;
 }
 
-interface DslLintError {
-    id: string;
-    line: number;
-    column: number;
-    length: number;
-    severity: 'error' | 'warning' | 'info' | 'hint';
-    code: string;
-    message: string;
-    suggestion?: string;
-    quickFix?: DslQuickFix;
-    category: 'syntax' | 'semantic' | 'style' | 'performance' | 'best-practice';
-    tags?: string[];
-}
-interface DslQuickFix {
-    title: string;
-    description: string;
-    edits: DslEdit[];
-}
-interface DslEdit {
-    range: {
-        startLine: number;
-        startColumn: number;
-        endLine: number;
-        endColumn: number;
-    };
-    newText: string;
-}
-interface DslLintStats {
-    totalErrors: number;
-    totalWarnings: number;
-    totalInfos: number;
-    totalHints: number;
-    complexity: number;
-    maintainabilityIndex: number;
-    lastLintTime: Date;
-    lintDuration: number;
-}
-interface DslLintRule {
-    id: string;
-    name: string;
-    description: string;
-    category: string;
-    severity: 'error' | 'warning' | 'info' | 'hint';
-    enabled: boolean;
-    configurable: boolean;
-    config?: any;
-}
-declare class DslLinterComponent implements OnInit, OnDestroy {
-    private ruleBuilderService;
-    private specificationBridge;
-    private cdr;
-    dsl: string;
-    autoLint: boolean;
-    lintDelay: number;
-    errorSelected: EventEmitter<DslLintError>;
-    quickFixApplied: EventEmitter<{
-        error: DslLintError;
-        fix: DslQuickFix;
-    }>;
-    ruleToggled: EventEmitter<{
-        rule: DslLintRule;
-        enabled: boolean;
-    }>;
-    private destroy$;
-    private lintSubject;
-    isLinting: boolean;
-    activeTabIndex: number;
-    allErrors: DslLintError[];
-    filteredErrors: DslLintError[];
-    selectedSeverities: string[];
-    selectedCategories: string[];
-    stats: DslLintStats;
-    lintRules: DslLintRule[];
-    constructor(ruleBuilderService: RuleBuilderService, specificationBridge: SpecificationBridgeService, cdr: ChangeDetectorRef);
-    ngOnInit(): void;
-    ngOnDestroy(): void;
-    private setupSubscriptions;
-    private initializeLinting;
-    private triggerLinting;
-    runLinting(): void;
-    private performLinting;
-    private analyzeDsl;
-    private checkSyntaxRules;
-    private checkSemanticRules;
-    private checkStyleRules;
-    private checkPerformanceRules;
-    private checkBestPracticeRules;
-    private isRuleEnabled;
-    private getRuleConfig;
-    private updateStats;
-    private calculateComplexity;
-    private calculateMaintainabilityIndex;
-    toggleAutoLint(): void;
-    onSeverityFilterChange(event: MatSelectChange): void;
-    onCategoryFilterChange(event: MatSelectChange): void;
-    private applyFilters;
-    trackByErrorId(index: number, error: DslLintError): string;
-    getSeverityIcon(severity: string): string;
-    translateSeverity(severity: string): string;
-    translateCategory(category: string): string;
-    getComplexityClass(complexity: number): string;
-    getMaintainabilityClass(maintainability: number): string;
-    getIssueDistribution(): any[];
-    getMostCommonIssues(): any[];
-    getRuleCategories(): any[];
-    navigateToError(error: DslLintError): void;
-    applyQuickFix(error: DslLintError): void;
-    ignoreError(error: DslLintError): void;
-    toggleRule(rule: DslLintRule, change: MatSlideToggleChange): void;
-    configureRule(rule: DslLintRule): void;
-    openLinterSettings(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<DslLinterComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<DslLinterComponent, "praxis-dsl-linter", never, { "dsl": { "alias": "dsl"; "required": false; }; "autoLint": { "alias": "autoLint"; "required": false; }; "lintDelay": { "alias": "lintDelay"; "required": false; }; }, { "errorSelected": "errorSelected"; "quickFixApplied": "quickFixApplied"; "ruleToggled": "ruleToggled"; }, never, never, true, never>;
-}
-
 /**
  * Placeholder Visual Rule Builder Component
  *
@@ -3541,7 +2786,6 @@ declare class TemplateEditorDialogComponent implements OnInit {
     data: TemplateEditorDialogData;
     private fb;
     private templateService;
-    private bridgeService;
     private snackBar;
     basicInfoForm: FormGroup;
     rulesForm: FormGroup;
@@ -3561,7 +2805,7 @@ declare class TemplateEditorDialogComponent implements OnInit {
     previewNodes: RuleNode[];
     detectedVariables: string[];
     get nodeCount(): number;
-    constructor(dialogRef: MatDialogRef<TemplateEditorDialogComponent>, data: TemplateEditorDialogData, fb: FormBuilder, templateService: RuleTemplateService, bridgeService: SpecificationBridgeService, snackBar: MatSnackBar);
+    constructor(dialogRef: MatDialogRef<TemplateEditorDialogComponent>, data: TemplateEditorDialogData, fb: FormBuilder, templateService: RuleTemplateService, snackBar: MatSnackBar);
     ngOnInit(): void;
     private createBasicInfoForm;
     private createRulesForm;
@@ -3641,6 +2885,7 @@ declare class RuleListComponent {
     getPrimaryEffectLabel(item: RuleListItem): string;
     getEffectDetail(item: RuleListItem): string;
     getSummary(item: RuleListItem): string;
+    private hasConfiguredCondition;
     getRelativeTime(item: RuleListItem): string | null;
     getTargetPreview(item: RuleListItem): string[];
     t(key: string, fallback: string): string;
@@ -3660,5 +2905,5 @@ declare class RuleListComponent {
     static ɵcmp: i0.ɵɵComponentDeclaration<RuleListComponent, "praxis-rule-list", never, { "rules": { "alias": "rules"; "required": false; }; "selectedRuleId": { "alias": "selectedRuleId"; "required": false; }; "nodeMap": { "alias": "nodeMap"; "required": false; }; "validationErrors": { "alias": "validationErrors"; "required": false; }; }, { "ruleSelected": "ruleSelected"; "ruleDeleted": "ruleDeleted"; "ruleDuplicated": "ruleDuplicated"; "ruleAdded": "ruleAdded"; "aiRequested": "aiRequested"; }, never, never, true, never>;
 }
 
-export { ArrayFieldAnalyzer, CollectionValidatorEditorComponent, ConditionalValidatorEditorComponent, ConditionalValidatorType, ConfigurationError, ContextError, ContextManagementService, ConversionError, ConverterFactoryService, DslError, DslLinterComponent, DslViewerComponent, ErrorCategory, ErrorHandler, ErrorSeverity, ExportDialogComponent, ExportIntegrationService, FIELD_TYPE_OPERATORS, FieldConditionEditorComponent, FieldSchemaService, FieldType, InternalError, JsonViewerComponent, MetadataEditorComponent, OPERATOR_LABELS, PraxisVisualBuilder, RegistryError, RoundTripTesterComponent, RoundTripValidatorService, RuleBuilderService, RuleCanvasComponent, RuleConversionService, RuleEditorComponent, RuleListComponent, RuleNodeComponent, RuleNodeRegistryService, RuleNodeType, RuleTemplateService, RuleValidationService, SpecificationBridgeService, TemplateEditorDialogComponent, TemplateGalleryComponent, TemplatePreviewDialogComponent, ValidationError as VBValidationError, ValidationCategory, ValidationSeverity, VisualBuilderError, VisualRuleBuilderComponent, WebhookIntegrationService, createError, getArrayItemFieldPaths, globalErrorHandler, isArrayFieldSchema };
-export type { ArrayCollectionValidationRule, ArrayFieldSchema, ArrayValidationContext, ArrayValidationError, BooleanGroupConfig, CardinalityConfig, CircularReference, CleanupResult, CollectionValidationConfig, CollectionValidatorConfig, ConditionalValidatorConfig, ConditionalValidatorPreview, ContextEntry, ContextScope, ContextValue, ContextVariable, ContextualConfig$1 as ContextualConfig, ContextualTemplateConfig, ConversionStatistics, ConversionValidationResult, ConverterStatistics, CustomConfig, CustomFunction, DslEdit, DslLintError, DslLintRule, DslLintStats, DslQuickFix, EnhancedFieldSchema, ErrorInfo, ErrorStatistics, ExportDialogData, ExportFormat, ExportOptions, ExportResult, ExpressionConfig, ExternalSystemConfig, FieldConditionConfig, FieldFormat, FieldOption, FieldSchema, FieldSchemaContext, FieldToFieldConfig, FieldUIConfig, FunctionCallConfig, FunctionParameter, ImportOptions, IntegrationEndpoint, IntegrationResult, MemoryStats, OptionalFieldConfig, PropertyRuleConfig, RegistryIntegrityResult, RegistryValidationResult, RoundTripTestCase, RoundTripValidationResult, RuleBuilderConfig, RuleBuilderSnapshot, RuleBuilderState, RuleNode, RuleNodeConfig, RuleNodeTree, RuleNodeTypeString, RuleTemplate, RuleValidationResult, SpecificationContextualConfig, TemplateApplicationResult, TemplateCategory, TemplateDisplayMode, TemplateEditorDialogData, TemplateEditorResult, TemplateMetadata, TemplatePreviewDialogData, TemplateSearchCriteria, TemplateSortOption, TemplateStats, TemplateValidationResult, ValidComparisonOperator, ValidationConfig, ValidationContext, ValidationError$1 as ValidationError, ValidationIssue, ValidationResult, ValidationRule, ValueType, WebhookConfig, WebhookDelivery, WebhookEvent, WebhookStats };
+export { ArrayFieldAnalyzer, CollectionValidatorEditorComponent, ConditionalValidatorEditorComponent, ConditionalValidatorType, ConfigurationError, ContextError, ContextManagementService, ConversionError, ErrorCategory, ErrorHandler, ErrorSeverity, ExportDialogComponent, ExportIntegrationService, ExpressionError, FIELD_TYPE_OPERATORS, FieldConditionEditorComponent, FieldSchemaService, FieldType, InternalError, JsonViewerComponent, MetadataEditorComponent, OPERATOR_LABELS, PraxisVisualBuilder, RegistryError, RuleBuilderService, RuleCanvasComponent, RuleEditorComponent, RuleListComponent, RuleNodeComponent, RuleNodeRegistryService, RuleNodeType, RuleTemplateService, RuleValidationService, TemplateEditorDialogComponent, TemplateGalleryComponent, TemplatePreviewDialogComponent, ValidationError as VBValidationError, ValidationCategory, ValidationSeverity, VisualBuilderError, VisualRuleBuilderComponent, WebhookIntegrationService, createError, getArrayItemFieldPaths, globalErrorHandler, isArrayFieldSchema };
+export type { ArrayCollectionValidationRule, ArrayFieldSchema, ArrayValidationContext, ArrayValidationError, BooleanGroupConfig, CardinalityConfig, CircularReference, CleanupResult, CollectionValidationConfig, CollectionValidatorConfig, ConditionalValidatorConfig, ConditionalValidatorPreview, ContextEntry, ContextScope, ContextValue, ContextVariable, ContextualConfig, ContextualTemplateConfig, CustomConfig, CustomFunction, DocumentationLink, EnhancedFieldSchema, ErrorInfo, ErrorStatistics, ExportDialogData, ExportFormat, ExportOptions, ExportResult, ExpressionConfig, ExternalSystemConfig, FieldConditionConfig, FieldFormat, FieldOption, FieldSchema, FieldSchemaContext, FieldToFieldConfig, FieldUIConfig, FunctionCallConfig, FunctionParameter, ImportOptions, IntegrationEndpoint, IntegrationResult, MemoryStats, OptionalFieldConfig, PropertyRuleConfig, RegistryIntegrityResult, RegistryValidationResult, RuleBuilderConfig, RuleBuilderSnapshot, RuleBuilderState, RuleContextProvider, RuleFunctionRegistry, RuleNode, RuleNodeConfig, RuleNodeTree, RuleNodeTypeString, RuleTemplate, RuleValidationResult, SpecificationMetadata, TemplateApplicationResult, TemplateCategory, TemplateDisplayMode, TemplateEditorDialogData, TemplateEditorResult, TemplateMetadata, TemplatePreviewDialogData, TemplateSearchCriteria, TemplateSortOption, TemplateStats, TemplateValidationResult, ValidComparisonOperator, ValidationConfig, ValidationContext, ValidationError$1 as ValidationError, ValidationIssue, ValidationResult, ValidationRule, ValueType, WebhookConfig, WebhookDelivery, WebhookEvent, WebhookStats };