@praxisui/specification 0.0.1

package/index.d.ts

@@ -0,0 +1,894 @@
+import { Specification, SpecificationMetadata } from '@praxisui/specification-core';
+export * from '@praxisui/specification-core';
+
+declare enum ComparisonOperator {
+    EQUALS = "eq",
+    NOT_EQUALS = "neq",
+    LESS_THAN = "lt",
+    LESS_THAN_OR_EQUAL = "lte",
+    GREATER_THAN = "gt",
+    GREATER_THAN_OR_EQUAL = "gte",
+    CONTAINS = "contains",
+    STARTS_WITH = "startsWith",
+    ENDS_WITH = "endsWith",
+    IN = "in"
+}
+declare const OPERATOR_SYMBOLS: Record<ComparisonOperator, string>;
+
+declare class FieldSpecification<T extends object = any> extends Specification<T> {
+    private field;
+    private operator;
+    private value;
+    constructor(field: keyof T, operator: ComparisonOperator, value: any, metadata?: SpecificationMetadata);
+    isSatisfiedBy(obj: T): boolean;
+    toJSON(): any;
+    static fromJSON<T extends object = any>(json: any): FieldSpecification<T>;
+    clone(): FieldSpecification<T>;
+    toDSL(): string;
+    getField(): keyof T;
+    getOperator(): ComparisonOperator;
+    getValue(): any;
+}
+
+declare class AndSpecification<T extends object = any> extends Specification<T> {
+    private specifications;
+    constructor(specifications: Specification<T>[], metadata?: SpecificationMetadata);
+    isSatisfiedBy(obj: T): boolean;
+    toJSON(): any;
+    static fromJSON<T extends object = any>(json: any): AndSpecification<T>;
+    toDSL(): string;
+    getSpecifications(): Specification<T>[];
+    add(specification: Specification<T>): AndSpecification<T>;
+    clone(): AndSpecification<T>;
+    getOperatorKind(): 'and' | 'or' | 'xor' | undefined;
+}
+
+declare class OrSpecification<T extends object = any> extends Specification<T> {
+    private specifications;
+    constructor(specifications: Specification<T>[], metadata?: SpecificationMetadata);
+    isSatisfiedBy(obj: T): boolean;
+    toJSON(): any;
+    static fromJSON<T extends object = any>(json: any): OrSpecification<T>;
+    toDSL(): string;
+    getSpecifications(): Specification<T>[];
+    add(specification: Specification<T>): OrSpecification<T>;
+    clone(): OrSpecification<T>;
+    getOperatorKind(): 'and' | 'or' | 'xor' | undefined;
+}
+
+declare class NotSpecification<T extends object = any> extends Specification<T> {
+    private specification;
+    constructor(specification: Specification<T>, metadata?: SpecificationMetadata);
+    isSatisfiedBy(obj: T): boolean;
+    toJSON(): any;
+    static fromJSON<T extends object = any>(json: any): NotSpecification<T>;
+    toDSL(): string;
+    getSpecification(): Specification<T>;
+    clone(): NotSpecification<T>;
+}
+
+declare class XorSpecification<T extends object = any> extends Specification<T> {
+    private specifications;
+    constructor(specifications: Specification<T>[], metadata?: SpecificationMetadata);
+    isSatisfiedBy(obj: T): boolean;
+    toJSON(): any;
+    static fromJSON<T extends object = any>(json: any): XorSpecification<T>;
+    toDSL(): string;
+    getSpecifications(): Specification<T>[];
+    clone(): XorSpecification<T>;
+    getOperatorKind(): 'and' | 'or' | 'xor' | undefined;
+}
+
+declare class ImpliesSpecification<T extends object = any> extends Specification<T> {
+    private antecedent;
+    private consequent;
+    constructor(antecedent: Specification<T>, consequent: Specification<T>, metadata?: SpecificationMetadata);
+    isSatisfiedBy(obj: T): boolean;
+    toJSON(): any;
+    static fromJSON<T extends object = any>(json: any): ImpliesSpecification<T>;
+    toDSL(): string;
+    getAntecedent(): Specification<T>;
+    getConsequent(): Specification<T>;
+    clone(): ImpliesSpecification<T>;
+}
+
+type SpecificationFunction<T> = (obj: T, ...args: any[]) => boolean;
+declare class FunctionRegistry<T> {
+    private contextKey;
+    private static instances;
+    private functions;
+    private constructor();
+    static getInstance<T>(contextKey?: string): FunctionRegistry<T>;
+    register(name: string, fn: SpecificationFunction<T>): void;
+    unregister(name: string): boolean;
+    get(name: string): SpecificationFunction<T> | undefined;
+    has(name: string): boolean;
+    getAll(): Map<string, SpecificationFunction<T>>;
+    clear(): void;
+    execute(name: string, obj: T, ...args: any[]): boolean;
+    getContextKey(): string;
+}
+
+declare class FunctionSpecification<T extends object = any> extends Specification<T> {
+    private functionName;
+    private args;
+    private registry?;
+    constructor(functionName: string, args: any[], registry?: FunctionRegistry<T> | undefined, metadata?: SpecificationMetadata);
+    isSatisfiedBy(obj: T): boolean;
+    toJSON(): any;
+    static fromJSON<T extends object = any>(json: any, registry?: FunctionRegistry<T>): FunctionSpecification<T>;
+    toDSL(): string;
+    getFunctionName(): string;
+    getArgs(): any[];
+    getRegistry(): FunctionRegistry<T> | undefined;
+    clone(): FunctionSpecification<T>;
+}
+
+declare class AtLeastSpecification<T extends object = any> extends Specification<T> {
+    private minimum;
+    private specifications;
+    constructor(minimum: number, specifications: Specification<T>[], metadata?: SpecificationMetadata);
+    isSatisfiedBy(obj: T): boolean;
+    toJSON(): any;
+    static fromJSON<T extends object = any>(json: any): AtLeastSpecification<T>;
+    toDSL(): string;
+    getMinimum(): number;
+    getSpecifications(): Specification<T>[];
+    getSatisfiedCount(obj: T): number;
+    clone(): AtLeastSpecification<T>;
+}
+
+declare class ExactlySpecification<T extends object = any> extends Specification<T> {
+    private exact;
+    private specifications;
+    constructor(exact: number, specifications: Specification<T>[], metadata?: SpecificationMetadata);
+    isSatisfiedBy(obj: T): boolean;
+    toJSON(): any;
+    static fromJSON<T extends object = any>(json: any): ExactlySpecification<T>;
+    toDSL(): string;
+    getExact(): number;
+    getSpecifications(): Specification<T>[];
+    getSatisfiedCount(obj: T): number;
+    clone(): ExactlySpecification<T>;
+}
+
+type TransformFunction = (value: any) => any;
+declare class TransformRegistry {
+    private static instance;
+    private transforms;
+    private constructor();
+    static getInstance(): TransformRegistry;
+    private registerDefaults;
+    register(name: string, fn: TransformFunction): void;
+    unregister(name: string): boolean;
+    get(name: string): TransformFunction | undefined;
+    has(name: string): boolean;
+    getAll(): Map<string, TransformFunction>;
+    clear(): void;
+    apply(name: string, value: any): any;
+    applyChain(transforms: string[], value: any): any;
+}
+
+declare class FieldToFieldSpecification<T extends object = any> extends Specification<T> {
+    private fieldA;
+    private operator;
+    private fieldB;
+    private transformA?;
+    private transformB?;
+    private transformRegistry?;
+    constructor(fieldA: keyof T, operator: ComparisonOperator, fieldB: keyof T, transformA?: string[] | undefined, transformB?: string[] | undefined, transformRegistry?: TransformRegistry | undefined, metadata?: SpecificationMetadata);
+    isSatisfiedBy(obj: T): boolean;
+    toJSON(): any;
+    static fromJSON<T extends object = any>(json: any, transformRegistry?: TransformRegistry): FieldToFieldSpecification<T>;
+    toDSL(): string;
+    getFieldA(): keyof T;
+    getFieldB(): keyof T;
+    getOperator(): ComparisonOperator;
+    getTransformA(): string[] | undefined;
+    getTransformB(): string[] | undefined;
+    clone(): FieldToFieldSpecification<T>;
+}
+
+interface ContextProvider {
+    getValue(path: string): any;
+    hasValue(path: string): boolean;
+}
+declare class DefaultContextProvider implements ContextProvider {
+    private context;
+    constructor(context?: Record<string, any>);
+    getValue(path: string): any;
+    hasValue(path: string): boolean;
+    private getNestedValue;
+    setContext(context: Record<string, any>): void;
+    updateContext(updates: Record<string, any>): void;
+    getContext(): Record<string, any>;
+}
+declare class DateContextProvider implements ContextProvider {
+    getValue(path: string): any;
+    hasValue(path: string): boolean;
+}
+declare class CompositeContextProvider implements ContextProvider {
+    private providers;
+    constructor(providers: ContextProvider[]);
+    getValue(path: string): any;
+    hasValue(path: string): boolean;
+    addProvider(provider: ContextProvider): void;
+    removeProvider(provider: ContextProvider): void;
+}
+
+declare class ContextualSpecification<T extends object> extends Specification<T> {
+    private template;
+    private contextProvider?;
+    private static readonly TOKEN_REGEX;
+    constructor(template: string, contextProvider?: ContextProvider | undefined, metadata?: SpecificationMetadata);
+    isSatisfiedBy(obj: T): boolean;
+    toJSON(): any;
+    static fromJSON<T extends object>(json: any, contextProvider?: ContextProvider): ContextualSpecification<T>;
+    toDSL(): string;
+    resolveTokens(template: string, obj: T): string;
+    private valueToString;
+    getTemplate(): string;
+    getContextProvider(): ContextProvider | undefined;
+    setContextProvider(provider: ContextProvider): ContextualSpecification<T>;
+    getTokens(): string[];
+    clone(): ContextualSpecification<T>;
+}
+
+/**
+ * Types of conditional validation
+ */
+declare enum ConditionalType {
+    REQUIRED_IF = "requiredIf",
+    VISIBLE_IF = "visibleIf",
+    DISABLED_IF = "disabledIf",
+    READONLY_IF = "readonlyIf"
+}
+/**
+ * Base class for conditional validators
+ */
+declare abstract class ConditionalSpecification<T extends object = any> extends Specification<T> {
+    protected condition: Specification<T>;
+    protected conditionalType: ConditionalType;
+    constructor(condition: Specification<T>, conditionalType: ConditionalType, metadata?: SpecificationMetadata);
+    getCondition(): Specification<T>;
+    getConditionalType(): ConditionalType;
+    abstract clone(): ConditionalSpecification<T>;
+}
+/**
+ * Validates that a field is required when a condition is met
+ */
+declare class RequiredIfSpecification<T extends object = any> extends ConditionalSpecification<T> {
+    private field;
+    constructor(field: keyof T, condition: Specification<T>, metadata?: SpecificationMetadata);
+    isSatisfiedBy(obj: T): boolean;
+    toJSON(): any;
+    static fromJSON<T extends object = any>(json: any): RequiredIfSpecification<T>;
+    toDSL(): string;
+    clone(): RequiredIfSpecification<T>;
+    getField(): keyof T;
+}
+/**
+ * Determines if a field should be visible based on a condition
+ */
+declare class VisibleIfSpecification<T extends object = any> extends ConditionalSpecification<T> {
+    private field;
+    constructor(field: keyof T, condition: Specification<T>, metadata?: SpecificationMetadata);
+    isSatisfiedBy(obj: T): boolean;
+    toJSON(): any;
+    static fromJSON<T extends object = any>(json: any): VisibleIfSpecification<T>;
+    toDSL(): string;
+    clone(): VisibleIfSpecification<T>;
+    getField(): keyof T;
+}
+/**
+ * Determines if a field should be disabled based on a condition
+ */
+declare class DisabledIfSpecification<T extends object = any> extends ConditionalSpecification<T> {
+    private field;
+    constructor(field: keyof T, condition: Specification<T>, metadata?: SpecificationMetadata);
+    isSatisfiedBy(obj: T): boolean;
+    toJSON(): any;
+    static fromJSON<T extends object = any>(json: any): DisabledIfSpecification<T>;
+    toDSL(): string;
+    clone(): DisabledIfSpecification<T>;
+    getField(): keyof T;
+}
+/**
+ * Determines if a field should be readonly based on a condition
+ */
+declare class ReadonlyIfSpecification<T extends object = any> extends ConditionalSpecification<T> {
+    private field;
+    constructor(field: keyof T, condition: Specification<T>, metadata?: SpecificationMetadata);
+    isSatisfiedBy(obj: T): boolean;
+    toJSON(): any;
+    static fromJSON<T extends object = any>(json: any): ReadonlyIfSpecification<T>;
+    toDSL(): string;
+    clone(): ReadonlyIfSpecification<T>;
+    getField(): keyof T;
+}
+
+/**
+ * Applies a specification to all elements in an array field
+ */
+declare class ForEachSpecification<T extends object = any, TItem extends object = any> extends Specification<T> {
+    private arrayField;
+    private itemSpecification;
+    constructor(arrayField: keyof T, itemSpecification: Specification<TItem>, metadata?: SpecificationMetadata);
+    isSatisfiedBy(obj: T): boolean;
+    toJSON(): any;
+    static fromJSON<T extends object = any>(json: any): ForEachSpecification<T>;
+    toDSL(): string;
+    clone(): ForEachSpecification<T, TItem>;
+    getArrayField(): keyof T;
+    getItemSpecification(): Specification<TItem>;
+    /**
+     * Gets items that fail the specification
+     */
+    getFailingItems(obj: T): {
+        index: number;
+        item: any;
+        errors?: string[];
+    }[];
+}
+/**
+ * Ensures all items in an array are unique based on a field or key selector
+ */
+declare class UniqueBySpecification<T extends object = any> extends Specification<T> {
+    private arrayField;
+    private keySelector;
+    constructor(arrayField: keyof T, keySelector: string | ((item: any) => any), metadata?: SpecificationMetadata);
+    isSatisfiedBy(obj: T): boolean;
+    toJSON(): any;
+    static fromJSON<T extends object = any>(json: any): UniqueBySpecification<T>;
+    toDSL(): string;
+    clone(): UniqueBySpecification<T>;
+    getArrayField(): keyof T;
+    getKeySelector(): string | ((item: any) => any);
+    /**
+     * Gets duplicate items found in the array
+     */
+    getDuplicates(obj: T): {
+        key: any;
+        items: {
+            index: number;
+            item: any;
+        }[];
+    }[];
+}
+/**
+ * Validates that an array has a minimum number of elements
+ */
+declare class MinLengthSpecification<T extends object = any> extends Specification<T> {
+    private arrayField;
+    private minLength;
+    constructor(arrayField: keyof T, minLength: number, metadata?: SpecificationMetadata);
+    isSatisfiedBy(obj: T): boolean;
+    toJSON(): any;
+    static fromJSON<T extends object = any>(json: any): MinLengthSpecification<T>;
+    toDSL(): string;
+    clone(): MinLengthSpecification<T>;
+    getArrayField(): keyof T;
+    getMinLength(): number;
+}
+/**
+ * Validates that an array has a maximum number of elements
+ */
+declare class MaxLengthSpecification<T extends object = any> extends Specification<T> {
+    private arrayField;
+    private maxLength;
+    constructor(arrayField: keyof T, maxLength: number, metadata?: SpecificationMetadata);
+    isSatisfiedBy(obj: T): boolean;
+    toJSON(): any;
+    static fromJSON<T extends object = any>(json: any): MaxLengthSpecification<T>;
+    toDSL(): string;
+    clone(): MaxLengthSpecification<T>;
+    getArrayField(): keyof T;
+    getMaxLength(): number;
+}
+
+/**
+ * Only applies the inner specification if the field is defined (not null, undefined, or empty)
+ */
+declare class IfDefinedSpecification<T extends object = any> extends Specification<T> {
+    private field;
+    private innerSpecification;
+    constructor(field: keyof T, innerSpecification: Specification<T>, metadata?: SpecificationMetadata);
+    isSatisfiedBy(obj: T): boolean;
+    private isUndefined;
+    toJSON(): any;
+    static fromJSON<T extends object = any>(json: any): IfDefinedSpecification<T>;
+    toDSL(): string;
+    clone(): IfDefinedSpecification<T>;
+    getField(): keyof T;
+    getInnerSpecification(): Specification<T>;
+}
+/**
+ * Only applies the inner specification if the field value is not null
+ */
+declare class IfNotNullSpecification<T extends object = any> extends Specification<T> {
+    private field;
+    private innerSpecification;
+    constructor(field: keyof T, innerSpecification: Specification<T>, metadata?: SpecificationMetadata);
+    isSatisfiedBy(obj: T): boolean;
+    toJSON(): any;
+    static fromJSON<T extends object = any>(json: any): IfNotNullSpecification<T>;
+    toDSL(): string;
+    clone(): IfNotNullSpecification<T>;
+    getField(): keyof T;
+    getInnerSpecification(): Specification<T>;
+}
+/**
+ * Only applies the inner specification if the field exists as a property on the object
+ */
+declare class IfExistsSpecification<T extends object = any> extends Specification<T> {
+    private field;
+    private innerSpecification;
+    constructor(field: keyof T, innerSpecification: Specification<T>, metadata?: SpecificationMetadata);
+    isSatisfiedBy(obj: T): boolean;
+    toJSON(): any;
+    static fromJSON<T extends object = any>(json: any): IfExistsSpecification<T>;
+    toDSL(): string;
+    clone(): IfExistsSpecification<T>;
+    getField(): keyof T;
+    getInnerSpecification(): Specification<T>;
+}
+/**
+ * Provides a default value for a field if it's undefined, then applies the specification
+ */
+declare class WithDefaultSpecification<T extends object = any> extends Specification<T> {
+    private field;
+    private defaultValue;
+    private innerSpecification;
+    constructor(field: keyof T, defaultValue: any, innerSpecification: Specification<T>, metadata?: SpecificationMetadata);
+    isSatisfiedBy(obj: T): boolean;
+    private isUndefined;
+    toJSON(): any;
+    static fromJSON<T extends object = any>(json: any): WithDefaultSpecification<T>;
+    toDSL(): string;
+    clone(): WithDefaultSpecification<T>;
+    getField(): keyof T;
+    getDefaultValue(): any;
+    getInnerSpecification(): Specification<T>;
+}
+
+/**
+ * Form validation result for a specific field
+ */
+interface FieldValidationResult {
+    field: string;
+    isValid: boolean;
+    errors: string[];
+    warnings: string[];
+    metadata?: SpecificationMetadata;
+}
+/**
+ * Complete form validation result
+ */
+interface FormValidationResult {
+    isValid: boolean;
+    fields: Record<string, FieldValidationResult>;
+    globalErrors: string[];
+    warnings: string[];
+}
+/**
+ * Field rules configuration
+ */
+interface FieldRules<T extends object = any> {
+    validation?: Specification<T>[];
+    required?: boolean | Specification<T>;
+    visible?: boolean | Specification<T>;
+    disabled?: boolean | Specification<T>;
+    readonly?: boolean | Specification<T>;
+    metadata?: SpecificationMetadata;
+}
+/**
+ * Form specification that manages validation rules for multiple fields
+ */
+declare class FormSpecification<T extends object = any> extends Specification<T> {
+    private fieldRules;
+    private globalValidations;
+    constructor(metadata?: SpecificationMetadata);
+    /**
+     * Adds validation rules for a specific field
+     */
+    addFieldRules(field: keyof T, rules: FieldRules<T>): FormSpecification<T>;
+    /**
+     * Adds a global validation rule that applies to the entire form
+     */
+    addGlobalValidation(specification: Specification<T>): FormSpecification<T>;
+    /**
+     * Sets required condition for a field
+     */
+    setRequired(field: keyof T, condition: boolean | Specification<T>): FormSpecification<T>;
+    /**
+     * Sets visibility condition for a field
+     */
+    setVisible(field: keyof T, condition: boolean | Specification<T>): FormSpecification<T>;
+    /**
+     * Sets disabled condition for a field
+     */
+    setDisabled(field: keyof T, condition: boolean | Specification<T>): FormSpecification<T>;
+    /**
+     * Sets readonly condition for a field
+     */
+    setReadonly(field: keyof T, condition: boolean | Specification<T>): FormSpecification<T>;
+    /**
+     * Basic satisfaction check - validates all rules
+     */
+    isSatisfiedBy(obj: T): boolean;
+    /**
+     * Comprehensive form validation with detailed results
+     */
+    validateForm(obj: T): FormValidationResult;
+    private validateField;
+    /**
+     * Checks if a field should be visible
+     */
+    isFieldVisible(field: keyof T, rules: FieldRules<T> | undefined, obj: T): boolean;
+    /**
+     * Checks if a field should be disabled
+     */
+    isFieldDisabled(field: keyof T, obj: T): boolean;
+    /**
+     * Checks if a field should be readonly
+     */
+    isFieldReadonly(field: keyof T, obj: T): boolean;
+    /**
+     * Gets all configured fields
+     */
+    getFields(): (keyof T)[];
+    /**
+     * Gets rules for a specific field
+     */
+    getFieldRules(field: keyof T): FieldRules<T> | undefined;
+    toJSON(): any;
+    static fromJSON<T extends object = any>(json: any): FormSpecification<T>;
+    toDSL(): string;
+    clone(): FormSpecification<T>;
+}
+
+declare enum TokenType {
+    IDENTIFIER = "IDENTIFIER",
+    STRING = "STRING",
+    NUMBER = "NUMBER",
+    BOOLEAN = "BOOLEAN",
+    NULL = "NULL",
+    AND = "AND",
+    OR = "OR",
+    NOT = "NOT",
+    XOR = "XOR",
+    IMPLIES = "IMPLIES",
+    EQUALS = "EQUALS",
+    NOT_EQUALS = "NOT_EQUALS",
+    LESS_THAN = "LESS_THAN",
+    LESS_THAN_OR_EQUAL = "LESS_THAN_OR_EQUAL",
+    GREATER_THAN = "GREATER_THAN",
+    GREATER_THAN_OR_EQUAL = "GREATER_THAN_OR_EQUAL",
+    IN = "IN",
+    CONTAINS = "CONTAINS",
+    STARTS_WITH = "STARTS_WITH",
+    ENDS_WITH = "ENDS_WITH",
+    AT_LEAST = "AT_LEAST",
+    EXACTLY = "EXACTLY",
+    LEFT_PAREN = "LEFT_PAREN",
+    RIGHT_PAREN = "RIGHT_PAREN",
+    LEFT_BRACKET = "LEFT_BRACKET",
+    RIGHT_BRACKET = "RIGHT_BRACKET",
+    COMMA = "COMMA",
+    DOT = "DOT",
+    FIELD_REFERENCE = "FIELD_REFERENCE",// ${field}
+    EOF = "EOF",
+    WHITESPACE = "WHITESPACE"
+}
+interface Token {
+    type: TokenType;
+    value: string;
+    position: number;
+    line: number;
+    column: number;
+}
+declare const OPERATOR_KEYWORDS: Record<string, TokenType>;
+declare const COMPARISON_OPERATORS: Record<string, TokenType>;
+
+declare class DslTokenizer {
+    private input;
+    private position;
+    private line;
+    private column;
+    constructor(input: string);
+    tokenize(): Token[];
+    private nextToken;
+    private readFieldReference;
+    private readString;
+    private readNumber;
+    private readIdentifier;
+    private skipWhitespace;
+    private createToken;
+    private createTokenAndAdvance;
+    private advance;
+    private peek;
+    private isDigit;
+    private isAlpha;
+    private isAlphaNumeric;
+    private isWhitespace;
+}
+
+declare class DslParser<T extends object = any> {
+    private functionRegistry?;
+    private tokens;
+    private current;
+    constructor(functionRegistry?: FunctionRegistry<T> | undefined);
+    parse(input: string): Specification<T>;
+    private parseExpression;
+    private parseImplies;
+    private parseXor;
+    private parseOr;
+    private parseAnd;
+    private parseUnary;
+    private parseComparison;
+    private parsePrimary;
+    private parseFunctionCall;
+    private parseArgument;
+    private matchComparison;
+    private tokenTypeToComparisonOperator;
+    private functionNameToOperator;
+    private extractValue;
+    private match;
+    private check;
+    private advance;
+    private isAtEnd;
+    private peek;
+    private previous;
+    private consume;
+}
+
+interface ExportOptions {
+    prettyPrint?: boolean;
+    indentSize?: number;
+    maxLineLength?: number;
+    useParentheses?: 'minimal' | 'explicit' | 'auto';
+    includeMetadata?: boolean;
+    metadataPosition?: 'before' | 'after' | 'inline';
+}
+declare class DslExporter {
+    private options;
+    constructor(options?: ExportOptions);
+    export<T extends object = any>(specification: Specification<T>): string;
+    /**
+     * Exports specification with metadata comments
+     */
+    exportWithMetadata<T extends object = any>(specification: Specification<T>): string;
+    private exportSpecification;
+    private getSpecificationDsl;
+    private addMetadataComments;
+    private exportFieldSpecification;
+    private exportAndSpecification;
+    private exportOrSpecification;
+    private exportNotSpecification;
+    private exportXorSpecification;
+    private exportImpliesSpecification;
+    private exportFunctionSpecification;
+    private exportAtLeastSpecification;
+    private exportExactlySpecification;
+    private exportFieldToFieldSpecification;
+    private exportContextualSpecification;
+    private needsParentheses;
+    private getOperatorPrecedence;
+    private getContextPrecedence;
+    private shouldBreakLine;
+    private formatPretty;
+}
+
+/**
+ * Types of validation issues that can be found in DSL
+ */
+declare enum ValidationIssueType {
+    SYNTAX_ERROR = "SyntaxError",
+    UNKNOWN_FUNCTION = "UnknownFunction",
+    UNKNOWN_OPERATOR = "UnknownOperator",
+    UNBALANCED_PARENTHESES = "UnbalancedParentheses",
+    UNBALANCED_BRACKETS = "UnbalancedBrackets",
+    INVALID_TOKEN = "InvalidToken",
+    UNEXPECTED_TOKEN = "UnexpectedToken",
+    MISSING_ARGUMENT = "MissingArgument",
+    TOO_MANY_ARGUMENTS = "TooManyArguments",
+    INVALID_FIELD_REFERENCE = "InvalidFieldReference",
+    EMPTY_EXPRESSION = "EmptyExpression",
+    UNTERMINATED_STRING = "UnterminatedString",
+    INVALID_NUMBER = "InvalidNumber",
+    DEPRECATED_SYNTAX = "DeprecatedSyntax",
+    PERFORMANCE_WARNING = "PerformanceWarning"
+}
+/**
+ * Severity levels for validation issues
+ */
+declare enum ValidationSeverity {
+    ERROR = "error",
+    WARNING = "warning",
+    INFO = "info",
+    HINT = "hint"
+}
+/**
+ * Represents a validation issue found in DSL code
+ */
+interface ValidationIssue {
+    /**
+     * Type of the issue
+     */
+    type: ValidationIssueType;
+    /**
+     * Severity level
+     */
+    severity: ValidationSeverity;
+    /**
+     * Human-readable error message
+     */
+    message: string;
+    /**
+     * Position information
+     */
+    position: {
+        /**
+         * Starting index in the input string
+         */
+        start: number;
+        /**
+         * Ending index in the input string
+         */
+        end: number;
+        /**
+         * Line number (1-based)
+         */
+        line: number;
+        /**
+         * Column number (1-based)
+         */
+        column: number;
+    };
+    /**
+     * Suggested fix or correction
+     */
+    suggestion?: string;
+    /**
+     * Additional context or help text
+     */
+    help?: string;
+    /**
+     * Related documentation or examples
+     */
+    documentation?: string;
+}
+
+/**
+ * Configuration for DSL validation
+ */
+interface DslValidatorConfig {
+    /**
+     * Available function names for validation
+     */
+    knownFunctions?: string[];
+    /**
+     * Function registry to check against
+     */
+    functionRegistry?: FunctionRegistry<any>;
+    /**
+     * Known field names for the target type
+     */
+    knownFields?: string[];
+    /**
+     * Maximum expression complexity (number of operators)
+     */
+    maxComplexity?: number;
+    /**
+     * Enable performance warnings
+     */
+    enablePerformanceWarnings?: boolean;
+    /**
+     * Enable deprecated syntax warnings
+     */
+    enableDeprecationWarnings?: boolean;
+}
+/**
+ * Validates DSL expressions and provides detailed error reporting
+ */
+declare class DslValidator {
+    private config;
+    private readonly BUILT_IN_FUNCTIONS;
+    constructor(config?: DslValidatorConfig);
+    /**
+     * Validates a DSL expression and returns all issues found
+     */
+    validate(input: string): ValidationIssue[];
+    private validateBasicStructure;
+    private validateBalancedDelimiters;
+    private validateStringLiterals;
+    private validateTokens;
+    private validateSyntax;
+    private validateSemantics;
+    private validateFunctionArguments;
+    private validateComplexity;
+    private getExpectedArgumentCount;
+    private isOperatorToken;
+    private isBinaryOperatorToken;
+    private suggestSimilarField;
+    private suggestSimilarFunction;
+    private findSimilar;
+    private levenshteinDistance;
+    private getLineColumn;
+}
+
+declare class SpecificationFactory {
+    static fromJSON<T extends object = any>(json: any): Specification<T>;
+    static field<T extends object = any>(field: keyof T, operator: ComparisonOperator, value: any): FieldSpecification<T>;
+    static and<T extends object = any>(...specs: Specification<T>[]): AndSpecification<T>;
+    static or<T extends object = any>(...specs: Specification<T>[]): OrSpecification<T>;
+    static not<T extends object = any>(spec: Specification<T>): NotSpecification<T>;
+    static xor<T extends object = any>(...specs: Specification<T>[]): XorSpecification<T>;
+    static implies<T extends object = any>(antecedent: Specification<T>, consequent: Specification<T>): ImpliesSpecification<T>;
+    static func<T extends object = any>(name: string, args: any[], registry?: FunctionRegistry<T>): FunctionSpecification<T>;
+    static atLeast<T extends object = any>(minimum: number, specs: Specification<T>[]): AtLeastSpecification<T>;
+    static exactly<T extends object = any>(exact: number, specs: Specification<T>[]): ExactlySpecification<T>;
+    static fieldToField<T extends object = any>(fieldA: keyof T, operator: ComparisonOperator, fieldB: keyof T, transformA?: string[], transformB?: string[], registry?: TransformRegistry): FieldToFieldSpecification<T>;
+    static contextual<T extends object = any>(template: string, provider?: ContextProvider): ContextualSpecification<T>;
+    static equals<T extends object = any>(field: keyof T, value: any): FieldSpecification<T>;
+    static notEquals<T extends object = any>(field: keyof T, value: any): FieldSpecification<T>;
+    static greaterThan<T extends object = any>(field: keyof T, value: any): FieldSpecification<T>;
+    static lessThan<T extends object = any>(field: keyof T, value: any): FieldSpecification<T>;
+    static contains<T extends object = any>(field: keyof T, value: any): FieldSpecification<T>;
+    static startsWith<T extends object = any>(field: keyof T, value: any): FieldSpecification<T>;
+    static endsWith<T extends object = any>(field: keyof T, value: any): FieldSpecification<T>;
+    static isIn<T extends object = any>(field: keyof T, values: any[]): FieldSpecification<T>;
+    static requiredIf<T extends object = any>(field: keyof T, condition: Specification<T>, metadata?: SpecificationMetadata): RequiredIfSpecification<T>;
+    static visibleIf<T extends object = any>(field: keyof T, condition: Specification<T>, metadata?: SpecificationMetadata): VisibleIfSpecification<T>;
+    static disabledIf<T extends object = any>(field: keyof T, condition: Specification<T>, metadata?: SpecificationMetadata): DisabledIfSpecification<T>;
+    static readonlyIf<T extends object = any>(field: keyof T, condition: Specification<T>, metadata?: SpecificationMetadata): ReadonlyIfSpecification<T>;
+    static forEach<T extends object = any, TItem extends object = any>(arrayField: keyof T, itemSpecification: Specification<TItem>, metadata?: SpecificationMetadata): ForEachSpecification<T, TItem>;
+    static uniqueBy<T extends object = any>(arrayField: keyof T, keySelector: string | ((item: any) => any), metadata?: SpecificationMetadata): UniqueBySpecification<T>;
+    static minLength<T extends object = any>(arrayField: keyof T, minLength: number, metadata?: SpecificationMetadata): MinLengthSpecification<T>;
+    static maxLength<T extends object = any>(arrayField: keyof T, maxLength: number, metadata?: SpecificationMetadata): MaxLengthSpecification<T>;
+    static ifDefined<T extends object = any>(field: keyof T, specification: Specification<T>, metadata?: SpecificationMetadata): IfDefinedSpecification<T>;
+    static ifNotNull<T extends object = any>(field: keyof T, specification: Specification<T>, metadata?: SpecificationMetadata): IfNotNullSpecification<T>;
+    static ifExists<T extends object = any>(field: keyof T, specification: Specification<T>, metadata?: SpecificationMetadata): IfExistsSpecification<T>;
+    static withDefault<T extends object = any>(field: keyof T, defaultValue: any, specification: Specification<T>, metadata?: SpecificationMetadata): WithDefaultSpecification<T>;
+    static form<T extends object = any>(metadata?: SpecificationMetadata): FormSpecification<T>;
+    static fieldWithMetadata<T extends object = any>(field: keyof T, operator: ComparisonOperator, value: any, metadata: SpecificationMetadata): FieldSpecification<T>;
+    static equalsWithMetadata<T extends object = any>(field: keyof T, value: any, metadata: SpecificationMetadata): FieldSpecification<T>;
+    static greaterThanWithMetadata<T extends object = any>(field: keyof T, value: any, metadata: SpecificationMetadata): FieldSpecification<T>;
+}
+
+declare class SpecificationUtils {
+    /**
+     * Simplifies a specification by removing redundant nesting and applying logical rules
+     */
+    static simplify<T extends object = any>(spec: Specification<T>): Specification<T>;
+    private static simplifyAnd;
+    private static simplifyOr;
+    private static simplifyNot;
+    private static removeDuplicates;
+    /**
+     * Checks if two specifications are logically equivalent
+     */
+    static areEquivalent<T extends object = any>(spec1: Specification<T>, spec2: Specification<T>): boolean;
+    /**
+     * Gets all field references used in a specification
+     */
+    static getReferencedFields<T extends object = any>(spec: Specification<T>): Set<keyof T>;
+    private static collectFields;
+    /**
+     * Validates a specification for common issues
+     */
+    static validate<T extends object = any>(spec: Specification<T>): ValidationResult;
+    private static validateSpecification;
+    /**
+     * Estimates the complexity of a specification (useful for performance analysis)
+     */
+    static getComplexity<T extends object = any>(spec: Specification<T>): number;
+}
+interface ValidationResult {
+    isValid: boolean;
+    errors: string[];
+    warnings: string[];
+}
+
+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 };
+export type { ContextProvider, DslValidatorConfig, ExportOptions, FieldRules, FieldValidationResult, FormValidationResult, SpecificationFunction, Token, TransformFunction, ValidationIssue, ValidationResult };