/**
 * Variant Naming Convention System
 * Provides utilities for generating consistent file names and schema names for different variants
 */
import { VariantType, NamingConfig } from '../types/variants';
/**
 * Global naming configuration options
 */
export interface GlobalNamingOptions {
    useModelPrefix?: boolean;
    usePascalCase?: boolean;
    customSeparator?: string;
    baseDirectory?: string;
}
/**
 * Name collision resolution strategies
 */
export declare enum CollisionStrategy {
    SUFFIX_INCREMENT = "suffix_increment",// Add _1, _2, etc.
    PREFIX_VARIANT = "prefix_variant",// Add variant prefix
    THROW_ERROR = "throw_error"
}
/**
 * Naming collision resolution configuration
 */
export interface CollisionResolutionConfig {
    strategy: CollisionStrategy;
    maxAttempts?: number;
    customPrefix?: string;
    customSuffix?: string;
}
/**
 * Generated naming result
 */
export interface NamingResult {
    fileName: string;
    filePath: string;
    directoryPath: string;
    schemaName: string;
    typeName: string;
    schemaExportName: string;
    typeExportName: string;
    variantType: VariantType;
    modelName: string;
    isCollisionResolved: boolean;
    originalNames?: {
        fileName: string;
        schemaName: string;
        typeName: string;
    };
}
/**
 * Name validation result
 */
export interface NameValidationResult {
    isValid: boolean;
    errors: string[];
    warnings: string[];
    suggestions: string[];
}
/**
 * Utility class for variant naming conventions
 */
export declare class VariantNamingSystem {
    private globalOptions;
    private collisionConfig;
    private usedFileNames;
    private usedSchemaNames;
    constructor(globalOptions?: GlobalNamingOptions, collisionConfig?: CollisionResolutionConfig);
    /**
     * Generate complete naming for a model variant
     */
    generateNaming(modelName: string, variantType: VariantType, customConfig?: Partial<NamingConfig>): NamingResult;
    /**
     * Generate file name for a variant
     */
    private generateFileName;
    /**
     * Generate schema name for a variant
     */
    private generateSchemaName;
    /**
     * Generate type name for a variant
     */
    private generateTypeName;
    /**
     * Build directory path for variant
     */
    private buildDirectoryPath;
    /**
     * Build full file path
     */
    private buildFilePath;
    /**
     * Resolve naming collisions
     */
    private resolveNamingCollisions;
    /**
     * Resolve file name collision
     */
    private resolveFileNameCollision;
    /**
     * Resolve schema name collision
     */
    private resolveSchemaNameCollision;
    /**
     * Merge naming configuration with defaults
     */
    private mergeNamingConfig;
    /**
     * Normalize model name for consistent naming
     */
    private normalizeModelName;
    /**
     * Convert string to PascalCase
     */
    private toPascalCase;
    /**
     * Convert string to camelCase
     */
    private toCamelCase;
    /**
     * Validate naming conventions
     */
    validateNaming(naming: NamingResult): NameValidationResult;
    /**
     * Check if file name is valid for file system
     */
    private isValidFileName;
    /**
     * Check if schema name follows TypeScript naming conventions
     */
    private isValidSchemaName;
    /**
     * Check if type name follows TypeScript naming conventions
     */
    private isValidTypeName;
    /**
     * Clear tracked names (useful for batch operations)
     */
    clearTrackedNames(): void;
    /**
     * Get all tracked file names
     */
    getTrackedFileNames(): string[];
    /**
     * Get all tracked schema names
     */
    getTrackedSchemaNames(): string[];
}
/**
 * Utility functions for common naming operations
 */
export declare class NamingUtils {
    /**
     * Generate barrel export file name for variant type
     */
    static generateBarrelFileName(variantType: VariantType): string;
    /**
     * Generate index file name for all variants
     */
    static generateIndexFileName(): string;
    /**
     * Generate variant directory name
     */
    static generateVariantDirectoryName(variantType: VariantType): string;
    /**
     * Extract model name from file name
     */
    static extractModelNameFromFileName(fileName: string, variantType: VariantType): string;
    /**
     * Check if two names would conflict
     */
    static wouldConflict(name1: string, name2: string): boolean;
    /**
     * Generate safe identifier from string
     */
    static toSafeIdentifier(input: string): string;
}
export default VariantNamingSystem;