import * as effect_Effect from 'effect/Effect';

declare class NoPragmaFoundError extends Error {
    /**
     * @type {'NoPragmaFoundError'}
     */
    _tag: "NoPragmaFoundError";
    /**
     * @type {'NoPragmaFoundError'}
     * @override
     */
    override name: "NoPragmaFoundError";
}

declare class CouldNotResolveImportError extends Error {
    /**
     * @param {string} importPath
     * @param {string} absolutePath
     * @param {Error} cause
     */
    constructor(importPath: string, absolutePath: string, cause: Error);
    /**
     * @type {'CouldNotResolveImportError'}
     */
    _tag: "CouldNotResolveImportError";
    /**
     * @type {'CouldNotResolveImportError'}
     * @override
     */
    override name: "CouldNotResolveImportError";
}

type FileAccessObject$1 = {
    readFile: (path: string, encoding: BufferEncoding) => Promise<string>;
    readFileSync: (path: string, encoding: BufferEncoding) => string;
    existsSync: (path: string) => boolean;
    exists: (path: string) => Promise<boolean>;
};
type Logger$1 = {
    info: (...messages: string[]) => void;
    error: (...message: string[]) => void;
    warn: (...message: string[]) => void;
    log: (...message: string[]) => void;
};
/**
 * Copied from rollup (kinda)
 * @see https://rollupjs.org/plugin-development/#this-getmoduleinfo
 */
interface ModuleInfo$1 {
    id: string;
    rawCode: string | null;
    code: string | null;
    importedIds: string[];
}

/**
 * @typedef {ReturnType<typeof safeFao>} SafeFao
 */
declare class ReadFileError extends Error {
    /**
     * @param {Error} cause
     */
    constructor(cause: Error);
    /**
     * @type {'ReadFileError'}
     */
    _tag: "ReadFileError";
    /**
     * @type {'ReadFileError'}
     * @override
     */
    override name: "ReadFileError";
}

type ResolveImportsError = ImportDoesNotExistError | CouldNotResolveImportError;
declare class ImportDoesNotExistError extends Error {
    constructor();
    /**
     * @type {'ImportDoesNotExistError'}
     */
    _tag: "ImportDoesNotExistError";
    /**
     * @type {'ImportDoesNotExistError'}
     * @override
     */
    override name: "ImportDoesNotExistError";
}

declare function moduleFactory(absolutePath: string, rawCode: string, remappings: Record<string, string>, libs: ReadonlyArray<string>, fao: FileAccessObject$1, sync: boolean): effect_Effect.Effect<Map<string, ModuleInfo$1>, ModuleFactoryError$1, never>;
type ModuleFactoryError$1 = ResolveImportsError | ReadFileError | CouldNotResolveImportError | NoPragmaFoundError;

/**
 * ./types.ts
 */
type FileAccessObject = FileAccessObject$1;
/**
 * ./types.ts
 */
type Logger = Logger$1;
/**
 * ./moduleFactory.js
 */
type ModuleInfo = ModuleInfo$1;
/**
 * ./types.ts
 */
type ModuleFactoryError = ModuleFactoryError$1;

export { type FileAccessObject, type Logger, type ModuleFactoryError, type ModuleInfo, moduleFactory };