@praxisui/specification 0.0.1

package/fesm2022/praxisui-specification.mjs

@@ -0,0 +1,3495 @@
+import { Specification } from '@praxisui/specification-core';
+export * from '@praxisui/specification-core';
+
+var ComparisonOperator;
+(function (ComparisonOperator) {
+    ComparisonOperator["EQUALS"] = "eq";
+    ComparisonOperator["NOT_EQUALS"] = "neq";
+    ComparisonOperator["LESS_THAN"] = "lt";
+    ComparisonOperator["LESS_THAN_OR_EQUAL"] = "lte";
+    ComparisonOperator["GREATER_THAN"] = "gt";
+    ComparisonOperator["GREATER_THAN_OR_EQUAL"] = "gte";
+    ComparisonOperator["CONTAINS"] = "contains";
+    ComparisonOperator["STARTS_WITH"] = "startsWith";
+    ComparisonOperator["ENDS_WITH"] = "endsWith";
+    ComparisonOperator["IN"] = "in";
+})(ComparisonOperator || (ComparisonOperator = {}));
+const OPERATOR_SYMBOLS = {
+    [ComparisonOperator.EQUALS]: '==',
+    [ComparisonOperator.NOT_EQUALS]: '!=',
+    [ComparisonOperator.LESS_THAN]: '<',
+    [ComparisonOperator.LESS_THAN_OR_EQUAL]: '<=',
+    [ComparisonOperator.GREATER_THAN]: '>',
+    [ComparisonOperator.GREATER_THAN_OR_EQUAL]: '>=',
+    [ComparisonOperator.CONTAINS]: 'contains',
+    [ComparisonOperator.STARTS_WITH]: 'startsWith',
+    [ComparisonOperator.ENDS_WITH]: 'endsWith',
+    [ComparisonOperator.IN]: 'in'
+};
+
+class FieldSpecification extends Specification {
+    field;
+    operator;
+    value;
+    constructor(field, operator, value, metadata) {
+        super(metadata);
+        this.field = field;
+        this.operator = operator;
+        this.value = value;
+    }
+    isSatisfiedBy(obj) {
+        const fieldValue = obj[this.field];
+        switch (this.operator) {
+            case ComparisonOperator.EQUALS:
+                return fieldValue === this.value;
+            case ComparisonOperator.NOT_EQUALS:
+                return fieldValue !== this.value;
+            case ComparisonOperator.LESS_THAN:
+                return fieldValue < this.value;
+            case ComparisonOperator.LESS_THAN_OR_EQUAL:
+                return fieldValue <= this.value;
+            case ComparisonOperator.GREATER_THAN:
+                return fieldValue > this.value;
+            case ComparisonOperator.GREATER_THAN_OR_EQUAL:
+                return fieldValue >= this.value;
+            case ComparisonOperator.CONTAINS:
+                return String(fieldValue).includes(String(this.value));
+            case ComparisonOperator.STARTS_WITH:
+                return String(fieldValue).startsWith(String(this.value));
+            case ComparisonOperator.ENDS_WITH:
+                return String(fieldValue).endsWith(String(this.value));
+            case ComparisonOperator.IN:
+                return Array.isArray(this.value) && this.value.includes(fieldValue);
+            default:
+                throw new Error(`Unsupported operator: ${this.operator}`);
+        }
+    }
+    toJSON() {
+        return {
+            type: 'field',
+            field: String(this.field),
+            operator: this.operator,
+            value: this.value,
+            metadata: this.metadata,
+        };
+    }
+    static fromJSON(json) {
+        return new FieldSpecification(json.field, json.operator, json.value, json.metadata);
+    }
+    clone() {
+        return new FieldSpecification(this.field, this.operator, this.value, this.metadata);
+    }
+    toDSL() {
+        const fieldName = String(this.field);
+        const symbol = OPERATOR_SYMBOLS[this.operator];
+        switch (this.operator) {
+            case ComparisonOperator.CONTAINS:
+                return `contains(${fieldName}, ${JSON.stringify(this.value)})`;
+            case ComparisonOperator.STARTS_WITH:
+                return `startsWith(${fieldName}, ${JSON.stringify(this.value)})`;
+            case ComparisonOperator.ENDS_WITH:
+                return `endsWith(${fieldName}, ${JSON.stringify(this.value)})`;
+            case ComparisonOperator.IN:
+                const values = Array.isArray(this.value)
+                    ? this.value.map((v) => JSON.stringify(v)).join(', ')
+                    : JSON.stringify(this.value);
+                return `${fieldName} in (${values})`;
+            default:
+                return `${fieldName} ${symbol} ${JSON.stringify(this.value)}`;
+        }
+    }
+    getField() {
+        return this.field;
+    }
+    getOperator() {
+        return this.operator;
+    }
+    getValue() {
+        return this.value;
+    }
+}
+
+class AndSpecification extends Specification {
+    specifications;
+    constructor(specifications, metadata) {
+        super(metadata);
+        this.specifications = specifications;
+        if (specifications.length === 0) {
+            throw new Error('AndSpecification requires at least one specification');
+        }
+    }
+    isSatisfiedBy(obj) {
+        return this.specifications.every((spec) => spec.isSatisfiedBy(obj));
+    }
+    toJSON() {
+        return {
+            type: 'and',
+            specs: this.specifications.map((spec) => spec.toJSON()),
+        };
+    }
+    static fromJSON(json) {
+        const specs = json.specs.map((specJson) => Specification.fromJSON(specJson));
+        return new AndSpecification(specs);
+    }
+    toDSL() {
+        if (this.specifications.length === 1) {
+            return this.specifications[0].toDSL();
+        }
+        const parts = this.specifications.map((spec) => {
+            const dsl = spec.toDSL();
+            // Add parentheses if needed for precedence
+            const kind = spec.getOperatorKind?.();
+            if (kind === 'or' || kind === 'xor') {
+                return `(${dsl})`;
+            }
+            return dsl;
+        });
+        return parts.join(' && ');
+    }
+    getSpecifications() {
+        return [...this.specifications];
+    }
+    add(specification) {
+        return new AndSpecification([...this.specifications, specification], this.metadata);
+    }
+    clone() {
+        return new AndSpecification(this.specifications.map((spec) => spec.clone()), this.metadata);
+    }
+    getOperatorKind() {
+        return 'and';
+    }
+}
+
+class OrSpecification extends Specification {
+    specifications;
+    constructor(specifications, metadata) {
+        super(metadata);
+        this.specifications = specifications;
+        if (specifications.length === 0) {
+            throw new Error('OrSpecification requires at least one specification');
+        }
+    }
+    isSatisfiedBy(obj) {
+        return this.specifications.some((spec) => spec.isSatisfiedBy(obj));
+    }
+    toJSON() {
+        return {
+            type: 'or',
+            specs: this.specifications.map((spec) => spec.toJSON()),
+        };
+    }
+    static fromJSON(json) {
+        const specs = json.specs.map((specJson) => Specification.fromJSON(specJson));
+        return new OrSpecification(specs);
+    }
+    toDSL() {
+        if (this.specifications.length === 1) {
+            return this.specifications[0].toDSL();
+        }
+        const parts = this.specifications.map((spec) => {
+            const dsl = spec.toDSL();
+            // Add parentheses if needed for precedence
+            const kind = spec.getOperatorKind?.();
+            if (kind === 'and') {
+                return `(${dsl})`;
+            }
+            return dsl;
+        });
+        return parts.join(' || ');
+    }
+    getSpecifications() {
+        return [...this.specifications];
+    }
+    add(specification) {
+        return new OrSpecification([...this.specifications, specification], this.metadata);
+    }
+    clone() {
+        return new OrSpecification(this.specifications.map((spec) => spec.clone()), this.metadata);
+    }
+    getOperatorKind() {
+        return 'or';
+    }
+}
+
+class XorSpecification extends Specification {
+    specifications;
+    constructor(specifications, metadata) {
+        super(metadata);
+        this.specifications = specifications;
+        if (specifications.length < 2) {
+            throw new Error('XorSpecification requires at least two specifications');
+        }
+    }
+    isSatisfiedBy(obj) {
+        const satisfiedCount = this.specifications.filter((spec) => spec.isSatisfiedBy(obj)).length;
+        return satisfiedCount === 1;
+    }
+    toJSON() {
+        return {
+            type: 'xor',
+            specs: this.specifications.map((spec) => spec.toJSON()),
+        };
+    }
+    static fromJSON(json) {
+        const specs = json.specs.map((specJson) => Specification.fromJSON(specJson));
+        return new XorSpecification(specs);
+    }
+    toDSL() {
+        const parts = this.specifications.map((spec) => {
+            const dsl = spec.toDSL();
+            // Add parentheses if needed for precedence
+            const kind = spec.getOperatorKind?.();
+            if (kind === 'and' || kind === 'or') {
+                return `(${dsl})`;
+            }
+            return dsl;
+        });
+        return parts.join(' xor ');
+    }
+    getSpecifications() {
+        return [...this.specifications];
+    }
+    clone() {
+        return new XorSpecification(this.specifications.map((spec) => spec.clone()), this.metadata);
+    }
+    getOperatorKind() {
+        return 'xor';
+    }
+}
+
+class ImpliesSpecification extends Specification {
+    antecedent;
+    consequent;
+    constructor(antecedent, consequent, metadata) {
+        super(metadata);
+        this.antecedent = antecedent;
+        this.consequent = consequent;
+    }
+    isSatisfiedBy(obj) {
+        // A implies B is equivalent to (!A || B)
+        return (!this.antecedent.isSatisfiedBy(obj) || this.consequent.isSatisfiedBy(obj));
+    }
+    toJSON() {
+        return {
+            type: 'implies',
+            antecedent: this.antecedent.toJSON(),
+            consequent: this.consequent.toJSON(),
+        };
+    }
+    static fromJSON(json) {
+        const antecedent = Specification.fromJSON(json.antecedent);
+        const consequent = Specification.fromJSON(json.consequent);
+        return new ImpliesSpecification(antecedent, consequent);
+    }
+    toDSL() {
+        const antecedentDsl = this.antecedent.toDSL();
+        const consequentDsl = this.consequent.toDSL();
+        // Add parentheses for complex expressions
+        const leftPart = this.antecedent instanceof AndSpecification ||
+            this.antecedent instanceof OrSpecification ||
+            this.antecedent instanceof XorSpecification
+            ? `(${antecedentDsl})`
+            : antecedentDsl;
+        const rightPart = this.consequent instanceof AndSpecification ||
+            this.consequent instanceof OrSpecification ||
+            this.consequent instanceof XorSpecification
+            ? `(${consequentDsl})`
+            : consequentDsl;
+        return `${leftPart} implies ${rightPart}`;
+    }
+    getAntecedent() {
+        return this.antecedent;
+    }
+    getConsequent() {
+        return this.consequent;
+    }
+    clone() {
+        return new ImpliesSpecification(this.antecedent.clone(), this.consequent.clone(), this.metadata);
+    }
+}
+
+class NotSpecification extends Specification {
+    specification;
+    constructor(specification, metadata) {
+        super(metadata);
+        this.specification = specification;
+    }
+    isSatisfiedBy(obj) {
+        return !this.specification.isSatisfiedBy(obj);
+    }
+    toJSON() {
+        return {
+            type: 'not',
+            spec: this.specification.toJSON(),
+        };
+    }
+    static fromJSON(json) {
+        const spec = Specification.fromJSON(json.spec);
+        return new NotSpecification(spec);
+    }
+    toDSL() {
+        const innerDsl = this.specification.toDSL();
+        // Add parentheses for complex expressions
+        if (this.specification instanceof AndSpecification ||
+            this.specification instanceof OrSpecification ||
+            this.specification instanceof XorSpecification ||
+            this.specification instanceof ImpliesSpecification) {
+            return `!(${innerDsl})`;
+        }
+        return `!${innerDsl}`;
+    }
+    getSpecification() {
+        return this.specification;
+    }
+    clone() {
+        return new NotSpecification(this.specification.clone(), this.metadata);
+    }
+}
+
+class FunctionRegistry {
+    contextKey;
+    static instances = new Map();
+    functions = new Map();
+    constructor(contextKey) {
+        this.contextKey = contextKey;
+    }
+    static getInstance(contextKey = 'default') {
+        if (!this.instances.has(contextKey)) {
+            this.instances.set(contextKey, new FunctionRegistry(contextKey));
+        }
+        return this.instances.get(contextKey);
+    }
+    register(name, fn) {
+        this.functions.set(name, fn);
+    }
+    unregister(name) {
+        return this.functions.delete(name);
+    }
+    get(name) {
+        return this.functions.get(name);
+    }
+    has(name) {
+        return this.functions.has(name);
+    }
+    getAll() {
+        return new Map(this.functions);
+    }
+    clear() {
+        this.functions.clear();
+    }
+    execute(name, obj, ...args) {
+        const fn = this.functions.get(name);
+        if (!fn) {
+            throw new Error(`Function '${name}' not found in registry`);
+        }
+        return fn(obj, ...args);
+    }
+    getContextKey() {
+        return this.contextKey;
+    }
+}
+
+class FunctionSpecification extends Specification {
+    functionName;
+    args;
+    registry;
+    constructor(functionName, args, registry, metadata) {
+        super(metadata);
+        this.functionName = functionName;
+        this.args = args;
+        this.registry = registry;
+    }
+    isSatisfiedBy(obj) {
+        const registry = this.registry || FunctionRegistry.getInstance();
+        return registry.execute(this.functionName, obj, ...this.args);
+    }
+    toJSON() {
+        return {
+            type: 'function',
+            name: this.functionName,
+            args: this.args,
+        };
+    }
+    static fromJSON(json, registry) {
+        return new FunctionSpecification(json.name, json.args, registry);
+    }
+    toDSL() {
+        const argsStr = this.args
+            .map((arg) => {
+            if (typeof arg === 'string') {
+                return JSON.stringify(arg);
+            }
+            if (typeof arg === 'object' && arg !== null && arg.type === 'field') {
+                return `${arg.field}`;
+            }
+            return JSON.stringify(arg);
+        })
+            .join(', ');
+        return `${this.functionName}(${argsStr})`;
+    }
+    getFunctionName() {
+        return this.functionName;
+    }
+    getArgs() {
+        return [...this.args];
+    }
+    getRegistry() {
+        return this.registry;
+    }
+    clone() {
+        return new FunctionSpecification(this.functionName, [...this.args], this.registry, this.metadata);
+    }
+}
+
+class AtLeastSpecification extends Specification {
+    minimum;
+    specifications;
+    constructor(minimum, specifications, metadata) {
+        super(metadata);
+        this.minimum = minimum;
+        this.specifications = specifications;
+        if (minimum < 0) {
+            throw new Error('Minimum count must be non-negative');
+        }
+        if (specifications.length === 0) {
+            throw new Error('AtLeastSpecification requires at least one specification');
+        }
+    }
+    isSatisfiedBy(obj) {
+        const satisfiedCount = this.specifications.filter((spec) => spec.isSatisfiedBy(obj)).length;
+        return satisfiedCount >= this.minimum;
+    }
+    toJSON() {
+        return {
+            type: 'atLeast',
+            minimum: this.minimum,
+            specs: this.specifications.map((spec) => spec.toJSON()),
+            metadata: this.metadata,
+        };
+    }
+    static fromJSON(json) {
+        const specs = json.specs.map((specJson) => Specification.fromJSON(specJson));
+        return new AtLeastSpecification(json.minimum, specs, json.metadata);
+    }
+    toDSL() {
+        const specDsls = this.specifications.map((spec) => spec.toDSL());
+        const specsStr = specDsls.join(', ');
+        return `atLeast(${this.minimum}, [${specsStr}])`;
+    }
+    getMinimum() {
+        return this.minimum;
+    }
+    getSpecifications() {
+        return [...this.specifications];
+    }
+    getSatisfiedCount(obj) {
+        return this.specifications.filter((spec) => spec.isSatisfiedBy(obj)).length;
+    }
+    clone() {
+        const clonedSpecs = this.specifications.map((spec) => spec.clone());
+        return new AtLeastSpecification(this.minimum, clonedSpecs, this.metadata);
+    }
+}
+
+class ExactlySpecification extends Specification {
+    exact;
+    specifications;
+    constructor(exact, specifications, metadata) {
+        super(metadata);
+        this.exact = exact;
+        this.specifications = specifications;
+        if (exact < 0) {
+            throw new Error('Exact count must be non-negative');
+        }
+        if (specifications.length === 0) {
+            throw new Error('ExactlySpecification requires at least one specification');
+        }
+    }
+    isSatisfiedBy(obj) {
+        const satisfiedCount = this.specifications.filter((spec) => spec.isSatisfiedBy(obj)).length;
+        return satisfiedCount === this.exact;
+    }
+    toJSON() {
+        return {
+            type: 'exactly',
+            exact: this.exact,
+            specs: this.specifications.map((spec) => spec.toJSON()),
+            metadata: this.metadata,
+        };
+    }
+    static fromJSON(json) {
+        const specs = json.specs.map((specJson) => Specification.fromJSON(specJson));
+        return new ExactlySpecification(json.exact, specs, json.metadata);
+    }
+    toDSL() {
+        const specDsls = this.specifications.map((spec) => spec.toDSL());
+        const specsStr = specDsls.join(', ');
+        return `exactly(${this.exact}, [${specsStr}])`;
+    }
+    getExact() {
+        return this.exact;
+    }
+    getSpecifications() {
+        return [...this.specifications];
+    }
+    getSatisfiedCount(obj) {
+        return this.specifications.filter((spec) => spec.isSatisfiedBy(obj)).length;
+    }
+    clone() {
+        const clonedSpecs = this.specifications.map((spec) => spec.clone());
+        return new ExactlySpecification(this.exact, clonedSpecs, this.metadata);
+    }
+}
+
+class TransformRegistry {
+    static instance;
+    transforms = new Map();
+    constructor() {
+        // Register default transforms
+        this.registerDefaults();
+    }
+    static getInstance() {
+        if (!this.instance) {
+            this.instance = new TransformRegistry();
+        }
+        return this.instance;
+    }
+    registerDefaults() {
+        this.register('toLowerCase', (value) => String(value).toLowerCase());
+        this.register('toUpperCase', (value) => String(value).toUpperCase());
+        this.register('trim', (value) => String(value).trim());
+        this.register('toString', (value) => String(value));
+        this.register('toNumber', (value) => Number(value));
+        this.register('toBoolean', (value) => Boolean(value));
+        this.register('length', (value) => {
+            if (typeof value === 'string' || Array.isArray(value)) {
+                return value.length;
+            }
+            return 0;
+        });
+    }
+    register(name, fn) {
+        this.transforms.set(name, fn);
+    }
+    unregister(name) {
+        return this.transforms.delete(name);
+    }
+    get(name) {
+        return this.transforms.get(name);
+    }
+    has(name) {
+        return this.transforms.has(name);
+    }
+    getAll() {
+        return new Map(this.transforms);
+    }
+    clear() {
+        this.transforms.clear();
+        this.registerDefaults();
+    }
+    apply(name, value) {
+        const transform = this.transforms.get(name);
+        if (!transform) {
+            throw new Error(`Transform '${name}' not found in registry`);
+        }
+        return transform(value);
+    }
+    applyChain(transforms, value) {
+        return transforms.reduce((acc, transformName) => {
+            return this.apply(transformName, acc);
+        }, value);
+    }
+}
+
+class FieldToFieldSpecification extends Specification {
+    fieldA;
+    operator;
+    fieldB;
+    transformA;
+    transformB;
+    transformRegistry;
+    constructor(fieldA, operator, fieldB, transformA, transformB, transformRegistry, metadata) {
+        super(metadata);
+        this.fieldA = fieldA;
+        this.operator = operator;
+        this.fieldB = fieldB;
+        this.transformA = transformA;
+        this.transformB = transformB;
+        this.transformRegistry = transformRegistry;
+    }
+    isSatisfiedBy(obj) {
+        let valueA = obj[this.fieldA];
+        let valueB = obj[this.fieldB];
+        const registry = this.transformRegistry || TransformRegistry.getInstance();
+        // Apply transforms if specified
+        if (this.transformA && this.transformA.length > 0) {
+            valueA = registry.applyChain(this.transformA, valueA);
+        }
+        if (this.transformB && this.transformB.length > 0) {
+            valueB = registry.applyChain(this.transformB, valueB);
+        }
+        switch (this.operator) {
+            case ComparisonOperator.EQUALS:
+                return valueA === valueB;
+            case ComparisonOperator.NOT_EQUALS:
+                return valueA !== valueB;
+            case ComparisonOperator.LESS_THAN:
+                return valueA < valueB;
+            case ComparisonOperator.LESS_THAN_OR_EQUAL:
+                return valueA <= valueB;
+            case ComparisonOperator.GREATER_THAN:
+                return valueA > valueB;
+            case ComparisonOperator.GREATER_THAN_OR_EQUAL:
+                return valueA >= valueB;
+            case ComparisonOperator.CONTAINS:
+                return String(valueA).includes(String(valueB));
+            case ComparisonOperator.STARTS_WITH:
+                return String(valueA).startsWith(String(valueB));
+            case ComparisonOperator.ENDS_WITH:
+                return String(valueA).endsWith(String(valueB));
+            case ComparisonOperator.IN:
+                return Array.isArray(valueB) && valueB.includes(valueA);
+            default:
+                throw new Error(`Unsupported operator: ${this.operator}`);
+        }
+    }
+    toJSON() {
+        return {
+            type: 'fieldToField',
+            fieldA: String(this.fieldA),
+            operator: this.operator,
+            fieldB: String(this.fieldB),
+            transformA: this.transformA,
+            transformB: this.transformB,
+            metadata: this.metadata,
+        };
+    }
+    static fromJSON(json, transformRegistry) {
+        return new FieldToFieldSpecification(json.fieldA, json.operator, json.fieldB, json.transformA, json.transformB, transformRegistry, json.metadata);
+    }
+    toDSL() {
+        const fieldAName = String(this.fieldA);
+        const fieldBName = String(this.fieldB);
+        let leftField = fieldAName;
+        let rightField = fieldBName;
+        // Apply transform notation
+        if (this.transformA && this.transformA.length > 0) {
+            leftField = `${fieldAName}.${this.transformA.join('.')}`;
+        }
+        if (this.transformB && this.transformB.length > 0) {
+            rightField = `${fieldBName}.${this.transformB.join('.')}`;
+        }
+        const symbol = OPERATOR_SYMBOLS[this.operator];
+        switch (this.operator) {
+            case ComparisonOperator.CONTAINS:
+                return `contains(${leftField}, ${rightField})`;
+            case ComparisonOperator.STARTS_WITH:
+                return `startsWith(${leftField}, ${rightField})`;
+            case ComparisonOperator.ENDS_WITH:
+                return `endsWith(${leftField}, ${rightField})`;
+            case ComparisonOperator.IN:
+                return `${leftField} in ${rightField}`;
+            default:
+                return `${leftField} ${symbol} ${rightField}`;
+        }
+    }
+    getFieldA() {
+        return this.fieldA;
+    }
+    getFieldB() {
+        return this.fieldB;
+    }
+    getOperator() {
+        return this.operator;
+    }
+    getTransformA() {
+        return this.transformA ? [...this.transformA] : undefined;
+    }
+    getTransformB() {
+        return this.transformB ? [...this.transformB] : undefined;
+    }
+    clone() {
+        return new FieldToFieldSpecification(this.fieldA, this.operator, this.fieldB, this.transformA ? [...this.transformA] : undefined, this.transformB ? [...this.transformB] : undefined, this.transformRegistry, this.metadata);
+    }
+}
+
+class DefaultContextProvider {
+    context;
+    constructor(context = {}) {
+        this.context = context;
+    }
+    getValue(path) {
+        return this.getNestedValue(this.context, path);
+    }
+    hasValue(path) {
+        try {
+            const value = this.getNestedValue(this.context, path);
+            return value !== undefined;
+        }
+        catch {
+            return false;
+        }
+    }
+    getNestedValue(obj, path) {
+        return path.split('.').reduce((current, key) => {
+            return current && current[key] !== undefined ? current[key] : undefined;
+        }, obj);
+    }
+    setContext(context) {
+        this.context = context;
+    }
+    updateContext(updates) {
+        this.context = { ...this.context, ...updates };
+    }
+    getContext() {
+        return { ...this.context };
+    }
+}
+class DateContextProvider {
+    getValue(path) {
+        switch (path) {
+            case 'now':
+                return new Date();
+            case 'today':
+                const today = new Date();
+                today.setHours(0, 0, 0, 0);
+                return today;
+            case 'timestamp':
+                return Date.now();
+            default:
+                return undefined;
+        }
+    }
+    hasValue(path) {
+        return ['now', 'today', 'timestamp'].includes(path);
+    }
+}
+class CompositeContextProvider {
+    providers;
+    constructor(providers) {
+        this.providers = providers;
+    }
+    getValue(path) {
+        for (const provider of this.providers) {
+            if (provider.hasValue(path)) {
+                return provider.getValue(path);
+            }
+        }
+        return undefined;
+    }
+    hasValue(path) {
+        return this.providers.some(provider => provider.hasValue(path));
+    }
+    addProvider(provider) {
+        this.providers.push(provider);
+    }
+    removeProvider(provider) {
+        const index = this.providers.indexOf(provider);
+        if (index > -1) {
+            this.providers.splice(index, 1);
+        }
+    }
+}
+
+class ContextualSpecification extends Specification {
+    template;
+    contextProvider;
+    static TOKEN_REGEX = /\$\{([^}]+)\}/g;
+    constructor(template, contextProvider, metadata) {
+        super(metadata);
+        this.template = template;
+        this.contextProvider = contextProvider;
+    }
+    isSatisfiedBy(obj) {
+        const resolvedExpression = this.resolveTokens(this.template, obj);
+        // This would need to be evaluated by the DSL parser
+        // For now, we'll throw an error indicating this needs the parser
+        throw new Error(`ContextualSpecification requires DSL parser to evaluate: ${resolvedExpression}`);
+    }
+    toJSON() {
+        return {
+            type: 'contextual',
+            template: this.template,
+            metadata: this.metadata,
+        };
+    }
+    static fromJSON(json, contextProvider) {
+        return new ContextualSpecification(json.template, contextProvider, json.metadata);
+    }
+    toDSL() {
+        return this.template;
+    }
+    resolveTokens(template, obj) {
+        const provider = this.contextProvider || new DefaultContextProvider();
+        return template.replace(ContextualSpecification.TOKEN_REGEX, (match, tokenPath) => {
+            // First try to resolve from context
+            if (provider.hasValue(tokenPath)) {
+                const value = provider.getValue(tokenPath);
+                return this.valueToString(value);
+            }
+            // Then try to resolve from object fields
+            if (tokenPath in obj) {
+                const value = obj[tokenPath];
+                return this.valueToString(value);
+            }
+            // If not found, return the original token
+            return match;
+        });
+    }
+    valueToString(value) {
+        if (value === null || value === undefined) {
+            return 'null';
+        }
+        if (typeof value === 'string') {
+            return `"${value}"`;
+        }
+        if (typeof value === 'number' || typeof value === 'boolean') {
+            return String(value);
+        }
+        if (value instanceof Date) {
+            return `"${value.toISOString()}"`;
+        }
+        return JSON.stringify(value);
+    }
+    getTemplate() {
+        return this.template;
+    }
+    getContextProvider() {
+        return this.contextProvider;
+    }
+    setContextProvider(provider) {
+        return new ContextualSpecification(this.template, provider, this.metadata);
+    }
+    getTokens() {
+        const tokens = [];
+        let match;
+        const regex = new RegExp(ContextualSpecification.TOKEN_REGEX);
+        while ((match = regex.exec(this.template)) !== null) {
+            tokens.push(match[1]);
+        }
+        return tokens;
+    }
+    clone() {
+        return new ContextualSpecification(this.template, this.contextProvider, this.metadata);
+    }
+}
+
+/**
+ * Types of conditional validation
+ */
+var ConditionalType;
+(function (ConditionalType) {
+    ConditionalType["REQUIRED_IF"] = "requiredIf";
+    ConditionalType["VISIBLE_IF"] = "visibleIf";
+    ConditionalType["DISABLED_IF"] = "disabledIf";
+    ConditionalType["READONLY_IF"] = "readonlyIf";
+})(ConditionalType || (ConditionalType = {}));
+/**
+ * Base class for conditional validators
+ */
+class ConditionalSpecification extends Specification {
+    condition;
+    conditionalType;
+    constructor(condition, conditionalType, metadata) {
+        super(metadata);
+        this.condition = condition;
+        this.conditionalType = conditionalType;
+    }
+    getCondition() {
+        return this.condition;
+    }
+    getConditionalType() {
+        return this.conditionalType;
+    }
+}
+/**
+ * Validates that a field is required when a condition is met
+ */
+class RequiredIfSpecification extends ConditionalSpecification {
+    field;
+    constructor(field, condition, metadata) {
+        super(condition, ConditionalType.REQUIRED_IF, metadata);
+        this.field = field;
+    }
+    isSatisfiedBy(obj) {
+        // If condition is not met, validation passes (field is not required)
+        if (!this.condition.isSatisfiedBy(obj)) {
+            return true;
+        }
+        // If condition is met, check if field has a value
+        const fieldValue = obj[this.field];
+        return fieldValue !== null && fieldValue !== undefined && fieldValue !== '';
+    }
+    toJSON() {
+        return {
+            type: 'requiredIf',
+            field: String(this.field),
+            condition: this.condition.toJSON(),
+            metadata: this.metadata,
+        };
+    }
+    static fromJSON(json) {
+        // This would need the SpecificationFactory to reconstruct the condition
+        throw new Error('Use SpecificationFactory.fromJSON() for proper reconstruction');
+    }
+    toDSL() {
+        return `requiredIf(${String(this.field)}, ${this.condition.toDSL()})`;
+    }
+    clone() {
+        return new RequiredIfSpecification(this.field, this.condition.clone(), this.metadata);
+    }
+    getField() {
+        return this.field;
+    }
+}
+/**
+ * Determines if a field should be visible based on a condition
+ */
+class VisibleIfSpecification extends ConditionalSpecification {
+    field;
+    constructor(field, condition, metadata) {
+        super(condition, ConditionalType.VISIBLE_IF, metadata);
+        this.field = field;
+    }
+    isSatisfiedBy(obj) {
+        // This returns whether the field should be visible
+        return this.condition.isSatisfiedBy(obj);
+    }
+    toJSON() {
+        return {
+            type: 'visibleIf',
+            field: String(this.field),
+            condition: this.condition.toJSON(),
+            metadata: this.metadata,
+        };
+    }
+    static fromJSON(json) {
+        throw new Error('Use SpecificationFactory.fromJSON() for proper reconstruction');
+    }
+    toDSL() {
+        return `visibleIf(${String(this.field)}, ${this.condition.toDSL()})`;
+    }
+    clone() {
+        return new VisibleIfSpecification(this.field, this.condition.clone(), this.metadata);
+    }
+    getField() {
+        return this.field;
+    }
+}
+/**
+ * Determines if a field should be disabled based on a condition
+ */
+class DisabledIfSpecification extends ConditionalSpecification {
+    field;
+    constructor(field, condition, metadata) {
+        super(condition, ConditionalType.DISABLED_IF, metadata);
+        this.field = field;
+    }
+    isSatisfiedBy(obj) {
+        // This returns whether the field should be disabled
+        return this.condition.isSatisfiedBy(obj);
+    }
+    toJSON() {
+        return {
+            type: 'disabledIf',
+            field: String(this.field),
+            condition: this.condition.toJSON(),
+            metadata: this.metadata,
+        };
+    }
+    static fromJSON(json) {
+        throw new Error('Use SpecificationFactory.fromJSON() for proper reconstruction');
+    }
+    toDSL() {
+        return `disabledIf(${String(this.field)}, ${this.condition.toDSL()})`;
+    }
+    clone() {
+        return new DisabledIfSpecification(this.field, this.condition.clone(), this.metadata);
+    }
+    getField() {
+        return this.field;
+    }
+}
+/**
+ * Determines if a field should be readonly based on a condition
+ */
+class ReadonlyIfSpecification extends ConditionalSpecification {
+    field;
+    constructor(field, condition, metadata) {
+        super(condition, ConditionalType.READONLY_IF, metadata);
+        this.field = field;
+    }
+    isSatisfiedBy(obj) {
+        // This returns whether the field should be readonly
+        return this.condition.isSatisfiedBy(obj);
+    }
+    toJSON() {
+        return {
+            type: 'readonlyIf',
+            field: String(this.field),
+            condition: this.condition.toJSON(),
+            metadata: this.metadata,
+        };
+    }
+    static fromJSON(json) {
+        throw new Error('Use SpecificationFactory.fromJSON() for proper reconstruction');
+    }
+    toDSL() {
+        return `readonlyIf(${String(this.field)}, ${this.condition.toDSL()})`;
+    }
+    clone() {
+        return new ReadonlyIfSpecification(this.field, this.condition.clone(), this.metadata);
+    }
+    getField() {
+        return this.field;
+    }
+}
+
+/**
+ * Applies a specification to all elements in an array field
+ */
+class ForEachSpecification extends Specification {
+    arrayField;
+    itemSpecification;
+    constructor(arrayField, itemSpecification, metadata) {
+        super(metadata);
+        this.arrayField = arrayField;
+        this.itemSpecification = itemSpecification;
+    }
+    isSatisfiedBy(obj) {
+        const arrayValue = obj[this.arrayField];
+        // If not an array, fail validation
+        if (!Array.isArray(arrayValue)) {
+            return false;
+        }
+        // Check if all items satisfy the specification
+        return arrayValue.every((item) => {
+            try {
+                return this.itemSpecification.isSatisfiedBy(item);
+            }
+            catch (error) {
+                // If item doesn't match expected structure, fail validation
+                return false;
+            }
+        });
+    }
+    toJSON() {
+        return {
+            type: 'forEach',
+            arrayField: String(this.arrayField),
+            itemSpecification: this.itemSpecification.toJSON(),
+            metadata: this.metadata,
+        };
+    }
+    static fromJSON(json) {
+        throw new Error('Use SpecificationFactory.fromJSON() for proper reconstruction');
+    }
+    toDSL() {
+        return `forEach(${String(this.arrayField)}, ${this.itemSpecification.toDSL()})`;
+    }
+    clone() {
+        return new ForEachSpecification(this.arrayField, this.itemSpecification.clone(), this.metadata);
+    }
+    getArrayField() {
+        return this.arrayField;
+    }
+    getItemSpecification() {
+        return this.itemSpecification;
+    }
+    /**
+     * Gets items that fail the specification
+     */
+    getFailingItems(obj) {
+        const arrayValue = obj[this.arrayField];
+        if (!Array.isArray(arrayValue)) {
+            return [];
+        }
+        const failingItems = [];
+        arrayValue.forEach((item, index) => {
+            if (!this.itemSpecification.isSatisfiedBy(item)) {
+                failingItems.push({
+                    index,
+                    item,
+                    errors: [`Item at index ${index} failed validation`],
+                });
+            }
+        });
+        return failingItems;
+    }
+}
+/**
+ * Ensures all items in an array are unique based on a field or key selector
+ */
+class UniqueBySpecification extends Specification {
+    arrayField;
+    keySelector;
+    constructor(arrayField, keySelector, metadata) {
+        super(metadata);
+        this.arrayField = arrayField;
+        this.keySelector = keySelector;
+    }
+    isSatisfiedBy(obj) {
+        const arrayValue = obj[this.arrayField];
+        // If not an array, pass validation (empty case)
+        if (!Array.isArray(arrayValue)) {
+            return true;
+        }
+        // If empty array, pass validation
+        if (arrayValue.length === 0) {
+            return true;
+        }
+        const seen = new Set();
+        for (const item of arrayValue) {
+            let key;
+            if (typeof this.keySelector === 'string') {
+                // Field name selector
+                key = item?.[this.keySelector];
+            }
+            else {
+                // Function selector
+                key = this.keySelector(item);
+            }
+            // Convert key to string for Set comparison
+            const keyStr = JSON.stringify(key);
+            if (seen.has(keyStr)) {
+                return false; // Duplicate found
+            }
+            seen.add(keyStr);
+        }
+        return true;
+    }
+    toJSON() {
+        return {
+            type: 'uniqueBy',
+            arrayField: String(this.arrayField),
+            keySelector: typeof this.keySelector === 'string' ? this.keySelector : '[Function]',
+            metadata: this.metadata,
+        };
+    }
+    static fromJSON(json) {
+        return new UniqueBySpecification(json.arrayField, json.keySelector, json.metadata);
+    }
+    toDSL() {
+        const selector = typeof this.keySelector === 'string'
+            ? `"${this.keySelector}"`
+            : '[Function]';
+        return `uniqueBy(${String(this.arrayField)}, ${selector})`;
+    }
+    clone() {
+        return new UniqueBySpecification(this.arrayField, this.keySelector, this.metadata);
+    }
+    getArrayField() {
+        return this.arrayField;
+    }
+    getKeySelector() {
+        return this.keySelector;
+    }
+    /**
+     * Gets duplicate items found in the array
+     */
+    getDuplicates(obj) {
+        const arrayValue = obj[this.arrayField];
+        if (!Array.isArray(arrayValue)) {
+            return [];
+        }
+        const keyMap = new Map();
+        arrayValue.forEach((item, index) => {
+            let key;
+            if (typeof this.keySelector === 'string') {
+                key = item?.[this.keySelector];
+            }
+            else {
+                key = this.keySelector(item);
+            }
+            const keyStr = JSON.stringify(key);
+            if (!keyMap.has(keyStr)) {
+                keyMap.set(keyStr, []);
+            }
+            keyMap.get(keyStr).push({ index, item });
+        });
+        // Return only keys that have duplicates
+        return Array.from(keyMap.entries())
+            .filter(([_, items]) => items.length > 1)
+            .map(([keyStr, items]) => ({
+            key: JSON.parse(keyStr),
+            items,
+        }));
+    }
+}
+/**
+ * Validates that an array has a minimum number of elements
+ */
+class MinLengthSpecification extends Specification {
+    arrayField;
+    minLength;
+    constructor(arrayField, minLength, metadata) {
+        super(metadata);
+        this.arrayField = arrayField;
+        this.minLength = minLength;
+    }
+    isSatisfiedBy(obj) {
+        const arrayValue = obj[this.arrayField];
+        if (!Array.isArray(arrayValue)) {
+            return false;
+        }
+        return arrayValue.length >= this.minLength;
+    }
+    toJSON() {
+        return {
+            type: 'minLength',
+            arrayField: String(this.arrayField),
+            minLength: this.minLength,
+            metadata: this.metadata,
+        };
+    }
+    static fromJSON(json) {
+        return new MinLengthSpecification(json.arrayField, json.minLength, json.metadata);
+    }
+    toDSL() {
+        return `minLength(${String(this.arrayField)}, ${this.minLength})`;
+    }
+    clone() {
+        return new MinLengthSpecification(this.arrayField, this.minLength, this.metadata);
+    }
+    getArrayField() {
+        return this.arrayField;
+    }
+    getMinLength() {
+        return this.minLength;
+    }
+}
+/**
+ * Validates that an array has a maximum number of elements
+ */
+class MaxLengthSpecification extends Specification {
+    arrayField;
+    maxLength;
+    constructor(arrayField, maxLength, metadata) {
+        super(metadata);
+        this.arrayField = arrayField;
+        this.maxLength = maxLength;
+    }
+    isSatisfiedBy(obj) {
+        const arrayValue = obj[this.arrayField];
+        if (!Array.isArray(arrayValue)) {
+            return true; // If not array, max length doesn't apply
+        }
+        return arrayValue.length <= this.maxLength;
+    }
+    toJSON() {
+        return {
+            type: 'maxLength',
+            arrayField: String(this.arrayField),
+            maxLength: this.maxLength,
+            metadata: this.metadata,
+        };
+    }
+    static fromJSON(json) {
+        return new MaxLengthSpecification(json.arrayField, json.maxLength, json.metadata);
+    }
+    toDSL() {
+        return `maxLength(${String(this.arrayField)}, ${this.maxLength})`;
+    }
+    clone() {
+        return new MaxLengthSpecification(this.arrayField, this.maxLength, this.metadata);
+    }
+    getArrayField() {
+        return this.arrayField;
+    }
+    getMaxLength() {
+        return this.maxLength;
+    }
+}
+
+/**
+ * Only applies the inner specification if the field is defined (not null, undefined, or empty)
+ */
+class IfDefinedSpecification extends Specification {
+    field;
+    innerSpecification;
+    constructor(field, innerSpecification, metadata) {
+        super(metadata);
+        this.field = field;
+        this.innerSpecification = innerSpecification;
+    }
+    isSatisfiedBy(obj) {
+        const fieldValue = obj[this.field];
+        // If field is not defined, validation passes
+        if (this.isUndefined(fieldValue)) {
+            return true;
+        }
+        // If field is defined, apply the inner specification
+        return this.innerSpecification.isSatisfiedBy(obj);
+    }
+    isUndefined(value) {
+        return value === null || value === undefined || value === '';
+    }
+    toJSON() {
+        return {
+            type: 'ifDefined',
+            field: String(this.field),
+            specification: this.innerSpecification.toJSON(),
+            metadata: this.metadata,
+        };
+    }
+    static fromJSON(json) {
+        throw new Error('Use SpecificationFactory.fromJSON() for proper reconstruction');
+    }
+    toDSL() {
+        return `ifDefined(${String(this.field)}, ${this.innerSpecification.toDSL()})`;
+    }
+    clone() {
+        return new IfDefinedSpecification(this.field, this.innerSpecification.clone(), this.metadata);
+    }
+    getField() {
+        return this.field;
+    }
+    getInnerSpecification() {
+        return this.innerSpecification;
+    }
+}
+/**
+ * Only applies the inner specification if the field value is not null
+ */
+class IfNotNullSpecification extends Specification {
+    field;
+    innerSpecification;
+    constructor(field, innerSpecification, metadata) {
+        super(metadata);
+        this.field = field;
+        this.innerSpecification = innerSpecification;
+    }
+    isSatisfiedBy(obj) {
+        const fieldValue = obj[this.field];
+        // If field is null, validation passes
+        if (fieldValue === null) {
+            return true;
+        }
+        // If field is not null, apply the inner specification
+        return this.innerSpecification.isSatisfiedBy(obj);
+    }
+    toJSON() {
+        return {
+            type: 'ifNotNull',
+            field: String(this.field),
+            specification: this.innerSpecification.toJSON(),
+            metadata: this.metadata,
+        };
+    }
+    static fromJSON(json) {
+        throw new Error('Use SpecificationFactory.fromJSON() for proper reconstruction');
+    }
+    toDSL() {
+        return `ifNotNull(${String(this.field)}, ${this.innerSpecification.toDSL()})`;
+    }
+    clone() {
+        return new IfNotNullSpecification(this.field, this.innerSpecification.clone(), this.metadata);
+    }
+    getField() {
+        return this.field;
+    }
+    getInnerSpecification() {
+        return this.innerSpecification;
+    }
+}
+/**
+ * Only applies the inner specification if the field exists as a property on the object
+ */
+class IfExistsSpecification extends Specification {
+    field;
+    innerSpecification;
+    constructor(field, innerSpecification, metadata) {
+        super(metadata);
+        this.field = field;
+        this.innerSpecification = innerSpecification;
+    }
+    isSatisfiedBy(obj) {
+        // If field doesn't exist as a property, validation passes
+        if (!(this.field in obj)) {
+            return true;
+        }
+        // If field exists, apply the inner specification
+        return this.innerSpecification.isSatisfiedBy(obj);
+    }
+    toJSON() {
+        return {
+            type: 'ifExists',
+            field: String(this.field),
+            specification: this.innerSpecification.toJSON(),
+            metadata: this.metadata,
+        };
+    }
+    static fromJSON(json) {
+        throw new Error('Use SpecificationFactory.fromJSON() for proper reconstruction');
+    }
+    toDSL() {
+        return `ifExists(${String(this.field)}, ${this.innerSpecification.toDSL()})`;
+    }
+    clone() {
+        return new IfExistsSpecification(this.field, this.innerSpecification.clone(), this.metadata);
+    }
+    getField() {
+        return this.field;
+    }
+    getInnerSpecification() {
+        return this.innerSpecification;
+    }
+}
+/**
+ * Provides a default value for a field if it's undefined, then applies the specification
+ */
+class WithDefaultSpecification extends Specification {
+    field;
+    defaultValue;
+    innerSpecification;
+    constructor(field, defaultValue, innerSpecification, metadata) {
+        super(metadata);
+        this.field = field;
+        this.defaultValue = defaultValue;
+        this.innerSpecification = innerSpecification;
+    }
+    isSatisfiedBy(obj) {
+        // Create a copy of the object with default value if field is undefined
+        const objWithDefault = { ...obj };
+        if (this.isUndefined(obj[this.field])) {
+            objWithDefault[this.field] = this.defaultValue;
+        }
+        return this.innerSpecification.isSatisfiedBy(objWithDefault);
+    }
+    isUndefined(value) {
+        return value === null || value === undefined;
+    }
+    toJSON() {
+        return {
+            type: 'withDefault',
+            field: String(this.field),
+            defaultValue: this.defaultValue,
+            specification: this.innerSpecification.toJSON(),
+            metadata: this.metadata,
+        };
+    }
+    static fromJSON(json) {
+        throw new Error('Use SpecificationFactory.fromJSON() for proper reconstruction');
+    }
+    toDSL() {
+        const defaultStr = JSON.stringify(this.defaultValue);
+        return `withDefault(${String(this.field)}, ${defaultStr}, ${this.innerSpecification.toDSL()})`;
+    }
+    clone() {
+        return new WithDefaultSpecification(this.field, this.defaultValue, this.innerSpecification.clone(), this.metadata);
+    }
+    getField() {
+        return this.field;
+    }
+    getDefaultValue() {
+        return this.defaultValue;
+    }
+    getInnerSpecification() {
+        return this.innerSpecification;
+    }
+}
+
+/**
+ * Form specification that manages validation rules for multiple fields
+ */
+class FormSpecification extends Specification {
+    fieldRules = new Map();
+    globalValidations = [];
+    constructor(metadata) {
+        super(metadata);
+    }
+    /**
+     * Adds validation rules for a specific field
+     */
+    addFieldRules(field, rules) {
+        this.fieldRules.set(field, rules);
+        return this;
+    }
+    /**
+     * Adds a global validation rule that applies to the entire form
+     */
+    addGlobalValidation(specification) {
+        this.globalValidations.push(specification);
+        return this;
+    }
+    /**
+     * Sets required condition for a field
+     */
+    setRequired(field, condition) {
+        const existing = this.fieldRules.get(field) || {};
+        existing.required = condition;
+        this.fieldRules.set(field, existing);
+        return this;
+    }
+    /**
+     * Sets visibility condition for a field
+     */
+    setVisible(field, condition) {
+        const existing = this.fieldRules.get(field) || {};
+        existing.visible = condition;
+        this.fieldRules.set(field, existing);
+        return this;
+    }
+    /**
+     * Sets disabled condition for a field
+     */
+    setDisabled(field, condition) {
+        const existing = this.fieldRules.get(field) || {};
+        existing.disabled = condition;
+        this.fieldRules.set(field, existing);
+        return this;
+    }
+    /**
+     * Sets readonly condition for a field
+     */
+    setReadonly(field, condition) {
+        const existing = this.fieldRules.get(field) || {};
+        existing.readonly = condition;
+        this.fieldRules.set(field, existing);
+        return this;
+    }
+    /**
+     * Basic satisfaction check - validates all rules
+     */
+    isSatisfiedBy(obj) {
+        const result = this.validateForm(obj);
+        return result.isValid;
+    }
+    /**
+     * Comprehensive form validation with detailed results
+     */
+    validateForm(obj) {
+        const result = {
+            isValid: true,
+            fields: {},
+            globalErrors: [],
+            warnings: [],
+        };
+        // Validate each field
+        for (const [field, rules] of this.fieldRules.entries()) {
+            const fieldResult = this.validateField(field, rules, obj);
+            result.fields[String(field)] = fieldResult;
+            if (!fieldResult.isValid) {
+                result.isValid = false;
+            }
+        }
+        // Validate global rules
+        for (const globalSpec of this.globalValidations) {
+            try {
+                if (!globalSpec.isSatisfiedBy(obj)) {
+                    const metadata = globalSpec.getMetadata();
+                    const message = metadata?.message || 'Global validation failed';
+                    result.globalErrors.push(message);
+                    result.isValid = false;
+                }
+            }
+            catch (error) {
+                result.globalErrors.push(`Global validation error: ${error}`);
+                result.isValid = false;
+            }
+        }
+        return result;
+    }
+    validateField(field, rules, obj) {
+        const fieldResult = {
+            field: String(field),
+            isValid: true,
+            errors: [],
+            warnings: [],
+            metadata: rules.metadata,
+        };
+        // Check if field should be visible
+        if (!this.isFieldVisible(field, rules, obj)) {
+            // If field is not visible, skip validation
+            return fieldResult;
+        }
+        // Check required validation
+        if (rules.required) {
+            const isRequired = typeof rules.required === 'boolean'
+                ? rules.required
+                : rules.required.isSatisfiedBy(obj);
+            if (isRequired) {
+                const fieldValue = obj[field];
+                if (fieldValue === null ||
+                    fieldValue === undefined ||
+                    fieldValue === '') {
+                    fieldResult.errors.push(rules.metadata?.message || `${String(field)} is required`);
+                    fieldResult.isValid = false;
+                }
+            }
+        }
+        // Run validation specifications
+        if (rules.validation) {
+            for (const spec of rules.validation) {
+                try {
+                    if (!spec.isSatisfiedBy(obj)) {
+                        const metadata = spec.getMetadata();
+                        const message = metadata?.message || `${String(field)} validation failed`;
+                        fieldResult.errors.push(message);
+                        fieldResult.isValid = false;
+                    }
+                }
+                catch (error) {
+                    fieldResult.errors.push(`Validation error for ${String(field)}: ${error}`);
+                    fieldResult.isValid = false;
+                }
+            }
+        }
+        return fieldResult;
+    }
+    /**
+     * Checks if a field should be visible
+     */
+    isFieldVisible(field, rules, obj) {
+        if (!rules?.visible) {
+            return true; // Default to visible
+        }
+        return typeof rules.visible === 'boolean'
+            ? rules.visible
+            : rules.visible.isSatisfiedBy(obj);
+    }
+    /**
+     * Checks if a field should be disabled
+     */
+    isFieldDisabled(field, obj) {
+        const rules = this.fieldRules.get(field);
+        if (!rules?.disabled) {
+            return false; // Default to enabled
+        }
+        return typeof rules.disabled === 'boolean'
+            ? rules.disabled
+            : rules.disabled.isSatisfiedBy(obj);
+    }
+    /**
+     * Checks if a field should be readonly
+     */
+    isFieldReadonly(field, obj) {
+        const rules = this.fieldRules.get(field);
+        if (!rules?.readonly) {
+            return false; // Default to editable
+        }
+        return typeof rules.readonly === 'boolean'
+            ? rules.readonly
+            : rules.readonly.isSatisfiedBy(obj);
+    }
+    /**
+     * Gets all configured fields
+     */
+    getFields() {
+        return Array.from(this.fieldRules.keys());
+    }
+    /**
+     * Gets rules for a specific field
+     */
+    getFieldRules(field) {
+        return this.fieldRules.get(field);
+    }
+    toJSON() {
+        const fieldsJson = {};
+        for (const [field, rules] of this.fieldRules.entries()) {
+            fieldsJson[String(field)] = {
+                validation: rules.validation?.map((spec) => spec.toJSON()),
+                required: typeof rules.required === 'object'
+                    ? rules.required.toJSON()
+                    : rules.required,
+                visible: typeof rules.visible === 'object'
+                    ? rules.visible.toJSON()
+                    : rules.visible,
+                disabled: typeof rules.disabled === 'object'
+                    ? rules.disabled.toJSON()
+                    : rules.disabled,
+                readonly: typeof rules.readonly === 'object'
+                    ? rules.readonly.toJSON()
+                    : rules.readonly,
+                metadata: rules.metadata,
+            };
+        }
+        return {
+            type: 'form',
+            fields: fieldsJson,
+            globalValidations: this.globalValidations.map((spec) => spec.toJSON()),
+            metadata: this.metadata,
+        };
+    }
+    static fromJSON(json) {
+        throw new Error('FormSpecification.fromJSON not yet implemented - requires SpecificationFactory');
+    }
+    toDSL() {
+        const parts = [];
+        // Export field rules
+        for (const [field, rules] of this.fieldRules.entries()) {
+            if (rules.required && typeof rules.required === 'object') {
+                parts.push(`requiredIf(${String(field)}, ${rules.required.toDSL()})`);
+            }
+            if (rules.visible && typeof rules.visible === 'object') {
+                parts.push(`visibleIf(${String(field)}, ${rules.visible.toDSL()})`);
+            }
+            if (rules.disabled && typeof rules.disabled === 'object') {
+                parts.push(`disabledIf(${String(field)}, ${rules.disabled.toDSL()})`);
+            }
+            if (rules.readonly && typeof rules.readonly === 'object') {
+                parts.push(`readonlyIf(${String(field)}, ${rules.readonly.toDSL()})`);
+            }
+            if (rules.validation) {
+                for (const spec of rules.validation) {
+                    parts.push(spec.toDSL());
+                }
+            }
+        }
+        // Export global validations
+        for (const spec of this.globalValidations) {
+            parts.push(spec.toDSL());
+        }
+        return parts.join(' && ');
+    }
+    clone() {
+        const cloned = new FormSpecification(this.metadata);
+        // Clone field rules
+        for (const [field, rules] of this.fieldRules.entries()) {
+            const clonedRules = {
+                validation: rules.validation?.map((spec) => spec.clone()),
+                required: typeof rules.required === 'object'
+                    ? rules.required.clone()
+                    : rules.required,
+                visible: typeof rules.visible === 'object'
+                    ? rules.visible.clone()
+                    : rules.visible,
+                disabled: typeof rules.disabled === 'object'
+                    ? rules.disabled.clone()
+                    : rules.disabled,
+                readonly: typeof rules.readonly === 'object'
+                    ? rules.readonly.clone()
+                    : rules.readonly,
+                metadata: rules.metadata,
+            };
+            cloned.fieldRules.set(field, clonedRules);
+        }
+        // Clone global validations
+        cloned.globalValidations = this.globalValidations.map((spec) => spec.clone());
+        return cloned;
+    }
+}
+
+var TokenType;
+(function (TokenType) {
+    // Literals
+    TokenType["IDENTIFIER"] = "IDENTIFIER";
+    TokenType["STRING"] = "STRING";
+    TokenType["NUMBER"] = "NUMBER";
+    TokenType["BOOLEAN"] = "BOOLEAN";
+    TokenType["NULL"] = "NULL";
+    // Operators
+    TokenType["AND"] = "AND";
+    TokenType["OR"] = "OR";
+    TokenType["NOT"] = "NOT";
+    TokenType["XOR"] = "XOR";
+    TokenType["IMPLIES"] = "IMPLIES";
+    // Comparison operators
+    TokenType["EQUALS"] = "EQUALS";
+    TokenType["NOT_EQUALS"] = "NOT_EQUALS";
+    TokenType["LESS_THAN"] = "LESS_THAN";
+    TokenType["LESS_THAN_OR_EQUAL"] = "LESS_THAN_OR_EQUAL";
+    TokenType["GREATER_THAN"] = "GREATER_THAN";
+    TokenType["GREATER_THAN_OR_EQUAL"] = "GREATER_THAN_OR_EQUAL";
+    TokenType["IN"] = "IN";
+    // Function tokens
+    TokenType["CONTAINS"] = "CONTAINS";
+    TokenType["STARTS_WITH"] = "STARTS_WITH";
+    TokenType["ENDS_WITH"] = "ENDS_WITH";
+    TokenType["AT_LEAST"] = "AT_LEAST";
+    TokenType["EXACTLY"] = "EXACTLY";
+    // Punctuation
+    TokenType["LEFT_PAREN"] = "LEFT_PAREN";
+    TokenType["RIGHT_PAREN"] = "RIGHT_PAREN";
+    TokenType["LEFT_BRACKET"] = "LEFT_BRACKET";
+    TokenType["RIGHT_BRACKET"] = "RIGHT_BRACKET";
+    TokenType["COMMA"] = "COMMA";
+    TokenType["DOT"] = "DOT";
+    // Special
+    TokenType["FIELD_REFERENCE"] = "FIELD_REFERENCE";
+    TokenType["EOF"] = "EOF";
+    TokenType["WHITESPACE"] = "WHITESPACE";
+})(TokenType || (TokenType = {}));
+const OPERATOR_KEYWORDS = {
+    'and': TokenType.AND,
+    '&&': TokenType.AND,
+    'or': TokenType.OR,
+    '||': TokenType.OR,
+    'not': TokenType.NOT,
+    '!': TokenType.NOT,
+    'xor': TokenType.XOR,
+    'implies': TokenType.IMPLIES,
+    'in': TokenType.IN,
+    'contains': TokenType.CONTAINS,
+    'startsWith': TokenType.STARTS_WITH,
+    'endsWith': TokenType.ENDS_WITH,
+    'atLeast': TokenType.AT_LEAST,
+    'exactly': TokenType.EXACTLY,
+    'true': TokenType.BOOLEAN,
+    'false': TokenType.BOOLEAN,
+    'null': TokenType.NULL
+};
+const COMPARISON_OPERATORS = {
+    '==': TokenType.EQUALS,
+    '!=': TokenType.NOT_EQUALS,
+    '<': TokenType.LESS_THAN,
+    '<=': TokenType.LESS_THAN_OR_EQUAL,
+    '>': TokenType.GREATER_THAN,
+    '>=': TokenType.GREATER_THAN_OR_EQUAL
+};
+
+class DslTokenizer {
+    input;
+    position = 0;
+    line = 1;
+    column = 1;
+    constructor(input) {
+        this.input = input;
+    }
+    tokenize() {
+        const tokens = [];
+        while (this.position < this.input.length) {
+            const token = this.nextToken();
+            if (token.type !== TokenType.WHITESPACE) {
+                tokens.push(token);
+            }
+        }
+        tokens.push({
+            type: TokenType.EOF,
+            value: '',
+            position: this.position,
+            line: this.line,
+            column: this.column
+        });
+        return tokens;
+    }
+    nextToken() {
+        this.skipWhitespace();
+        if (this.position >= this.input.length) {
+            return this.createToken(TokenType.EOF, '');
+        }
+        const char = this.input[this.position];
+        // Field references ${...}
+        if (char === '$' && this.peek() === '{') {
+            return this.readFieldReference();
+        }
+        // String literals
+        if (char === '"' || char === "'") {
+            return this.readString(char);
+        }
+        // Numbers
+        if (this.isDigit(char) || (char === '-' && this.isDigit(this.peek()))) {
+            return this.readNumber();
+        }
+        // Multi-character operators
+        const twoChar = this.input.substr(this.position, 2);
+        if (COMPARISON_OPERATORS[twoChar]) {
+            const token = this.createToken(COMPARISON_OPERATORS[twoChar], twoChar);
+            this.advance(2);
+            return token;
+        }
+        // Single character operators and punctuation
+        switch (char) {
+            case '(':
+                return this.createTokenAndAdvance(TokenType.LEFT_PAREN, char);
+            case ')':
+                return this.createTokenAndAdvance(TokenType.RIGHT_PAREN, char);
+            case '[':
+                return this.createTokenAndAdvance(TokenType.LEFT_BRACKET, char);
+            case ']':
+                return this.createTokenAndAdvance(TokenType.RIGHT_BRACKET, char);
+            case ',':
+                return this.createTokenAndAdvance(TokenType.COMMA, char);
+            case '.':
+                return this.createTokenAndAdvance(TokenType.DOT, char);
+            case '!':
+                if (this.peek() === '=') {
+                    const token = this.createToken(TokenType.NOT_EQUALS, '!=');
+                    this.advance(2);
+                    return token;
+                }
+                return this.createTokenAndAdvance(TokenType.NOT, char);
+            case '<':
+                if (this.peek() === '=') {
+                    const token = this.createToken(TokenType.LESS_THAN_OR_EQUAL, '<=');
+                    this.advance(2);
+                    return token;
+                }
+                return this.createTokenAndAdvance(TokenType.LESS_THAN, char);
+            case '>':
+                if (this.peek() === '=') {
+                    const token = this.createToken(TokenType.GREATER_THAN_OR_EQUAL, '>=');
+                    this.advance(2);
+                    return token;
+                }
+                return this.createTokenAndAdvance(TokenType.GREATER_THAN, char);
+            case '=':
+                if (this.peek() === '=') {
+                    const token = this.createToken(TokenType.EQUALS, '==');
+                    this.advance(2);
+                    return token;
+                }
+                break;
+            case '&':
+                if (this.peek() === '&') {
+                    const token = this.createToken(TokenType.AND, '&&');
+                    this.advance(2);
+                    return token;
+                }
+                break;
+            case '|':
+                if (this.peek() === '|') {
+                    const token = this.createToken(TokenType.OR, '||');
+                    this.advance(2);
+                    return token;
+                }
+                break;
+        }
+        // Identifiers and keywords
+        if (this.isAlpha(char) || char === '_') {
+            return this.readIdentifier();
+        }
+        throw new Error(`Unexpected character '${char}' at position ${this.position}`);
+    }
+    readFieldReference() {
+        const start = this.position;
+        this.advance(2); // Skip ${
+        let value = '';
+        while (this.position < this.input.length && this.input[this.position] !== '}') {
+            value += this.input[this.position];
+            this.advance();
+        }
+        if (this.position >= this.input.length) {
+            throw new Error('Unterminated field reference');
+        }
+        this.advance(); // Skip }
+        return this.createToken(TokenType.FIELD_REFERENCE, value, start);
+    }
+    readString(quote) {
+        const start = this.position;
+        this.advance(); // Skip opening quote
+        let value = '';
+        while (this.position < this.input.length && this.input[this.position] !== quote) {
+            if (this.input[this.position] === '\\') {
+                this.advance();
+                if (this.position < this.input.length) {
+                    const escaped = this.input[this.position];
+                    switch (escaped) {
+                        case 'n':
+                            value += '\n';
+                            break;
+                        case 't':
+                            value += '\t';
+                            break;
+                        case 'r':
+                            value += '\r';
+                            break;
+                        case '\\':
+                            value += '\\';
+                            break;
+                        case '"':
+                            value += '"';
+                            break;
+                        case "'":
+                            value += "'";
+                            break;
+                        default:
+                            value += escaped;
+                            break;
+                    }
+                    this.advance();
+                }
+            }
+            else {
+                value += this.input[this.position];
+                this.advance();
+            }
+        }
+        if (this.position >= this.input.length) {
+            throw new Error('Unterminated string literal');
+        }
+        this.advance(); // Skip closing quote
+        return this.createToken(TokenType.STRING, value, start);
+    }
+    readNumber() {
+        const start = this.position;
+        let value = '';
+        if (this.input[this.position] === '-') {
+            value += this.input[this.position];
+            this.advance();
+        }
+        while (this.position < this.input.length && this.isDigit(this.input[this.position])) {
+            value += this.input[this.position];
+            this.advance();
+        }
+        if (this.position < this.input.length && this.input[this.position] === '.') {
+            value += this.input[this.position];
+            this.advance();
+            while (this.position < this.input.length && this.isDigit(this.input[this.position])) {
+                value += this.input[this.position];
+                this.advance();
+            }
+        }
+        return this.createToken(TokenType.NUMBER, value, start);
+    }
+    readIdentifier() {
+        const start = this.position;
+        let value = '';
+        while (this.position < this.input.length &&
+            (this.isAlphaNumeric(this.input[this.position]) || this.input[this.position] === '_')) {
+            value += this.input[this.position];
+            this.advance();
+        }
+        const tokenType = OPERATOR_KEYWORDS[value] || TokenType.IDENTIFIER;
+        return this.createToken(tokenType, value, start);
+    }
+    skipWhitespace() {
+        while (this.position < this.input.length && this.isWhitespace(this.input[this.position])) {
+            if (this.input[this.position] === '\n') {
+                this.line++;
+                this.column = 1;
+            }
+            else {
+                this.column++;
+            }
+            this.position++;
+        }
+    }
+    createToken(type, value, startPos) {
+        return {
+            type,
+            value,
+            position: startPos ?? this.position,
+            line: this.line,
+            column: this.column - value.length
+        };
+    }
+    createTokenAndAdvance(type, value) {
+        const token = this.createToken(type, value);
+        this.advance();
+        return token;
+    }
+    advance(count = 1) {
+        for (let i = 0; i < count && this.position < this.input.length; i++) {
+            if (this.input[this.position] === '\n') {
+                this.line++;
+                this.column = 1;
+            }
+            else {
+                this.column++;
+            }
+            this.position++;
+        }
+    }
+    peek(offset = 1) {
+        const pos = this.position + offset;
+        return pos < this.input.length ? this.input[pos] : '';
+    }
+    isDigit(char) {
+        return char >= '0' && char <= '9';
+    }
+    isAlpha(char) {
+        return (char >= 'a' && char <= 'z') || (char >= 'A' && char <= 'Z');
+    }
+    isAlphaNumeric(char) {
+        return this.isAlpha(char) || this.isDigit(char);
+    }
+    isWhitespace(char) {
+        return char === ' ' || char === '\t' || char === '\n' || char === '\r';
+    }
+}
+
+class DslParser {
+    functionRegistry;
+    tokens = [];
+    current = 0;
+    constructor(functionRegistry) {
+        this.functionRegistry = functionRegistry;
+    }
+    parse(input) {
+        const tokenizer = new DslTokenizer(input);
+        this.tokens = tokenizer.tokenize();
+        this.current = 0;
+        const spec = this.parseExpression();
+        if (!this.isAtEnd()) {
+            throw new Error(`Unexpected token: ${this.peek().value}`);
+        }
+        return spec;
+    }
+    parseExpression() {
+        return this.parseImplies();
+    }
+    parseImplies() {
+        let expr = this.parseXor();
+        while (this.match(TokenType.IMPLIES)) {
+            const right = this.parseXor();
+            expr = new ImpliesSpecification(expr, right);
+        }
+        return expr;
+    }
+    parseXor() {
+        let expr = this.parseOr();
+        while (this.match(TokenType.XOR)) {
+            const right = this.parseOr();
+            if (expr instanceof XorSpecification) {
+                expr = new XorSpecification([...expr.getSpecifications(), right]);
+            }
+            else {
+                expr = new XorSpecification([expr, right]);
+            }
+        }
+        return expr;
+    }
+    parseOr() {
+        let expr = this.parseAnd();
+        while (this.match(TokenType.OR)) {
+            const right = this.parseAnd();
+            if (expr instanceof OrSpecification) {
+                expr = new OrSpecification([...expr.getSpecifications(), right]);
+            }
+            else {
+                expr = new OrSpecification([expr, right]);
+            }
+        }
+        return expr;
+    }
+    parseAnd() {
+        let expr = this.parseUnary();
+        while (this.match(TokenType.AND)) {
+            const right = this.parseUnary();
+            if (expr instanceof AndSpecification) {
+                expr = new AndSpecification([...expr.getSpecifications(), right]);
+            }
+            else {
+                expr = new AndSpecification([expr, right]);
+            }
+        }
+        return expr;
+    }
+    parseUnary() {
+        if (this.match(TokenType.NOT)) {
+            const expr = this.parseUnary();
+            return new NotSpecification(expr);
+        }
+        return this.parseComparison();
+    }
+    parseComparison() {
+        let left = this.parsePrimary();
+        if (this.matchComparison()) {
+            const operator = this.previous().type;
+            // Parse RHS allowing literals, arrays and identifiers (as values)
+            const rightValue = this.parseArgument();
+            // Field to field comparison not implemented
+            if (left instanceof FieldSpecification && rightValue instanceof FieldSpecification) {
+                throw new Error('Field to field comparison not yet implemented in parser');
+            }
+            if (left instanceof FieldSpecification) {
+                const field = left.getField();
+                const compOp = this.tokenTypeToComparisonOperator(operator);
+                return new FieldSpecification(field, compOp, rightValue);
+            }
+            throw new Error('Invalid comparison expression');
+        }
+        return left;
+    }
+    parsePrimary() {
+        if (this.match(TokenType.LEFT_PAREN)) {
+            const expr = this.parseExpression();
+            this.consume(TokenType.RIGHT_PAREN, "Expected ')' after expression");
+            return expr;
+        }
+        if (this.match(TokenType.FIELD_REFERENCE)) {
+            const fieldName = this.previous().value;
+            return new FieldSpecification(fieldName, ComparisonOperator.EQUALS, true);
+        }
+        if (this.match(TokenType.IDENTIFIER)) {
+            const identifier = this.previous().value;
+            // Check if this is a function call
+            if (this.match(TokenType.LEFT_PAREN)) {
+                return this.parseFunctionCall(identifier);
+            }
+            // Otherwise treat as field reference
+            return new FieldSpecification(identifier, ComparisonOperator.EQUALS, true);
+        }
+        throw new Error(`Unexpected token: ${this.peek().value}`);
+    }
+    parseFunctionCall(functionName) {
+        const args = [];
+        if (!this.check(TokenType.RIGHT_PAREN)) {
+            do {
+                args.push(this.parseArgument());
+            } while (this.match(TokenType.COMMA));
+        }
+        this.consume(TokenType.RIGHT_PAREN, "Expected ')' after function arguments");
+        // Handle special built-in functions
+        switch (functionName) {
+            case 'atLeast':
+                if (args.length !== 2) {
+                    throw new Error('atLeast requires exactly 2 arguments');
+                }
+                const min = args[0];
+                const specs = args[1];
+                if (!Array.isArray(specs)) {
+                    throw new Error('atLeast second argument must be an array of specifications');
+                }
+                return new AtLeastSpecification(min, specs);
+            case 'exactly':
+                if (args.length !== 2) {
+                    throw new Error('exactly requires exactly 2 arguments');
+                }
+                const exact = args[0];
+                const exactSpecs = args[1];
+                if (!Array.isArray(exactSpecs)) {
+                    throw new Error('exactly second argument must be an array of specifications');
+                }
+                return new ExactlySpecification(exact, exactSpecs);
+            case 'contains':
+            case 'startsWith':
+            case 'endsWith':
+                if (args.length !== 2) {
+                    throw new Error(`${functionName} requires exactly 2 arguments`);
+                }
+                const field = args[0];
+                const value = args[1];
+                const op = this.functionNameToOperator(functionName);
+                return new FieldSpecification(field, op, value);
+            default:
+                return new FunctionSpecification(functionName, args, this.functionRegistry);
+        }
+    }
+    parseArgument() {
+        if (this.match(TokenType.STRING)) {
+            return this.previous().value;
+        }
+        if (this.match(TokenType.NUMBER)) {
+            const value = this.previous().value;
+            return value.includes('.') ? parseFloat(value) : parseInt(value, 10);
+        }
+        if (this.match(TokenType.BOOLEAN)) {
+            return this.previous().value === 'true';
+        }
+        if (this.match(TokenType.NULL)) {
+            return null;
+        }
+        if (this.match(TokenType.FIELD_REFERENCE)) {
+            return this.previous().value;
+        }
+        if (this.match(TokenType.IDENTIFIER)) {
+            return this.previous().value;
+        }
+        if (this.match(TokenType.LEFT_BRACKET)) {
+            const elements = [];
+            if (!this.check(TokenType.RIGHT_BRACKET)) {
+                do {
+                    elements.push(this.parseArgument());
+                } while (this.match(TokenType.COMMA));
+            }
+            this.consume(TokenType.RIGHT_BRACKET, "Expected ']' after array elements");
+            return elements;
+        }
+        throw new Error(`Unexpected token in argument: ${this.peek().value}`);
+    }
+    matchComparison() {
+        return this.match(TokenType.EQUALS, TokenType.NOT_EQUALS, TokenType.LESS_THAN, TokenType.LESS_THAN_OR_EQUAL, TokenType.GREATER_THAN, TokenType.GREATER_THAN_OR_EQUAL, TokenType.IN);
+    }
+    tokenTypeToComparisonOperator(tokenType) {
+        switch (tokenType) {
+            case TokenType.EQUALS:
+                return ComparisonOperator.EQUALS;
+            case TokenType.NOT_EQUALS:
+                return ComparisonOperator.NOT_EQUALS;
+            case TokenType.LESS_THAN:
+                return ComparisonOperator.LESS_THAN;
+            case TokenType.LESS_THAN_OR_EQUAL:
+                return ComparisonOperator.LESS_THAN_OR_EQUAL;
+            case TokenType.GREATER_THAN:
+                return ComparisonOperator.GREATER_THAN;
+            case TokenType.GREATER_THAN_OR_EQUAL:
+                return ComparisonOperator.GREATER_THAN_OR_EQUAL;
+            case TokenType.IN:
+                return ComparisonOperator.IN;
+            default:
+                throw new Error(`Unknown comparison operator: ${tokenType}`);
+        }
+    }
+    functionNameToOperator(functionName) {
+        switch (functionName) {
+            case 'contains':
+                return ComparisonOperator.CONTAINS;
+            case 'startsWith':
+                return ComparisonOperator.STARTS_WITH;
+            case 'endsWith':
+                return ComparisonOperator.ENDS_WITH;
+            default:
+                throw new Error(`Unknown function: ${functionName}`);
+        }
+    }
+    extractValue(spec) {
+        // This is a simplified extraction - in a real implementation
+        // we'd need to handle more complex cases
+        if (spec instanceof FieldSpecification) {
+            return spec.getValue();
+        }
+        return spec;
+    }
+    match(...types) {
+        for (const type of types) {
+            if (this.check(type)) {
+                this.advance();
+                return true;
+            }
+        }
+        return false;
+    }
+    check(type) {
+        if (this.isAtEnd())
+            return false;
+        return this.peek().type === type;
+    }
+    advance() {
+        if (!this.isAtEnd())
+            this.current++;
+        return this.previous();
+    }
+    isAtEnd() {
+        return this.peek().type === TokenType.EOF;
+    }
+    peek() {
+        return this.tokens[this.current];
+    }
+    previous() {
+        return this.tokens[this.current - 1];
+    }
+    consume(type, message) {
+        if (this.check(type))
+            return this.advance();
+        throw new Error(`${message}. Got: ${this.peek().value}`);
+    }
+}
+
+class DslExporter {
+    options;
+    constructor(options = {}) {
+        this.options = {
+            prettyPrint: options.prettyPrint ?? false,
+            indentSize: options.indentSize ?? 2,
+            maxLineLength: options.maxLineLength ?? 80,
+            useParentheses: options.useParentheses ?? 'auto',
+            includeMetadata: options.includeMetadata ?? false,
+            metadataPosition: options.metadataPosition ?? 'before',
+        };
+    }
+    export(specification) {
+        const dsl = this.exportSpecification(specification, 0);
+        if (this.options.prettyPrint) {
+            return this.formatPretty(dsl);
+        }
+        return dsl;
+    }
+    /**
+     * Exports specification with metadata comments
+     */
+    exportWithMetadata(specification) {
+        const originalIncludeMetadata = this.options.includeMetadata;
+        this.options.includeMetadata = true;
+        const result = this.export(specification);
+        this.options.includeMetadata = originalIncludeMetadata;
+        return result;
+    }
+    exportSpecification(spec, depth) {
+        const baseDsl = this.getSpecificationDsl(spec, depth);
+        if (!this.options.includeMetadata) {
+            return baseDsl;
+        }
+        return this.addMetadataComments(spec, baseDsl, depth);
+    }
+    getSpecificationDsl(spec, depth) {
+        if (spec instanceof FieldSpecification) {
+            return this.exportFieldSpecification(spec);
+        }
+        if (spec instanceof AndSpecification) {
+            return this.exportAndSpecification(spec, depth);
+        }
+        if (spec instanceof OrSpecification) {
+            return this.exportOrSpecification(spec, depth);
+        }
+        if (spec instanceof NotSpecification) {
+            return this.exportNotSpecification(spec, depth);
+        }
+        if (spec instanceof XorSpecification) {
+            return this.exportXorSpecification(spec, depth);
+        }
+        if (spec instanceof ImpliesSpecification) {
+            return this.exportImpliesSpecification(spec, depth);
+        }
+        if (spec instanceof FunctionSpecification) {
+            return this.exportFunctionSpecification(spec);
+        }
+        if (spec instanceof AtLeastSpecification) {
+            return this.exportAtLeastSpecification(spec, depth);
+        }
+        if (spec instanceof ExactlySpecification) {
+            return this.exportExactlySpecification(spec, depth);
+        }
+        if (spec instanceof FieldToFieldSpecification) {
+            return this.exportFieldToFieldSpecification(spec);
+        }
+        if (spec instanceof ContextualSpecification) {
+            return this.exportContextualSpecification(spec);
+        }
+        // Fallback to toDSL method
+        return spec.toDSL();
+    }
+    addMetadataComments(spec, dsl, depth) {
+        const metadata = spec.getMetadata();
+        if (!metadata) {
+            return dsl;
+        }
+        const indent = ' '.repeat(depth * this.options.indentSize);
+        const comments = [];
+        // Add metadata comments
+        if (metadata.code) {
+            comments.push(`${indent}// code: ${metadata.code}`);
+        }
+        if (metadata.message) {
+            comments.push(`${indent}// message: ${metadata.message}`);
+        }
+        if (metadata.tag) {
+            comments.push(`${indent}// tag: ${metadata.tag}`);
+        }
+        if (metadata.uiConfig) {
+            const uiConfigStr = JSON.stringify(metadata.uiConfig);
+            comments.push(`${indent}// uiConfig: ${uiConfigStr}`);
+        }
+        // Add any other metadata properties
+        const standardKeys = ['code', 'message', 'tag', 'uiConfig'];
+        for (const [key, value] of Object.entries(metadata)) {
+            if (!standardKeys.includes(key) && value !== undefined) {
+                comments.push(`${indent}// ${key}: ${JSON.stringify(value)}`);
+            }
+        }
+        if (comments.length === 0) {
+            return dsl;
+        }
+        switch (this.options.metadataPosition) {
+            case 'before':
+                return `${comments.join('\n')}\n${indent}${dsl}`;
+            case 'after':
+                return `${indent}${dsl}\n${comments.join('\n')}`;
+            case 'inline':
+                const firstComment = comments[0] ? ` ${comments[0].trim()}` : '';
+                return `${indent}${dsl}${firstComment}`;
+            default:
+                return dsl;
+        }
+    }
+    exportFieldSpecification(spec) {
+        return spec.toDSL();
+    }
+    exportAndSpecification(spec, depth) {
+        const specifications = spec.getSpecifications();
+        const parts = specifications.map((s) => {
+            const dsl = this.exportSpecification(s, depth + 1);
+            return this.needsParentheses(s, 'and') ? `(${dsl})` : dsl;
+        });
+        if (this.options.prettyPrint && this.shouldBreakLine(parts.join(' && '))) {
+            const indent = ' '.repeat(depth * this.options.indentSize);
+            const nextIndent = ' '.repeat((depth + 1) * this.options.indentSize);
+            return parts.join(` &&\n${nextIndent}`);
+        }
+        return parts.join(' && ');
+    }
+    exportOrSpecification(spec, depth) {
+        const specifications = spec.getSpecifications();
+        const parts = specifications.map((s) => {
+            const dsl = this.exportSpecification(s, depth + 1);
+            return this.needsParentheses(s, 'or') ? `(${dsl})` : dsl;
+        });
+        if (this.options.prettyPrint && this.shouldBreakLine(parts.join(' || '))) {
+            const nextIndent = ' '.repeat((depth + 1) * this.options.indentSize);
+            return parts.join(` ||\n${nextIndent}`);
+        }
+        return parts.join(' || ');
+    }
+    exportNotSpecification(spec, depth) {
+        const innerSpec = spec.getSpecification();
+        const innerDsl = this.exportSpecification(innerSpec, depth);
+        if (this.needsParentheses(innerSpec, 'not')) {
+            return `!(${innerDsl})`;
+        }
+        return `!${innerDsl}`;
+    }
+    exportXorSpecification(spec, depth) {
+        const specifications = spec.getSpecifications();
+        const parts = specifications.map((s) => {
+            const dsl = this.exportSpecification(s, depth + 1);
+            return this.needsParentheses(s, 'xor') ? `(${dsl})` : dsl;
+        });
+        if (this.options.prettyPrint && this.shouldBreakLine(parts.join(' xor '))) {
+            const nextIndent = ' '.repeat((depth + 1) * this.options.indentSize);
+            return parts.join(` xor\n${nextIndent}`);
+        }
+        return parts.join(' xor ');
+    }
+    exportImpliesSpecification(spec, depth) {
+        const antecedent = this.exportSpecification(spec.getAntecedent(), depth + 1);
+        const consequent = this.exportSpecification(spec.getConsequent(), depth + 1);
+        const leftPart = this.needsParentheses(spec.getAntecedent(), 'implies')
+            ? `(${antecedent})`
+            : antecedent;
+        const rightPart = this.needsParentheses(spec.getConsequent(), 'implies')
+            ? `(${consequent})`
+            : consequent;
+        if (this.options.prettyPrint &&
+            this.shouldBreakLine(`${leftPart} implies ${rightPart}`)) {
+            const nextIndent = ' '.repeat((depth + 1) * this.options.indentSize);
+            return `${leftPart} implies\n${nextIndent}${rightPart}`;
+        }
+        return `${leftPart} implies ${rightPart}`;
+    }
+    exportFunctionSpecification(spec) {
+        return spec.toDSL();
+    }
+    exportAtLeastSpecification(spec, depth) {
+        const minimum = spec.getMinimum();
+        const specifications = spec.getSpecifications();
+        const specDsls = specifications.map((s) => this.exportSpecification(s, depth + 1));
+        if (this.options.prettyPrint && specDsls.length > 2) {
+            const nextIndent = ' '.repeat((depth + 1) * this.options.indentSize);
+            const specsStr = specDsls.join(`,\n${nextIndent}`);
+            return `atLeast(${minimum}, [\n${nextIndent}${specsStr}\n${' '.repeat(depth * this.options.indentSize)}])`;
+        }
+        return `atLeast(${minimum}, [${specDsls.join(', ')}])`;
+    }
+    exportExactlySpecification(spec, depth) {
+        const exact = spec.getExact();
+        const specifications = spec.getSpecifications();
+        const specDsls = specifications.map((s) => this.exportSpecification(s, depth + 1));
+        if (this.options.prettyPrint && specDsls.length > 2) {
+            const nextIndent = ' '.repeat((depth + 1) * this.options.indentSize);
+            const specsStr = specDsls.join(`,\n${nextIndent}`);
+            return `exactly(${exact}, [\n${nextIndent}${specsStr}\n${' '.repeat(depth * this.options.indentSize)}])`;
+        }
+        return `exactly(${exact}, [${specDsls.join(', ')}])`;
+    }
+    exportFieldToFieldSpecification(spec) {
+        return spec.toDSL();
+    }
+    exportContextualSpecification(spec) {
+        return spec.toDSL();
+    }
+    needsParentheses(spec, parentContext) {
+        if (this.options.useParentheses === 'explicit') {
+            return true;
+        }
+        if (this.options.useParentheses === 'minimal') {
+            return false;
+        }
+        // Auto mode - determine based on operator precedence
+        const precedence = this.getOperatorPrecedence(spec);
+        const parentPrecedence = this.getContextPrecedence(parentContext);
+        return precedence < parentPrecedence;
+    }
+    getOperatorPrecedence(spec) {
+        if (spec instanceof NotSpecification)
+            return 5;
+        if (spec instanceof AndSpecification)
+            return 4;
+        if (spec instanceof OrSpecification)
+            return 3;
+        if (spec instanceof XorSpecification)
+            return 2;
+        if (spec instanceof ImpliesSpecification)
+            return 1;
+        return 6; // Highest precedence for primitives
+    }
+    getContextPrecedence(context) {
+        switch (context) {
+            case 'not':
+                return 5;
+            case 'and':
+                return 4;
+            case 'or':
+                return 3;
+            case 'xor':
+                return 2;
+            case 'implies':
+                return 1;
+            default:
+                return 0;
+        }
+    }
+    shouldBreakLine(line) {
+        return line.length > this.options.maxLineLength;
+    }
+    formatPretty(dsl) {
+        // Additional pretty-printing logic could go here
+        // For now, just return the DSL as-is since we handle formatting
+        // in the individual export methods
+        return dsl;
+    }
+}
+
+/**
+ * Types of validation issues that can be found in DSL
+ */
+var ValidationIssueType;
+(function (ValidationIssueType) {
+    ValidationIssueType["SYNTAX_ERROR"] = "SyntaxError";
+    ValidationIssueType["UNKNOWN_FUNCTION"] = "UnknownFunction";
+    ValidationIssueType["UNKNOWN_OPERATOR"] = "UnknownOperator";
+    ValidationIssueType["UNBALANCED_PARENTHESES"] = "UnbalancedParentheses";
+    ValidationIssueType["UNBALANCED_BRACKETS"] = "UnbalancedBrackets";
+    ValidationIssueType["INVALID_TOKEN"] = "InvalidToken";
+    ValidationIssueType["UNEXPECTED_TOKEN"] = "UnexpectedToken";
+    ValidationIssueType["MISSING_ARGUMENT"] = "MissingArgument";
+    ValidationIssueType["TOO_MANY_ARGUMENTS"] = "TooManyArguments";
+    ValidationIssueType["INVALID_FIELD_REFERENCE"] = "InvalidFieldReference";
+    ValidationIssueType["EMPTY_EXPRESSION"] = "EmptyExpression";
+    ValidationIssueType["UNTERMINATED_STRING"] = "UnterminatedString";
+    ValidationIssueType["INVALID_NUMBER"] = "InvalidNumber";
+    ValidationIssueType["DEPRECATED_SYNTAX"] = "DeprecatedSyntax";
+    ValidationIssueType["PERFORMANCE_WARNING"] = "PerformanceWarning";
+})(ValidationIssueType || (ValidationIssueType = {}));
+/**
+ * Severity levels for validation issues
+ */
+var ValidationSeverity;
+(function (ValidationSeverity) {
+    ValidationSeverity["ERROR"] = "error";
+    ValidationSeverity["WARNING"] = "warning";
+    ValidationSeverity["INFO"] = "info";
+    ValidationSeverity["HINT"] = "hint";
+})(ValidationSeverity || (ValidationSeverity = {}));
+
+/**
+ * Validates DSL expressions and provides detailed error reporting
+ */
+class DslValidator {
+    config;
+    BUILT_IN_FUNCTIONS = [
+        'contains', 'startsWith', 'endsWith', 'atLeast', 'exactly',
+        'forEach', 'uniqueBy', 'minLength', 'maxLength',
+        'requiredIf', 'visibleIf', 'disabledIf', 'readonlyIf',
+        'ifDefined', 'ifNotNull', 'ifExists', 'withDefault'
+    ];
+    constructor(config = {}) {
+        this.config = {
+            knownFunctions: config.knownFunctions || [],
+            functionRegistry: config.functionRegistry,
+            knownFields: config.knownFields || [],
+            maxComplexity: config.maxComplexity || 50,
+            enablePerformanceWarnings: config.enablePerformanceWarnings ?? true,
+            enableDeprecationWarnings: config.enableDeprecationWarnings ?? true
+        };
+    }
+    /**
+     * Validates a DSL expression and returns all issues found
+     */
+    validate(input) {
+        const issues = [];
+        try {
+            // Basic validation
+            this.validateBasicStructure(input, issues);
+            // Tokenize and validate tokens
+            const tokenizer = new DslTokenizer(input);
+            const tokens = tokenizer.tokenize();
+            this.validateTokens(tokens, input, issues);
+            this.validateSyntax(tokens, input, issues);
+            this.validateSemantics(tokens, input, issues);
+            this.validateComplexity(tokens, issues);
+        }
+        catch (error) {
+            issues.push({
+                type: ValidationIssueType.SYNTAX_ERROR,
+                severity: ValidationSeverity.ERROR,
+                message: `Unexpected error during validation: ${error}`,
+                position: { start: 0, end: input.length, line: 1, column: 1 }
+            });
+        }
+        return issues;
+    }
+    validateBasicStructure(input, issues) {
+        // Check for empty expression
+        if (input.trim().length === 0) {
+            issues.push({
+                type: ValidationIssueType.EMPTY_EXPRESSION,
+                severity: ValidationSeverity.ERROR,
+                message: 'Expression cannot be empty',
+                position: { start: 0, end: 0, line: 1, column: 1 },
+                suggestion: 'Add a valid expression'
+            });
+            return;
+        }
+        // Check for unbalanced parentheses
+        this.validateBalancedDelimiters(input, '(', ')', ValidationIssueType.UNBALANCED_PARENTHESES, issues);
+        // Check for unbalanced brackets
+        this.validateBalancedDelimiters(input, '[', ']', ValidationIssueType.UNBALANCED_BRACKETS, issues);
+        // Check for unterminated strings
+        this.validateStringLiterals(input, issues);
+    }
+    validateBalancedDelimiters(input, open, close, issueType, issues) {
+        let count = 0;
+        let openPositions = [];
+        for (let i = 0; i < input.length; i++) {
+            if (input[i] === open) {
+                count++;
+                openPositions.push(i);
+            }
+            else if (input[i] === close) {
+                count--;
+                if (count < 0) {
+                    const { line, column } = this.getLineColumn(input, i);
+                    issues.push({
+                        type: issueType,
+                        severity: ValidationSeverity.ERROR,
+                        message: `Unexpected closing ${close}`,
+                        position: { start: i, end: i + 1, line, column },
+                        suggestion: `Remove the extra ${close} or add a matching ${open}`
+                    });
+                }
+                else {
+                    openPositions.pop();
+                }
+            }
+        }
+        // Report unclosed delimiters
+        for (const pos of openPositions) {
+            const { line, column } = this.getLineColumn(input, pos);
+            issues.push({
+                type: issueType,
+                severity: ValidationSeverity.ERROR,
+                message: `Unclosed ${open}`,
+                position: { start: pos, end: pos + 1, line, column },
+                suggestion: `Add a closing ${close}`
+            });
+        }
+    }
+    validateStringLiterals(input, issues) {
+        const quotes = ['"', "'"];
+        for (const quote of quotes) {
+            let inString = false;
+            let startPos = -1;
+            for (let i = 0; i < input.length; i++) {
+                if (input[i] === quote) {
+                    if (!inString) {
+                        inString = true;
+                        startPos = i;
+                    }
+                    else {
+                        // Check if it's escaped
+                        let escaped = false;
+                        let backslashCount = 0;
+                        for (let j = i - 1; j >= 0 && input[j] === '\\'; j--) {
+                            backslashCount++;
+                        }
+                        escaped = backslashCount % 2 === 1;
+                        if (!escaped) {
+                            inString = false;
+                            startPos = -1;
+                        }
+                    }
+                }
+            }
+            if (inString) {
+                const { line, column } = this.getLineColumn(input, startPos);
+                issues.push({
+                    type: ValidationIssueType.UNTERMINATED_STRING,
+                    severity: ValidationSeverity.ERROR,
+                    message: `Unterminated string literal starting with ${quote}`,
+                    position: { start: startPos, end: input.length, line, column },
+                    suggestion: `Add a closing ${quote}`
+                });
+            }
+        }
+    }
+    validateTokens(tokens, input, issues) {
+        for (const token of tokens) {
+            if (token.type === TokenType.EOF)
+                continue;
+            // Validate numbers
+            if (token.type === TokenType.NUMBER) {
+                if (isNaN(Number(token.value))) {
+                    issues.push({
+                        type: ValidationIssueType.INVALID_NUMBER,
+                        severity: ValidationSeverity.ERROR,
+                        message: `Invalid number format: ${token.value}`,
+                        position: {
+                            start: token.position,
+                            end: token.position + token.value.length,
+                            line: token.line,
+                            column: token.column
+                        },
+                        suggestion: 'Use a valid number format (e.g., 42, 3.14, -5)'
+                    });
+                }
+            }
+            // Validate field references
+            if (token.type === TokenType.FIELD_REFERENCE || token.type === TokenType.IDENTIFIER) {
+                if (this.config.knownFields.length > 0) {
+                    if (!this.config.knownFields.includes(token.value)) {
+                        issues.push({
+                            type: ValidationIssueType.INVALID_FIELD_REFERENCE,
+                            severity: ValidationSeverity.WARNING,
+                            message: `Unknown field: ${token.value}`,
+                            position: {
+                                start: token.position,
+                                end: token.position + token.value.length,
+                                line: token.line,
+                                column: token.column
+                            },
+                            suggestion: this.suggestSimilarField(token.value),
+                            help: `Available fields: ${this.config.knownFields.join(', ')}`
+                        });
+                    }
+                }
+            }
+        }
+    }
+    validateSyntax(tokens, input, issues) {
+        for (let i = 0; i < tokens.length; i++) {
+            const token = tokens[i];
+            const nextToken = tokens[i + 1];
+            const prevToken = tokens[i - 1];
+            // Check for consecutive operators
+            if (this.isOperatorToken(token) && this.isOperatorToken(nextToken)) {
+                issues.push({
+                    type: ValidationIssueType.UNEXPECTED_TOKEN,
+                    severity: ValidationSeverity.ERROR,
+                    message: `Unexpected ${nextToken.type} after ${token.type}`,
+                    position: {
+                        start: nextToken.position,
+                        end: nextToken.position + nextToken.value.length,
+                        line: nextToken.line,
+                        column: nextToken.column
+                    },
+                    suggestion: 'Add an operand between operators'
+                });
+            }
+            // Check for operators at the beginning/end
+            if (i === 0 && this.isBinaryOperatorToken(token)) {
+                issues.push({
+                    type: ValidationIssueType.UNEXPECTED_TOKEN,
+                    severity: ValidationSeverity.ERROR,
+                    message: `Expression cannot start with ${token.type}`,
+                    position: {
+                        start: token.position,
+                        end: token.position + token.value.length,
+                        line: token.line,
+                        column: token.column
+                    },
+                    suggestion: 'Add an operand before the operator'
+                });
+            }
+            if (i === tokens.length - 2 && this.isBinaryOperatorToken(token) && nextToken.type === TokenType.EOF) {
+                issues.push({
+                    type: ValidationIssueType.UNEXPECTED_TOKEN,
+                    severity: ValidationSeverity.ERROR,
+                    message: `Expression cannot end with ${token.type}`,
+                    position: {
+                        start: token.position,
+                        end: token.position + token.value.length,
+                        line: token.line,
+                        column: token.column
+                    },
+                    suggestion: 'Add an operand after the operator'
+                });
+            }
+        }
+    }
+    validateSemantics(tokens, input, issues) {
+        // Check function calls
+        for (let i = 0; i < tokens.length; i++) {
+            const token = tokens[i];
+            const nextToken = tokens[i + 1];
+            if (token.type === TokenType.IDENTIFIER && nextToken?.type === TokenType.LEFT_PAREN) {
+                const functionName = token.value;
+                // Check if function is known
+                const allKnownFunctions = [
+                    ...this.BUILT_IN_FUNCTIONS,
+                    ...this.config.knownFunctions
+                ];
+                if (this.config.functionRegistry) {
+                    allKnownFunctions.push(...Array.from(this.config.functionRegistry.getAll().keys()));
+                }
+                if (!allKnownFunctions.includes(functionName)) {
+                    issues.push({
+                        type: ValidationIssueType.UNKNOWN_FUNCTION,
+                        severity: ValidationSeverity.ERROR,
+                        message: `Unknown function: ${functionName}`,
+                        position: {
+                            start: token.position,
+                            end: token.position + token.value.length,
+                            line: token.line,
+                            column: token.column
+                        },
+                        suggestion: this.suggestSimilarFunction(functionName, allKnownFunctions),
+                        help: `Available functions: ${allKnownFunctions.join(', ')}`
+                    });
+                }
+                // Validate function arguments (basic check)
+                this.validateFunctionArguments(functionName, i, tokens, issues);
+            }
+        }
+    }
+    validateFunctionArguments(functionName, startIndex, tokens, issues) {
+        // Find the argument list
+        let parenCount = 0;
+        let argCount = 0;
+        let inArgs = false;
+        for (let i = startIndex + 1; i < tokens.length; i++) {
+            const token = tokens[i];
+            if (token.type === TokenType.LEFT_PAREN) {
+                parenCount++;
+                if (parenCount === 1) {
+                    inArgs = true;
+                }
+            }
+            else if (token.type === TokenType.RIGHT_PAREN) {
+                parenCount--;
+                if (parenCount === 0) {
+                    break;
+                }
+            }
+            else if (token.type === TokenType.COMMA && parenCount === 1) {
+                argCount++;
+            }
+            else if (inArgs && parenCount === 1 && token.type !== TokenType.COMMA) {
+                // We have at least one argument
+                if (argCount === 0) {
+                    argCount = 1;
+                }
+            }
+        }
+        // Check argument count for known functions
+        const expectedArgs = this.getExpectedArgumentCount(functionName);
+        if (expectedArgs !== null && argCount !== expectedArgs) {
+            const functionToken = tokens[startIndex];
+            const severity = argCount < expectedArgs ? ValidationSeverity.ERROR : ValidationSeverity.WARNING;
+            const message = argCount < expectedArgs
+                ? `Function ${functionName} expects ${expectedArgs} arguments, got ${argCount}`
+                : `Function ${functionName} expects ${expectedArgs} arguments, got ${argCount}`;
+            issues.push({
+                type: argCount < expectedArgs ? ValidationIssueType.MISSING_ARGUMENT : ValidationIssueType.TOO_MANY_ARGUMENTS,
+                severity,
+                message,
+                position: {
+                    start: functionToken.position,
+                    end: functionToken.position + functionToken.value.length,
+                    line: functionToken.line,
+                    column: functionToken.column
+                },
+                suggestion: `Use exactly ${expectedArgs} arguments`
+            });
+        }
+    }
+    validateComplexity(tokens, issues) {
+        if (!this.config.enablePerformanceWarnings)
+            return;
+        const operatorCount = tokens.filter(token => this.isOperatorToken(token)).length;
+        if (operatorCount > this.config.maxComplexity) {
+            issues.push({
+                type: ValidationIssueType.PERFORMANCE_WARNING,
+                severity: ValidationSeverity.WARNING,
+                message: `Expression complexity is high (${operatorCount} operators). Consider breaking into smaller expressions.`,
+                position: { start: 0, end: 0, line: 1, column: 1 },
+                help: 'Complex expressions can impact performance and readability'
+            });
+        }
+    }
+    getExpectedArgumentCount(functionName) {
+        const argCounts = {
+            'contains': 2,
+            'startsWith': 2,
+            'endsWith': 2,
+            'atLeast': 2,
+            'exactly': 2,
+            'forEach': 2,
+            'uniqueBy': 2,
+            'minLength': 2,
+            'maxLength': 2,
+            'requiredIf': 2,
+            'visibleIf': 2,
+            'disabledIf': 2,
+            'readonlyIf': 2,
+            'ifDefined': 2,
+            'ifNotNull': 2,
+            'ifExists': 2,
+            'withDefault': 3
+        };
+        return argCounts[functionName] ?? null;
+    }
+    isOperatorToken(token) {
+        return [
+            TokenType.AND, TokenType.OR, TokenType.NOT, TokenType.XOR, TokenType.IMPLIES,
+            TokenType.EQUALS, TokenType.NOT_EQUALS, TokenType.LESS_THAN,
+            TokenType.LESS_THAN_OR_EQUAL, TokenType.GREATER_THAN, TokenType.GREATER_THAN_OR_EQUAL,
+            TokenType.IN
+        ].includes(token.type);
+    }
+    isBinaryOperatorToken(token) {
+        return [
+            TokenType.AND, TokenType.OR, TokenType.XOR, TokenType.IMPLIES,
+            TokenType.EQUALS, TokenType.NOT_EQUALS, TokenType.LESS_THAN,
+            TokenType.LESS_THAN_OR_EQUAL, TokenType.GREATER_THAN, TokenType.GREATER_THAN_OR_EQUAL,
+            TokenType.IN
+        ].includes(token.type);
+    }
+    suggestSimilarField(fieldName) {
+        return this.findSimilar(fieldName, this.config.knownFields);
+    }
+    suggestSimilarFunction(functionName, knownFunctions) {
+        return this.findSimilar(functionName, knownFunctions);
+    }
+    findSimilar(target, candidates) {
+        if (candidates.length === 0)
+            return undefined;
+        const similarities = candidates.map(candidate => ({
+            candidate,
+            distance: this.levenshteinDistance(target.toLowerCase(), candidate.toLowerCase())
+        }));
+        similarities.sort((a, b) => a.distance - b.distance);
+        // Only suggest if the distance is reasonable
+        if (similarities[0].distance <= Math.max(2, target.length * 0.4)) {
+            return `Did you mean "${similarities[0].candidate}"?`;
+        }
+        return undefined;
+    }
+    levenshteinDistance(a, b) {
+        const matrix = [];
+        for (let i = 0; i <= b.length; i++) {
+            matrix[i] = [i];
+        }
+        for (let j = 0; j <= a.length; j++) {
+            matrix[0][j] = j;
+        }
+        for (let i = 1; i <= b.length; i++) {
+            for (let j = 1; j <= a.length; j++) {
+                if (b.charAt(i - 1) === a.charAt(j - 1)) {
+                    matrix[i][j] = matrix[i - 1][j - 1];
+                }
+                else {
+                    matrix[i][j] = Math.min(matrix[i - 1][j - 1] + 1, matrix[i][j - 1] + 1, matrix[i - 1][j] + 1);
+                }
+            }
+        }
+        return matrix[b.length][a.length];
+    }
+    getLineColumn(input, position) {
+        let line = 1;
+        let column = 1;
+        for (let i = 0; i < position && i < input.length; i++) {
+            if (input[i] === '\n') {
+                line++;
+                column = 1;
+            }
+            else {
+                column++;
+            }
+        }
+        return { line, column };
+    }
+}
+
+class SpecificationFactory {
+    static fromJSON(json) {
+        // Robustez: validar entrada e inferir quando possível
+        if (json == null) {
+            throw new Error('Invalid specification JSON: null/undefined');
+        }
+        if (Array.isArray(json)) {
+            const specs = json.map((specJson) => SpecificationFactory.fromJSON(specJson));
+            return new AndSpecification(specs);
+        }
+        if (typeof json !== 'object') {
+            throw new Error(`Invalid specification JSON: expected object/array, got ${typeof json}`);
+        }
+        // Inferência quando 'type' está ausente
+        if (!json.type) {
+            if (Array.isArray(json.specs)) {
+                const specs = json.specs.map((specJson) => SpecificationFactory.fromJSON(specJson));
+                return new AndSpecification(specs);
+            }
+            if ('field' in json && 'operator' in json) {
+                return FieldSpecification.fromJSON({ type: 'field', ...json });
+            }
+            if ('antecedent' in json && 'consequent' in json) {
+                const antecedent = SpecificationFactory.fromJSON(json.antecedent);
+                const consequent = SpecificationFactory.fromJSON(json.consequent);
+                return new ImpliesSpecification(antecedent, consequent);
+            }
+            if ('spec' in json) {
+                const notSpec = SpecificationFactory.fromJSON(json.spec);
+                return new NotSpecification(notSpec);
+            }
+            if ('itemSpecification' in json && 'arrayField' in json) {
+                const itemSpec = SpecificationFactory.fromJSON(json.itemSpecification);
+                return new ForEachSpecification(json.arrayField, itemSpec, json.metadata);
+            }
+            // Se não for possível inferir, manter erro claro
+            throw new Error('Unknown specification type: undefined');
+        }
+        switch (json.type) {
+            case 'field':
+                return FieldSpecification.fromJSON(json);
+            case 'and':
+                const andSpecs = json.specs.map((specJson) => SpecificationFactory.fromJSON(specJson));
+                return new AndSpecification(andSpecs);
+            case 'or':
+                const orSpecs = json.specs.map((specJson) => SpecificationFactory.fromJSON(specJson));
+                return new OrSpecification(orSpecs);
+            case 'not':
+                const notSpec = SpecificationFactory.fromJSON(json.spec);
+                return new NotSpecification(notSpec);
+            case 'xor':
+                const xorSpecs = json.specs.map((specJson) => SpecificationFactory.fromJSON(specJson));
+                return new XorSpecification(xorSpecs);
+            case 'implies':
+                const antecedent = SpecificationFactory.fromJSON(json.antecedent);
+                const consequent = SpecificationFactory.fromJSON(json.consequent);
+                return new ImpliesSpecification(antecedent, consequent);
+            case 'function':
+                return FunctionSpecification.fromJSON(json);
+            case 'atLeast':
+                const atLeastSpecs = json.specs.map((specJson) => SpecificationFactory.fromJSON(specJson));
+                return new AtLeastSpecification(json.minimum, atLeastSpecs);
+            case 'exactly':
+                const exactlySpecs = json.specs.map((specJson) => SpecificationFactory.fromJSON(specJson));
+                return new ExactlySpecification(json.exact, exactlySpecs);
+            case 'fieldToField':
+                return FieldToFieldSpecification.fromJSON(json);
+            case 'contextual':
+                return ContextualSpecification.fromJSON(json);
+            case 'requiredIf':
+                const requiredCondition = SpecificationFactory.fromJSON(json.condition);
+                return new RequiredIfSpecification(json.field, requiredCondition, json.metadata);
+            case 'visibleIf':
+                const visibleCondition = SpecificationFactory.fromJSON(json.condition);
+                return new VisibleIfSpecification(json.field, visibleCondition, json.metadata);
+            case 'disabledIf':
+                const disabledCondition = SpecificationFactory.fromJSON(json.condition);
+                return new DisabledIfSpecification(json.field, disabledCondition, json.metadata);
+            case 'readonlyIf':
+                const readonlyCondition = SpecificationFactory.fromJSON(json.condition);
+                return new ReadonlyIfSpecification(json.field, readonlyCondition, json.metadata);
+            case 'forEach':
+                const itemSpec = SpecificationFactory.fromJSON(json.itemSpecification);
+                return new ForEachSpecification(json.arrayField, itemSpec, json.metadata);
+            case 'uniqueBy':
+                return UniqueBySpecification.fromJSON(json);
+            case 'minLength':
+                return MinLengthSpecification.fromJSON(json);
+            case 'maxLength':
+                return MaxLengthSpecification.fromJSON(json);
+            case 'ifDefined':
+                const ifDefinedSpec = SpecificationFactory.fromJSON(json.specification);
+                return new IfDefinedSpecification(json.field, ifDefinedSpec, json.metadata);
+            case 'ifNotNull':
+                const ifNotNullSpec = SpecificationFactory.fromJSON(json.specification);
+                return new IfNotNullSpecification(json.field, ifNotNullSpec, json.metadata);
+            case 'ifExists':
+                const ifExistsSpec = SpecificationFactory.fromJSON(json.specification);
+                return new IfExistsSpecification(json.field, ifExistsSpec, json.metadata);
+            case 'withDefault':
+                const withDefaultSpec = SpecificationFactory.fromJSON(json.specification);
+                return new WithDefaultSpecification(json.field, json.defaultValue, withDefaultSpec, json.metadata);
+            case 'form':
+                // Form specifications require special reconstruction
+                throw new Error('FormSpecification.fromJSON not yet implemented');
+            default:
+                throw new Error(`Unknown specification type: ${json.type}`);
+        }
+    }
+    static field(field, operator, value) {
+        return new FieldSpecification(field, operator, value);
+    }
+    static and(...specs) {
+        return new AndSpecification(specs);
+    }
+    static or(...specs) {
+        return new OrSpecification(specs);
+    }
+    static not(spec) {
+        return new NotSpecification(spec);
+    }
+    static xor(...specs) {
+        return new XorSpecification(specs);
+    }
+    static implies(antecedent, consequent) {
+        return new ImpliesSpecification(antecedent, consequent);
+    }
+    static func(name, args, registry) {
+        return new FunctionSpecification(name, args, registry);
+    }
+    static atLeast(minimum, specs) {
+        return new AtLeastSpecification(minimum, specs);
+    }
+    static exactly(exact, specs) {
+        return new ExactlySpecification(exact, specs);
+    }
+    static fieldToField(fieldA, operator, fieldB, transformA, transformB, registry) {
+        return new FieldToFieldSpecification(fieldA, operator, fieldB, transformA, transformB, registry);
+    }
+    static contextual(template, provider) {
+        return new ContextualSpecification(template, provider);
+    }
+    // Convenience methods for common operators
+    static equals(field, value) {
+        return new FieldSpecification(field, ComparisonOperator.EQUALS, value);
+    }
+    static notEquals(field, value) {
+        return new FieldSpecification(field, ComparisonOperator.NOT_EQUALS, value);
+    }
+    static greaterThan(field, value) {
+        return new FieldSpecification(field, ComparisonOperator.GREATER_THAN, value);
+    }
+    static lessThan(field, value) {
+        return new FieldSpecification(field, ComparisonOperator.LESS_THAN, value);
+    }
+    static contains(field, value) {
+        return new FieldSpecification(field, ComparisonOperator.CONTAINS, value);
+    }
+    static startsWith(field, value) {
+        return new FieldSpecification(field, ComparisonOperator.STARTS_WITH, value);
+    }
+    static endsWith(field, value) {
+        return new FieldSpecification(field, ComparisonOperator.ENDS_WITH, value);
+    }
+    static isIn(field, values) {
+        return new FieldSpecification(field, ComparisonOperator.IN, values);
+    }
+    // Phase 2: Conditional validators
+    static requiredIf(field, condition, metadata) {
+        return new RequiredIfSpecification(field, condition, metadata);
+    }
+    static visibleIf(field, condition, metadata) {
+        return new VisibleIfSpecification(field, condition, metadata);
+    }
+    static disabledIf(field, condition, metadata) {
+        return new DisabledIfSpecification(field, condition, metadata);
+    }
+    static readonlyIf(field, condition, metadata) {
+        return new ReadonlyIfSpecification(field, condition, metadata);
+    }
+    // Phase 2: Collection specifications
+    static forEach(arrayField, itemSpecification, metadata) {
+        return new ForEachSpecification(arrayField, itemSpecification, metadata);
+    }
+    static uniqueBy(arrayField, keySelector, metadata) {
+        return new UniqueBySpecification(arrayField, keySelector, metadata);
+    }
+    static minLength(arrayField, minLength, metadata) {
+        return new MinLengthSpecification(arrayField, minLength, metadata);
+    }
+    static maxLength(arrayField, maxLength, metadata) {
+        return new MaxLengthSpecification(arrayField, maxLength, metadata);
+    }
+    // Phase 2: Optional field handling
+    static ifDefined(field, specification, metadata) {
+        return new IfDefinedSpecification(field, specification, metadata);
+    }
+    static ifNotNull(field, specification, metadata) {
+        return new IfNotNullSpecification(field, specification, metadata);
+    }
+    static ifExists(field, specification, metadata) {
+        return new IfExistsSpecification(field, specification, metadata);
+    }
+    static withDefault(field, defaultValue, specification, metadata) {
+        return new WithDefaultSpecification(field, defaultValue, specification, metadata);
+    }
+    // Phase 2: Form specifications
+    static form(metadata) {
+        return new FormSpecification(metadata);
+    }
+    // Phase 2: Enhanced field specifications with metadata
+    static fieldWithMetadata(field, operator, value, metadata) {
+        return new FieldSpecification(field, operator, value, metadata);
+    }
+    // Convenience methods with metadata support
+    static equalsWithMetadata(field, value, metadata) {
+        return new FieldSpecification(field, ComparisonOperator.EQUALS, value, metadata);
+    }
+    static greaterThanWithMetadata(field, value, metadata) {
+        return new FieldSpecification(field, ComparisonOperator.GREATER_THAN, value, metadata);
+    }
+}
+
+class SpecificationUtils {
+    /**
+     * Simplifies a specification by removing redundant nesting and applying logical rules
+     */
+    static simplify(spec) {
+        if (spec instanceof AndSpecification) {
+            return this.simplifyAnd(spec);
+        }
+        if (spec instanceof OrSpecification) {
+            return this.simplifyOr(spec);
+        }
+        if (spec instanceof NotSpecification) {
+            return this.simplifyNot(spec);
+        }
+        return spec;
+    }
+    static simplifyAnd(spec) {
+        const specs = spec.getSpecifications();
+        const flattened = [];
+        // Flatten nested AND specifications
+        for (const s of specs) {
+            const simplified = this.simplify(s);
+            if (simplified instanceof AndSpecification) {
+                flattened.push(...simplified.getSpecifications());
+            }
+            else {
+                flattened.push(simplified);
+            }
+        }
+        // Remove duplicates and contradictions
+        const unique = this.removeDuplicates(flattened);
+        if (unique.length === 0) {
+            throw new Error('Empty AND specification');
+        }
+        if (unique.length === 1) {
+            return unique[0];
+        }
+        return new AndSpecification(unique);
+    }
+    static simplifyOr(spec) {
+        const specs = spec.getSpecifications();
+        const flattened = [];
+        // Flatten nested OR specifications
+        for (const s of specs) {
+            const simplified = this.simplify(s);
+            if (simplified instanceof OrSpecification) {
+                flattened.push(...simplified.getSpecifications());
+            }
+            else {
+                flattened.push(simplified);
+            }
+        }
+        // Remove duplicates
+        const unique = this.removeDuplicates(flattened);
+        if (unique.length === 0) {
+            throw new Error('Empty OR specification');
+        }
+        if (unique.length === 1) {
+            return unique[0];
+        }
+        return new OrSpecification(unique);
+    }
+    static simplifyNot(spec) {
+        const inner = spec.getSpecification();
+        // Double negation elimination: !!A = A
+        if (inner instanceof NotSpecification) {
+            return this.simplify(inner.getSpecification());
+        }
+        const simplified = this.simplify(inner);
+        if (simplified === inner) {
+            return spec;
+        }
+        return new NotSpecification(simplified);
+    }
+    static removeDuplicates(specs) {
+        const unique = [];
+        const seen = new Set();
+        for (const spec of specs) {
+            const key = JSON.stringify(spec.toJSON());
+            if (!seen.has(key)) {
+                seen.add(key);
+                unique.push(spec);
+            }
+        }
+        return unique;
+    }
+    /**
+     * Checks if two specifications are logically equivalent
+     */
+    static areEquivalent(spec1, spec2) {
+        const json1 = JSON.stringify(this.simplify(spec1).toJSON());
+        const json2 = JSON.stringify(this.simplify(spec2).toJSON());
+        return json1 === json2;
+    }
+    /**
+     * Gets all field references used in a specification
+     */
+    static getReferencedFields(spec) {
+        const fields = new Set();
+        this.collectFields(spec, fields);
+        return fields;
+    }
+    static collectFields(spec, fields) {
+        if (spec instanceof FieldSpecification) {
+            fields.add(spec.getField());
+        }
+        else if (spec instanceof AndSpecification ||
+            spec instanceof OrSpecification) {
+            spec.getSpecifications().forEach((s) => this.collectFields(s, fields));
+        }
+        else if (spec instanceof NotSpecification) {
+            this.collectFields(spec.getSpecification(), fields);
+        }
+        // Add more cases as needed for other specification types
+    }
+    /**
+     * Validates a specification for common issues
+     */
+    static validate(spec) {
+        const errors = [];
+        const warnings = [];
+        try {
+            this.validateSpecification(spec, errors, warnings);
+        }
+        catch (error) {
+            errors.push(`Validation error: ${error}`);
+        }
+        return {
+            isValid: errors.length === 0,
+            errors,
+            warnings,
+        };
+    }
+    static validateSpecification(spec, errors, warnings) {
+        if (spec instanceof AndSpecification || spec instanceof OrSpecification) {
+            const specs = spec.getSpecifications();
+            if (specs.length === 0) {
+                errors.push(`${spec.constructor.name} must have at least one specification`);
+            }
+            specs.forEach((s) => this.validateSpecification(s, errors, warnings));
+        }
+        else if (spec instanceof NotSpecification) {
+            this.validateSpecification(spec.getSpecification(), errors, warnings);
+        }
+        // Add more validation rules as needed
+    }
+    /**
+     * Estimates the complexity of a specification (useful for performance analysis)
+     */
+    static getComplexity(spec) {
+        if (spec instanceof FieldSpecification) {
+            return 1;
+        }
+        if (spec instanceof AndSpecification || spec instanceof OrSpecification) {
+            return spec
+                .getSpecifications()
+                .reduce((total, s) => total + this.getComplexity(s), 1);
+        }
+        if (spec instanceof NotSpecification) {
+            return 1 + this.getComplexity(spec.getSpecification());
+        }
+        return 1; // Base complexity for unknown types
+    }
+}
+
+// Utility functions for specifications
+
+// Main entry point for @praxisui/specification library
+
+/*
+ * Public API Surface of @praxisui/specification
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AndSpecification, AtLeastSpecification, COMPARISON_OPERATORS, ComparisonOperator, CompositeContextProvider, ConditionalSpecification, ConditionalType, ContextualSpecification, DateContextProvider, DefaultContextProvider, DisabledIfSpecification, DslExporter, DslParser, DslTokenizer, DslValidator, ExactlySpecification, FieldSpecification, FieldToFieldSpecification, ForEachSpecification, FormSpecification, FunctionRegistry, FunctionSpecification, IfDefinedSpecification, IfExistsSpecification, IfNotNullSpecification, ImpliesSpecification, MaxLengthSpecification, MinLengthSpecification, NotSpecification, OPERATOR_KEYWORDS, OPERATOR_SYMBOLS, OrSpecification, ReadonlyIfSpecification, RequiredIfSpecification, SpecificationFactory, SpecificationUtils, TokenType, TransformRegistry, UniqueBySpecification, ValidationIssueType, ValidationSeverity, VisibleIfSpecification, WithDefaultSpecification, XorSpecification };
+//# sourceMappingURL=praxisui-specification.mjs.map