import * as Eta from "eta";
import { TargetLanguage, GeneratedFile, ValidationResult, GeneratorConfig, EntityGenerationOptions, ControllerGenerationOptions, ServiceGenerationOptions, DtoGenerationOptions, MigrationGenerationOptions, LanguageGenerator, Entity, AuthConfig } from "../types";
/**
 * Abstract base class for language-specific generators.
 * Provides common functionality and enforces the LanguageGenerator interface.
 */
export declare abstract class BaseGenerator implements LanguageGenerator {
    protected config: GeneratorConfig;
    protected templateEngine: typeof Eta;
    protected templateBasePath: string;
    constructor(config: GeneratorConfig);
    /**
     * Get the target language this generator supports
     */
    abstract getLanguage(): TargetLanguage;
    /**
     * Get the file extension for generated files (e.g., ".ts", ".py", ".go")
     */
    abstract getFileExtension(): string;
    /**
     * Validate the configuration for this language
     */
    abstract validateConfig(config: GeneratorConfig): ValidationResult;
    /**
     * Generate entity/model files
     */
    abstract generateEntity(options: EntityGenerationOptions): Promise<GeneratedFile[]>;
    /**
     * Generate controller/router files
     */
    abstract generateController(options: ControllerGenerationOptions): Promise<GeneratedFile[]>;
    /**
     * Generate service files
     */
    abstract generateService(options: ServiceGenerationOptions): Promise<GeneratedFile[]>;
    /**
     * Generate DTO/schema files
     */
    abstract generateDto(options: DtoGenerationOptions): Promise<GeneratedFile[]>;
    /**
     * Generate module/router registration files
     */
    abstract generateModule(options: EntityGenerationOptions): Promise<GeneratedFile[]>;
    /**
     * Generate migration files
     */
    abstract generateMigration(options: MigrationGenerationOptions): Promise<GeneratedFile[]>;
    /**
     * Generate enum files for all entities
     */
    abstract generateEnums(entities: Entity[], apiType: string): Promise<GeneratedFile[]>;
    /**
     * Generate the index/main module file
     */
    abstract generateIndexModule(entities: Entity[], apiType: string, opts?: {
        emitEvents?: boolean;
        http?: boolean;
    }): Promise<GeneratedFile[]>;
    /**
     * Generate guard files (auth, scope, etc.)
     */
    abstract generateGuards(entities: Entity[], auth?: AuthConfig): Promise<GeneratedFile[]>;
    /**
     * Generate shared query utility files (filter, sort, pagination).
     * Default no-op. Override in language generators that need query utils.
     */
    generateQueryUtils(_entities: Entity[], _apiType: string): Promise<GeneratedFile[]>;
    /**
     * Emit a schema-derived manifest of entities that opt in to `emitEvents`.
     * The domain-event engine ships in the `@apso/domain-events` library (wired
     * by the `domain-events` skill); the generator only declares participants.
     * Default no-op. Override in language generators that support it.
     */
    generateDomainEvents(_entities: Entity[], _apiType?: string, _opts?: {
        emitEvents?: boolean;
    }): Promise<GeneratedFile[]>;
    /**
     * Render a template file with the given data
     */
    protected renderTemplate(templatePath: string, data: Record<string, unknown>): Promise<string>;
    /**
     * Write generated files to disk
     * Note: Sequential writes are intentional to avoid race conditions
     */
    protected writeFiles(baseDir: string, files: GeneratedFile[]): Promise<void>;
    /**
     * Get the configuration for this generator
     */
    getConfig(): GeneratorConfig;
    /**
     * Get the template base path for this generator
     */
    getTemplateBasePath(): string;
    /**
     * Helper to create a validation result
     */
    protected createValidationResult(errors?: string[], warnings?: string[]): ValidationResult;
    /**
     * Helper to check if an entity has a specific field type
     */
    protected entityHasFieldType(entity: Entity, fieldType: string): boolean;
    /**
     * Helper to get all unique field types from entities
     */
    protected getUniqueFieldTypes(entities: Entity[]): string[];
    /**
     * Helper to check if any entity has enum fields
     */
    protected hasEnumFields(entities: Entity[]): boolean;
}