credl-parser-evaluator/dist/src/engine/IRBuilder.d.ts

TypeScript-based CREDL Parser and Evaluator that processes CREDL files and outputs complete Intermediate Representations

/**
 * IRBuilder - Builds Intermediate Representation from parsed and validated CREDL data
 *
 * This class takes validated CREDL data and transforms it into a complete IR structure
 * that includes all resolved references, flattened hierarchies, and computed relationships.
 */
import { CREDLFile, IR, Asset } from '../types/CREDLTypes';
export interface IRBuilderOptions {
    includeMetadata?: boolean;
    resolvePresets?: boolean;
    resolveTemplates?: boolean;
    validateReferences?: boolean;
    generateIds?: boolean;
}
export declare class IRBuilder {
    private static readonly DEFAULT_OPTIONS;
    private static buildingRegistry;
    private static presetResolver;
    private static templateResolver;
    private static templatePresetResolver;
    private static presetApplications;
    /**
     * Get building registry for reference validation
     */
    static getBuildingRegistry(): Map<string, {
        asset: Asset;
        building: any;
    }>;
    /**
     * Get parent asset for a building ID
     */
    static getAssetForBuilding(buildingId: string): Asset | undefined;
    /**
     * Build complete IR from validated CREDL data
     */
    static buildIR(credlFile: CREDLFile, options?: IRBuilderOptions): IR;
    /**
     * Process assets with property types, locations, and total areas
     * Validates asset structure and builds asset registry for reference resolution
     */
    private static processAssets;
    /**
     * Validate asset property type for consistency
     */
    private static validateAssetPropertyType;
    /**
     * Validate asset location format and consistency
     */
    private static validateAssetLocation;
    /**
     * Validate building structure and properties
     */
    private static validateBuildingStructure;
    /**
     * Validate asset total area consistency with buildings
     */
    private static validateAssetAreas;
    /**
     * Process assumptions with comprehensive validation and cross-reference checking
     */
    private static processAssumptions;
    /**
     * Process assumption based on its type with specific validation
     */
    private static processAssumptionByType;
    /**
     * Process fixed assumption with validation
     */
    private static processFixedAssumption;
    /**
     * Process distribution assumption with parameter validation
     */
    private static processDistributionAssumption;
    /**
     * Process expression assumption with formula validation
     */
    private static processExpressionAssumption;
    /**
     * Process table assumption with table validation
     */
    private static processTableAssumption;
    /**
     * Validate distribution parameters based on distribution type
     */
    private static validateDistributionParameters;
    /**
     * Validate cross-references to assets and spaces in assumption scope
     */
    private static validateAssumptionCrossReferences;
    /**
     * Resolve scope hierarchy for assumptions per DSL-to-Engine mapping
     */
    private static resolveScopeHierarchy;
    /**
     * Get hierarchy level for scope types (lower number = more specific)
     */
    private static getScopeHierarchyLevel;
    /**
     * Calculate applicable spaces based on scope per DSL-to-Engine mapping
     */
    private static calculateApplicableSpaces;
    /**
     * Validate assumption metadata (tags, description, etc.)
     */
    private static validateAssumptionMetadata;
    /**
     * Validate dependencies between assumptions
     */
    private static validateAssumptionDependencies;
    /**
     * Process spaces with types, areas, and lease information
     * Validates space structure and resolves building relationships
     */
    private static processSpaces;
    /**
     * Resolve preset references in a space and populate resolved fields
     */
    private static resolveSpacePresetReferences;
    /**
     * Process templates and generate template-based spaces
     * Uses TemplateResolver for comprehensive template processing and validation
     */
    private static processTemplates;
    /**
     * Validate template-generated spaces don't violate constraints
     */
    private static validateTemplateConstraints;
    /**
     * Validate parent building exists and return building info
     */
    private static validateParentBuilding;
    /**
     * Process lease information with validation
     */
    private static processLeaseInformation;
    /**
     * Validate space structure and properties
     */
    private static validateSpaceStructure;
    /**
     * Validate space type-specific requirements
     */
    private static validateSpaceTypeSpecific;
    /**
     * Validate preset references on original space object
     */
    private static validatePresetReferences;
    /**
     * Validate comprehensive relationships after all processing
     */
    private static validateRelationships;
    /**
     * Validate that all spaces reference valid buildings
     */
    private static validateSpaceToBuildingRelationships;
    /**
     * Validate building-to-asset relationships
     */
    private static validateBuildingToAssetRelationships;
    /**
     * Validate space area aggregations against building and asset totals
     */
    private static validateSpaceAreaAggregations;
    /**
     * Validate reference integrity across the data model
     */
    private static validateReferenceIntegrity;
    /**
     * Generate summary warnings about relationships
     */
    private static generateRelationshipSummary;
    /**
     * Process models with type, duration, steps, and input/output validation
     * Validates model structure and cross-references to existing assumptions
     */
    private static processModels;
    /**
     * Validate model structure and parameter ranges
     */
    private static validateModelStructure;
    /**
     * Validate model input references to ensure all assumptions exist
     */
    private static validateModelInputReferences;
    /**
     * Validate model output references for consistency
     */
    private static validateModelOutputReferences;
    /**
     * Process simulation configurations including Monte Carlo parameters
     * Validates simulation structure and Monte Carlo specific parameters
     */
    private static processSimulation;
    /**
     * Validate simulation processes configuration
     */
    private static validateSimulationProcesses;
    /**
     * Validate process parameters
     */
    private static validateProcessParameters;
    /**
     * Validate simulation outputs configuration
     */
    private static validateSimulationOutputs;
    /**
     * Validate Monte Carlo specific parameters
     */
    private static validateMonteCarloParameters;
    /**
     * Process output specifications including metrics, tables, and charts
     * Validates output format, metrics array, and optional tables/charts arrays
     */
    private static processOutputs;
    /**
     * Validate output metrics array with comprehensive checks
     */
    private static validateOutputMetrics;
    /**
     * Validate output tables array
     */
    private static validateOutputTables;
    /**
     * Validate output charts array
     */
    private static validateOutputCharts;
    /**
     * Validate consistency between output specifications and model outputs
     */
    private static validateOutputModelConsistency;
    /**
     * Process extension blocks including scenarios and waterfall configurations
     * Validates extension structure and integrates scenarios/waterfall into IR
     */
    private static processExtensions;
    /**
     * Process scenarios array with comprehensive validation
     */
    private static processScenarios;
    /**
     * Process scenario overrides with assumption validation
     */
    private static processScenarioOverrides;
    /**
     * Validate scenario override compatibility with original assumption
     */
    private static validateScenarioOverrideCompatibility;
    /**
     * Process scenario triggers with condition validation
     */
    private static processScenarioTriggers;
    /**
     * Validate trigger condition format and syntax
     */
    private static validateTriggerCondition;
    /**
     * Process scenario actions with type validation
     */
    private static processScenarioActions;
    /**
     * Validate scenario action type and associated fields
     */
    private static validateScenarioActionType;
    /**
     * Process waterfall configuration with validation
     */
    private static processWaterfall;
    /**
     * Comprehensive IR validation across all parsed elements
     * Validates the complete IR structure for consistency and integrity
     */
    private static validateCompleteIR;
    /**
     * Validate IR structure completeness
     */
    private static validateIRStructureCompleteness;
    /**
     * Cross-validate relationships between all elements
     */
    private static validateCrossElementRelationships;
    /**
     * Validate assumption-model-output consistency
     */
    private static validateAssumptionModelOutputConsistency;
    /**
     * Validate simulation-model compatibility
     */
    private static validateSimulationModelCompatibility;
    /**
     * Validate extension-element consistency
     */
    private static validateExtensionElementConsistency;
    /**
     * Validate overall IR logical consistency
     */
    private static validateIRLogicalConsistency;
    /**
     * Generate comprehensive validation summary
     */
    private static generateComprehensiveValidationSummary;
    /**
     * Resolve cross-references between assumptions, models, and outputs
     * Creates dependency graphs and analyzes element relationships
     */
    private static resolveCrossReferences;
    /**
     * Build cross-reference mappings between elements
     */
    private static buildCrossReferenceMappings;
    /**
     * Build dependency graph from cross-references
     */
    private static buildDependencyGraph;
    /**
     * Detect circular dependencies in the dependency graph
     */
    private static detectCircularDependencies;
    /**
     * Calculate optimal resolution order based on dependency depth
     */
    private static calculateResolutionOrder;
    /**
     * Identify orphaned elements not connected to the dependency graph
     */
    private static identifyOrphanedElements;
    /**
     * Perform coverage analysis of cross-references
     */
    private static performCoverageAnalysis;
    /**
     * Generate cross-reference resolution summary
     */
    private static generateCrossReferenceSummary;
    /**
     * Execute a processing step with comprehensive error recovery
     */
    private static executeStepWithRecovery;
    /**
     * Attempt recovery for a failed processing step
     */
    private static attemptStepRecovery;
    /**
     * Get the recovery action description for a step
     */
    private static getRecoveryAction;
    /**
     * Generate comprehensive processing summary
     */
    private static generateProcessingSummary;
}
//# sourceMappingURL=IRBuilder.d.ts.map