qnce-engine/dist/engine/validation.d.ts

Core QNCE (Quantum Narrative Convergence Engine) - Framework agnostic narrative engine with performance optimization

import { Choice, NarrativeNode, QNCEState } from './core';
/**
 * Validation context containing all state needed for choice validation
 */
export interface ValidationContext {
    currentNode: NarrativeNode;
    state: QNCEState;
    availableChoices: Choice[];
    timestamp?: number;
    metadata?: Record<string, unknown>;
}
/**
 * Result of choice validation with detailed information
 */
export interface ValidationResult {
    isValid: boolean;
    reason?: string;
    failedConditions?: string[];
    suggestedChoices?: Choice[];
    metadata?: Record<string, unknown>;
}
/**
 * Choice validation rule interface for extensible validation logic
 */
export interface ValidationRule {
    name: string;
    priority: number;
    validate(choice: Choice, context: ValidationContext): ValidationResult;
}
/**
 * Core ChoiceValidator interface
 * Provides validation logic for choice execution and availability filtering
 */
export interface ChoiceValidator {
    /**
     * Validate a specific choice against current state
     * @param choice - The choice to validate
     * @param context - Current validation context
     * @returns Validation result with details
     */
    validate(choice: Choice, context: ValidationContext): ValidationResult;
    /**
     * Get all currently available/valid choices
     * @param context - Current validation context
     * @returns Array of valid choices
     */
    getAvailableChoices(context: ValidationContext): Choice[];
    /**
     * Add a validation rule to the validator
     * @param rule - Validation rule to add
     */
    addRule(rule: ValidationRule): void;
    /**
     * Remove a validation rule by name
     * @param ruleName - Name of the rule to remove
     */
    removeRule(ruleName: string): void;
    /**
     * Get all registered validation rules
     * @returns Array of validation rules sorted by priority
     */
    getRules(): ValidationRule[];
}
/**
 * Built-in validation rules for common scenarios
 */
export declare class StandardValidationRules {
    /**
     * Validates that choice exists in the current node's choices
     */
    static readonly CHOICE_EXISTS: ValidationRule;
    /**
     * Validates flag-based conditions for choice availability
     */
    static readonly FLAG_CONDITIONS: ValidationRule;
    /**
     * Validates choice is not disabled or marked as unavailable
     */
    static readonly CHOICE_ENABLED: ValidationRule;
    /**
     * Validates time-based requirements for choice availability
     */
    static readonly TIME_CONDITIONS: ValidationRule;
    /**
     * Validates inventory-based requirements for choice availability
     */
    static readonly INVENTORY_CONDITIONS: ValidationRule;
}
/**
 * Default implementation of ChoiceValidator
 * Uses a rule-based system for extensible validation logic
 */
export declare class DefaultChoiceValidator implements ChoiceValidator {
    private rules;
    constructor();
    validate(choice: Choice, context: ValidationContext): ValidationResult;
    getAvailableChoices(context: ValidationContext): Choice[];
    addRule(rule: ValidationRule): void;
    removeRule(ruleName: string): void;
    getRules(): ValidationRule[];
}
/**
 * Factory function to create a choice validator with default rules
 */
export declare function createChoiceValidator(): ChoiceValidator;
/**
 * Utility function to create validation context from engine state
 */
export declare function createValidationContext(currentNode: NarrativeNode, state: QNCEState, availableChoices: Choice[], metadata?: Record<string, unknown>): ValidationContext;
//# sourceMappingURL=validation.d.ts.map