@hey-api/codegen-core 0.0.1 → 0.2.0

package/dist/index.d.cts

@@ -1,391 +1,592 @@
 /**
- * Arbitrary metadata passed to render functions.
+ * Bi-directional map interface.
  *
- * Implementors should extend this interface for their own needs.
+ * Keys map to values and values map back to keys.
+ *
+ * @template Key Type of the map keys
+ * @template Value Type of the map values
  */
-interface ICodegenMeta {
-  [key: string]: unknown;
-}
-
-interface ICodegenOutput {
+interface IBiMap<Key, Value> {
   /**
-   * The main content of the file to output.
+   * Deletes a key and its associated value from the map.
    *
-   * A raw string representing source code.
+   * @param key The key to delete.
+   */
+  delete(key: Key): boolean;
+  /**
+   * Deletes a value and its associated key from the map.
    *
-   * @example "function foo(): void {\n  // implementation\n}\n"
+   * @param value The value to delete.
    */
-  content: string;
+  deleteValue(value: Value): boolean;
   /**
-   * Optional metadata or hints for the emitter, such as formatting options,
-   * source maps, or language-specific flags.
+   * Returns an iterator of [key, value] pairs.
+   */
+  entries(): IterableIterator<[Key, Value]>;
+  /**
+   * Gets the value associated with a key.
    *
-   * @example { format: "prettier", sourceMap: true }
+   * @param key The key to look up.
    */
-  meta: Record<string, unknown>;
+  get(key: Key): Value | undefined;
   /**
-   * Logical output path (used for writing the file).
+   * Gets the key associated with a value.
    *
-   * @example "models/user.ts"
+   * @param value The value to look up.
    */
-  path: string;
-}
-
-interface ICodegenRenderer {
+  getKey(value: Value): Key | undefined;
   /**
-   * Optional: hook for renderer-level setup logic (e.g., formatting, config)
+   * Checks if a key exists in the map.
+   *
+   * @param key The key to check.
    */
-  configure?(options: Record<string, unknown>): void;
+  hasKey(key: Key): boolean;
   /**
-   * Unique identifier for this renderer.
+   * Checks if a value exists in the map.
    *
-   * @example "typescript"
+   * @param value The value to check.
+   */
+  hasValue(value: Value): boolean;
+  /**
+   * Returns an iterator of keys.
    */
-  id: string;
+  keys(): IterableIterator<Key>;
   /**
-   * Returns printable data.
+   * Sets a key-value pair in the map.
    *
-   * @param file The file to render.
-   * @param meta Arbitrary metadata.
-   * @returns Output for file emit step
+   * @param key The key.
+   * @param value The value.
+   * @returns This instance for chaining.
+   */
+  set(key: Key, value: Value): this;
+  /**
+   * Number of key-value pairs in the map.
+   */
+  readonly size: number;
+  /**
+   * Returns an iterator of values.
    */
-  render(file: CodegenFile, meta?: ICodegenMeta): ICodegenOutput;
+  values(): IterableIterator<Value>;
+  /**
+   * Enables iteration with `for...of`.
+   */
+  [Symbol.iterator](): IterableIterator<[Key, Value]>;
 }
 
-interface ICodegenSymbol {
+interface IBinding {
   /**
-   * Optional description or doc comment.
+   * Optional aliasing map for named symbols.
+   *
+   * Keys must be a subset of `names`, values are aliases.
    *
-   * @example "Represents a user in the system"
+   * @example { User: "ImportedUser" }
    */
-  description?: string;
+  aliases?: Record<string, string>;
   /**
-   * Optional kind of symbol (e.g. "class", "function", "type", etc.).
+   * Name of the default binding, if any.
    *
-   * @example "class"
+   * @example "React"
    */
-  kind?: string;
+  defaultBinding?: string;
   /**
-   * Unique identifier for the symbol within its file.
+   * Source file or external module from which symbols are imported.
    *
-   * @example "UserModel"
+   * @example "./models/user"
+   * @example "node:path"
    */
-  name: string;
+  from: string;
   /**
-   * Internal representation of the symbol (e.g. AST node, IR object, raw
-   * code). Used to generate output.
+   * Names of the symbols imported from the source.
+   *
+   * Must be non-empty unless `namespaceBinding` is true.
+   * All imported names, regardless of whether they are used as types or values.
+   *
+   * @example ["User", "UserDTO"]
    */
-  value?: unknown;
-}
-
-interface ICodegenFile {
+  names?: ReadonlyArray<string>;
   /**
-   * Adds an export to this file.
+   * If this import is a namespace import (e.g. `import * as ns from "..."`),
+   * this should be the namespace alias. Set to `true` if no alias is needed.
    *
-   * This is also known as a re-export.
+   * @example "utils"
+   * @example true
+   */
+  namespaceBinding?: boolean | string;
+  /**
+   * Whether the default binding is type-only.
    *
-   * @param exp The export to add
+   * @example true
    */
-  addExport(exp: ICodegenImport): void;
+  typeDefaultBinding?: boolean;
   /**
-   * Adds an import to this file.
+   * Subset of `names` that are imported using the `type` modifier.
+   * These symbols will be emitted as type-only imports in TypeScript.
    *
-   * @param imp The import to add
+   * @example ["UserDTO"]
    */
-  addImport(imp: ICodegenImport): void;
+  typeNames?: ReadonlyArray<string>;
   /**
-   * Adds a symbol defined by this file.
+   * Whether the namespace binding is type-only.
    *
-   * @param symbol The symbol to add
+   * @example true
    */
-  addSymbol(symbol: ICodegenSymbol): void;
+  typeNamespaceBinding?: boolean;
+}
+
+/**
+ * Selector array used to reference resources. We don't enforce
+ * uniqueness, but in practice it's desirable.
+ *
+ * @example ["zod", "#/components/schemas/Foo"]
+ */
+type ISelector = ReadonlyArray<string>;
+
+interface IFileIn {
   /**
-   * Symbols exported from other files.
-   **/
-  exports: ReadonlyArray<ICodegenImport>;
+   * File extension, if any.
+   */
+  readonly extension?: string;
   /**
-   * Returns all symbols used in this file (declared + imported).
+   * Indicates whether the file is external, meaning it is not generated
+   * as part of the project but is referenced (e.g., a module from
+   * node_modules).
    *
-   * @returns List of all symbols used in this file
+   * @example true
    */
-  getAllSymbols(): ReadonlyArray<ICodegenSymbol>;
+  readonly external?: boolean;
   /**
-   * Checks if this file contains any content.
+   * Unique file ID. If one is not provided, it will be auto-generated.
+   */
+  readonly id?: number;
+  /**
+   * The desired name for the file within the project. If there are multiple files
+   * with the same desired name, this might not end up being the actual name.
    *
-   * This is used to determine whether we want to process the file further.
-   * By default, we consider only symbols and exports as content.
+   * @example "UserModel"
+   */
+  readonly name?: string;
+  /**
+   * Absolute logical output path for the file.
    *
-   * @returns True if the file contains content
+   * @example "/src/models/user.ts"
    */
-  hasContent(): boolean;
+  readonly path?: string;
   /**
-   * Checks if this file defines a symbol with the given name.
+   * Selector array used to select this file. It doesn't have to be
+   * unique, but in practice it might be desirable.
    *
-   * @param name Symbol name to check
-   * @returns True if the symbol is defined by this file
+   * @example ["zod", "#/components/schemas/Foo"]
    */
-  hasSymbol(name: string): boolean;
+  readonly selector?: ISelector;
+}
+
+interface IFileOut extends IFileIn {
   /**
-   * Symbols imported from other files.
-   **/
-  imports: ReadonlyArray<ICodegenImport>;
+   * Unique file ID.
+   */
+  readonly id: number;
+  /**
+   * Map holding resolved names for symbols in this file.
+   */
+  readonly resolvedNames: IBiMap<number, string>;
   /**
-   * Optional metadata about the file.
-   **/
-  meta: {
+   * Symbols in this file, categorized by their role.
+   */
+  readonly symbols: {
+    /**
+     * Symbols declared in the body of this file.
+     */
+    body: Array<number>;
     /**
-     * Optional file extension.
-     *
-     * @example ".ts"
+     * Symbols re-exported from other files.
      */
-    extension?: '.ts' | (string & {});
+    exports: Array<number>;
     /**
-     * Optional logical module or package name.
-     *
-     * @example "models.user"
+     * Symbols imported from other files.
      */
-    moduleName?: string;
+    imports: Array<number>;
+  };
+}
+
+interface IFileRegistry {
+  /**
+   * Get a file by its ID.
+   *
+   * @param fileIdOrSelector File ID or selector to reference.
+   * @returns The file, or undefined if not found.
+   */
+  get(fileIdOrSelector: number | ISelector): IFileOut | undefined;
+  /**
+   * Returns the current file ID and increments it.
+   *
+   * @returns File ID before being incremented
+   */
+  readonly id: number;
+  /**
+   * Returns a file by ID or selector, registering it if it doesn't exist.
+   *
+   * @param fileIdOrSelector File ID or selector to reference.
+   * @returns The referenced or newly registered file.
+   */
+  reference(fileIdOrSelector: number | ISelector): IFileOut;
+  /**
+   * Get all unregistered files in the order they were referenced.
+   *
+   * @returns Array of all unregistered files, in reference order.
+   */
+  referenced(): IterableIterator<IFileOut>;
+  /**
+   * Register a file globally.
+   *
+   * Deduplicates identical files by ID.
+   *
+   * @param file File to register.
+   * @returns true if added, false if duplicate.
+   */
+  register(file: IFileIn): IFileOut;
+  /**
+   * Get all files in the order they were registered.
+   *
+   * @returns Array of all registered files, in insert order.
+   */
+  registered(): IterableIterator<IFileOut>;
+}
+
+/**
+ * Arbitrary metadata passed to the project's render function.
+ *
+ * Implementers should extend this interface for their own needs.
+ */
+interface IProjectRenderMeta {
+  [key: string]: unknown;
+}
+
+/**
+ * Additional metadata about the symbol.
+ *
+ * Implementers should extend this interface for their own needs.
+ */
+interface ISymbolMeta {
+  [key: string]: unknown;
+}
+
+interface ISymbolIn {
+  /**
+   * Array of file names (without extensions) from which this symbol is re-exported.
+   *
+   * @default undefined
+   */
+  readonly exportFrom?: ReadonlyArray<string>;
+  /**
+   * Whether this symbol is exported from its own file.
+   *
+   * @default false
+   */
+  readonly exported?: boolean;
+  /**
+   * External module name if this symbol is imported from a module not managed
+   * by the project (e.g. "zod", "lodash").
+   *
+   * @default undefined
+   */
+  readonly external?: string;
+  /**
+   * Optional output strategy to override default behavior.
+   *
+   * @returns The file path to output the symbol to, or undefined to fallback to default behavior.
+   */
+  readonly getFilePath?: (symbol: ISymbolOut) => string | undefined;
+  /**
+   * Unique symbol ID. If one is not provided, it will be auto-generated.
+   */
+  readonly id?: number;
+  /**
+   * Arbitrary metadata about the symbol.
+   *
+   * @default undefined
+   */
+  readonly meta?: ISymbolMeta & {
     /**
-     * Optional path transformer.
-     *
-     * @param path Original file path passed to the constructor.
+     * Kind of import if this symbol represents an import.
      */
-    path?: ((path: string) => string) | string;
+    importKind?: 'namespace' | 'default' | 'named';
     /**
-     * Renderer ID.
-     *
-     * @example "typescript"
+     * Kind of symbol.
      */
-    renderer?: ICodegenRenderer['id'];
+    kind?: 'type';
   };
   /**
-   * Logical output path (used for writing the file).
+   * The desired name for the symbol within its file. If there are multiple symbols
+   * with the same desired name, this might not end up being the actual name.
    *
-   * @example "models/user.ts"
+   * @example "UserModel"
    */
-  path: string;
+  readonly name?: string;
   /**
-   * Returns a relative path to this file from another file.
+   * Placeholder name for the symbol to be replaced later with the final value.
    *
-   * @param file The file from which we want the relative path to this file.
-   * @example "./this-file.ts"
+   * @example "_heyapi_31_"
    */
-  relativePathFromFile(file: Pick<ICodegenFile, 'path'>): string;
+  readonly placeholder?: string;
   /**
-   * Returns a relative path to file from this file.
+   * Selector array used to select this symbol. It doesn't have to be
+   * unique, but in practice it might be desirable.
    *
-   * @param file The file to which we want the relative path.
-   * @example "./another-file.ts"
+   * @example ["zod", "#/components/schemas/Foo"]
    */
-  relativePathToFile(file: Pick<ICodegenFile, 'path'>): string;
+  readonly selector?: ISelector;
+}
+
+interface ISymbolOut extends ISymbolIn {
   /**
-   * Top-level symbols declared in this file.
-   **/
-  symbols: ReadonlyArray<ICodegenSymbol>;
+   * Array of file names (without extensions) from which this symbol is re-exported.
+   */
+  readonly exportFrom: ReadonlyArray<string>;
+  /**
+   * Unique symbol ID.
+   */
+  readonly id: number;
+  /**
+   * Placeholder name for the symbol to be replaced later with the final value.
+   *
+   * @example "_heyapi_31_"
+   */
+  readonly placeholder: string;
 }
 
-interface ICodegenImport {
+interface ISymbolRegistry {
   /**
-   * Optional aliasing map for imported symbols.
+   * Get a symbol by its ID.
    *
-   * Keys must be a subset of `names`, values are aliases.
+   * @param symbolIdOrSelector Symbol ID or selector to reference.
+   * @returns The symbol, or undefined if not found.
+   */
+  get(symbolIdOrSelector: number | ISelector): ISymbolOut | undefined;
+  /**
+   * Returns the value associated with a symbol ID.
    *
-   * @example { User: "ImportedUser" }
+   * @param symbolId Symbol ID.
+   * @return The value associated with the symbol ID, or undefined if not found.
    */
-  aliases?: Record<string, string>;
+  getValue(symbolId: number): unknown;
   /**
-   * Name of the default import, if any.
+   * Checks if the registry has a value associated with a symbol ID.
    *
-   * @example "React"
+   * @param symbolId Symbol ID.
+   * @returns True if the registry has a value for symbol ID, false otherwise.
    */
-  defaultImport?: string;
+  hasValue(symbolId: number): boolean;
   /**
-   * Source file or external module from which symbols are imported.
+   * Returns the current symbol ID and increments it.
    *
-   * For internal files, this should be a ICodegenFile instance to enable
-   * dynamic path computation. For external or system modules, use a string.
+   * @returns Symbol ID before being incremented.
+   */
+  readonly id: number;
+  /**
+   * Returns a symbol by ID or selector, registering it if it doesn't exist.
    *
-   * @example "./models/user"
-   * @example "node:path"
+   * @param symbolIdOrSelector Symbol ID or selector to reference.
+   * @returns The referenced or newly registered symbol.
    */
-  from: ICodegenFile | string;
+  reference(symbolIdOrSelector: number | ISelector): ISymbolOut;
   /**
-   * Names of the symbols imported from the source.
+   * Register a symbol globally.
    *
-   * Must be non-empty unless `isNamespaceImport` is true.
-   * All imported names, regardless of whether they are used as types or values.
+   * Deduplicates identical symbols by ID.
    *
-   * @example ["User", "UserDTO"]
+   * @param symbol Symbol to register.
+   * @returns The registered symbol.
    */
-  names?: ReadonlyArray<string>;
+  register(symbol: ISymbolIn): ISymbolOut;
   /**
-   * If this import is a namespace import (e.g. `import * as ns from "..."`),
-   * this should be the namespace alias. Set to `true` if no alias is needed.
+   * Get all symbols in the order they were registered.
    *
-   * @example "utils"
-   * @example true
+   * @returns Array of all registered symbols, in insert order.
    */
-  namespaceImport?: boolean | string;
+  registered(): IterableIterator<ISymbolOut>;
   /**
-   * Whether the default import is type-only.
+   * Sets a value for a symbol by its ID.
    *
-   * @example true
+   * @param symbolId Symbol ID.
+   * @param value The value to set.
+   * @returns void
    */
-  typeDefaultImport?: boolean;
+  setValue(symbolId: number, value: unknown): Map<number, unknown>;
+}
+
+declare const createBinding: ({ file, modulePath, symbol, symbolFile, }: {
+    file: IFileOut;
+    modulePath: string;
+    symbol: ISymbolOut;
+    symbolFile: IFileOut;
+}) => IBinding;
+declare const mergeBindings: (target: IBinding, source: IBinding) => void;
+
+interface IOutput {
   /**
-   * Subset of `names` that are imported using the `type` modifier.
-   * These symbols will be emitted as type-only imports in TypeScript.
+   * The main content of the file to output.
    *
-   * @example ["UserDTO"]
+   * A raw string representing source code.
+   *
+   * @example "function foo(): void {\n  // implementation\n}\n"
    */
-  typeNames?: ReadonlyArray<string>;
+  content: string;
   /**
-   * Whether the namespace import is type-only.
+   * Logical output path (used for writing the file).
    *
-   * @example true
+   * @example "models/user.ts"
    */
-  typeNamespaceImport?: boolean;
+  path: string;
 }
 
-declare class CodegenFile implements ICodegenFile {
-    path: string;
-    meta: ICodegenFile['meta'];
-    private cache;
-    private state;
-    constructor(path: string, meta?: ICodegenFile['meta']);
-    addExport(exp: ICodegenImport): void;
-    addImport(imp: ICodegenImport): void;
-    private addImportExport;
-    addSymbol(symbol: ICodegenSymbol): void;
-    get exports(): ReadonlyArray<ICodegenImport>;
-    getAllSymbols(): ReadonlyArray<ICodegenSymbol>;
-    hasContent(): boolean;
-    hasSymbol(name: string): boolean;
-    get imports(): ReadonlyArray<ICodegenImport>;
-    private mergeImportExportValues;
-    static pathToFilePath(source: string): string;
-    relativePathFromFile(file: Pick<ICodegenFile, 'path'>): string;
-    relativePathToFile(file: Pick<ICodegenFile, 'path'>): string;
-    get symbols(): ReadonlyArray<ICodegenSymbol>;
+declare class FileRegistry implements IFileRegistry {
+    private _id;
+    private referenceOrder;
+    private registerOrder;
+    private selectorToId;
+    private values;
+    get(fileIdOrSelector: number | ISelector): IFileOut | undefined;
+    get id(): number;
+    private idOrSelector;
+    reference(fileIdOrSelector: number | ISelector): IFileOut;
+    referenced(): IterableIterator<IFileOut>;
+    register(file: IFileIn): IFileOut;
+    registered(): IterableIterator<IFileOut>;
 }
 
 /**
  * Represents a code generation project consisting of multiple codegen files.
  * Manages imports, symbols, and output generation across the project.
  */
-interface ICodegenProject {
+interface IProject {
   /**
-   * Adds an export declaration to a specific file, creating the file if it doesn't exist.
+   * The default file to assign symbols without a specific file selector.
    *
-   * @param fileOrPath - File instance or file path where to add the export.
-   * @param imp - The export declaration to add.
-   * @example
-   * project.addExportToFile("models/user.ts", { from: "lib", names: ["User"] });
+   * @default 'main'
    */
-  addExportToFile(fileOrPath: ICodegenFile | string, imp: ICodegenImport): void;
+  readonly defaultFileName?: string;
   /**
-   * Adds an import declaration to a specific file, creating the file if it doesn't exist.
+   * Optional function to transform file names before they are used.
    *
-   * @param fileOrPath - File instance or file path where to add the import.
-   * @param imp - The import declaration to add.
-   * @example
-   * project.addImportToFile("models/user.ts", { from: "lib", names: ["User"] });
+   * @param name The original file name.
+   * @returns The transformed file name.
    */
-  addImportToFile(fileOrPath: ICodegenFile | string, imp: ICodegenImport): void;
+  readonly fileName?: (name: string) => string;
   /**
-   * Adds a symbol to a specific file, creating the file if it doesn't exist.
-   *
-   * @param fileOrPath - File instance or file path where to add the symbol.
-   * @param symbol - The symbol to add.
-   * @example
-   * project.addSymbolToFile("models/user.ts", { name: "User", value: tsNode });
+   * Centralized file registry for the project.
    */
-  addSymbolToFile(
-    fileOrPath: ICodegenFile | string,
-    symbol: ICodegenSymbol,
-  ): void;
+  readonly files: IFileRegistry;
   /**
-   * Creates a new codegen file with optional metadata and adds it to the project.
-   *
-   * If a file with the same path already exists, it is returned instead.
+   * Produces output representations for all files in the project.
    *
-   * @param path - The logical output path for the file (e.g. "models/user.ts").
-   * @param meta - Optional renderer and metadata to attach to the file (e.g. { isInternal: true }).
-   * @returns The newly created file instance.
+   * @param meta Arbitrary metadata.
+   * @returns Array of outputs ready for writing or further processing.
    * @example
-   * const file = project.createFile("models/user.ts", { isInternal: true });
+   * project.render().forEach(output => writeFile(output));
    */
-  createFile(
-    path: string,
-    meta?: ICodegenFile['meta'] & { renderer?: ICodegenRenderer },
-  ): ICodegenFile;
+  render(meta?: IProjectRenderMeta): ReadonlyArray<IOutput>;
   /**
-   * Ensures a codegen file exists and returns it.
-   *
-   * If a file does not exist yet, it is created with minimal information.
-   * Later, it is expected `createFile()` will be called which will fill in
-   * the missing information such as optional metadata.
+   * Map of available renderers by file extension.
    *
-   * @param fileOrPath - The logical output path for the file or the file itself.
-   * @returns The file instance.
    * @example
-   * const file = project.ensureFile("models/user.ts");
+   * {
+   *   ".ts": tsRenderer,
+   *   ".js": jsRenderer,
+   * }
    */
-  ensureFile(fileOrPath: ICodegenFile | string): ICodegenFile;
+  readonly renderers: Record<string, IRenderer>;
   /**
-   * Returns all files in the project in insertion order.
-   *
-   * @example
-   * project.files.forEach(file => console.log(file.path));
+   * The absolute path to the root folder of the project.
    */
-  readonly files: ReadonlyArray<ICodegenFile>;
+  readonly root: string;
   /**
-   * Returns all symbols declared or imported across all files.
+   * Retrieves files that include symbol ID. The first file is the one
+   * where the symbol is declared, the rest are files that re-export it.
    *
-   * @returns Flattened list of all codegen symbols.
+   * @param symbolId The symbol ID to find.
+   * @returns An array of files containing the symbol.
    * @example
-   * project.getAllSymbols().filter(s => s.name === "User");
+   * const files = project.symbolIdToFiles(31);
+   * for (const file of files) {
+   *   console.log(file.path);
+   * }
+   */
+  symbolIdToFiles(symbolId: number): ReadonlyArray<IFileOut>;
+  /**
+   * Centralized symbol registry for the project.
    */
-  getAllSymbols(): ReadonlyArray<ICodegenSymbol>;
+  readonly symbols: ISymbolRegistry;
+}
+
+interface IRenderer {
   /**
-   * Retrieves a file by its logical output path.
+   * Renders content with replaced symbols.
    *
-   * @param path - The file path to find.
-   * @returns The file if found, or undefined otherwise.
-   * @example
-   * const file = project.getFileByPath("models/user.ts");
+   * @param content Content to render.
+   * @param file The file to render.
+   * @param project The parent project the file belongs to.
+   * @returns Rendered content.
    */
-  getFileByPath(path: string): ICodegenFile | undefined;
+  renderFile(
+    content: string,
+    file: IFile,
+    project: IProject,
+    meta?: IProjectRenderMeta,
+  ): string;
   /**
-   * Produces output representations for all files in the project.
+   * Returns printable data containing symbols and exports.
    *
+   * @param file The file to render.
+   * @param project The parent project the file belongs to.
    * @param meta Arbitrary metadata.
-   * @returns Array of outputs ready for writing or further processing.
-   * @example
-   * project.render().forEach(output => writeFile(output));
+   * @returns Printable string containing symbols and exports.
    */
-  render(meta?: ICodegenMeta): ReadonlyArray<ICodegenOutput>;
+  renderSymbols(
+    file: IFileOut,
+    project: IProject,
+    meta?: IProjectRenderMeta,
+  ): string;
 }
 
-declare class CodegenProject implements ICodegenProject {
-    private filesMap;
-    private filesOrder;
-    private renderers;
-    addExportToFile(fileOrPath: CodegenFile | string, imp: ICodegenImport): void;
-    addImportToFile(fileOrPath: CodegenFile | string, imp: ICodegenImport): void;
-    addSymbolToFile(fileOrPath: CodegenFile | string, symbol: ICodegenSymbol): void;
-    createFile(path: string, meta?: Omit<CodegenFile['meta'], 'renderer'> & {
-        /**
-         * Renderer to use to render this file.
-         */
-        renderer?: ICodegenRenderer;
-    }): CodegenFile;
-    ensureFile(fileOrPath: CodegenFile | string): CodegenFile;
-    private ensureRenderer;
-    get files(): ReadonlyArray<CodegenFile>;
-    getAllSymbols(): ReadonlyArray<ICodegenSymbol>;
-    getFileByPath(path: string): CodegenFile | undefined;
-    render(meta?: ICodegenMeta): ReadonlyArray<ICodegenOutput>;
+declare class SymbolRegistry implements ISymbolRegistry {
+    private _id;
+    private nodes;
+    private registerOrder;
+    private selectorToId;
+    private values;
+    get(symbolIdOrSelector: number | ISelector): ISymbolOut | undefined;
+    getValue(symbolId: number): unknown;
+    hasValue(symbolId: number): boolean;
+    get id(): number;
+    private idOrSelector;
+    reference(symbolIdOrSelector: number | ISelector): ISymbolOut;
+    register(symbol: ISymbolIn): ISymbolOut;
+    registered(): IterableIterator<ISymbolOut>;
+    setValue(symbolId: number, value: unknown): Map<number, unknown>;
 }
 
-export { CodegenFile, CodegenProject, type ICodegenFile, type ICodegenImport, type ICodegenMeta, type ICodegenOutput, type ICodegenProject, type ICodegenRenderer, type ICodegenSymbol };
+declare class Project implements IProject {
+    private symbolIdToFileIds;
+    readonly defaultFileName: string;
+    readonly files: FileRegistry;
+    readonly fileName?: (name: string) => string;
+    readonly renderers: Record<string, IRenderer>;
+    readonly root: string;
+    readonly symbols: SymbolRegistry;
+    constructor({ defaultFileName, fileName, renderers, root, }: Pick<IProject, 'defaultFileName' | 'fileName' | 'renderers' | 'root'>);
+    private getRenderer;
+    private prepareFiles;
+    render(meta?: IProjectRenderMeta): ReadonlyArray<IOutput>;
+    symbolIdToFiles(symbolId: number): ReadonlyArray<IFileOut>;
+    private symbolToFileSelector;
+}
+
+/**
+ *
+ * @param source The source string to replace.
+ * @param replacerFn Accepts a symbol ID, returns resolved symbol name.
+ * @returns The replaced source string.
+ */
+declare const renderIds: (source: string, replacerFn: (symbolId: number) => string | undefined) => string;
+
+export { type IBiMap as BiMap, type IBinding as Binding, type IFileOut as File, type IFileIn as FileIn, type IProject, type IOutput as Output, Project, type IProjectRenderMeta as ProjectRenderMeta, type IRenderer as Renderer, type ISelector as Selector, type ISymbolOut as Symbol, type ISymbolIn as SymbolIn, type ISymbolMeta as SymbolMeta, createBinding, mergeBindings, renderIds };