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

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

/**
 * Variant Import/Export Management System
 * Manages TypeScript imports and exports across variants including barrel exports and cross-variant references
 */
import { VariantType, ModelVariantCollection } from '../types/variants';
/**
 * Import statement configuration
 */
export interface ImportStatement {
    moduleSpecifier: string;
    namedImports: string[];
    defaultImport?: string;
    namespaceImport?: string;
    isTypeOnly?: boolean;
}
/**
 * Export statement configuration
 */
export interface ExportStatement {
    namedExports: string[];
    moduleSpecifier?: string;
    defaultExport?: string;
    namespaceExport?: string;
    isTypeOnly?: boolean;
}
/**
 * Barrel export configuration
 */
export interface BarrelExportConfig {
    variantType: VariantType;
    includeTypes: boolean;
    includeSchemas: boolean;
    groupByModel: boolean;
    customHeader?: string;
    sortExports: boolean;
}
/**
 * Cross-variant reference mapping
 */
export interface CrossVariantReference {
    sourceVariant: VariantType;
    targetVariant: VariantType;
    referencedItems: string[];
    referenceType: 'import' | 'extends' | 'utility';
}
/**
 * Module resolution configuration
 */
export interface ModuleResolutionConfig {
    baseUrl: string;
    paths: Record<string, string[]>;
    extensions: string[];
    useRelativePaths: boolean;
    pathMapping: Record<string, string>;
}
/**
 * Export validation result
 */
export interface ExportValidationResult {
    isValid: boolean;
    circularDependencies: string[][];
    unresolvedImports: string[];
    duplicateExports: string[];
    warnings: string[];
}
/**
 * Variant Import/Export Manager
 * Central manager for handling all import/export operations across variants
 */
export declare class VariantImportExportManager {
    private moduleResolutionConfig;
    private globalImports;
    private exportCache;
    constructor(moduleResolutionConfig?: Partial<ModuleResolutionConfig>);
    /**
     * Generate barrel export files for all variant types
     */
    generateBarrelExports(collections: ModelVariantCollection[], configs: Record<VariantType, BarrelExportConfig>, importExtension?: string): Promise<{
        files: Array<{
            path: string;
            content: string;
            exports: string[];
        }>;
        mainIndex: {
            path: string;
            content: string;
            exports: string[];
        };
    }>;
    /**
     * Generate barrel export for a specific variant type
     */
    private generateVariantBarrelExport;
    /**
     * Generate main index file that exports all variant barrels
     */
    private generateMainIndexFile;
    /**
     * Handle cross-variant references
     */
    manageCrossVariantReferences(collections: ModelVariantCollection[]): Promise<CrossVariantReference[]>;
    /**
     * Update files with cross-variant imports
     */
    private updateFilesWithCrossVariantImports;
    /**
     * Add imports to a specific file
     */
    private addImportsToFile;
    /**
     * Validate export consistency and detect issues
     */
    validateExports(collections: ModelVariantCollection[]): ExportValidationResult;
    /**
     * Private helper methods
     */
    private generateBarrelFileContent;
    private generateMainIndexContent;
    private resolveModulePath;
    private extractVariantTypeFromPath;
    private findReferencedItems;
    private determineReferenceType;
    private generateImportStatements;
    private formatImportStatement;
    private findImportInsertionPoint;
    private detectCircularDependencies;
    private findUnresolvedImports;
    private isExternalImport;
}
export default VariantImportExportManager;