/**
 * Import/Export Parser
 *
 * Parses source files to extract imports and exports.
 * Uses regex-based parsing for speed and simplicity.
 * Supports JavaScript/TypeScript, Python, and Java.
 */
/**
 * Information about an import statement
 */
export interface ImportInfo {
    source: string;
    isRelative: boolean;
    isPackage: boolean;
    isBuiltin: boolean;
    importedNames: string[];
    /**
     * Exact names bound from the source module for statically named imports.
     * Unlike importedNames, aliases retain their source identity (`X as Y` -> X).
     * Absent for default, namespace, star, dynamic, and otherwise uncertain forms.
     */
    importedSourceNames?: string[];
    /** Python only: true when the import is module-level and therefore may re-export a binding. */
    isTopLevel?: boolean;
    hasDefault: boolean;
    hasNamespace: boolean;
    isTypeOnly: boolean;
    isDynamic: boolean;
    line: number;
    /**
     * Set when this import is an HTML asset reference (`<script src>` /
     * `<link rel=stylesheet href>`) rather than a code import, so the dependency
     * graph can label the edge. Absent for ordinary code imports.
     */
    assetKind?: 'script' | 'stylesheet';
}
/**
 * Information about an export statement
 */
export interface ExportInfo {
    name: string;
    isDefault: boolean;
    isType: boolean;
    isReExport: boolean;
    reExportSource?: string;
    kind: 'function' | 'class' | 'variable' | 'type' | 'interface' | 'enum' | 'unknown';
    line: number;
}
/**
 * Complete analysis of a file's imports and exports
 */
export interface FileAnalysis {
    filePath: string;
    imports: ImportInfo[];
    exports: ExportInfo[];
    localImports: string[];
    externalImports: string[];
    parseErrors: string[];
    /** Java package declaration (e.g. "com.example.service"), if this is a .java file */
    javaPackage?: string;
}
/**
 * Options for import resolution
 */
export interface ResolveOptions {
    /** Base directory for resolving relative imports */
    baseDir: string;
    /** TypeScript paths aliases (from tsconfig) */
    pathAliases?: Record<string, string[]>;
    /** File extensions to try when resolving */
    extensions?: string[];
    /** Java package declaration of the source file (used to locate source root) */
    sourcePackage?: string;
}
/**
 * Parse imports from JavaScript/TypeScript content
 */
export declare function parseJSImports(content: string): ImportInfo[];
/**
 * Parse exports from JavaScript/TypeScript content
 */
export declare function parseJSExports(content: string): ExportInfo[];
/**
 * Parse imports from Python content
 */
export declare function parsePythonImports(content: string): ImportInfo[];
/**
 * Extract the package declaration from Java source content.
 * Returns undefined for files without a package declaration (default package).
 */
export declare function parseJavaPackage(content: string): string | undefined;
/**
 * Parse exports from Java source content.
 *
 * "Exports" in Java are public top-level types: classes, interfaces,
 * enums, records, and annotations. Also includes public static methods
 * and public fields on those types since downstream mapping uses
 * function-level exports to connect requirements to code.
 */
export declare function parseJavaExports(content: string): ExportInfo[];
/**
 * Resolve a relative import to an absolute file path
 */
export declare function resolveImport(importSource: string, fromFile: string, options: ResolveOptions): Promise<string | null>;
/**
 * Extract local asset references from an HTML file as ImportInfo entries:
 * `<script src=…>` (script) and `<link rel="stylesheet" href=…>` (stylesheet).
 * External/CDN URLs and non-stylesheet links are excluded. The existing
 * dependency-graph edge machinery resolves these against the document directory.
 */
export declare function parseHtmlAssetImports(content: string): ImportInfo[];
/**
 * Whether `parseContent` extracts EXPORTS for this file (change: ground-generated-specs-in-the-graph).
 * Derived from the same extension dispatch, so a consumer that reads the export inventory can tell
 * "this file exports nothing by that name" from "exports are never extracted for this language".
 */
export declare function extractsExports(filePath: string): boolean;
export declare class ImportExportParser {
    private cache;
    /**
     * Clear the parse cache
     */
    clearCache(): void;
    /**
     * Get file extension type
     */
    private getFileType;
    /** Parse caller-supplied bytes without re-reading a path that may have changed. */
    parseContent(filePath: string, content: string): FileAnalysis;
    /**
     * Parse a file and extract imports/exports
     */
    parseFile(filePath: string): Promise<FileAnalysis>;
    /**
     * Parse multiple files
     */
    parseFiles(filePaths: string[]): Promise<Map<string, FileAnalysis>>;
}
/**
 * Convenience function to parse a single file
 */
export declare function parseFile(filePath: string): Promise<FileAnalysis>;
/**
 * Convenience function to parse multiple files
 */
export declare function parseFiles(filePaths: string[]): Promise<Map<string, FileAnalysis>>;
//# sourceMappingURL=import-parser.d.ts.map