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

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

import { CREDLFile, ValidationError, Space, TemplateSpace } from '../types/CREDLTypes';
/**
 * Individual template definition interface (CREDL spec compliant)
 */
interface ParsedTemplate {
    name: string;
    spaces: TemplateSpace[];
}
/**
 * TemplateResolver handles parsing and processing of template definitions
 * for space generation in CREDL files (CREDL specification compliant)
 */
export declare class TemplateResolver {
    private templates;
    private generatedSpaces;
    private templateApplications;
    /**
     * Parse and store template definitions from a CREDL file
     */
    parseTemplates(credlFile: CREDLFile, errors: ValidationError[], warnings: ValidationError[]): void;
    /**
     * Validate and store a single template definition
     */
    private validateAndStoreTemplate;
    /**
     * Validate space definition structure
     */
    private validateSpaceDefinition;
    /**
     * Validate that template spaces do not reference other templates
     * This enforces the constraint that templates cannot reference other templates
     */
    private validateNoTemplateReferences;
    /**
     * Generate spaces from template definitions (CREDL spec compliant)
     */
    generateSpacesFromTemplate(templateName: string, parentBuilding: string, parentAsset?: string, startIndex?: number, errors?: ValidationError[], _warnings?: ValidationError[]): Space[];
    /**
     * Validate template-generated spaces against parent asset area constraints
     * Enforce constraint that template-generated spaces do not exceed parent asset total area
     */
    validateGeneratedSpaces(templateName: string, spaces: Space[], parentAssetTotalArea?: number, errors?: ValidationError[], warnings?: ValidationError[]): boolean;
    /**
     * Validate template area constraints at definition time
     * This pre-validates templates before they are used to generate spaces
     */
    validateTemplateAreaConstraints(templateName: string, template: ParsedTemplate, maxAssetArea?: number, errors?: ValidationError[], warnings?: ValidationError[]): boolean;
    /**
     * Get a template by name
     */
    getTemplate(name: string): ParsedTemplate | undefined;
    /**
     * Check if a template exists
     */
    hasTemplate(name: string): boolean;
    /**
     * Get all template names
     */
    getTemplateNames(): string[];
    /**
     * Get all generated spaces
     */
    getGeneratedSpaces(): Space[];
    /**
     * Get template applications (which spaces were generated from which templates)
     */
    getTemplateApplications(): Record<string, string[]>;
    /**
     * Get validation summary for templates
     */
    getValidationSummary(): {
        totalTemplates: number;
        totalGeneratedSpaces: number;
        templateNames: string[];
        templateApplications: Record<string, number>;
    };
    /**
     * Clear all stored templates and generated spaces (useful for testing)
     */
    clear(): void;
    /**
     * Get all templates for debugging/inspection
     */
    getAllTemplates(): Map<string, ParsedTemplate>;
}
export {};
//# sourceMappingURL=TemplateResolver.d.ts.map