@praxisui/visual-builder 1.0.0-beta.8 → 2.0.0-beta.0

package/index.d.ts

@@ -1,15 +1,17 @@
 import * as i0 from '@angular/core';
-import { EventEmitter, OnInit, OnDestroy, OnChanges, SimpleChanges, ElementRef, ChangeDetectorRef } from '@angular/core';
-import { ContextProvider, FunctionRegistry, ExportOptions as ExportOptions$1, ValidationIssue as ValidationIssue$1, ContextualSpecification } from '@praxisui/specification';
+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 { Observable } from 'rxjs';
-import { FormBuilder, FormGroup, FormArray } from '@angular/forms';
+import { FormLayoutRule, RulePropertySchema } from '@praxisui/core';
+import { DslParsingConfig, DslParsingResult, DslParsingService, AiResponseValidatorService, AiRuleResponse } from '@praxisui/ai';
 import { MatSnackBar } from '@angular/material/snack-bar';
-import { MatButtonToggleChange } from '@angular/material/button-toggle';
 import { MatDialog, MatDialogRef } from '@angular/material/dialog';
-import { CdkDragDrop } from '@angular/cdk/drag-drop';
+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';
 
@@ -24,7 +26,7 @@ type ValueType = 'literal' | 'field' | 'context' | 'function';
 /**
  * Valid comparison operators (aligned with @praxisui/specification)
  */
-type ValidComparisonOperator = 'eq' | 'neq' | 'lt' | 'lte' | 'gt' | 'gte' | 'contains' | 'startsWith' | 'endsWith' | 'in';
+type ValidComparisonOperator = 'eq' | 'neq' | 'lt' | 'lte' | 'gt' | 'gte' | 'contains' | 'startsWith' | 'endsWith' | 'in' | 'notIn' | 'matches' | 'notMatches' | 'isNull' | 'isNotNull' | 'isEmpty' | 'isNotEmpty';
 interface RuleNode {
     /** Unique identifier for this rule node */
     id: string;
@@ -47,6 +49,7 @@ interface RuleNode {
 }
 declare enum RuleNodeType {
     FIELD_CONDITION = "fieldCondition",
+    PROPERTY_RULE = "propertyRule",
     AND_GROUP = "andGroup",
     OR_GROUP = "orGroup",
     NOT_GROUP = "notGroup",
@@ -76,8 +79,8 @@ declare enum RuleNodeType {
 /**
  * String literal type for rule node types (for flexibility)
  */
-type RuleNodeTypeString = 'fieldCondition' | '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 | BooleanGroupConfig | ConditionalValidatorConfig | CollectionValidationConfig | CollectionValidatorConfig | OptionalFieldConfig | FunctionCallConfig | FieldToFieldConfig | ContextualConfig$1 | CardinalityConfig | ExpressionConfig | ContextualTemplateConfig | CustomConfig;
+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;
 interface FieldConditionConfig {
     type: 'fieldCondition';
     /** Primary field name */
@@ -85,7 +88,7 @@ interface FieldConditionConfig {
     /** Comparison operator aligned with @praxisui/specification */
     operator: ValidComparisonOperator | string;
     /** Comparison value */
-    value: unknown;
+    value?: unknown;
     /** Type of value for proper handling */
     valueType?: ValueType;
     /** Field to compare against (for field-to-field comparisons) */
@@ -97,6 +100,22 @@ interface FieldConditionConfig {
     /** Legacy field alias for backward compatibility */
     field?: string;
 }
+interface PropertyRuleConfig {
+    type: 'propertyRule';
+    targetType: 'field' | 'section' | 'action' | 'row' | 'column';
+    /** Target IDs without prefix (namespace is defined by targetType) */
+    targets: string[];
+    /** Properties applied when condition is true */
+    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 reference to a condition node inside the graph */
+    conditionNodeId?: string;
+    /** Metadata for UI/description */
+    metadata?: SpecificationMetadata;
+}
 interface BooleanGroupConfig {
     type: 'booleanGroup' | 'andGroup' | 'orGroup' | 'notGroup' | 'xorGroup' | 'impliesGroup';
     /** Boolean operator type */
@@ -370,6 +389,11 @@ interface RuleBuilderSnapshot {
         nodes: Record<string, RuleNode>;
         rootNodes: string[];
         selectedNodeId?: string;
+        currentDSL?: string;
+        currentJSON?: any;
+        validationErrors?: ValidationError$1[];
+        mode?: 'visual' | 'dsl' | 'json';
+        isDirty?: boolean;
     };
 }
 /**
@@ -470,6 +494,27 @@ interface ImportOptions {
 interface RuleBuilderConfig {
     /** Available field schemas */
     fieldSchemas: Record<string, unknown>;
+    /** Optional map of available targets by type (fields, sections, actions) */
+    targetSchemas?: {
+        fields?: Record<string, unknown>;
+        sections?: Record<string, unknown>;
+        actions?: Record<string, unknown>;
+        rows?: Record<string, unknown>;
+        columns?: Record<string, unknown>;
+    };
+    /** Optional property schema per targetType for typed property editing */
+    targetPropertySchemas?: Record<'field' | 'section' | 'action' | 'row' | 'column', Array<{
+        name: string;
+        type: 'string' | 'boolean' | 'object' | 'enum' | 'number';
+        label?: string;
+        description?: string;
+        enumValues?: Array<{
+            value: string;
+            label?: string;
+        }>;
+    }>>;
+    /** Backward-compatible property schema key */
+    propertySchema?: Record<string, unknown>;
     /** Context variables */
     contextVariables?: unknown[];
     /** Custom functions */
@@ -566,12 +611,12 @@ interface ContextualTemplateConfig {
 declare class PraxisVisualBuilder {
     config: RuleBuilderConfig | null;
     initialRules: any;
-    rulesChanged: EventEmitter<any>;
+    rulesChanged: EventEmitter<RuleBuilderState>;
     exportRequested: EventEmitter<ExportOptions>;
     importRequested: EventEmitter<ImportOptions>;
-    onRulesChanged(rules: any): void;
-    onExportRequested(options: ExportOptions): void;
-    onImportRequested(options: ImportOptions): void;
+    onRulesChanged(rules: RuleBuilderState): void;
+    onExportRequested(options: any): void;
+    onImportRequested(options: any): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<PraxisVisualBuilder, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<PraxisVisualBuilder, "praxis-visual-builder", never, { "config": { "alias": "config"; "required": false; }; "initialRules": { "alias": "initialRules"; "required": false; }; }, { "rulesChanged": "rulesChanged"; "exportRequested": "exportRequested"; "importRequested": "importRequested"; }, never, never, true, never>;
 }
@@ -584,8 +629,10 @@ interface FieldSchema {
     name: string;
     /** Human-readable field label */
     label: string;
+    /** Logical origin to help context-sensitive filtering (form field, section, row, column, table column, etc.) */
+    origin?: 'field' | 'section' | 'action' | 'row' | 'column' | 'tableField' | 'tableColumn';
     /** Field data type */
-    type: FieldType;
+    type: FieldType | string;
     /** Optional description or help text */
     description?: string;
     /** Whether this field is required */
@@ -661,7 +708,7 @@ declare enum FieldType {
 /**
  * Available comparison operators for each field type
  */
-declare const FIELD_TYPE_OPERATORS: Record<FieldType, string[]>;
+declare const FIELD_TYPE_OPERATORS: Record<string, string[]>;
 /**
  * Operator display labels for UI
  */
@@ -886,11 +933,11 @@ declare class FieldSchemaService {
     /**
      * Get available operators for a field type
      */
-    getAvailableOperators(fieldType: FieldType): string[];
+    getAvailableOperators(fieldType: FieldType | string): string[];
     /**
      * Get operator labels for a field type
      */
-    getOperatorLabels(fieldType: FieldType): Record<string, string>;
+    getOperatorLabels(fieldType: FieldType | string): Record<string, string>;
     /**
      * Validate field value against schema
      */
@@ -937,13 +984,14 @@ 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: 'user' | 'session' | 'env' | 'global';
+    scope: DslContextScope;
     /** Description */
     description?: string;
     /** Example value */
@@ -965,6 +1013,10 @@ declare class RuleNodeRegistryService {
      * Register a node in the registry
      */
     register(node: RuleNode): void;
+    /**
+     * Backwards-compatible alias for register()
+     */
+    registerNode(node: RuleNode): void;
     /**
      * Register multiple nodes at once
      */
@@ -1210,6 +1262,9 @@ declare class FieldConditionConverter extends BaseRuleConverter {
     private mapOperator;
     private convertValue;
     private inferAndConvertValue;
+    private operatorRequiresValue;
+    private defaultValueForOperator;
+    private getImpliedValue;
     static ɵfac: i0.ɵɵFactoryDeclaration<FieldConditionConverter, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<FieldConditionConverter>;
 }
@@ -1307,37 +1362,6 @@ interface ConverterStatistics {
     converterNames: string[];
 }
 
-/**
- * Configuration for parsing DSL expressions
- */
-interface DslParsingConfig$1 {
-    /** Available function registry */
-    functionRegistry?: FunctionRegistry<any>;
-    /** Context provider for variable resolution */
-    contextProvider?: ContextProvider;
-    /** Known field names for validation */
-    knownFields?: string[];
-    /** Enable performance warnings */
-    enablePerformanceWarnings?: boolean;
-    /** Maximum expression complexity */
-    maxComplexity?: number;
-}
-/**
- * Result of parsing a DSL expression
- */
-interface DslParsingResult$1<T extends object = any> {
-    /** Whether parsing was successful */
-    success: boolean;
-    /** Parsed specification (if successful) */
-    specification?: Specification<T>;
-    /** Validation issues found */
-    issues: ValidationIssue$1[];
-    /** Performance metrics */
-    metrics?: {
-        parseTime: number;
-        complexity: number;
-    };
-}
 /**
  * Configuration for contextual specification support
  */
@@ -1361,6 +1385,7 @@ declare class SpecificationBridgeService {
      * 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
      */
@@ -1396,7 +1421,7 @@ declare class SpecificationBridgeService {
     /**
      * Parses a DSL expression string into a Specification
      */
-    parseDslExpression<T extends object = any>(expression: string, config?: DslParsingConfig$1): DslParsingResult$1<T>;
+    parseDslExpression<T extends object = any>(expression: string, config?: DslParsingConfig): DslParsingResult<T>;
     /**
      * Creates a ContextualSpecification with token resolution
      */
@@ -1424,7 +1449,7 @@ declare class SpecificationBridgeService {
     /**
      * Performs round-trip validation for expression specifications
      */
-    validateExpressionRoundTrip<T extends object = any>(originalExpression: string, config?: DslParsingConfig$1): {
+    validateExpressionRoundTrip<T extends object = any>(originalExpression: string, config?: DslParsingConfig): {
         success: boolean;
         errors: string[];
         warnings: string[];
@@ -1465,6 +1490,9 @@ declare class SpecificationBridgeService {
     private createContextualSpecificationFromNode;
     private convertToComparisonOperator;
     private convertValue;
+    private comparisonExpectsValue;
+    private defaultValueForOperator;
+    private getImpliedValueForOperator;
     private jsonToRuleNode;
     private mapSpecificationTypeToNodeType;
     private mapComparisonOperator;
@@ -1497,7 +1525,7 @@ declare class SpecificationBridgeService {
      */
     parseDslExpressionValue(expression: string | {
         expr: string;
-    } | null | undefined, _config?: DslParsingConfig$1): {
+    } | null | undefined, _config?: DslParsingConfig): {
         success: boolean;
         issues: string[];
     };
@@ -1559,15 +1587,17 @@ interface RoundTripTestCase {
         expectedErrors?: string[];
         expectedWarnings?: string[];
     };
+    relatedNodes?: RuleNode[];
 }
 declare class RoundTripValidatorService {
     private specificationBridge;
+    private nodeRegistry;
     private dslParser;
-    constructor(specificationBridge: SpecificationBridgeService);
+    constructor(specificationBridge: SpecificationBridgeService, nodeRegistry: RuleNodeRegistryService);
     /**
      * Validates complete round-trip conversion: Visual → DSL → Visual
      */
-    validateRoundTrip(visualRule: RuleNode): RoundTripValidationResult;
+    validateRoundTrip(visualRule: RuleNode, relatedNodes?: RuleNode[]): RoundTripValidationResult;
     /**
      * Validates data integrity between original and reconstructed visual rules
      */
@@ -1616,6 +1646,7 @@ declare class RoundTripValidatorService {
 declare class RuleBuilderService {
     private specificationBridge;
     private roundTripValidator;
+    private nodeRegistry;
     private readonly _state;
     private readonly _validationErrors;
     private readonly _nodeSelected;
@@ -1628,7 +1659,7 @@ declare class RuleBuilderService {
     readonly validationErrors$: Observable<ValidationError$1[]>;
     readonly nodeSelected$: Observable<string>;
     readonly stateChanged$: Observable<void>;
-    constructor(specificationBridge: SpecificationBridgeService, roundTripValidator: RoundTripValidatorService);
+    constructor(specificationBridge: SpecificationBridgeService, roundTripValidator: RoundTripValidatorService, nodeRegistry: RuleNodeRegistryService);
     /**
      * Initialize the rule builder with configuration
      */
@@ -1637,6 +1668,18 @@ declare class RuleBuilderService {
      * Get current state
      */
     getCurrentState(): RuleBuilderState;
+    /**
+     * Initial empty builder state
+     */
+    private getInitialState;
+    /**
+     * Add a high-level property rule (bridge method)
+     */
+    addPropertyRule(rule: FormLayoutRule): string;
+    /**
+     * Update a high-level property rule (bridge method)
+     */
+    updatePropertyRule(id: string, rule: Partial<FormLayoutRule>): void;
     /**
      * Add a new rule node
      */
@@ -1646,7 +1689,7 @@ declare class RuleBuilderService {
      */
     updateNode(nodeId: string, updates: Partial<RuleNode>): void;
     /**
-     * Remove a rule node
+     * Remove a rule node (and its descendants)
      */
     removeNode(nodeId: string): void;
     /**
@@ -1654,70 +1697,67 @@ declare class RuleBuilderService {
      */
     selectNode(nodeId?: string): void;
     /**
-     * Move a node to a new parent
+     * Undo last change
      */
-    moveNode(nodeId: string, newParentId?: string, index?: number): void;
+    undo(): void;
     /**
-     * Convert current rules to Specification
+     * Redo previously undone change
      */
-    toSpecification(): Specification<any> | null;
+    redo(): void;
     /**
-     * Export current rules
+     * Clear all rules
      */
-    export(options: ExportOptions): string;
+    clear(): void;
     /**
-     * Import rules from external source.
-     *
-     * Empty strings or structures with no data are ignored to preserve the
-     * current state. When parsing JSON, the specification type must be
-     * present otherwise an error is thrown, ensuring business rules are
-     * explicit and valid.
-     *
-     * @throws Error when the specification type is missing or the format is
-     * unsupported.
+     * Import rules from supported formats
      */
     import(content: string, options: ImportOptions): void;
     /**
-     * Undo last action
-     */
-    undo(): void;
-    /**
-     * Redo last undone action
+     * Export rules to JSON payload
      */
-    redo(): void;
+    export(options: ExportOptions): string;
     /**
-     * Clear all rules
+     * Convert current builder state to Specification (best-effort)
      */
-    clear(): void;
+    toSpecification(): Specification<any> | null;
+    private updateState;
     /**
-     * Validate current rules
+     * Validate current rules (lightweight placeholder)
      */
     validateRules(): void;
     /**
-     * Validates round-trip conversion for all root nodes
+     * Replace builder state with a parsed DSL graph without reinitializing the service.
      */
-    private validateRoundTrip;
+    loadFromParsedDsl(nodes: Record<string, RuleNode>, rootNodes: string[], description?: string): void;
     /**
-     * Runs comprehensive round-trip validation for current state
+     * Update builder state with a parsed DSL graph while preserving history.
      */
-    runRoundTripValidation(): {
-        success: boolean;
-        results: Array<{
-            nodeId: string;
-            result: any;
-        }>;
-        summary: {
-            totalNodes: number;
-            successfulNodes: number;
-            failedNodes: number;
-            totalErrors: number;
-            totalWarnings: number;
-        };
-    };
-    private getInitialState;
-    private updateState;
+    updateFromParsedDsl(nodes: Record<string, RuleNode>, rootNodes: string[], description?: string): void;
     private saveSnapshot;
     private generateNodeLabel;
+    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.
+     */
+    private exportFormRulesFromState;
+    private toFormLayoutRule;
+    private normalizeTargets;
+    private buildDslFromCondition;
+    private buildDslFromState;
+    private applyBuilderState;
+    private extractFormRules;
+    private isFormRuleCandidate;
+    private validateFormRulesPayload;
+    private sanitizeRuleProperties;
+    private coerceRulePropertyValue;
+    private sanitizeStructuredValue;
+    private formRulesToBuilderState;
+    private inferRuleTypeFromFormRule;
+    private parseSimpleCondition;
+    private normalizeOperator;
+    private prefixTarget;
     private buildRuleNodeTree;
     private flattenRuleNodeTree;
     private validateNode;
@@ -2306,69 +2346,6 @@ declare class RuleValidationService {
     static ɵprov: i0.ɵɵInjectableDeclaration<RuleValidationService>;
 }
 
-/**
- * Configuration for parsing DSL expressions
- */
-interface DslParsingConfig {
-    /** Available function registry */
-    functionRegistry?: FunctionRegistry<any>;
-    /** Context provider for variable resolution */
-    contextProvider?: ContextProvider;
-    /** Known field names for validation */
-    knownFields?: string[];
-    /** Enable performance warnings */
-    enablePerformanceWarnings?: boolean;
-    /** Maximum expression complexity */
-    maxComplexity?: number;
-}
-/**
- * Result of parsing a DSL expression
- */
-interface DslParsingResult<T extends object = any> {
-    /** Whether parsing was successful */
-    success: boolean;
-    /** Parsed specification (if successful) */
-    specification?: any;
-    /** Validation issues found */
-    issues: ValidationIssue$1[];
-    /** Performance metrics */
-    metrics?: {
-        parseTime: number;
-        complexity: number;
-    };
-}
-/**
- * Dedicated service for DSL parsing and validation
- * Extracted from SpecificationBridgeService to follow SRP
- */
-declare class DslParsingService {
-    constructor();
-    /**
-     * Parse a DSL expression into a specification
-     */
-    parseDsl<T extends object = any>(dslExpression: string, config?: DslParsingConfig): DslParsingResult<T>;
-    /**
-     * Validate DSL syntax without parsing
-     */
-    validateDsl(dslExpression: string, config?: DslParsingConfig): ValidationIssue$1[];
-    /**
-     * Get suggestions for DSL completion
-     */
-    getDslSuggestions(partialExpression: string, cursorPosition: number, config?: DslParsingConfig): string[];
-    /**
-     * Format DSL expression for readability
-     */
-    formatDsl(dslExpression: string): string;
-    /**
-     * Check if DSL expression is syntactically valid
-     */
-    isValidDsl(dslExpression: string, config?: DslParsingConfig): boolean;
-    private calculateComplexity;
-    private getCurrentToken;
-    static ɵfac: i0.ɵɵFactoryDeclaration<DslParsingService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<DslParsingService>;
-}
-
 /**
  * Context variable definition used by the context management service
  * Renamed to avoid conflicts with other ContextVariable interfaces
@@ -2743,78 +2720,74 @@ declare const createError: {
     internal: (message: string, cause?: Error) => InternalError;
 };
 
-declare class RuleEditorComponent implements OnInit, OnDestroy {
+type TargetType = 'field' | 'section' | 'action' | 'row' | 'column';
+type RuleNodeConfigExtended = RuleNodeConfig & {
+    targetType?: TargetType;
+    properties?: Record<string, any>;
+    propertiesWhenFalse?: Record<string, any>;
+    targets?: string[];
+    condition?: RuleNode | string | null;
+};
+declare class RuleEditorComponent implements OnInit, OnDestroy, OnChanges, AfterViewInit {
     private ruleBuilderService;
     private fieldSchemaService;
+    private aiResponseValidator;
     private snackBar;
-    private fb;
     private dialog;
+    private cdr;
+    embedded: boolean;
     config: RuleBuilderConfig | null;
     initialRules: any;
-    embedded: boolean;
-    rulesChanged: EventEmitter<any>;
+    stateChanged: EventEmitter<RuleBuilderState>;
+    save: EventEmitter<RuleBuilderState>;
+    rulesChanged: EventEmitter<RuleBuilderState>;
     exportRequested: EventEmitter<ExportOptions>;
     importRequested: EventEmitter<ImportOptions>;
+    fileInput: ElementRef<HTMLInputElement>;
     private destroy$;
     currentState: RuleBuilderState | null;
+    fieldSchemas: Record<string, FieldSchema>;
+    showDebugPanel: boolean;
     validationErrors: ValidationError$1[];
+    isListPanelOpen: boolean;
     selectedNode: RuleNode | null;
-    fieldSchemas: Record<string, FieldSchema>;
-    fieldCategories: any[];
-    activeTabIndex: number;
-    showValidationErrors: boolean;
+    propertySchemaMap: RulePropertySchema;
+    targetSchemas?: RuleBuilderConfig['targetSchemas'];
+    private lastErrorCount;
     get canUndo(): boolean;
     get canRedo(): boolean;
-    constructor(ruleBuilderService: RuleBuilderService, fieldSchemaService: FieldSchemaService, snackBar: MatSnackBar, fb: FormBuilder, dialog: MatDialog);
+    constructor(ruleBuilderService: RuleBuilderService, fieldSchemaService: FieldSchemaService, aiResponseValidator: AiResponseValidatorService, snackBar: MatSnackBar, dialog: MatDialog, cdr: ChangeDetectorRef);
     ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngAfterViewInit(): void;
     ngOnDestroy(): void;
     private setupSubscriptions;
-    private initializeBuilder;
-    private importInitialRules;
-    private updateSelectedNode;
-    trackByNodeId(index: number, nodeId: string): string;
-    getNode(nodeId: string): RuleNode | null;
-    getNodeLabel(nodeId: string): string;
-    getNodeIcon(node: RuleNode | null): string;
-    getFieldIcon(type: string): string;
-    isNodeSelected(nodeId: string): boolean;
-    hasChildren(nodeId: string): boolean;
-    getChildren(nodeId: string): string[];
-    getRuleCount(): number;
-    getErrorIcon(severity: string): string;
-    onModeChange(event: MatButtonToggleChange): void;
-    selectNode(nodeId?: string): void;
-    editNode(nodeId: string): void;
-    removeNode(nodeId: string): void;
-    onRuleDrop(event: CdkDragDrop<string[]>): void;
-    onFieldDragStart(field: FieldSchema, event: DragEvent): void;
-    showAddRuleDialog(): void;
-    onNodeAdded(event: {
-        type: RuleNodeType;
-        parentId?: string;
-        config?: RuleNodeConfig;
-    }): void;
-    onNodeUpdated(event: {
-        nodeId: string;
-        updates: Partial<RuleNode>;
-    }): void;
-    onMetadataUpdated(event: any): void;
-    onDslChanged(dsl: string): void;
-    onJsonChanged(json: any): void;
     undo(): void;
     redo(): void;
     clearRules(): void;
+    toggleListPanel(): void;
+    openAiWizard(): void;
+    createRuleFromAI(aiResponse: AiRuleResponse): Promise<void>;
+    private validateAiResponse;
+    addPropertyRule(): void;
+    selectNode(nodeId: string): void;
+    onRuleUpdated(config: RuleNodeConfigExtended): void;
+    removeNode(nodeId: string): void;
+    isPropertyRule(node: RuleNode | null): boolean;
+    private buildPropertyRuleLabel;
+    private stripTargetPrefix;
+    private normalizeRuleConfig;
     openExportDialog(): void;
     importRules(): void;
-    hideValidationErrors(): void;
-    onLinterErrorSelected(error: any): void;
-    onQuickFixApplied(event: any): void;
-    onLinterRuleToggled(event: any): void;
+    onFileSelected(event: Event): void;
+    getRuleCount(): number;
+    trackByNodeId(index: number, nodeId: string): string;
     static ɵfac: i0.ɵɵFactoryDeclaration<RuleEditorComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<RuleEditorComponent, "praxis-rule-editor", never, { "config": { "alias": "config"; "required": false; }; "initialRules": { "alias": "initialRules"; "required": false; }; "embedded": { "alias": "embedded"; "required": false; }; }, { "rulesChanged": "rulesChanged"; "exportRequested": "exportRequested"; "importRequested": "importRequested"; }, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RuleEditorComponent, "praxis-rule-editor", never, { "embedded": { "alias": "embedded"; "required": false; }; "config": { "alias": "config"; "required": false; }; "initialRules": { "alias": "initialRules"; "required": false; }; }, { "stateChanged": "stateChanged"; "save": "save"; "rulesChanged": "rulesChanged"; "exportRequested": "exportRequested"; "importRequested": "importRequested"; }, never, never, true, never>;
 }
 
 declare class RuleCanvasComponent implements OnInit, OnDestroy {
+    conditionOnly: boolean;
     state: RuleBuilderState | null;
     fieldSchemas: Record<string, FieldSchema>;
     nodeSelected: EventEmitter<string>;
@@ -2838,6 +2811,7 @@ declare class RuleCanvasComponent implements OnInit, OnDestroy {
         color: string;
     }[];
     get isEmpty(): boolean;
+    get filteredAddMenuOptions(): typeof this.addMenuOptions;
     constructor();
     ngOnInit(): void;
     ngOnDestroy(): void;
@@ -2862,13 +2836,15 @@ declare class RuleCanvasComponent implements OnInit, OnDestroy {
     toggleAddMenu(): void;
     addFirstRule(): void;
     addRule(type: RuleNodeType): void;
+    private isAllowedConditionType;
     static ɵfac: i0.ɵɵFactoryDeclaration<RuleCanvasComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<RuleCanvasComponent, "praxis-rule-canvas", never, { "state": { "alias": "state"; "required": false; }; "fieldSchemas": { "alias": "fieldSchemas"; "required": false; }; }, { "nodeSelected": "nodeSelected"; "nodeAdded": "nodeAdded"; "nodeUpdated": "nodeUpdated"; "nodeRemoved": "nodeRemoved"; }, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RuleCanvasComponent, "praxis-rule-canvas", never, { "conditionOnly": { "alias": "conditionOnly"; "required": false; }; "state": { "alias": "state"; "required": false; }; "fieldSchemas": { "alias": "fieldSchemas"; "required": false; }; }, { "nodeSelected": "nodeSelected"; "nodeAdded": "nodeAdded"; "nodeUpdated": "nodeUpdated"; "nodeRemoved": "nodeRemoved"; }, never, never, true, never>;
 }
 
 declare class RuleNodeComponent {
     private fb;
     node: RuleNode | null;
+    nodes: Record<string, RuleNode>;
     fieldSchemas: Record<string, FieldSchema>;
     level: number;
     isSelected: boolean;
@@ -2929,7 +2905,7 @@ declare class RuleNodeComponent {
     onChildDrop(event: CdkDragDrop<string[]>): void;
     private formatNodeType;
     static ɵfac: i0.ɵɵFactoryDeclaration<RuleNodeComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<RuleNodeComponent, "praxis-rule-node", never, { "node": { "alias": "node"; "required": false; }; "fieldSchemas": { "alias": "fieldSchemas"; "required": false; }; "level": { "alias": "level"; "required": false; }; "isSelected": { "alias": "isSelected"; "required": false; }; "validationErrors": { "alias": "validationErrors"; "required": false; }; }, { "nodeClicked": "nodeClicked"; "nodeUpdated": "nodeUpdated"; "nodeDeleted": "nodeDeleted"; "childAdded": "childAdded"; "childMoved": "childMoved"; }, never, never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RuleNodeComponent, "praxis-rule-node", never, { "node": { "alias": "node"; "required": false; }; "nodes": { "alias": "nodes"; "required": false; }; "fieldSchemas": { "alias": "fieldSchemas"; "required": false; }; "level": { "alias": "level"; "required": false; }; "isSelected": { "alias": "isSelected"; "required": false; }; "validationErrors": { "alias": "validationErrors"; "required": false; }; }, { "nodeClicked": "nodeClicked"; "nodeUpdated": "nodeUpdated"; "nodeDeleted": "nodeDeleted"; "childAdded": "childAdded"; "childMoved": "childMoved"; }, never, never, true, never>;
 }
 
 declare class FieldConditionEditorComponent implements OnInit, OnChanges {
@@ -2937,12 +2913,18 @@ declare class FieldConditionEditorComponent implements OnInit, OnChanges {
     config: FieldConditionConfig | null;
     fieldSchemas: Record<string, FieldSchema>;
     configChanged: EventEmitter<FieldConditionConfig>;
+    searchInput?: ElementRef<HTMLInputElement>;
     private destroy$;
     conditionForm: FormGroup;
+    searchControl: FormControl<string>;
     fieldCategories: {
         name: string;
         fields: FieldSchema[];
     }[];
+    filteredFieldCategories: {
+        name: string;
+        fields: FieldSchema[];
+    }[];
     contextVariables: any[];
     customFunctions: any[];
     selectedField: FieldSchema | null;
@@ -2950,7 +2932,10 @@ declare class FieldConditionEditorComponent implements OnInit, OnChanges {
     valueType: string;
     availableOperators: string[];
     constructor(fb: FormBuilder);
+    focusSearchInput(): void;
+    clearSearch(event: Event): void;
     ngOnInit(): void;
+    filterCategories(): void;
     ngOnChanges(changes: SimpleChanges): void;
     ngOnDestroy(): void;
     private createForm;
@@ -2959,6 +2944,9 @@ declare class FieldConditionEditorComponent implements OnInit, OnChanges {
     private loadInitialConfig;
     private emitConfigChange;
     private processValue;
+    private normalizeFieldName;
+    private resolveFieldSchema;
+    private normalizeOperatorForForm;
     getFieldIcon(type: string): string;
     getOperatorLabel(operator: string): string;
     getValuePlaceholder(): string;
@@ -2980,6 +2968,7 @@ declare class FieldConditionEditorComponent implements OnInit, OnChanges {
     hasValidationErrors(): boolean;
     getValidationErrors(): string[];
     isValid(): boolean;
+    hasFieldOptions(): boolean;
     static ɵfac: i0.ɵɵFactoryDeclaration<FieldConditionEditorComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<FieldConditionEditorComponent, "praxis-field-condition-editor", never, { "config": { "alias": "config"; "required": false; }; "fieldSchemas": { "alias": "fieldSchemas"; "required": false; }; }, { "configChanged": "configChanged"; }, never, never, true, never>;
 }
@@ -2999,6 +2988,10 @@ declare class ConditionalValidatorEditorComponent implements OnInit, OnChanges {
     validatorType: string;
     targetField: string;
     conditionMode: string;
+    validatorTypeLabels: Record<string, {
+        label: string;
+        icon: string;
+    }>;
     get showDisabledMessage(): boolean;
     constructor(fb: FormBuilder);
     ngOnInit(): void;
@@ -3012,6 +3005,8 @@ declare class ConditionalValidatorEditorComponent implements OnInit, OnChanges {
     getFieldIcon(type: string): string;
     trackByIndex(index: number): number;
     getSimpleConditionConfig(): any;
+    getFieldLabel(fieldName: string): string;
+    private findFieldByNameFragment;
     getPreviewText(): string;
     getLogicPreview(): string;
     onValidatorTypeChanged(event: MatSelectChange): void;
@@ -3025,6 +3020,7 @@ declare class ConditionalValidatorEditorComponent implements OnInit, OnChanges {
     getValidationErrors(): string[];
     isValid(): boolean;
     private createEmptyCondition;
+    private isConditionIncomplete;
     private mapRuleTypeToValidatorType;
     private mapValidatorTypeToRuleType;
     static ɵfac: i0.ɵɵFactoryDeclaration<ConditionalValidatorEditorComponent, never>;
@@ -3088,6 +3084,7 @@ declare class MetadataEditorComponent implements OnInit, OnChanges {
     selectedNode: RuleNode | null;
     metadataUpdated: EventEmitter<SpecificationMetadata>;
     private destroy$;
+    private lastSelectedNodeId;
     metadataForm: FormGroup;
     activeTabIndex: number;
     hasUnsavedChanges: boolean;
@@ -3118,6 +3115,8 @@ declare class MetadataEditorComponent implements OnInit, OnChanges {
     private getDocumentationLinksValue;
     private inferType;
     private convertValueByType;
+    private normalizePriority;
+    getPriorityLabel(priority: string | null | undefined): string;
     getNodeIcon(): string;
     getNodeTitle(): string;
     getNodeSubtitle(): string;
@@ -3131,7 +3130,7 @@ declare class MetadataEditorComponent implements OnInit, OnChanges {
     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 {
+declare class DslViewerComponent implements OnInit, OnChanges, AfterViewInit {
     private snackBar;
     dsl: string;
     editable: boolean;
@@ -3143,11 +3142,11 @@ declare class DslViewerComponent implements OnInit, OnChanges {
         errors: any[];
         warnings: any[];
     }>;
-    editorContainer: ElementRef;
-    private destroy$;
-    private monacoEditor;
+    editorTextarea?: ElementRef<HTMLTextAreaElement>;
+    syntaxOverlay?: ElementRef<HTMLDivElement>;
     private originalDsl;
-    isLoading: boolean;
+    private parser;
+    private validator;
     hasChanges: boolean;
     showErrors: boolean;
     syntaxErrors: any[];
@@ -3156,22 +3155,23 @@ declare class DslViewerComponent implements OnInit, OnChanges {
         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;
-    private initializeMonacoEditor;
-    private loadMonacoEditor;
-    private createEditor;
-    private createFallbackEditor;
-    private setupEditorEvents;
-    private updateEditorContent;
+    get themeClass(): string;
+    private setEditorValue;
+    getEditorValue(): string;
+    onEditorInput(event: Event): void;
     private updateEditorOptions;
-    private onContentChanged;
-    private updateCursorPosition;
+    syncScroll(): void;
+    updateCursorPosition(): void;
     private validateSyntaxDebounced;
     private debounce;
     getValidationStatusClass(): string;
@@ -3191,8 +3191,8 @@ declare class DslViewerComponent implements OnInit, OnChanges {
     hideErrorDetails(): void;
     goToError(error: any): void;
     private formatDslCode;
-    private calculateIndentationDepth;
     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>;
 }
@@ -3226,6 +3226,7 @@ declare class JsonViewerComponent implements OnInit, OnChanges {
     downloadJson(): void;
     toggleLineNumbers(): void;
     toggleWordWrap(): void;
+    private syncWordWrapWithMode;
     static ɵfac: i0.ɵɵFactoryDeclaration<JsonViewerComponent, never>;
     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>;
 }
@@ -3235,13 +3236,14 @@ declare class RoundTripTesterComponent implements OnInit {
     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);
+    constructor(roundTripValidator: RoundTripValidatorService, ruleBuilderService: RuleBuilderService, snackBar: MatSnackBar, cdr: ChangeDetectorRef, nodeRegistry: RuleNodeRegistryService);
     ngOnInit(): void;
     private loadDefaultTestCases;
     private checkCurrentRule;
@@ -3269,6 +3271,7 @@ interface ExportDialogData {
     preselectedFormat?: string;
     showIntegrationTab?: boolean;
     showSharingTab?: boolean;
+    onExport?: (options: ExportOptions) => void;
 }
 declare class ExportDialogComponent implements OnInit {
     dialogRef: MatDialogRef<ExportDialogComponent>;
@@ -3416,6 +3419,8 @@ declare class DslLinterComponent implements OnInit, OnDestroy {
     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[];
@@ -3596,5 +3601,29 @@ declare class TemplatePreviewDialogComponent {
     static ɵcmp: i0.ɵɵComponentDeclaration<TemplatePreviewDialogComponent, "praxis-template-preview-dialog", never, {}, {}, never, never, true, never>;
 }
 
-export { ArrayFieldAnalyzer, CollectionValidatorEditorComponent, ConditionalValidatorEditorComponent, ConditionalValidatorType, ConfigurationError, ContextError, ContextManagementService, ConversionError, ConverterFactoryService, DslError, DslLinterComponent, DslParsingService, 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, 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, DslParsingConfig, DslParsingResult, DslQuickFix, EnhancedFieldSchema, ErrorInfo, ErrorStatistics, ExportDialogData, ExportFormat, ExportOptions, ExportResult, ExpressionConfig, ExternalSystemConfig, FieldConditionConfig, FieldFormat, FieldOption, FieldSchema, FieldSchemaContext, FieldToFieldConfig, FieldUIConfig, FunctionCallConfig, FunctionParameter, ImportOptions, IntegrationEndpoint, IntegrationResult, MemoryStats, OptionalFieldConfig, 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 };
+type RuleListItem = string | RuleNode;
+declare class RuleListComponent {
+    rules: RuleListItem[];
+    selectedRuleId: string;
+    nodeMap: Record<string, RuleNode>;
+    ruleSelected: EventEmitter<string>;
+    ruleDeleted: EventEmitter<string>;
+    ruleAdded: EventEmitter<void>;
+    searchTerm: string;
+    get filteredRules(): RuleListItem[];
+    trackById: (_index: number, item: RuleListItem) => string;
+    isSelected(item: RuleListItem): boolean;
+    getLabel(item: RuleListItem): string;
+    getDescription(item: RuleListItem): string | undefined;
+    getTooltip(item: RuleListItem): string;
+    private getItemId;
+    onSelect(item: RuleListItem): void;
+    onDelete(item: RuleListItem, event: MouseEvent): void;
+    onKeySelect(item: RuleListItem, event: Event): void;
+    onAddRule(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RuleListComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RuleListComponent, "praxis-rule-list", never, { "rules": { "alias": "rules"; "required": false; }; "selectedRuleId": { "alias": "selectedRuleId"; "required": false; }; "nodeMap": { "alias": "nodeMap"; "required": false; }; }, { "ruleSelected": "ruleSelected"; "ruleDeleted": "ruleDeleted"; "ruleAdded": "ruleAdded"; }, 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 };