@praxisui/visual-builder 0.0.1

package/index.d.ts

@@ -0,0 +1,3600 @@
+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 { SpecificationMetadata, Specification } from '@praxisui/specification-core';
+export { SpecificationMetadata } from '@praxisui/specification-core';
+import { Observable } from 'rxjs';
+import { FormBuilder, FormGroup, FormArray } from '@angular/forms';
+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 { MatSelectChange } from '@angular/material/select';
+import { MatSlideToggleChange } from '@angular/material/slide-toggle';
+import { MatChipInputEvent } from '@angular/material/chips';
+
+/**
+ * Models for the Visual Rule Builder
+ */
+
+/**
+ * Value types for rule configuration
+ */
+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';
+interface RuleNode {
+    /** Unique identifier for this rule node */
+    id: string;
+    /** Type of rule node */
+    type: RuleNodeType | RuleNodeTypeString;
+    /** Human-readable label for this rule */
+    label?: string;
+    /** Rule metadata */
+    metadata?: SpecificationMetadata;
+    /** Whether this node is currently selected */
+    selected?: boolean;
+    /** Whether this node is expanded (for groups) */
+    expanded?: boolean;
+    /** Parent node ID */
+    parentId?: string;
+    /** Child node IDs (for groups) */
+    children?: string[];
+    /** Rule-specific configuration */
+    config?: RuleNodeConfig;
+}
+declare enum RuleNodeType {
+    FIELD_CONDITION = "fieldCondition",
+    AND_GROUP = "andGroup",
+    OR_GROUP = "orGroup",
+    NOT_GROUP = "notGroup",
+    XOR_GROUP = "xorGroup",
+    IMPLIES_GROUP = "impliesGroup",
+    REQUIRED_IF = "requiredIf",
+    VISIBLE_IF = "visibleIf",
+    DISABLED_IF = "disabledIf",
+    READONLY_IF = "readonlyIf",
+    FOR_EACH = "forEach",
+    UNIQUE_BY = "uniqueBy",
+    MIN_LENGTH = "minLength",
+    MAX_LENGTH = "maxLength",
+    IF_DEFINED = "ifDefined",
+    IF_NOT_NULL = "ifNotNull",
+    IF_EXISTS = "ifExists",
+    WITH_DEFAULT = "withDefault",
+    FUNCTION_CALL = "functionCall",
+    FIELD_TO_FIELD = "fieldToField",
+    CONTEXTUAL = "contextual",
+    AT_LEAST = "atLeast",
+    EXACTLY = "exactly",
+    EXPRESSION = "expression",
+    CONTEXTUAL_TEMPLATE = "contextualTemplate",
+    CUSTOM = "custom"
+}
+/**
+ * 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;
+interface FieldConditionConfig {
+    type: 'fieldCondition';
+    /** Primary field name */
+    fieldName: string;
+    /** Comparison operator aligned with @praxisui/specification */
+    operator: ValidComparisonOperator | string;
+    /** Comparison value */
+    value: unknown;
+    /** Type of value for proper handling */
+    valueType?: ValueType;
+    /** Field to compare against (for field-to-field comparisons) */
+    compareToField?: string;
+    /** Context variable to use as value */
+    contextVariable?: string;
+    /** Optional metadata for error messages and UI hints */
+    metadata?: SpecificationMetadata;
+    /** Legacy field alias for backward compatibility */
+    field?: string;
+}
+interface BooleanGroupConfig {
+    type: 'booleanGroup' | 'andGroup' | 'orGroup' | 'notGroup' | 'xorGroup' | 'impliesGroup';
+    /** Boolean operator type */
+    operator: 'and' | 'or' | 'not' | 'xor' | 'implies';
+    /** Minimum required true conditions (for atLeast scenarios) */
+    minimumRequired?: number;
+    /** Exact required true conditions (for exactly scenarios) */
+    exactRequired?: number;
+    /** Optional metadata for group validation */
+    metadata?: SpecificationMetadata;
+}
+interface ConditionalValidatorConfig {
+    type: 'requiredIf' | 'visibleIf' | 'disabledIf' | 'readonlyIf';
+    /** Specific validator type (mirrors type for backward compatibility) */
+    validatorType: 'requiredIf' | 'visibleIf' | 'disabledIf' | 'readonlyIf';
+    /** Target field to apply conditional logic */
+    targetField: string;
+    /** Optional single condition (legacy support) */
+    condition?: RuleNode;
+    /** Multiple conditions for advanced mode */
+    conditions?: RuleNode[];
+    /** Reference to condition rule node ID (for backward compatibility) */
+    conditionNodeId?: string;
+    /** Whether to invert the condition result */
+    inverse?: boolean;
+    /** Logic operator to combine multiple conditions */
+    logicOperator?: 'and' | 'or';
+    /** Custom error message */
+    errorMessage?: string;
+    /** Validate on value change */
+    validateOnChange?: boolean;
+    /** Validate on blur */
+    validateOnBlur?: boolean;
+    /** Show error immediately */
+    showErrorImmediately?: boolean;
+    /** Animation type */
+    animation?: string;
+    /** Hide field label */
+    hideLabel?: boolean;
+    /** Preserve space when hidden */
+    preserveSpace?: boolean;
+    /** Style when disabled */
+    disabledStyle?: string;
+    /** Clear value when disabled */
+    clearOnDisable?: boolean;
+    /** Show disabled message */
+    showDisabledMessage?: boolean;
+    /** Custom disabled message */
+    disabledMessage?: string;
+    /** Readonly style */
+    readonlyStyle?: string;
+    /** Show readonly indicator */
+    showReadonlyIndicator?: boolean;
+    /** Metadata aligned with @praxisui/specification */
+    metadata?: SpecificationMetadata;
+}
+interface CollectionValidationConfig {
+    type: 'collectionValidation';
+    /** Type of collection validation */
+    validationType: 'forEach' | 'uniqueBy' | 'minLength' | 'maxLength';
+    /** Array field to validate */
+    arrayField: string;
+    /** Reference to rule node ID for forEach validation */
+    itemCondition?: string;
+    /** Property name for uniqueBy validation */
+    uniqueKey?: string;
+    /** Length value for min/max length validation */
+    lengthValue?: number;
+    /** Optional metadata for validation */
+    metadata?: SpecificationMetadata;
+}
+/**
+ * Enhanced collection validator configuration (Phase 2 Implementation)
+ * Aligned with @praxisui/specification collection validation patterns
+ */
+interface CollectionValidatorConfig {
+    type: 'forEach' | 'uniqueBy' | 'minLength' | 'maxLength';
+    /** Target collection field name */
+    targetCollection: string;
+    /** Variable name for current item in forEach */
+    itemVariable?: string;
+    /** Variable name for current index in forEach */
+    indexVariable?: string;
+    /** Validation rules applied to each item */
+    itemValidationRules?: {
+        ruleType: string;
+        fieldPath: string;
+        errorMessage?: string;
+    }[];
+    /** Fields to check uniqueness by */
+    uniqueByFields?: string[];
+    /** Case-sensitive uniqueness check */
+    caseSensitive?: boolean;
+    /** Ignore empty values in uniqueness check */
+    ignoreEmpty?: boolean;
+    /** Custom error message for duplicates */
+    duplicateErrorMessage?: string;
+    /** Minimum number of items */
+    minItems?: number;
+    /** Maximum number of items */
+    maxItems?: number;
+    /** Custom error message for length validation */
+    lengthErrorMessage?: string;
+    /** Show current item count in UI */
+    showItemCount?: boolean;
+    /** Prevent adding items beyond maxItems */
+    preventExcess?: boolean;
+    /** Validate when items are added */
+    validateOnAdd?: boolean;
+    /** Validate when items are removed */
+    validateOnRemove?: boolean;
+    /** Validate when items are changed */
+    validateOnChange?: boolean;
+    /** Validate on form submit */
+    validateOnSubmit?: boolean;
+    /** Error display strategy */
+    errorStrategy?: 'summary' | 'inline' | 'both';
+    /** Stop validation on first error */
+    stopOnFirstError?: boolean;
+    /** Highlight items with errors */
+    highlightErrorItems?: boolean;
+    /** Batch size for large collections */
+    batchSize?: number;
+    /** Debounce validation for performance */
+    debounceValidation?: boolean;
+    /** Debounce delay in milliseconds */
+    debounceDelay?: number;
+    /** Optional metadata for validation messages */
+    metadata?: SpecificationMetadata;
+}
+interface FunctionCallConfig {
+    type: 'functionCall';
+    /** Name of the function to call */
+    functionName: string;
+    /** Function parameters with type information */
+    parameters: FunctionParameter[];
+    /** Optional metadata for validation */
+    metadata?: SpecificationMetadata;
+}
+interface FunctionParameter {
+    /** Parameter name */
+    name: string;
+    /** Parameter value */
+    value: unknown;
+    /** Type of parameter value */
+    valueType: ValueType;
+    /** Field name if valueType is 'field' */
+    fieldName?: string;
+    /** Context variable name if valueType is 'context' */
+    contextVariable?: string;
+}
+interface FieldToFieldConfig {
+    type: 'fieldToField';
+    /** Left side field name */
+    leftField: string;
+    /** Comparison operator */
+    operator: ValidComparisonOperator | string;
+    /** Right side field name */
+    rightField: string;
+    /** Transform functions applied to left field */
+    leftTransforms?: string[];
+    /** Transform functions applied to right field */
+    rightTransforms?: string[];
+    /** Optional metadata for validation */
+    metadata?: SpecificationMetadata;
+}
+interface ContextualConfig$1 {
+    type: 'contextual';
+    /** Template string with context placeholders */
+    template: string;
+    /** Available context variables */
+    contextVariables: Record<string, unknown>;
+    /** Optional context provider for dynamic values */
+    contextProvider?: ContextProvider;
+    /** Strict validation of context tokens */
+    strictContextValidation?: boolean;
+    /** Optional metadata */
+    metadata?: SpecificationMetadata;
+}
+interface CardinalityConfig {
+    type: 'cardinality';
+    /** Type of cardinality check */
+    cardinalityType: 'atLeast' | 'exactly';
+    /** Required count of true conditions */
+    count: number;
+    /** References to rule node IDs to evaluate */
+    conditions: string[];
+    /** Optional metadata for validation */
+    metadata?: SpecificationMetadata;
+}
+interface CustomConfig {
+    type: 'custom';
+    /** Custom configuration type identifier */
+    customType: string;
+    /** Custom properties specific to the type */
+    properties: Record<string, unknown>;
+    /** Optional metadata for validation */
+    metadata?: SpecificationMetadata;
+}
+/**
+ * Validator types for conditional validation
+ */
+declare enum ConditionalValidatorType {
+    REQUIRED_IF = "requiredIf",
+    VISIBLE_IF = "visibleIf",
+    DISABLED_IF = "disabledIf",
+    READONLY_IF = "readonlyIf"
+}
+/**
+ * Preview data for conditional validator simulation
+ */
+interface ConditionalValidatorPreview {
+    targetField: string;
+    currentValue: unknown;
+    conditionResult: boolean;
+    validatorType: ConditionalValidatorType;
+    resultingState: {
+        isRequired?: boolean;
+        isVisible?: boolean;
+        isDisabled?: boolean;
+        isReadonly?: boolean;
+    };
+    example: string;
+}
+/**
+ * Rule building session state
+ */
+interface RuleBuilderState {
+    /** All rule nodes in the current session */
+    nodes: Record<string, RuleNode>;
+    /** Root node IDs (top-level rules) */
+    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';
+    /** Whether the rule is dirty (has unsaved changes) */
+    isDirty: boolean;
+    /** Undo/redo history */
+    history: RuleBuilderSnapshot[];
+    /** Current history position */
+    historyPosition: number;
+}
+interface ValidationError$1 {
+    /** Error ID */
+    id: string;
+    /** Error message */
+    message: string;
+    /** Error severity */
+    severity: 'error' | 'warning' | 'info';
+    /** Associated node ID */
+    nodeId?: string;
+    /** Error code for programmatic handling */
+    code?: string;
+    /** Suggested fix */
+    suggestion?: string;
+}
+interface RuleBuilderSnapshot {
+    /** Timestamp of this snapshot */
+    timestamp: number;
+    /** Description of the change */
+    description: string;
+    /** Complete state at this point */
+    state: {
+        nodes: Record<string, RuleNode>;
+        rootNodes: string[];
+        selectedNodeId?: string;
+    };
+}
+/**
+ * Rule template for common scenarios
+ */
+interface RuleTemplate {
+    /** Template ID */
+    id: string;
+    /** Template name */
+    name: string;
+    /** Template description */
+    description: string;
+    /** Template category */
+    category: string;
+    /** Template tags for search */
+    tags: string[];
+    /** Rule nodes that make up this template */
+    nodes: RuleNode[];
+    /** Root node IDs */
+    rootNodes: string[];
+    /** Required field schemas for this template */
+    requiredFields?: string[];
+    /** Example usage */
+    example?: string;
+    /** Template preview image/icon */
+    icon?: string;
+    /** Template metadata */
+    metadata?: TemplateMetadata;
+}
+/**
+ * Template metadata for tracking and management
+ */
+interface TemplateMetadata {
+    /** Creation date */
+    createdAt?: Date;
+    /** Last update date */
+    updatedAt?: Date;
+    /** Last used date */
+    lastUsed?: Date;
+    /** Import date (if imported) */
+    importedAt?: Date;
+    /** Template version */
+    version?: string;
+    /** Usage count */
+    usageCount?: number;
+    /** Template complexity */
+    complexity?: 'simple' | 'medium' | 'complex';
+    /** Original template ID (for imports/copies) */
+    originalId?: string;
+    /** Author information */
+    author?: {
+        name?: string;
+        email?: string;
+        organization?: string;
+    };
+    /** Template size metrics */
+    metrics?: {
+        nodeCount?: number;
+        maxDepth?: number;
+        fieldCount?: number;
+    };
+}
+/**
+ * Export options for rules
+ */
+interface ExportOptions {
+    /** Export format */
+    format: 'json' | 'dsl' | 'typescript' | 'form-config';
+    /** Include metadata in export */
+    includeMetadata?: boolean;
+    /** Pretty print JSON/DSL */
+    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 */
+    config?: Record<string, unknown>;
+}
+/**
+ * Import options for rules
+ */
+interface ImportOptions {
+    /** Source format */
+    format: 'json' | 'dsl' | 'form-config';
+    /** Whether to merge with existing rules */
+    merge?: boolean;
+    /** Whether to preserve existing metadata */
+    preserveMetadata?: boolean;
+    /** Field schema mapping for validation */
+    fieldSchemas?: Record<string, unknown>;
+}
+/**
+ * Rule builder configuration
+ */
+interface RuleBuilderConfig {
+    /** Available field schemas */
+    fieldSchemas: Record<string, unknown>;
+    /** Context variables */
+    contextVariables?: unknown[];
+    /** Custom functions */
+    customFunctions?: unknown[];
+    /** Available rule templates */
+    templates?: RuleTemplate[];
+    /** UI configuration */
+    ui?: {
+        /** Theme */
+        theme?: 'light' | 'dark' | 'auto';
+        /** Show advanced features */
+        showAdvanced?: boolean;
+        /** Enable drag and drop */
+        enableDragDrop?: boolean;
+        /** Show DSL preview */
+        showDSLPreview?: boolean;
+        /** Show validation errors inline */
+        showInlineErrors?: boolean;
+        /** Auto-save interval (ms) */
+        autoSaveInterval?: number;
+    };
+    /** Validation configuration */
+    validation?: {
+        /** Enable real-time validation */
+        realTime?: boolean;
+        /** Validation strictness */
+        strictness?: 'strict' | 'normal' | 'loose';
+        /** Custom validation rules */
+        customRules?: unknown[];
+    };
+    /** Export/import configuration */
+    exportImport?: {
+        /** Default export format */
+        defaultExportFormat?: 'json' | 'dsl' | 'typescript';
+        /** Supported formats */
+        supportedFormats?: string[];
+        /** Include metadata by default */
+        includeMetadataByDefault?: boolean;
+    };
+}
+/**
+ * Configuration for optional field handling
+ */
+interface OptionalFieldConfig {
+    type: 'optionalField';
+    /** Type of optional field validation */
+    validationType: 'ifDefined' | 'ifNotNull' | 'ifExists' | 'withDefault';
+    /** Target field name */
+    fieldName: string;
+    /** Default value when field is undefined/null */
+    defaultValue?: unknown;
+    /** Reference to condition rule node ID */
+    conditionNodeId?: string;
+    /** Optional metadata for validation */
+    metadata?: SpecificationMetadata;
+}
+/**
+ * Configuration for expression specifications (aligned with @praxisui/specification)
+ */
+interface ExpressionConfig {
+    type: 'expression';
+    /** DSL expression string */
+    expression: string;
+    /** Function registry for validation */
+    functionRegistry?: FunctionRegistry<unknown>;
+    /** Context provider for variable resolution */
+    contextProvider?: ContextProvider;
+    /** Known field names for validation */
+    knownFields?: string[];
+    /** Enable performance warnings */
+    enablePerformanceWarnings?: boolean;
+    /** Maximum expression complexity */
+    maxComplexity?: number;
+    /** Metadata aligned with @praxisui/specification */
+    metadata?: SpecificationMetadata;
+}
+/**
+ * Configuration for contextual template specifications (aligned with @praxisui/specification)
+ */
+interface ContextualTemplateConfig {
+    type: 'contextualTemplate';
+    /** Template string with context tokens */
+    template: string;
+    /** Available context variables */
+    contextVariables?: Record<string, unknown>;
+    /** Context provider instance */
+    contextProvider?: ContextProvider;
+    /** Enable strict validation of context tokens */
+    strictContextValidation?: boolean;
+    /** Metadata aligned with @praxisui/specification */
+    metadata?: SpecificationMetadata;
+}
+
+declare class PraxisVisualBuilder {
+    config: RuleBuilderConfig | null;
+    initialRules: any;
+    rulesChanged: EventEmitter<any>;
+    exportRequested: EventEmitter<ExportOptions>;
+    importRequested: EventEmitter<ImportOptions>;
+    onRulesChanged(rules: any): void;
+    onExportRequested(options: ExportOptions): void;
+    onImportRequested(options: ImportOptions): 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>;
+}
+
+/**
+ * Field schema model for dynamic field configuration in the Visual Builder
+ */
+interface FieldSchema {
+    /** Unique field identifier */
+    name: string;
+    /** Human-readable field label */
+    label: string;
+    /** Field data type */
+    type: FieldType;
+    /** Optional description or help text */
+    description?: string;
+    /** Whether this field is required */
+    required?: boolean;
+    /** Allowed values for enum/select fields */
+    allowedValues?: FieldOption[];
+    /** Format constraints for the field */
+    format?: FieldFormat;
+    /** UI configuration for field display */
+    uiConfig?: FieldUIConfig;
+    /** Nested fields for object types */
+    properties?: Record<string, FieldSchema>;
+    /** Item schema for array types */
+    items?: FieldSchema;
+}
+interface FieldOption {
+    /** Option value */
+    value: any;
+    /** Option display label */
+    label: string;
+    /** Optional description */
+    description?: string;
+    /** Whether this option is disabled */
+    disabled?: boolean;
+}
+interface FieldFormat {
+    /** Minimum value (for numbers) or length (for strings/arrays) */
+    minimum?: number;
+    /** Maximum value (for numbers) or length (for strings/arrays) */
+    maximum?: number;
+    /** Regular expression pattern for string validation */
+    pattern?: string;
+    /** Date format for date fields */
+    dateFormat?: string;
+    /** Number format options */
+    numberFormat?: {
+        decimals?: number;
+        currency?: string;
+        percentage?: boolean;
+    };
+}
+interface FieldUIConfig {
+    /** Icon to display with the field */
+    icon?: string;
+    /** Color theme for the field */
+    color?: string;
+    /** Field category for grouping */
+    category?: string;
+    /** Field priority for sorting */
+    priority?: number;
+    /** Whether to show this field in simple mode */
+    showInSimpleMode?: boolean;
+    /** Custom CSS classes */
+    cssClass?: string;
+}
+declare enum FieldType {
+    STRING = "string",
+    NUMBER = "number",
+    INTEGER = "integer",
+    BOOLEAN = "boolean",
+    DATE = "date",
+    DATETIME = "datetime",
+    TIME = "time",
+    EMAIL = "email",
+    URL = "url",
+    PHONE = "phone",
+    ARRAY = "array",
+    OBJECT = "object",
+    ENUM = "enum",
+    UUID = "uuid",
+    JSON = "json"
+}
+/**
+ * Available comparison operators for each field type
+ */
+declare const FIELD_TYPE_OPERATORS: Record<FieldType, string[]>;
+/**
+ * Operator display labels for UI
+ */
+declare const OPERATOR_LABELS: Record<string, string>;
+/**
+ * Context for field schema interpretation
+ */
+interface FieldSchemaContext {
+    /** Available context variables (e.g., ${user.role}, ${now}) */
+    contextVariables?: ContextVariable[];
+    /** Available custom functions */
+    customFunctions?: CustomFunction[];
+    /** Global configuration */
+    config?: {
+        /** Whether to show advanced features */
+        showAdvanced?: boolean;
+        /** Default locale for formatting */
+        locale?: string;
+        /** Theme configuration */
+        theme?: 'light' | 'dark' | 'auto';
+    };
+}
+interface ContextVariable {
+    /** Variable name (without ${} wrapper) */
+    name: string;
+    /** Display label */
+    label: string;
+    /** Variable type */
+    type: FieldType;
+    /** Example value for preview */
+    example?: any;
+    /** Description */
+    description?: string;
+}
+interface CustomFunction {
+    /** Function name */
+    name: string;
+    /** Display label */
+    label: string;
+    /** Function description */
+    description?: string;
+    /** Expected parameter types */
+    parameters: {
+        name: string;
+        type: FieldType;
+        required?: boolean;
+        description?: string;
+    }[];
+    /** Return type */
+    returnType: FieldType;
+    /** Example usage */
+    example?: string;
+}
+
+/**
+ * Array Field Schema Support for Collection Validators
+ * Phase 2 Implementation
+ */
+
+/**
+ * Extended field schema for array types
+ */
+interface ArrayFieldSchema extends FieldSchema {
+    type: FieldType.ARRAY;
+    /** Schema for individual items in the array */
+    itemSchema?: FieldSchema;
+    /** Minimum number of items */
+    minItems?: number;
+    /** Maximum number of items */
+    maxItems?: number;
+    /** Whether items must be unique */
+    uniqueItems?: boolean;
+    /** Fields to check for uniqueness */
+    uniqueBy?: string[];
+    /** Default value for new items */
+    defaultItem?: any;
+    /** Whether to allow adding items */
+    allowAdd?: boolean;
+    /** Whether to allow removing items */
+    allowRemove?: boolean;
+    /** Whether to allow reordering items */
+    allowReorder?: boolean;
+    /** Custom validation rules for the array */
+    arrayValidation?: {
+        forEach?: {
+            rules: any[];
+            stopOnFirstError?: boolean;
+        };
+        uniqueBy?: {
+            fields: string[];
+            caseSensitive?: boolean;
+            ignoreEmpty?: boolean;
+        };
+        length?: {
+            min?: number;
+            max?: number;
+            errorMessage?: string;
+        };
+    };
+    /** UI configuration specific to arrays */
+    arrayUiConfig?: {
+        /** How to display the array */
+        displayMode?: 'table' | 'cards' | 'list' | 'accordion';
+        /** Whether to show item count */
+        showCount?: boolean;
+        /** Custom add button text */
+        addButtonText?: string;
+        /** Custom remove button text */
+        removeButtonText?: string;
+        /** Whether to confirm before removing */
+        confirmRemove?: boolean;
+        /** Message to show when array is empty */
+        emptyMessage?: string;
+        /** Whether to collapse items by default */
+        collapsedByDefault?: boolean;
+        /** Maximum items to show before pagination */
+        pageSize?: number;
+    };
+}
+/**
+ * Utility to check if a field schema is an array
+ */
+declare function isArrayFieldSchema(schema: FieldSchema): schema is ArrayFieldSchema;
+/**
+ * Utility to get nested field paths from an array schema
+ */
+declare function getArrayItemFieldPaths(schema: ArrayFieldSchema, prefix?: string): string[];
+/**
+ * Array validation context for runtime validation
+ */
+interface ArrayValidationContext {
+    /** The array being validated */
+    array: any[];
+    /** Current item being validated (for forEach) */
+    currentItem?: any;
+    /** Current item index (for forEach) */
+    currentIndex?: number;
+    /** Parent context */
+    parentContext?: any;
+    /** Field schema */
+    schema: ArrayFieldSchema;
+    /** Accumulated errors */
+    errors: ArrayValidationError[];
+}
+/**
+ * Array validation error
+ */
+interface ArrayValidationError {
+    /** Error type */
+    type: 'forEach' | 'uniqueBy' | 'minLength' | 'maxLength' | 'other';
+    /** Error message */
+    message: string;
+    /** Item index (if applicable) */
+    itemIndex?: number;
+    /** Field path within item (if applicable) */
+    fieldPath?: string;
+    /** Duplicate indices (for uniqueBy) */
+    duplicateIndices?: number[];
+    /** Expected value */
+    expected?: any;
+    /** Actual value */
+    actual?: any;
+}
+/**
+ * Array field analyzer for detecting array fields in schemas
+ */
+declare class ArrayFieldAnalyzer {
+    /**
+     * Analyze a schema tree and find all array fields
+     */
+    static findArrayFields(schemas: Record<string, FieldSchema>): Record<string, ArrayFieldSchema>;
+    /**
+     * Get validation rules for an array field
+     */
+    static getValidationRules(schema: ArrayFieldSchema): ArrayCollectionValidationRule[];
+}
+/**
+ * Array collection validation rule
+ */
+interface ArrayCollectionValidationRule {
+    type: 'forEach' | 'uniqueBy' | 'minLength' | 'maxLength';
+    value?: any;
+    fields?: string[];
+    rules?: any[];
+    message: string;
+}
+
+declare class FieldSchemaService {
+    private readonly _fieldSchemas;
+    private readonly _context;
+    readonly fieldSchemas$: Observable<Record<string, FieldSchema>>;
+    readonly context$: Observable<FieldSchemaContext>;
+    constructor();
+    /**
+     * Set field schemas for the visual builder
+     */
+    setFieldSchemas(schemas: Record<string, FieldSchema>): void;
+    /**
+     * Add a single field schema
+     */
+    addFieldSchema(name: string, schema: FieldSchema): void;
+    /**
+     * Remove a field schema
+     */
+    removeFieldSchema(name: string): void;
+    /**
+     * Get field schema by name
+     */
+    getFieldSchema(name: string): FieldSchema | undefined;
+    /**
+     * Get all field schemas
+     */
+    getAllFieldSchemas(): Record<string, FieldSchema>;
+    /**
+     * Get field schemas as array with enhanced info
+     */
+    getFieldSchemasArray(): Observable<EnhancedFieldSchema[]>;
+    /**
+     * Set context for field schemas
+     */
+    setContext(context: FieldSchemaContext): void;
+    /**
+     * Get available operators for a field type
+     */
+    getAvailableOperators(fieldType: FieldType): string[];
+    /**
+     * Get operator labels for a field type
+     */
+    getOperatorLabels(fieldType: FieldType): Record<string, string>;
+    /**
+     * Validate field value against schema
+     */
+    validateFieldValue(fieldName: string, value: any): ValidationResult;
+    /**
+     * Get field suggestions based on partial input
+     */
+    getFieldSuggestions(partial: string, category?: string): FieldSchema[];
+    /**
+     * Create field schema from JSON Schema
+     */
+    createFromJsonSchema(jsonSchema: any): Record<string, FieldSchema>;
+    /**
+     * Create field schema from form metadata
+     */
+    createFromFormMetadata(formFields: any[]): Record<string, FieldSchema>;
+    /**
+     * Get context variables
+     */
+    getContextVariables(): Observable<ContextVariable[]>;
+    /**
+     * Get custom functions
+     */
+    getCustomFunctions(): Observable<CustomFunction[]>;
+    /**
+     * Group field schemas by category
+     */
+    getFieldSchemasByCategory(): Observable<Record<string, FieldSchema[]>>;
+    private isValidType;
+    private validateFormat;
+    private convertJsonSchemaProperty;
+    private mapJsonSchemaType;
+    private mapFormFieldType;
+    private extractFormatFromField;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FieldSchemaService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FieldSchemaService>;
+}
+interface EnhancedFieldSchema extends FieldSchema {
+    operators: string[];
+    operatorLabels: Record<string, string>;
+}
+interface ValidationResult {
+    valid: boolean;
+    errors: string[];
+}
+
+interface DslContextVariable {
+    /** Variable name */
+    name: string;
+    /** Variable type */
+    type: 'string' | 'number' | 'boolean' | 'date' | 'object' | 'array';
+    /** Variable scope */
+    scope: 'user' | 'session' | 'env' | 'global';
+    /** 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.
+ */
+declare class RuleNodeRegistryService {
+    private nodes;
+    private nodesSubject;
+    /**
+     * Observable stream of all registered nodes
+     */
+    nodes$: Observable<Map<string, RuleNode>>;
+    /**
+     * Register a node in the registry
+     */
+    register(node: RuleNode): void;
+    /**
+     * Register multiple nodes at once
+     */
+    registerAll(nodes: RuleNode[]): void;
+    /**
+     * Unregister a node from the registry
+     */
+    unregister(nodeId: string): boolean;
+    /**
+     * Resolve a node by its ID
+     */
+    resolve(nodeId: string): RuleNode | null;
+    /**
+     * Retrieve a node synchronously by its ID.
+     *
+     * Provided for backwards compatibility with code that expected a
+     * synchronous `getNode` API. Internally this simply delegates to
+     * {@link resolve}.
+     */
+    getNode(nodeId: string): RuleNode | null;
+    /**
+     * Resolve multiple nodes by their IDs
+     */
+    resolveMultiple(nodeIds: string[]): RuleNode[];
+    /**
+     * Resolve children nodes for a given node
+     */
+    resolveChildren(node: RuleNode): RuleNode[];
+    /**
+     * Get all nodes that have the specified parent ID
+     */
+    getChildrenOf(parentId: string): RuleNode[];
+    /**
+     * Get the parent node of a given node
+     */
+    getParent(node: RuleNode): RuleNode | null;
+    /**
+     * Get all root nodes (nodes without parents)
+     */
+    getRootNodes(): RuleNode[];
+    /**
+     * Check if a node exists in the registry
+     */
+    exists(nodeId: string): boolean;
+    /**
+     * Get all registered node IDs
+     */
+    getAllIds(): string[];
+    /**
+     * Get all registered nodes
+     */
+    getAllNodes(): RuleNode[];
+    /**
+     * Clear all nodes from the registry
+     */
+    clear(): void;
+    /**
+     * Get the size of the registry
+     */
+    size(): number;
+    /**
+     * Remove orphaned nodes (nodes without parents and not referenced by others)
+     */
+    cleanupOrphanedNodes(): string[];
+    /**
+     * Detect circular references in the registry
+     */
+    detectCircularReferences(): CircularReference[];
+    /**
+     * Get memory usage statistics
+     */
+    getMemoryStats(): MemoryStats;
+    /**
+     * Validate registry integrity
+     */
+    validateIntegrity(): RegistryIntegrityResult;
+    /**
+     * Perform automatic cleanup operations
+     */
+    performCleanup(): CleanupResult;
+    /**
+     * Build a tree structure starting from root nodes
+     */
+    buildTree(): RuleNodeTree[];
+    /**
+     * Build tree structure for a specific node
+     */
+    buildNodeTree(node: RuleNode): RuleNodeTree;
+    /**
+     * Find nodes by a predicate function
+     */
+    findNodes(predicate: (node: RuleNode) => boolean): RuleNode[];
+    /**
+     * Find nodes by type
+     */
+    findNodesByType(type: string): RuleNode[];
+    /**
+     * Validate the graph structure integrity (legacy method for backward compatibility)
+     */
+    validateGraphIntegrity(): RegistryValidationResult;
+    /**
+     * Check if a node has circular references
+     */
+    private hasCircularReference;
+    /**
+     * Get observable for a specific node
+     */
+    getNode$(nodeId: string): Observable<RuleNode | null>;
+    /**
+     * Get observable for children of a node
+     */
+    getChildren$(nodeId: string): Observable<RuleNode[]>;
+    private notifyChange;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RuleNodeRegistryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RuleNodeRegistryService>;
+}
+/**
+ * Tree structure for representing node hierarchies
+ */
+interface RuleNodeTree {
+    node: RuleNode;
+    children: RuleNodeTree[];
+}
+/**
+ * Result of registry integrity validation
+ */
+interface RegistryValidationResult {
+    isValid: boolean;
+    errors: string[];
+    warnings: string[];
+}
+/**
+ * Circular reference information
+ */
+interface CircularReference {
+    cycle: string[];
+    affectedNodes: string[];
+}
+/**
+ * Memory usage statistics
+ */
+interface MemoryStats {
+    totalNodes: number;
+    estimatedSizeBytes: number;
+    breakdown: {
+        config: number;
+        children: number;
+        metadata: number;
+        other: number;
+    };
+}
+/**
+ * Registry integrity validation result
+ */
+interface RegistryIntegrityResult {
+    isValid: boolean;
+    issues: string[];
+    warnings: string[];
+    circularReferences: CircularReference[];
+    memoryStats: MemoryStats;
+}
+/**
+ * Cleanup operation result
+ */
+interface CleanupResult {
+    orphanedNodesRemoved: string[];
+    circularReferencesDetected: CircularReference[];
+    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;
+    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 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
+ */
+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>;
+    /**
+     * 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$1): DslParsingResult$1<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$1): {
+        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 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$1): {
+        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[];
+    };
+}
+declare class RoundTripValidatorService {
+    private specificationBridge;
+    private dslParser;
+    constructor(specificationBridge: SpecificationBridgeService);
+    /**
+     * Validates complete round-trip conversion: Visual → DSL → Visual
+     */
+    validateRoundTrip(visualRule: 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 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);
+    /**
+     * Initialize the rule builder with configuration
+     */
+    initialize(config: RuleBuilderConfig): void;
+    /**
+     * Get current state
+     */
+    getCurrentState(): RuleBuilderState;
+    /**
+     * Add a new rule node
+     */
+    addNode(node: Partial<RuleNode>, parentId?: string): string;
+    /**
+     * Update an existing rule node
+     */
+    updateNode(nodeId: string, updates: Partial<RuleNode>): void;
+    /**
+     * Remove a rule node
+     */
+    removeNode(nodeId: string): void;
+    /**
+     * Select a rule node
+     */
+    selectNode(nodeId?: string): void;
+    /**
+     * Move a node to a new parent
+     */
+    moveNode(nodeId: string, newParentId?: string, index?: number): void;
+    /**
+     * Convert current rules to Specification
+     */
+    toSpecification(): Specification<any> | null;
+    /**
+     * Export current rules
+     */
+    export(options: ExportOptions): string;
+    /**
+     * 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(content: string, options: ImportOptions): void;
+    /**
+     * Undo last action
+     */
+    undo(): void;
+    /**
+     * Redo last undone action
+     */
+    redo(): void;
+    /**
+     * Clear all rules
+     */
+    clear(): void;
+    /**
+     * Validate current rules
+     */
+    validateRules(): void;
+    /**
+     * Validates round-trip conversion for all root nodes
+     */
+    private validateRoundTrip;
+    /**
+     * Runs comprehensive round-trip validation for current state
+     */
+    runRoundTripValidation(): {
+        success: boolean;
+        results: Array<{
+            nodeId: string;
+            result: any;
+        }>;
+        summary: {
+            totalNodes: number;
+            successfulNodes: number;
+            failedNodes: number;
+            totalErrors: number;
+            totalWarnings: number;
+        };
+    };
+    private getInitialState;
+    private updateState;
+    private saveSnapshot;
+    private generateNodeLabel;
+    private buildRuleNodeTree;
+    private flattenRuleNodeTree;
+    private validateNode;
+    private validateStructure;
+    private exportToTypeScript;
+    private exportToFormConfig;
+    private normalizeSpecJson;
+    private isBuilderState;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RuleBuilderService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RuleBuilderService>;
+}
+
+interface ExportFormat {
+    id: string;
+    name: string;
+    description: string;
+    fileExtension: string;
+    mimeType: string;
+    supportsMetadata: boolean;
+    supportsComments: boolean;
+}
+interface ExportResult {
+    success: boolean;
+    content: string;
+    format: ExportFormat;
+    filename: string;
+    size: number;
+    metadata?: {
+        rulesCount: number;
+        complexity: 'low' | 'medium' | 'high';
+        exportedAt: string;
+        version: string;
+    };
+    errors?: string[];
+    warnings?: string[];
+}
+interface IntegrationEndpoint {
+    id: string;
+    name: string;
+    description: string;
+    url?: string;
+    method: 'GET' | 'POST' | 'PUT' | 'PATCH';
+    headers?: Record<string, string>;
+    authentication?: {
+        type: 'none' | 'basic' | 'bearer' | 'apikey';
+        credentials?: any;
+    };
+    supportedFormats: string[];
+    responseFormat?: 'json' | 'xml' | 'text';
+}
+interface IntegrationResult {
+    success: boolean;
+    endpoint: IntegrationEndpoint;
+    response?: any;
+    statusCode?: number;
+    error?: string;
+    timestamp: string;
+}
+interface ExternalSystemConfig {
+    id: string;
+    name: string;
+    type: 'rest-api' | 'webhook' | 'file-system' | 'database' | 'cloud-storage';
+    config: any;
+    endpoints: IntegrationEndpoint[];
+    enabled: boolean;
+}
+declare class ExportIntegrationService {
+    private ruleBuilderService;
+    private specificationBridge;
+    private readonly SUPPORTED_FORMATS;
+    private externalSystems;
+    constructor(ruleBuilderService: RuleBuilderService, specificationBridge: SpecificationBridgeService);
+    /**
+     * Gets all supported export formats
+     */
+    getSupportedFormats(): ExportFormat[];
+    /**
+     * Gets a specific export format by ID
+     */
+    getFormat(formatId: string): ExportFormat | null;
+    /**
+     * Exports current rules in the specified format
+     */
+    exportRules(options: {
+        format: string;
+        includeMetadata?: boolean;
+        prettyPrint?: boolean;
+        includeComments?: boolean;
+        customFilename?: string;
+        downloadFile?: boolean;
+    }): Observable<ExportResult>;
+    /**
+     * Exports rules to multiple formats simultaneously
+     */
+    exportToMultipleFormats(formats: string[], options?: any): Observable<ExportResult[]>;
+    /**
+     * Integrates with external system
+     */
+    integrateWithSystem(systemId: string, endpointId: string, exportFormat: string, options?: any): Observable<IntegrationResult>;
+    /**
+     * Registers a new external system configuration
+     */
+    registerExternalSystem(config: ExternalSystemConfig): void;
+    /**
+     * Gets all registered external systems
+     */
+    getExternalSystems(): ExternalSystemConfig[];
+    /**
+     * Tests connectivity to an external system
+     */
+    testSystemConnectivity(systemId: string): Observable<{
+        success: boolean;
+        message: string;
+    }>;
+    /**
+     * Creates a shareable link for rules
+     */
+    createShareableLink(options: {
+        format: string;
+        expiration?: Date;
+        accessLevel?: 'public' | 'protected' | 'private';
+        password?: string;
+    }): Observable<{
+        url: string;
+        token: string;
+        expiresAt?: Date;
+    }>;
+    /**
+     * Imports rules from external source
+     */
+    importFromExternal(source: {
+        type: 'url' | 'file' | 'system';
+        location: string;
+        format: string;
+        authentication?: any;
+    }): Observable<{
+        success: boolean;
+        imported: any;
+        errors?: string[];
+    }>;
+    /**
+     * Private implementation methods
+     */
+    private performExport;
+    private generateContent;
+    private generateJson;
+    private generateJsonSchema;
+    private generateDsl;
+    private generateYaml;
+    private generateXml;
+    private generateTypeScript;
+    private generateOpenApi;
+    private generateCsv;
+    private performIntegration;
+    private sendToEndpoint;
+    private performConnectivityTest;
+    private generateShareableLink;
+    private performExternalImport;
+    private buildCompleteRuleNode;
+    private flattenCompleteRuleNode;
+    private generateExportMetadata;
+    private generateFilename;
+    private downloadFile;
+    private generateToken;
+    private generateSchemaProperties;
+    private generateSchemaRequired;
+    private convertNodeToYamlObject;
+    private objectToYaml;
+    private nodeToXml;
+    private escapeXml;
+    private generateOpenApiSchemas;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ExportIntegrationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ExportIntegrationService>;
+}
+
+interface WebhookConfig {
+    id: string;
+    name: string;
+    url: string;
+    method: 'POST' | 'PUT' | 'PATCH';
+    headers?: Record<string, string>;
+    authentication?: {
+        type: 'none' | 'basic' | 'bearer' | 'apikey';
+        credentials: any;
+    };
+    format: string;
+    events: WebhookEvent[];
+    enabled: boolean;
+    retryConfig?: {
+        maxRetries: number;
+        retryDelay: number;
+        backoffMultiplier: number;
+    };
+    filtering?: {
+        includeMetadata: boolean;
+        minRuleCount?: number;
+        maxRuleCount?: number;
+        ruleTypes?: string[];
+    };
+}
+interface WebhookEvent {
+    type: 'rule-added' | 'rule-updated' | 'rule-deleted' | 'rules-imported' | 'rules-exported' | 'validation-changed';
+    description: string;
+    enabled: boolean;
+}
+interface WebhookDelivery {
+    id: string;
+    webhookId: string;
+    event: string;
+    url: string;
+    payload: any;
+    status: 'pending' | 'delivered' | 'failed' | 'retrying';
+    attempts: number;
+    lastAttempt?: Date;
+    nextRetry?: Date;
+    response?: {
+        statusCode: number;
+        headers: Record<string, string>;
+        body: string;
+    };
+    error?: string;
+    createdAt: Date;
+    deliveredAt?: Date;
+}
+interface WebhookStats {
+    totalDeliveries: number;
+    successfulDeliveries: number;
+    failedDeliveries: number;
+    pendingDeliveries: number;
+    successRate: number;
+    lastDelivery?: Date;
+    averageResponseTime?: number;
+}
+declare class WebhookIntegrationService {
+    private ruleBuilderService;
+    private exportService;
+    private webhooks;
+    private deliveries;
+    private deliveryQueue;
+    private statusUpdates;
+    private readonly SUPPORTED_EVENTS;
+    readonly webhookStats$: Observable<Record<string, WebhookStats>>;
+    constructor(ruleBuilderService: RuleBuilderService, exportService: ExportIntegrationService);
+    /**
+     * Registers a new webhook configuration
+     */
+    registerWebhook(config: WebhookConfig): void;
+    /**
+     * Removes a webhook configuration
+     */
+    unregisterWebhook(webhookId: string): void;
+    /**
+     * Gets all registered webhooks
+     */
+    getWebhooks(): WebhookConfig[];
+    /**
+     * Gets a specific webhook by ID
+     */
+    getWebhook(webhookId: string): WebhookConfig | null;
+    /**
+     * Updates webhook configuration
+     */
+    updateWebhook(webhookId: string, updates: Partial<WebhookConfig>): void;
+    /**
+     * Enables or disables a webhook
+     */
+    toggleWebhook(webhookId: string, enabled: boolean): void;
+    /**
+     * Tests a webhook by sending a test payload
+     */
+    testWebhook(webhookId: string): Observable<WebhookDelivery>;
+    /**
+     * Gets delivery history for a webhook
+     */
+    getDeliveryHistory(webhookId: string, limit?: number): WebhookDelivery[];
+    /**
+     * Gets overall delivery statistics
+     */
+    getDeliveryStats(webhookId?: string): WebhookStats;
+    /**
+     * Retries failed deliveries
+     */
+    retryFailedDeliveries(webhookId?: string): void;
+    /**
+     * Clears delivery history
+     */
+    clearDeliveryHistory(webhookId?: string): void;
+    /**
+     * Gets supported webhook events
+     */
+    getSupportedEvents(): WebhookEvent[];
+    /**
+     * Manually triggers a webhook for testing
+     */
+    triggerWebhook(webhookId: string, eventType: string, payload: any): Observable<WebhookDelivery>;
+    /**
+     * Private implementation methods
+     */
+    private initializeWebhookProcessing;
+    private subscribeToRuleChanges;
+    private handleRuleChange;
+    private handleValidationChange;
+    private shouldTriggerWebhook;
+    private generateEventPayload;
+    private queueDelivery;
+    private preparePayload;
+    private deliverWebhook;
+    private sendWebhookRequest;
+    private updateDelivery;
+    private processRetries;
+    private updateStats;
+    private generateDeliveryId;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WebhookIntegrationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<WebhookIntegrationService>;
+}
+
+/**
+ * Template category for organization
+ */
+interface TemplateCategory {
+    id: string;
+    name: string;
+    description?: string;
+    icon?: string;
+    color?: string;
+    templates: RuleTemplate[];
+}
+/**
+ * Template search criteria
+ */
+interface TemplateSearchCriteria {
+    query?: string;
+    category?: string;
+    tags?: string[];
+    nodeTypes?: string[];
+    complexity?: 'simple' | 'medium' | 'complex';
+    dateRange?: {
+        from?: Date;
+        to?: Date;
+    };
+}
+/**
+ * Template validation result
+ */
+interface TemplateValidationResult {
+    isValid: boolean;
+    errors: string[];
+    warnings: string[];
+    missingFields?: string[];
+    incompatibleFeatures?: string[];
+}
+/**
+ * Template application result
+ */
+interface TemplateApplicationResult {
+    success: boolean;
+    appliedNodes: RuleNode[];
+    errors: string[];
+    warnings: string[];
+    modifiedNodeIds: string[];
+}
+/**
+ * Template statistics
+ */
+interface TemplateStats {
+    totalTemplates: number;
+    categoriesCount: number;
+    mostUsedTemplate?: RuleTemplate;
+    recentlyUsed: RuleTemplate[];
+    popularTags: string[];
+}
+declare class RuleTemplateService {
+    private bridgeService;
+    private readonly STORAGE_KEY;
+    private readonly VERSION_KEY;
+    private readonly CURRENT_VERSION;
+    private templatesSubject;
+    private categoriesSubject;
+    private recentlyUsedSubject;
+    templates$: Observable<RuleTemplate[]>;
+    categories$: Observable<TemplateCategory[]>;
+    recentlyUsed$: Observable<RuleTemplate[]>;
+    constructor(bridgeService: SpecificationBridgeService);
+    /**
+     * Get all templates
+     */
+    getTemplates(): Observable<RuleTemplate[]>;
+    /**
+     * Get templates by category
+     */
+    getTemplatesByCategory(categoryId: string): Observable<RuleTemplate[]>;
+    /**
+     * Search templates
+     */
+    searchTemplates(criteria: TemplateSearchCriteria): Observable<RuleTemplate[]>;
+    /**
+     * Get template by ID
+     */
+    getTemplate(id: string): Observable<RuleTemplate | null>;
+    /**
+     * Create new template
+     */
+    createTemplate(name: string, description: string, category: string, nodes: RuleNode[], rootNodes: string[], tags?: string[], requiredFields?: string[]): Observable<RuleTemplate>;
+    /**
+     * Update template
+     */
+    updateTemplate(id: string, updates: Partial<RuleTemplate>): Observable<RuleTemplate>;
+    /**
+     * Delete template
+     */
+    deleteTemplate(id: string): Observable<boolean>;
+    /**
+     * Duplicate template
+     */
+    duplicateTemplate(id: string, newName?: string): Observable<RuleTemplate>;
+    /**
+     * Apply template to current builder state
+     */
+    applyTemplate(templateId: string, targetBuilderState?: RuleBuilderState): Observable<TemplateApplicationResult>;
+    /**
+     * Validate template compatibility
+     */
+    validateTemplate(template: RuleTemplate, availableFields?: string[]): TemplateValidationResult;
+    /**
+     * Export template to JSON
+     */
+    exportTemplate(id: string, options?: ExportOptions): Observable<string>;
+    /**
+     * Import template from JSON
+     */
+    importTemplate(jsonData: string, options?: ImportOptions): Observable<RuleTemplate>;
+    /**
+     * Get template statistics
+     */
+    getTemplateStats(): Observable<TemplateStats>;
+    /**
+     * Get categories with template counts
+     */
+    getCategories(): Observable<TemplateCategory[]>;
+    private loadTemplatesFromStorage;
+    private saveTemplatesToStorage;
+    private updateCategories;
+    private initializeDefaultTemplates;
+    private createDefaultTemplates;
+    private generateTemplateId;
+    private cloneTemplateNodes;
+    private generateNodeId;
+    private replaceTemplateVariables;
+    private incrementTemplateUsage;
+    private addToRecentlyUsed;
+    private getTemplateComplexity;
+    private calculateComplexity;
+    private detectComplexFeatures;
+    private getCategoryDisplayName;
+    private getCategoryDescription;
+    private getDefaultIconForCategory;
+    private incrementVersion;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RuleTemplateService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RuleTemplateService>;
+}
+
+/**
+ * Validation issue severity levels
+ */
+declare enum ValidationSeverity {
+    ERROR = "error",
+    WARNING = "warning",
+    INFO = "info"
+}
+/**
+ * Validation issue categories
+ */
+declare enum ValidationCategory {
+    STRUCTURE = "structure",
+    DEPENDENCY = "dependency",
+    BUSINESS_LOGIC = "business_logic",
+    PERFORMANCE = "performance",
+    SEMANTIC = "semantic"
+}
+/**
+ * Validation issue details
+ */
+interface ValidationIssue {
+    /** Unique identifier for this issue */
+    id: string;
+    /** Issue severity level */
+    severity: ValidationSeverity;
+    /** Issue category */
+    category: ValidationCategory;
+    /** Human-readable message */
+    message: string;
+    /** Affected node ID */
+    nodeId: string;
+    /** Suggested fix (optional) */
+    suggestion?: string;
+    /** Additional context data */
+    context?: Record<string, any>;
+}
+/**
+ * Validation result for a rule tree
+ */
+interface RuleValidationResult {
+    /** Whether validation passed */
+    isValid: boolean;
+    /** Total number of issues found */
+    issueCount: number;
+    /** Issues found during validation */
+    issues: ValidationIssue[];
+    /** Performance metrics */
+    metrics: {
+        validationTime: number;
+        nodeCount: number;
+        maxDepth: number;
+        complexity: number;
+    };
+}
+/**
+ * Validation configuration options
+ */
+interface ValidationConfig {
+    /** Enable strict validation mode */
+    strict?: boolean;
+    /** Maximum allowed tree depth */
+    maxDepth?: number;
+    /** Maximum allowed complexity score */
+    maxComplexity?: number;
+    /** Enable performance warnings */
+    enablePerformanceWarnings?: boolean;
+    /** Custom validation rules */
+    customRules?: ValidationRule[];
+}
+/**
+ * Custom validation rule interface
+ */
+interface ValidationRule {
+    /** Rule identifier */
+    id: string;
+    /** Rule description */
+    description: string;
+    /** Validation function */
+    validate: (node: RuleNode, context: ValidationContext) => ValidationIssue[];
+}
+/**
+ * Validation context passed to validators
+ */
+interface ValidationContext {
+    /** Registry service for node resolution */
+    registry: RuleNodeRegistryService;
+    /** Current validation config */
+    config: ValidationConfig;
+    /** Visited nodes (for cycle detection) */
+    visitedNodes: Set<string>;
+    /** Current depth level */
+    currentDepth: number;
+    /** All nodes in the tree */
+    allNodes: Map<string, RuleNode>;
+}
+/**
+ * Centralized service for validating rule business logic and integrity
+ */
+declare class RuleValidationService {
+    private nodeRegistry;
+    private defaultConfig;
+    constructor(nodeRegistry: RuleNodeRegistryService);
+    /**
+     * Validate a complete rule tree
+     */
+    validateRuleTree(rootNode: RuleNode, config?: Partial<ValidationConfig>): RuleValidationResult;
+    /**
+     * Validate a single node
+     */
+    validateNode(node: RuleNode, context: ValidationContext): ValidationIssue[];
+    private validateStructure;
+    private validateDependencies;
+    private validateBusinessLogic;
+    private validatePerformance;
+    private validateNodeByType;
+    private validateFieldCondition;
+    private validateBooleanGroup;
+    private validateCardinality;
+    private getRequiredChildrenCount;
+    private collectAllNodes;
+    private calculateMetrics;
+    private getNodeComplexity;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RuleValidationService, never>;
+    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
+ */
+interface ContextEntry {
+    /** Full path identifier for the variable */
+    path: string;
+    /** Actual value of the variable */
+    value: unknown;
+    /** 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
+ */
+interface ContextValue {
+    /** The actual value */
+    value: any;
+    /** Variable type */
+    type: 'string' | 'number' | 'boolean' | 'object' | 'array';
+    /** Whether the value is computed */
+    computed?: boolean;
+    /** Last updated timestamp */
+    lastUpdated?: Date;
+}
+/**
+ * Context scope for variable resolution
+ */
+interface ContextScope {
+    /** Scope identifier */
+    id: string;
+    /** Scope name */
+    name: string;
+    /** Parent scope (for hierarchical contexts) */
+    parentId?: string;
+    /** Variables in this scope */
+    variables: Map<string, ContextValue>;
+}
+/**
+ * Dedicated service for context management and variable resolution
+ * Extracted from SpecificationBridgeService to follow SRP
+ */
+declare class ContextManagementService {
+    private scopes;
+    private globalScope;
+    constructor();
+    /**
+     * Create a context provider from context variables
+     */
+    createContextProvider(contextVariables: ContextEntry[]): ContextProvider;
+    /**
+     * Create a new context scope
+     */
+    createScope(id: string, name: string, parentId?: string): ContextScope;
+    /**
+     * Set a variable in a specific scope
+     */
+    setVariable(scopeId: string, name: string, value: any, type?: ContextValue['type']): void;
+    /**
+     * Get a variable value from a scope (with inheritance)
+     */
+    getVariable(scopeId: string, name: string): ContextValue | undefined;
+    /**
+     * Get all variables in a scope (including inherited)
+     */
+    getAllVariables(scopeId: string): Map<string, ContextValue>;
+    /**
+     * Validate context variables
+     */
+    validateContext(contextVariables: ContextEntry[]): {
+        isValid: boolean;
+        issues: string[];
+    };
+    /**
+     * Create a scoped context provider
+     */
+    createScopedProvider(scopeId: string): ContextProvider;
+    /**
+     * Merge multiple context providers
+     */
+    mergeProviders(...providers: ContextProvider[]): ContextProvider;
+    /**
+     * Get context statistics
+     */
+    getContextStatistics(scopeId?: string): {
+        scopeCount: number;
+        variableCount: number;
+        totalSize: number;
+        scopes: {
+            id: string;
+            name: string;
+            variableCount: number;
+        }[];
+    };
+    private hasContextValue;
+    private getContextValue;
+    private collectVariablesRecursive;
+    private isValidPath;
+    private inferType;
+    private estimateSize;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContextManagementService, never>;
+    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
+ */
+/**
+ * Error categories for classification
+ */
+declare enum ErrorCategory {
+    VALIDATION = "validation",
+    CONVERSION = "conversion",
+    REGISTRY = "registry",
+    DSL = "dsl",
+    CONTEXT = "context",
+    CONFIGURATION = "configuration",
+    NETWORK = "network",
+    INTERNAL = "internal"
+}
+/**
+ * Error severity levels
+ */
+declare enum ErrorSeverity {
+    LOW = "low",
+    MEDIUM = "medium",
+    HIGH = "high",
+    CRITICAL = "critical"
+}
+/**
+ * Base error class for all Visual Builder errors
+ */
+declare abstract class VisualBuilderError extends Error {
+    readonly cause?: Error | undefined;
+    abstract readonly code: string;
+    abstract readonly category: ErrorCategory;
+    abstract readonly severity: ErrorSeverity;
+    readonly timestamp: Date;
+    readonly context: Record<string, any>;
+    constructor(message: string, context?: Record<string, any>, cause?: Error | undefined);
+    /**
+     * Get structured error information
+     */
+    toJSON(): ErrorInfo;
+}
+/**
+ * Validation-related errors
+ */
+declare class ValidationError extends VisualBuilderError {
+    readonly nodeId?: string | undefined;
+    readonly validationRules?: string[] | undefined;
+    readonly code = "VALIDATION_ERROR";
+    readonly category = ErrorCategory.VALIDATION;
+    readonly severity = ErrorSeverity.HIGH;
+    constructor(message: string, nodeId?: string | undefined, validationRules?: string[] | undefined, context?: Record<string, any>);
+}
+/**
+ * Conversion-related errors
+ */
+declare class ConversionError extends VisualBuilderError {
+    readonly nodeId?: string | undefined;
+    readonly code: string;
+    readonly category = ErrorCategory.CONVERSION;
+    readonly severity = ErrorSeverity.HIGH;
+    constructor(code: string, message: string, nodeId?: string | undefined, context?: Record<string, any>, cause?: Error);
+}
+/**
+ * Registry-related errors
+ */
+declare class RegistryError extends VisualBuilderError {
+    readonly nodeId?: string | undefined;
+    readonly code: string;
+    readonly category = ErrorCategory.REGISTRY;
+    readonly severity = ErrorSeverity.MEDIUM;
+    constructor(operation: string, message: string, nodeId?: string | undefined, context?: Record<string, any>);
+}
+/**
+ * DSL parsing and processing errors
+ */
+declare class DslError extends VisualBuilderError {
+    readonly expression?: string | undefined;
+    readonly position?: {
+        start: number;
+        end: number;
+    } | undefined;
+    readonly code: string;
+    readonly category = ErrorCategory.DSL;
+    readonly severity = ErrorSeverity.HIGH;
+    constructor(type: 'PARSING' | 'VALIDATION' | 'EXPORT' | 'IMPORT', message: string, expression?: string | undefined, position?: {
+        start: number;
+        end: number;
+    } | undefined, context?: Record<string, any>);
+}
+/**
+ * Context management errors
+ */
+declare class ContextError extends VisualBuilderError {
+    readonly scopeId?: string | undefined;
+    readonly variablePath?: string | undefined;
+    readonly code: string;
+    readonly category = ErrorCategory.CONTEXT;
+    readonly severity = ErrorSeverity.MEDIUM;
+    constructor(operation: string, message: string, scopeId?: string | undefined, variablePath?: string | undefined, context?: Record<string, any>);
+}
+/**
+ * Configuration errors
+ */
+declare class ConfigurationError extends VisualBuilderError {
+    readonly configPath?: string | undefined;
+    readonly expectedType?: string | undefined;
+    readonly code = "CONFIGURATION_ERROR";
+    readonly category = ErrorCategory.CONFIGURATION;
+    readonly severity = ErrorSeverity.HIGH;
+    constructor(message: string, configPath?: string | undefined, expectedType?: string | undefined, context?: Record<string, any>);
+}
+/**
+ * Internal system errors
+ */
+declare class InternalError extends VisualBuilderError {
+    readonly code = "INTERNAL_ERROR";
+    readonly category = ErrorCategory.INTERNAL;
+    readonly severity = ErrorSeverity.CRITICAL;
+    constructor(message: string, context?: Record<string, any>, cause?: Error);
+}
+/**
+ * Structured error information
+ */
+interface ErrorInfo {
+    code: string;
+    category: ErrorCategory;
+    severity: ErrorSeverity;
+    message: string;
+    timestamp: string;
+    context: Record<string, any>;
+    stack?: string;
+    cause?: {
+        name: string;
+        message: string;
+        stack?: string;
+    };
+}
+/**
+ * Error handler for collecting and processing errors
+ */
+declare class ErrorHandler {
+    private errors;
+    private maxErrors;
+    /**
+     * Handle an error
+     */
+    handle(error: Error | VisualBuilderError): void;
+    /**
+     * Get all errors
+     */
+    getErrors(): VisualBuilderError[];
+    /**
+     * Get errors by category
+     */
+    getErrorsByCategory(category: ErrorCategory): VisualBuilderError[];
+    /**
+     * Get errors by severity
+     */
+    getErrorsBySeverity(severity: ErrorSeverity): VisualBuilderError[];
+    /**
+     * Clear all errors
+     */
+    clear(): void;
+    /**
+     * Get error statistics
+     */
+    getStatistics(): ErrorStatistics;
+    private logError;
+}
+/**
+ * Error statistics interface
+ */
+interface ErrorStatistics {
+    total: number;
+    byCategory: Record<ErrorCategory, number>;
+    bySeverity: Record<ErrorSeverity, number>;
+    recent: VisualBuilderError[];
+}
+/**
+ * Global error handler instance
+ */
+declare const globalErrorHandler: ErrorHandler;
+/**
+ * Utility function to create typed errors
+ */
+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;
+    context: (operation: string, message: string, scopeId?: string, variablePath?: string) => ContextError;
+    configuration: (message: string, configPath?: string, expectedType?: string) => ConfigurationError;
+    internal: (message: string, cause?: Error) => InternalError;
+};
+
+declare class RuleEditorComponent implements OnInit, OnDestroy {
+    private ruleBuilderService;
+    private fieldSchemaService;
+    private snackBar;
+    private fb;
+    private dialog;
+    config: RuleBuilderConfig | null;
+    initialRules: any;
+    embedded: boolean;
+    rulesChanged: EventEmitter<any>;
+    exportRequested: EventEmitter<ExportOptions>;
+    importRequested: EventEmitter<ImportOptions>;
+    private destroy$;
+    currentState: RuleBuilderState | null;
+    validationErrors: ValidationError$1[];
+    selectedNode: RuleNode | null;
+    fieldSchemas: Record<string, FieldSchema>;
+    fieldCategories: any[];
+    activeTabIndex: number;
+    showValidationErrors: boolean;
+    get canUndo(): boolean;
+    get canRedo(): boolean;
+    constructor(ruleBuilderService: RuleBuilderService, fieldSchemaService: FieldSchemaService, snackBar: MatSnackBar, fb: FormBuilder, dialog: MatDialog);
+    ngOnInit(): 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;
+    openExportDialog(): void;
+    importRules(): void;
+    hideValidationErrors(): void;
+    onLinterErrorSelected(error: any): void;
+    onQuickFixApplied(event: any): void;
+    onLinterRuleToggled(event: any): void;
+    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>;
+}
+
+declare class RuleCanvasComponent implements OnInit, OnDestroy {
+    state: RuleBuilderState | null;
+    fieldSchemas: Record<string, FieldSchema>;
+    nodeSelected: EventEmitter<string>;
+    nodeAdded: EventEmitter<{
+        type: RuleNodeType;
+        parentId?: string;
+        config?: RuleNodeConfig;
+    }>;
+    nodeUpdated: EventEmitter<{
+        nodeId: string;
+        updates: Partial<RuleNode>;
+    }>;
+    nodeRemoved: EventEmitter<string>;
+    private destroy$;
+    isDragOver: boolean;
+    showAddMenu: boolean;
+    addMenuOptions: {
+        type: RuleNodeType;
+        icon: string;
+        label: string;
+        color: string;
+    }[];
+    get isEmpty(): boolean;
+    constructor();
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    trackByNodeId(index: number, nodeId: string): string;
+    getNode(nodeId: string): RuleNode | null;
+    isNodeSelected(nodeId: string): boolean;
+    isLastRootNode(nodeId: string): boolean;
+    getNodeValidationErrors(nodeId: string): any[];
+    selectNode(nodeId: string): void;
+    updateNode(event: {
+        nodeId: string;
+        updates: Partial<RuleNode>;
+    }): void;
+    deleteNode(nodeId: string): void;
+    addChildNode(parentId: string, childType: RuleNodeType): void;
+    moveChildNode(event: any): void;
+    onDragOver(event: DragEvent): void;
+    onDragEnter(event: DragEvent): void;
+    onDragLeave(event: DragEvent): void;
+    onDrop(event: DragEvent): void;
+    private createFieldConditionFromDrop;
+    toggleAddMenu(): void;
+    addFirstRule(): void;
+    addRule(type: RuleNodeType): void;
+    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>;
+}
+
+declare class RuleNodeComponent {
+    private fb;
+    node: RuleNode | null;
+    fieldSchemas: Record<string, FieldSchema>;
+    level: number;
+    isSelected: boolean;
+    validationErrors: ValidationError$1[];
+    nodeClicked: EventEmitter<void>;
+    nodeUpdated: EventEmitter<{
+        nodeId: string;
+        updates: Partial<RuleNode>;
+    }>;
+    nodeDeleted: EventEmitter<void>;
+    childAdded: EventEmitter<RuleNodeType>;
+    childMoved: EventEmitter<CdkDragDrop<string[], string[], any>>;
+    get hasValidationErrors(): boolean;
+    constructor(fb: FormBuilder);
+    selectNode(): void;
+    getNodeIcon(): string;
+    getNodeLabel(): string;
+    getNodeTypeClass(): string;
+    getErrorIcon(severity: string): string;
+    isFieldCondition(): boolean;
+    isBooleanGroup(): boolean;
+    isConditionalValidator(): boolean;
+    isCollectionValidation(): boolean;
+    getFieldConditionConfig(): FieldConditionConfig | null;
+    getBooleanGroupConfig(): BooleanGroupConfig | null;
+    getConditionalValidatorConfig(): ConditionalValidatorConfig | null;
+    getCollectionValidationConfig(): CollectionValidatorConfig | null;
+    getBooleanOperator(): string;
+    hasChildren(): boolean;
+    canHaveChildren(): boolean;
+    getChildOptions(): {
+        type: RuleNodeType;
+        icon: string;
+        label: string;
+    }[];
+    trackByChildId(index: number, childId: string): string;
+    getChildNode(childId: string): RuleNode | null;
+    isChildSelected(childId: string): boolean;
+    getChildValidationErrors(childId: string): ValidationError$1[];
+    isLastChild(childId: string): boolean;
+    editNode(): void;
+    duplicateNode(): void;
+    deleteNode(): void;
+    addChild(type: RuleNodeType): void;
+    showAddChildMenu(): void;
+    onBooleanOperatorChanged(event: MatSelectChange): void;
+    onFieldConditionChanged(config: FieldConditionConfig): void;
+    onConditionalValidatorChanged(config: ConditionalValidatorConfig): void;
+    onCollectionValidationChanged(config: CollectionValidatorConfig): void;
+    onChildClicked(childId: string): void;
+    onChildUpdated(event: {
+        nodeId: string;
+        updates: Partial<RuleNode>;
+    }): void;
+    onChildDeleted(childId: string): void;
+    onChildAdded(event: RuleNodeType): void;
+    onChildMoved(event: CdkDragDrop<string[]>): void;
+    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>;
+}
+
+declare class FieldConditionEditorComponent implements OnInit, OnChanges {
+    private fb;
+    config: FieldConditionConfig | null;
+    fieldSchemas: Record<string, FieldSchema>;
+    configChanged: EventEmitter<FieldConditionConfig>;
+    private destroy$;
+    conditionForm: FormGroup;
+    fieldCategories: {
+        name: string;
+        fields: FieldSchema[];
+    }[];
+    contextVariables: any[];
+    customFunctions: any[];
+    selectedField: FieldSchema | null;
+    selectedOperator: string | null;
+    valueType: string;
+    availableOperators: string[];
+    constructor(fb: FormBuilder);
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    private createForm;
+    private setupFormSubscriptions;
+    private setupFieldCategories;
+    private loadInitialConfig;
+    private emitConfigChange;
+    private processValue;
+    getFieldIcon(type: string): string;
+    getOperatorLabel(operator: string): string;
+    getValuePlaceholder(): string;
+    getValueHint(): string;
+    getBooleanLabel(): string;
+    getCompatibleFields(): FieldSchema[];
+    getPreviewText(): string;
+    private formatValueForPreview;
+    isStringField(): boolean;
+    isNumberField(): boolean;
+    isBooleanField(): boolean;
+    isDateField(): boolean;
+    isEnumField(): boolean;
+    isArrayOperator(): boolean;
+    needsValue(): boolean;
+    onFieldChanged(event: string | MatSelectChange): void;
+    onOperatorChanged(event: MatSelectChange): void;
+    onValueTypeChanged(event: MatSelectChange): void;
+    hasValidationErrors(): boolean;
+    getValidationErrors(): string[];
+    isValid(): 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>;
+}
+
+declare class ConditionalValidatorEditorComponent implements OnInit, OnChanges {
+    private fb;
+    config: ConditionalValidatorConfig | null;
+    fieldSchemas: Record<string, FieldSchema>;
+    configChanged: EventEmitter<ConditionalValidatorConfig>;
+    private destroy$;
+    validatorForm: FormGroup;
+    fieldCategories: {
+        name: string;
+        fields: FieldSchema[];
+    }[];
+    advancedConditions: any[];
+    validatorType: string;
+    targetField: string;
+    conditionMode: string;
+    get showDisabledMessage(): boolean;
+    constructor(fb: FormBuilder);
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    private createForm;
+    private setupFormSubscriptions;
+    private setupFieldCategories;
+    private loadInitialConfig;
+    private emitConfigChange;
+    getFieldIcon(type: string): string;
+    trackByIndex(index: number): number;
+    getSimpleConditionConfig(): any;
+    getPreviewText(): string;
+    getLogicPreview(): string;
+    onValidatorTypeChanged(event: MatSelectChange): void;
+    onTargetFieldChanged(event: MatSelectChange): void;
+    onConditionModeChanged(event: MatButtonToggleChange): void;
+    onSimpleConditionChanged(condition: any): void;
+    updateAdvancedCondition(index: number, condition: any): void;
+    addCondition(): void;
+    removeCondition(index: number): void;
+    hasValidationErrors(): boolean;
+    getValidationErrors(): string[];
+    isValid(): boolean;
+    private createEmptyCondition;
+    private mapRuleTypeToValidatorType;
+    private mapValidatorTypeToRuleType;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConditionalValidatorEditorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ConditionalValidatorEditorComponent, "praxis-conditional-validator-editor", never, { "config": { "alias": "config"; "required": false; }; "fieldSchemas": { "alias": "fieldSchemas"; "required": false; }; }, { "configChanged": "configChanged"; }, never, never, true, never>;
+}
+
+declare class CollectionValidatorEditorComponent implements OnInit, OnChanges {
+    private fb;
+    config: CollectionValidatorConfig | null;
+    fieldSchemas: Record<string, FieldSchema>;
+    configChanged: EventEmitter<CollectionValidatorConfig>;
+    private destroy$;
+    collectionForm: FormGroup;
+    collectionFieldCategories: {
+        name: string;
+        fields: FieldSchema[];
+    }[];
+    validatorType: string;
+    targetCollection: string;
+    get itemValidationRules(): FormArray;
+    get uniqueByFields(): FormArray;
+    get minItems(): number;
+    get maxItems(): number;
+    get debounceValidation(): boolean;
+    constructor(fb: FormBuilder);
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    private createForm;
+    private setupFormSubscriptions;
+    private setupFieldCategories;
+    private loadInitialConfig;
+    private loadItemValidationRules;
+    private loadUniqueByFields;
+    private emitConfigChange;
+    private getItemValidationRulesValue;
+    private getUniqueByFieldsValue;
+    getFieldIcon(type: string): string;
+    getLengthErrorPlaceholder(): string;
+    getPreviewText(): string;
+    getForEachRulesPreview(): string;
+    getUniqueFieldsPreview(): string;
+    getLengthConstraintsPreview(): string;
+    onValidatorTypeChanged(event: MatSelectChange): void;
+    onTargetCollectionChanged(event: MatSelectChange): void;
+    addItemValidationRule(): void;
+    removeItemValidationRule(index: number): void;
+    addUniqueField(): void;
+    removeUniqueField(index: number): void;
+    hasValidationErrors(): boolean;
+    getValidationErrors(): string[];
+    isValid(): boolean;
+    private mapRuleTypeToValidatorType;
+    private mapValidatorTypeToRuleType;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CollectionValidatorEditorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CollectionValidatorEditorComponent, "praxis-collection-validator-editor", never, { "config": { "alias": "config"; "required": false; }; "fieldSchemas": { "alias": "fieldSchemas"; "required": false; }; }, { "configChanged": "configChanged"; }, never, never, true, never>;
+}
+
+declare class MetadataEditorComponent implements OnInit, OnChanges {
+    private fb;
+    selectedNode: RuleNode | null;
+    metadataUpdated: EventEmitter<SpecificationMetadata>;
+    private destroy$;
+    metadataForm: FormGroup;
+    activeTabIndex: number;
+    hasUnsavedChanges: boolean;
+    availableTags: string[];
+    filteredTags: Observable<string[]>;
+    availableIcons: {
+        value: string;
+        label: string;
+    }[];
+    get customProperties(): FormArray;
+    get documentationLinks(): FormArray;
+    get enableConditionalMetadata(): boolean;
+    constructor(fb: FormBuilder);
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    private createForm;
+    private setupFormSubscriptions;
+    private setupTagAutocomplete;
+    private filterTags;
+    private loadMetadata;
+    private resetForm;
+    private loadCustomProperties;
+    private loadDocumentationLinks;
+    private emitMetadataUpdate;
+    private cleanUiConfig;
+    private getCustomPropertiesValue;
+    private getDocumentationLinksValue;
+    private inferType;
+    private convertValueByType;
+    getNodeIcon(): string;
+    getNodeTitle(): string;
+    getNodeSubtitle(): string;
+    getNodeTypeIcon(type: string): string;
+    getMetadataPreview(): string;
+    addCustomProperty(): void;
+    removeCustomProperty(index: number): void;
+    addDocumentationLink(): void;
+    removeDocumentationLink(index: number): void;
+    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 {
+    private snackBar;
+    dsl: string;
+    editable: boolean;
+    language: string;
+    theme: string;
+    dslChanged: EventEmitter<string>;
+    validationChanged: EventEmitter<{
+        valid: boolean;
+        errors: any[];
+        warnings: any[];
+    }>;
+    editorContainer: ElementRef;
+    private destroy$;
+    private monacoEditor;
+    private originalDsl;
+    isLoading: boolean;
+    hasChanges: boolean;
+    showErrors: boolean;
+    syntaxErrors: any[];
+    warnings: any[];
+    cursorPosition: {
+        line: number;
+        column: number;
+    } | null;
+    showLineNumbers: boolean;
+    wordWrap: boolean;
+    showMinimap: boolean;
+    constructor(snackBar: MatSnackBar);
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    private initializeMonacoEditor;
+    private loadMonacoEditor;
+    private createEditor;
+    private createFallbackEditor;
+    private setupEditorEvents;
+    private updateEditorContent;
+    private updateEditorOptions;
+    private onContentChanged;
+    private updateCursorPosition;
+    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 calculateIndentationDepth;
+    private validateDslSyntax;
+    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;
+    editable: boolean;
+    jsonChanged: EventEmitter<any>;
+    formattedJson: string;
+    originalJson: string;
+    hasChanges: boolean;
+    validationError: string;
+    showLineNumbers: boolean;
+    wordWrap: boolean;
+    constructor(snackBar: MatSnackBar);
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private updateJsonContent;
+    onJsonInput(event: any): void;
+    getValidationStatusClass(): string;
+    getValidationIcon(): string;
+    getValidationText(): string;
+    getEditorInfo(): string;
+    getLineNumbers(): number[];
+    formatJson(): void;
+    validateJson(): void;
+    applyChanges(): void;
+    discardChanges(): void;
+    copyToClipboard(): void;
+    downloadJson(): void;
+    toggleLineNumbers(): void;
+    toggleWordWrap(): void;
+    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>;
+}
+
+declare class RoundTripTesterComponent implements OnInit {
+    private roundTripValidator;
+    private ruleBuilderService;
+    private snackBar;
+    private cdr;
+    isRunning: boolean;
+    showTestCases: boolean;
+    lastTestResult: RoundTripValidationResult | null;
+    testSuiteResults: any;
+    defaultTestCases: RoundTripTestCase[];
+    hasCurrentRule: boolean;
+    constructor(roundTripValidator: RoundTripValidatorService, ruleBuilderService: RuleBuilderService, snackBar: MatSnackBar, cdr: ChangeDetectorRef);
+    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;
+    preselectedFormat?: string;
+    showIntegrationTab?: boolean;
+    showSharingTab?: boolean;
+}
+declare class ExportDialogComponent implements OnInit {
+    dialogRef: MatDialogRef<ExportDialogComponent>;
+    data: ExportDialogData;
+    private fb;
+    private exportService;
+    private snackBar;
+    private cdr;
+    exportForm: FormGroup;
+    integrationForm: FormGroup;
+    sharingForm: FormGroup;
+    activeTabIndex: number;
+    isProcessing: boolean;
+    enableBatchExport: boolean;
+    isTestingConnectivity: boolean;
+    supportedFormats: ExportFormat[];
+    selectedFormat: ExportFormat | null;
+    externalSystems: ExternalSystemConfig[];
+    selectedSystem: ExternalSystemConfig | null;
+    exportResults: ExportResult[];
+    integrationResults: any[];
+    shareResult: any;
+    constructor(dialogRef: MatDialogRef<ExportDialogComponent>, data: ExportDialogData, fb: FormBuilder, exportService: ExportIntegrationService, snackBar: MatSnackBar, cdr: ChangeDetectorRef);
+    ngOnInit(): void;
+    private createExportForm;
+    private createIntegrationForm;
+    private createSharingForm;
+    private loadSupportedFormats;
+    private loadExternalSystems;
+    selectFormat(formatId: string): void;
+    isFormatSelected(formatId: string): boolean;
+    onSystemChange(event: MatSelectChange): void;
+    testConnectivity(): Promise<void>;
+    onExport(): Promise<void>;
+    onIntegrate(): Promise<void>;
+    onCreateShare(): Promise<void>;
+    canExport(): boolean;
+    canIntegrate(): boolean;
+    canShare(): boolean;
+    downloadResult(result: ExportResult): void;
+    previewResult(result: ExportResult): void;
+    copyToClipboard(content: string): void;
+    copyShareUrl(): void;
+    formatFileSize(bytes: number): string;
+    onCancel(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ExportDialogComponent, never>;
+    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;
+    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
+ *
+ * This is a placeholder component for the template integration example.
+ * In a real implementation, this would be the main visual rule builder interface.
+ */
+declare class VisualRuleBuilderComponent {
+    fieldSchemas: any[];
+    builderState: RuleBuilderState | null;
+    stateChanged: EventEmitter<RuleBuilderState>;
+    selectionChanged: EventEmitter<any[]>;
+    get nodeCount(): number;
+    addSampleNode(): void;
+    clearNodes(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisualRuleBuilderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VisualRuleBuilderComponent, "praxis-visual-rule-builder", never, { "fieldSchemas": { "alias": "fieldSchemas"; "required": false; }; "builderState": { "alias": "builderState"; "required": false; }; }, { "stateChanged": "stateChanged"; "selectionChanged": "selectionChanged"; }, never, never, true, never>;
+}
+
+/**
+ * Template display mode
+ */
+type TemplateDisplayMode = 'grid' | 'list' | 'compact';
+/**
+ * Template sort option
+ */
+interface TemplateSortOption {
+    field: keyof RuleTemplate | keyof TemplateMetadata;
+    direction: 'asc' | 'desc';
+    label: string;
+}
+declare class TemplateGalleryComponent implements OnInit, OnDestroy {
+    private templateService;
+    private fb;
+    private dialog;
+    private snackBar;
+    availableFields: string[];
+    templateApplied: EventEmitter<RuleTemplate>;
+    templateCreated: EventEmitter<RuleTemplate>;
+    templateDeleted: EventEmitter<string>;
+    private destroy$;
+    searchForm: FormGroup;
+    displayMode: TemplateDisplayMode;
+    showPreview: boolean;
+    selectedTags: Set<string>;
+    popularTags: string[];
+    templates$: Observable<RuleTemplate[]>;
+    categories$: Observable<TemplateCategory[]>;
+    recentlyUsed$: Observable<RuleTemplate[]>;
+    stats$: Observable<TemplateStats>;
+    filteredTemplates$: Observable<RuleTemplate[]>;
+    Array: ArrayConstructor;
+    constructor(templateService: RuleTemplateService, fb: FormBuilder, dialog: MatDialog, snackBar: MatSnackBar);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private createSearchForm;
+    private createFilteredTemplatesStream;
+    private setupFormSubscriptions;
+    private loadPopularTags;
+    private filterTemplates;
+    private sortTemplates;
+    trackByTemplateId(index: number, template: RuleTemplate): string;
+    setDisplayMode(mode: TemplateDisplayMode): void;
+    toggleTag(tag: string): void;
+    hasActiveFilters(): boolean;
+    clearFilter(field: string): void;
+    clearAllFilters(): void;
+    getCategoryName(categoryId: string): string;
+    getRelativeDate(date?: Date | string): string;
+    getNodeLabel(template: RuleTemplate, nodeId: string): string;
+    showCreateTemplateDialog(selectedNodes?: RuleNode[]): void;
+    importTemplate(): void;
+    applyTemplate(template: RuleTemplate): void;
+    previewTemplate(template: RuleTemplate): void;
+    editTemplate(template: RuleTemplate): void;
+    duplicateTemplate(template: RuleTemplate): void;
+    exportTemplate(template: RuleTemplate): void;
+    deleteTemplate(template: RuleTemplate): void;
+    private downloadFile;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TemplateGalleryComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TemplateGalleryComponent, "praxis-template-gallery", never, { "availableFields": { "alias": "availableFields"; "required": false; }; }, { "templateApplied": "templateApplied"; "templateCreated": "templateCreated"; "templateDeleted": "templateDeleted"; }, never, never, true, never>;
+}
+
+interface TemplateEditorDialogData {
+    mode: 'create' | 'edit';
+    template?: RuleTemplate;
+    selectedNodes?: RuleNode[];
+    availableCategories?: string[];
+}
+interface TemplateEditorResult {
+    action: 'save' | 'cancel';
+    template?: RuleTemplate;
+}
+declare class TemplateEditorDialogComponent implements OnInit {
+    private dialogRef;
+    data: TemplateEditorDialogData;
+    private fb;
+    private templateService;
+    private bridgeService;
+    private snackBar;
+    basicInfoForm: FormGroup;
+    rulesForm: FormGroup;
+    advancedForm: FormGroup;
+    tags: string[];
+    requiredFields: string[];
+    separatorKeysCodes: number[];
+    availableCategories: {
+        id: string;
+        name: string;
+        icon: string;
+    }[];
+    availableIcons: {
+        value: string;
+        label: string;
+    }[];
+    previewNodes: RuleNode[];
+    detectedVariables: string[];
+    get nodeCount(): number;
+    constructor(dialogRef: MatDialogRef<TemplateEditorDialogComponent>, data: TemplateEditorDialogData, fb: FormBuilder, templateService: RuleTemplateService, bridgeService: SpecificationBridgeService, snackBar: MatSnackBar);
+    ngOnInit(): void;
+    private createBasicInfoForm;
+    private createRulesForm;
+    private createAdvancedForm;
+    private loadTemplateData;
+    private setupPreviewNodes;
+    private detectTemplateVariables;
+    addTag(event: MatChipInputEvent): void;
+    removeTag(tag: string): void;
+    addRequiredField(event: MatChipInputEvent): void;
+    removeRequiredField(field: string): void;
+    isRootNode(node: RuleNode): boolean;
+    getNodeIcon(node: RuleNode): string;
+    canSave(): boolean;
+    canPreview(): boolean;
+    saveTemplate(): void;
+    previewTemplate(): void;
+    deleteTemplate(): void;
+    cancel(): void;
+    private calculateComplexity;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TemplateEditorDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TemplateEditorDialogComponent, "praxis-template-editor-dialog", never, {}, {}, never, never, true, never>;
+}
+
+interface TemplatePreviewDialogData {
+    template: RuleTemplate;
+}
+declare class TemplatePreviewDialogComponent {
+    private dialogRef;
+    data: TemplatePreviewDialogData;
+    constructor(dialogRef: MatDialogRef<TemplatePreviewDialogComponent>, data: TemplatePreviewDialogData);
+    getRootNode(nodeId: string): RuleNode | undefined;
+    getNodeHierarchy(rootNodeId: string): {
+        node: RuleNode;
+        level: number;
+    }[];
+    getNodeIcon(node?: RuleNode): string;
+    getNodeDescription(node?: RuleNode): string;
+    formatConfig(config: any): string;
+    formatDate(date?: Date | string): string;
+    applyTemplate(): void;
+    exportTemplate(): void;
+    cancel(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TemplatePreviewDialogComponent, never>;
+    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 };