prisma-zod-generator/lib/variants/generator.d.ts

Prisma 2+ generator to emit Zod schemas from your Prisma schema

/**
 * Variant File Generation Coordinator
 * Orchestrates creation of multiple schema files for each variant
 */
import { DMMF } from '@prisma/generator-helper';
import { PrismaTypeMapper } from '../generators/model';
import { ModelVariantCollection, VariantConfig, VariantGenerationResult, VariantType } from '../types/variants';
import { NamingResult, VariantNamingSystem } from '../utils/naming';
import { VariantConfigurationManager } from './config';
/**
 * File generation context
 */
export interface GenerationContext {
    model: DMMF.Model;
    variant: VariantType;
    config: VariantConfig;
    naming: NamingResult;
    outputDirectory: string;
    typeMapper: PrismaTypeMapper;
}
/**
 * Generation coordination options
 */
export interface GenerationCoordinationOptions {
    enabledVariants?: VariantType[];
    outputDirectory?: string;
    preserveExisting?: boolean;
    generateIndexFiles?: boolean;
    validateDependencies?: boolean;
    parallelGeneration?: boolean;
}
/**
 * Generation progress tracking
 */
export interface GenerationProgress {
    totalModels: number;
    processedModels: number;
    totalVariants: number;
    processedVariants: number;
    currentModel: string;
    currentVariant: VariantType;
    startTime: number;
    errors: Array<{
        model: string;
        variant: VariantType;
        error: string;
        timestamp: number;
    }>;
}
/**
 * Generation statistics
 */
export interface GenerationStatistics {
    totalTime: number;
    averageModelTime: number;
    variantCounts: Record<VariantType, number>;
    errorCounts: Record<VariantType, number>;
    filesSizesKB: Record<string, number>;
    dependencyGraph: Record<string, string[]>;
}
/**
 * Variant File Generation Coordinator
 * Main class that orchestrates generation of all schema variants
 */
export declare class VariantFileGenerationCoordinator {
    private configManager;
    private namingSystem;
    private typeMapper;
    private progressCallbacks;
    constructor(configManager?: VariantConfigurationManager, namingSystem?: VariantNamingSystem, typeMapper?: PrismaTypeMapper);
    /**
     * Generate all variants for multiple models
     */
    generateAllVariants(models: DMMF.Model[], options?: GenerationCoordinationOptions, importExtension?: string): Promise<{
        collections: ModelVariantCollection[];
        statistics: GenerationStatistics;
        errors: string[];
    }>;
    /**
     * Generate variants for a single model
     */
    generateModelVariants(model: DMMF.Model, options?: GenerationCoordinationOptions, progress?: GenerationProgress, importExtension?: string): Promise<ModelVariantCollection>;
    /**
     * Generate a single variant for a model
     */
    generateSingleVariant(model: DMMF.Model, variantType: VariantType, options?: GenerationCoordinationOptions): Promise<VariantGenerationResult>;
    /**
     * Apply variant-specific customizations to content
     */
    private applyVariantCustomizations;
    /**
     * Extract custom imports from content (non-enum related)
     */
    private extractCustomImports;
    /**
     * Extract model-level validation from content
     */
    private extractModelLevelValidation;
    /**
     * Restore custom imports to content
     */
    private restoreCustomImports;
    /**
     * Restore model-level validation to content
     */
    private restoreModelLevelValidation;
    private resolveVariantPrismaImportPath;
    /**
     * Generate model index file
     */
    private generateModelIndexFile;
    /**
     * Generate global index files for all variants
     */
    private generateIndexFiles;
    /**
     * Calculate cross-variant references
     */
    private calculateCrossVariantReferences;
    /**
     * Helper methods
     */
    private calculateTotalVariants;
    private calculateExcludedFields;
    private calculateValidationCount;
    private formatContent;
    private writeVariantFile;
    private validateDependencies;
    private calculateStatistics;
    private notifyProgress;
    /**
     * Public API methods
     */
    /**
     * Add progress callback
     */
    onProgress(callback: (progress: GenerationProgress) => void): void;
    /**
     * Remove progress callback
     */
    removeProgressCallback(callback: (progress: GenerationProgress) => void): void;
    /**
     * Get current configuration
     */
    getConfiguration(): VariantConfigurationManager;
    /**
     * Update configuration
     */
    updateConfiguration(configManager: VariantConfigurationManager): void;
}
export default VariantFileGenerationCoordinator;