import { SrcMap } from 'mini-parse';
import { ParsedRegistry } from './ParsedRegistry.js';
import { TextExport, TextModule } from './ParseModule.js';
import { WgslBundle } from './WgslBundle.js';
/** A named function to transform code fragments (e.g. by inserting parameters) */
export interface Template {
    name: string;
    apply: ApplyTemplateFn;
}
export type CodeGenFn = (name: string, params: Record<string, string>) => string;
export interface GeneratorExport {
    name: string;
    args: string[];
    generate: CodeGenFn;
}
/** a named code generation function */
export interface RegisterGenerator {
    /** export name for this generator */
    name: string;
    /** module namespace for this generator */
    moduleName: string;
    /** function to generate code at runtime */
    generate: CodeGenFn;
    /** arguments to pass when importing from this generator */
    args?: string[];
}
export type ApplyTemplateFn = (src: string, params: Record<string, any>) => SrcMap;
/** a single export from a module */
export type ModuleExport = TextModuleExport | GeneratorModuleExport;
export interface TextModuleExport {
    module: TextModule;
    exp: TextExport;
    kind: "text";
}
export interface GeneratorModule {
    kind: "generator";
    modulePath: string;
    exports: GeneratorExport[];
}
export interface GeneratorModuleExport {
    module: GeneratorModule;
    exp: GeneratorExport;
    kind: "function";
}
export interface RegistryParams {
    /** record of file names and wgsl text for modules */
    wgsl?: Record<string, string>;
    /** record of file names and wgsl text for modules */
    libs?: WgslBundle[];
    /** string template handlers for processing exported functions and structs */
    templates?: Template[];
    /** code generation functions */
    generators?: RegisterGenerator[];
}
/**
 * A ModuleRegistry collects exportable code fragments, code generator functions,
 * and template processors.
 *
 * The ModuleRegistry provides everything required for linkWgsl to process
 * #import statements and generate a complete wgsl shader.
 */
export declare class ModuleRegistry {
    templates: Map<string, ApplyTemplateFn>;
    wgslSrc: Map<string, string>;
    generators: Map<string, GeneratorModuleExport>;
    constructor(args?: RegistryParams);
    /**
     * Produce a linked wgsl string with all directives processed
     * (e.g. #import'd functions from other modules are inserted into the resulting string).
     * @param moduleName select the module to use as the root source
     * @param runtimeParams runtime parameters for #import/#export values,
     *  template values, and code generation parameters
     */
    link(moduleName: string, runtimeParams?: Record<string, any>): string;
    /** Parse the text modules in the registry */
    parsed(runtimeParams?: Record<string, any>): ParsedRegistry;
    /** register a function that generates code on demand */
    registerGenerator(reg: RegisterGenerator): void;
    /** register a template processor  */
    registerTemplate(...templates: Template[]): void;
}
export declare function relativeToAbsolute(relativePath: string, packageName: string): string;