@dbml/parse 7.1.2 → 8.0.0-alpha.10

package/dist/src/compiler/index.d.ts

@@ -1,72 +1,112 @@
-import { ProgramNode } from '../core/types/nodes';
-import { default as Report } from '../core/types/report';
-import { Database } from '../core/types/schemaJson';
-import { SyntaxToken } from '../core/types/tokens';
+import { Filepath } from '../core/types/filepath';
+import { SyntaxNode, SyntaxNodeIdGenerator } from '../core/types/nodes';
+import { NodeSymbolIdGenerator, SymbolFactory } from '../core/types/symbol';
 import { DBMLCompletionItemProvider, DBMLDefinitionProvider, DBMLDiagnosticsProvider, DBMLReferencesProvider } from '../services/index';
-import { DiagramViewBlock, DiagramViewSyncOperation, TableNameInput, TextEdit } from './queries/transform';
+import { DbmlProjectLayout } from './projectLayout';
+import { DiagramViewBlock, findDiagramViewBlocks } from './queries/transform';
 import { addDoubleQuoteIfNeeded, escapeString, formatRecordValue, isValidIdentifier, splitQualifiedIdentifier, unescapeString } from './queries/utils';
-export { ScopeKind, } from './types';
-export type { TextEdit, TableNameInput, DiagramViewSyncOperation, DiagramViewBlock, };
-export { splitQualifiedIdentifier, unescapeString, escapeString, formatRecordValue, isValidIdentifier, addDoubleQuoteIfNeeded, };
+export { ScopeKind } from './types';
+export type { DiagramViewBlock, TableNameInput, TextEdit } from './queries/transform';
+export { addDoubleQuoteIfNeeded, escapeString, formatRecordValue, isValidIdentifier, splitQualifiedIdentifier, unescapeString, findDiagramViewBlocks, };
 export default class Compiler {
-    private source;
-    private cache;
-    private nodeIdGenerator;
-    private symbolIdGenerator;
-    setSource(source: string): void;
-    private query;
-    private interpret;
-    renameTable(oldName: TableNameInput, newName: TableNameInput): string;
-    syncDiagramView(operations: DiagramViewSyncOperation[], blocks?: DiagramViewBlock[]): {
+    readonly nodeIdGenerator: SyntaxNodeIdGenerator;
+    readonly symbolIdGenerator: NodeSymbolIdGenerator;
+    readonly symbolFactory: SymbolFactory;
+    layout: DbmlProjectLayout;
+    constructor(layout?: DbmlProjectLayout);
+    getSource(filepath: Filepath): string | undefined;
+    private sourceSnapshot;
+    private cleanStaleLocalCache;
+    private entrypointsSnapshot;
+    private cleanStaleGlobalCache;
+    private globalCache;
+    private globalQuery;
+    private localCache;
+    private localQuery;
+    parseFile: (filepath: Filepath) => import('../core/types/report').default<import('./queries/pipeline/parse').FileParseIndex>;
+    parseProject: () => Map<string, import('../core/types/report').default<import('./queries/pipeline/parse').FileParseIndex>>;
+    validateNode: (node: SyntaxNode) => import('../core/types/report').default<typeof import('..').UNHANDLED> | import('../core/types/report').default<void>;
+    validateFile: (filepath: Filepath) => import('../core/types/report').default<void>;
+    nodeFullname: (node: SyntaxNode) => import('../core/types/report').default<typeof import('..').UNHANDLED> | import('../core/types/report').default<string[] | undefined>;
+    nodeAlias: (node: SyntaxNode) => import('../core/types/report').default<typeof import('..').UNHANDLED> | import('../core/types/report').default<string | undefined>;
+    nodeSettings: (node: SyntaxNode) => import('../core/types/report').default<import('../core/utils/validate').Settings> | import('../core/types/report').default<typeof import('..').UNHANDLED>;
+    canonicalName: (filepath: Filepath, symbol: import('../core/types/symbol').NodeSymbol) => import('../core/types/report').default<import('./queries/canonicalName').CanonicalName | undefined>;
+    bindNode: (node: SyntaxNode) => import('../core/types/report').default<typeof import('..').UNHANDLED> | import('../core/types/report').default<void>;
+    bindFile: (filepath: Filepath) => import('../core/types/report').default<void>;
+    bindProject: () => Map<string, import('../core/types/report').default<void>>;
+    interpretSymbol: (symbol: import('../core/types/symbol').NodeSymbol, filepath: Filepath) => import('../core/types/report').default<typeof import('..').UNHANDLED> | import('../core/types/report').default<import('..').SchemaElement | import('..').SchemaElement[] | undefined>;
+    interpretMetadata: (metadata: import('../core/types/symbol').NodeMetadata, filepath: Filepath) => import('../core/types/report').default<typeof import('..').UNHANDLED> | import('../core/types/report').default<import('..').SchemaElement | import('..').SchemaElement[] | undefined>;
+    interpretFile: (filepath: Filepath) => import('../core/types/report').default<Readonly<import('..').Database> | undefined>;
+    interpretProject: () => import('../core/types/report').default<import('..').MasterDatabase>;
+    nodeSymbol: (node: SyntaxNode) => import('../core/types/report').default<import('../core/types/symbol').NodeSymbol> | import('../core/types/report').default<typeof import('..').UNHANDLED>;
+    nodeMetadata: (node: SyntaxNode) => import('../core/types/report').default<typeof import('..').UNHANDLED> | import('../core/types/report').default<import('../core/types/symbol').NodeMetadata>;
+    symbolMembers: (symbol: import('../core/types/symbol').NodeSymbol) => import('../core/types/report').default<typeof import('..').UNHANDLED> | import('../core/types/report').default<import('../core/types/symbol').NodeSymbol[]>;
+    lookupMembers: (symbolOrNode: import('../core/types/symbol').NodeSymbol | SyntaxNode, targetKinds: import('../core/types/symbol').SymbolKind | import('../core/types/symbol').SymbolKind[], targetName: string) => import('../core/types/symbol').NodeSymbol | undefined;
+    nodeReferee: (node: SyntaxNode) => import('../core/types/report').default<typeof import('..').UNHANDLED> | import('../core/types/report').default<import('../core/types/symbol').NodeSymbol | undefined>;
+    resolutionIndex: () => import('./queries/resolutionIndex').ResolutionIndex;
+    symbolReferences: (symbol: import('../core/types/symbol').NodeSymbol) => SyntaxNode[];
+    symbolParent: (symbol: import('../core/types/symbol').NodeSymbol) => import('../core/types/symbol').NodeSymbol[];
+    symbolMetadata: (symbol: import('../core/types/symbol').NodeSymbol) => import('../core/types/symbol').NodeMetadata[];
+    symbolAliases: (symbol: import('../core/types/symbol').NodeSymbol) => import('../core/types/report').default<import('../core/types/symbol').AliasSymbol[]>;
+    symbolUses: (symbol: import('../core/types/symbol').NodeSymbol) => import('../core/types/report').default<import('../core/types/symbol').UseSymbol[]>;
+    fileDependencies: (filepath: Filepath) => Filepath[];
+    reachableFiles: (entry?: Filepath | undefined) => Filepath[];
+    usableMembers: (symbolOrFilepath: Filepath | import('../core/types/symbol').ProgramSymbol | import('../core/types/symbol').SchemaSymbol) => import('../core/types/report').default<{
+        nonSchemaMembers: import('../core/types/symbol').NodeSymbol[];
+        schemaMembers: import('../core/types/symbol').SchemaSymbol[];
+        reuses: {
+            selective: import('../core/types/nodes').UseSpecifierNode[];
+            wildcard: {
+                importPath: Filepath;
+                node: import('../core/types/nodes').WildcardNode;
+            }[];
+        };
+        uses: {
+            selective: import('../core/types/nodes').UseSpecifierNode[];
+            wildcard: {
+                importPath: Filepath;
+                node: import('../core/types/nodes').WildcardNode;
+            }[];
+        };
+    }>;
+    nodeAtPosition: (filepath: Filepath, offset: number) => SyntaxNode | import('..').SyntaxToken | undefined;
+    renameTable: (filepath: Filepath, oldName: import('.').TableNameInput, newName: import('.').TableNameInput) => Map<string, string>;
+    syncDiagramView: (filepath: Filepath, operations: import('..').DiagramViewSyncOperation[], blocks?: DiagramViewBlock[] | undefined) => {
         newDbml: string;
-        edits: TextEdit[];
+        edits: import('.').TextEdit[];
     };
-    findDiagramViewBlocks(): DiagramViewBlock[];
-    applyTextEdits(edits: TextEdit[]): string;
+    findDiagramViewBlocks(filepath: Filepath): DiagramViewBlock[];
     readonly token: {
-        invalidStream: () => readonly SyntaxToken[];
-        flatStream: () => readonly SyntaxToken[];
+        invalidStream: (filepath: Filepath) => readonly import('..').SyntaxToken[];
+        flatStream: (filepath: Filepath) => readonly import('..').SyntaxToken[];
     };
     readonly parse: {
-        source: () => Readonly<string>;
-        _: () => Report<{
-            ast: ProgramNode;
-            tokens: SyntaxToken[];
-            rawDb?: Database;
-        }>;
-        ast: () => Readonly<ProgramNode>;
-        errors: () => readonly Readonly<import('..').CompileError>[];
-        warnings: () => readonly Readonly<import('../core/types').CompileWarning>[];
-        tokens: () => Readonly<SyntaxToken>[];
-        rawDb: () => Readonly<Database> | undefined;
-        publicSymbolTable: () => Readonly<import('../core/types/symbol/symbolTable').default>;
+        source: (filepath: Filepath) => string;
+        ast: (filepath?: Filepath) => Readonly<import('../core/types/nodes').ProgramNode>;
+        errors: (filepath?: Filepath) => readonly Readonly<import('..').CompileError>[];
+        warnings: (filepath?: Filepath) => readonly Readonly<import('../core/types').CompileWarning>[];
+        tokens: (filepath?: Filepath) => readonly Readonly<import('..').SyntaxToken>[];
+        rawDb: (filepath?: Filepath) => Readonly<import('..').Database> | undefined;
+        publicSymbolTable: (filepath?: Filepath) => readonly Readonly<import('../core/types/symbol').NodeSymbol>[] | undefined;
     };
     readonly container: {
-        stack: (offset: number) => readonly Readonly<import('../core/types/nodes').SyntaxNode>[];
-        token: (offset: number) => {
-            token: SyntaxToken;
+        stack: (filepath: Filepath, offset: number) => readonly Readonly<SyntaxNode>[];
+        token: (filepath: Filepath, offset: number) => {
+            token: import('..').SyntaxToken;
             index: number;
         } | {
             token: undefined;
             index: undefined;
         };
-        element: (offset: number) => Readonly<ProgramNode | import('../core/types/nodes').ElementDeclarationNode>;
-        scope: (offset: number) => Readonly<import('../core/types/symbol/symbolTable').default> | undefined;
-        scopeKind: (offset: number) => import('./types').ScopeKind;
+        element: (filepath: Filepath, offset: number) => Readonly<import('../core/types/nodes').ElementDeclarationNode | import('../core/types/nodes').ProgramNode>;
+        scope: (filepath: Filepath, offset: number) => import('../core/types/symbol').NodeSymbol[] | undefined;
+        scopeKind: (filepath: Filepath, offset: number) => import('./types').ScopeKind;
     };
-    readonly symbol: {
-        ofName: (nameStack: string[], owner: ProgramNode | import('../core/types/nodes').ElementDeclarationNode) => {
-            symbol: import('../core/types/symbol/symbols').NodeSymbol;
-            kind: import('../core/types').SymbolKind;
-            name: string;
-        }[];
-        members: (ownerSymbol: import('../core/types/symbol/symbols').NodeSymbol) => {
-            symbol: import('../core/types/symbol/symbols').NodeSymbol;
-            name: string;
-            kind: import('../core/types').SymbolKind;
-        }[];
-    };
-    initMonacoServices(): {
+    initMonacoServices(options?: {
+        autocompletion?: {
+            triggerCharacters?: string[];
+        };
+    }): {
         definitionProvider: DBMLDefinitionProvider;
         referenceProvider: DBMLReferencesProvider;
         autocompletionProvider: DBMLCompletionItemProvider;

package/dist/src/compiler/projectLayout/index.d.ts

@@ -0,0 +1 @@
+export * from './layout';

package/dist/src/compiler/projectLayout/layout.d.ts

@@ -0,0 +1,23 @@
+import { Filepath } from '../../core/types/filepath';
+export interface DbmlProjectLayout {
+    getSource(filePath: Filepath): string | undefined;
+    exists(filePath: Filepath): boolean;
+    isFile(filePath: Filepath): boolean;
+    isDirectory(filePath: Filepath): boolean;
+    listDirectory(dirPath?: Filepath): Filepath[];
+    getEntrypoints(): Filepath[];
+}
+export declare class MemoryProjectLayout implements DbmlProjectLayout {
+    private files;
+    constructor(files?: Map<string, string> | Record<string, string>);
+    setSource(filePath: Filepath, content: string): void;
+    getSource(filePath: Filepath): string | undefined;
+    deleteSource(filePath: Filepath): void;
+    clearSource(): void;
+    exists(filePath: Filepath): boolean;
+    isFile(filePath: Filepath): boolean;
+    isDirectory(filePath: Filepath): boolean;
+    listDirectory(dirPath?: Filepath): Filepath[];
+    getEntrypoints(): Filepath[];
+    clone(): MemoryProjectLayout;
+}

package/dist/src/compiler/queries/canonicalName.d.ts

@@ -0,0 +1,9 @@
+import { default as Report } from '../../core/types/report';
+import { Filepath } from '../../core/types/filepath';
+import { NodeSymbol } from '../../core/types/symbol';
+import { default as Compiler } from '../index';
+export interface CanonicalName {
+    schema: string;
+    name: string;
+}
+export declare function canonicalName(this: Compiler, filepath: Filepath, symbol: NodeSymbol): Report<CanonicalName | undefined>;

package/dist/src/compiler/queries/container/element.d.ts

@@ -1,3 +1,4 @@
+import { Filepath } from '../../../core/types/filepath';
 import { ElementDeclarationNode, ProgramNode } from '../../../core/types/nodes';
 import { default as Compiler } from '../../index';
-export declare function containerElement(this: Compiler, offset: number): Readonly<ElementDeclarationNode | ProgramNode>;
+export declare function containerElement(this: Compiler, filepath: Filepath, offset: number): Readonly<ElementDeclarationNode | ProgramNode>;

package/dist/src/compiler/queries/container/index.d.ts

@@ -1,5 +1,5 @@
-export { containerStack, } from './stack';
-export { containerToken, } from './token';
-export { containerElement, } from './element';
-export { containerScope, } from './scope';
-export { containerScopeKind, } from './scopeKind';
+export { containerStack } from './stack';
+export { containerToken } from './token';
+export { containerElement } from './element';
+export { containerScope } from './scope';
+export { containerScopeKind } from './scopeKind';

package/dist/src/compiler/queries/container/scope.d.ts

@@ -1,3 +1,4 @@
-import { default as SymbolTable } from '../../../core/types/symbol/symbolTable';
+import { Filepath } from '../../../core/types/filepath';
+import { NodeSymbol } from '../../../core/types/symbol';
 import { default as Compiler } from '../../index';
-export declare function containerScope(this: Compiler, offset: number): Readonly<SymbolTable> | undefined;
+export declare function containerScope(this: Compiler, filepath: Filepath, offset: number): NodeSymbol[] | undefined;

package/dist/src/compiler/queries/container/scopeKind.d.ts

@@ -1,3 +1,4 @@
+import { Filepath } from '../../../core/types/filepath';
 import { default as Compiler } from '../../index';
 import { ScopeKind } from '../../types';
-export declare function containerScopeKind(this: Compiler, offset: number): ScopeKind;
+export declare function containerScopeKind(this: Compiler, filepath: Filepath, offset: number): ScopeKind;

package/dist/src/compiler/queries/container/stack.d.ts

@@ -1,3 +1,4 @@
+import { Filepath } from '../../../core/types/filepath';
 import { SyntaxNode } from '../../../core/types/nodes';
 import { default as Compiler } from '../../index';
-export declare function containerStack(this: Compiler, offset: number): readonly Readonly<SyntaxNode>[];
+export declare function containerStack(this: Compiler, filepath: Filepath, offset: number): readonly Readonly<SyntaxNode>[];

package/dist/src/compiler/queries/container/token.d.ts

@@ -1,6 +1,7 @@
+import { Filepath } from '../../../core/types';
 import { SyntaxToken } from '../../../core/types/tokens';
 import { default as Compiler } from '../../index';
-export declare function containerToken(this: Compiler, offset: number): {
+export declare function containerToken(this: Compiler, filepath: Filepath, offset: number): {
     token: SyntaxToken;
     index: number;
 } | {

package/dist/src/compiler/queries/files/fileDependencies.d.ts

@@ -0,0 +1,3 @@
+import { default as Compiler } from '../../index';
+import { Filepath } from '../../../core/types/filepath';
+export declare function fileDependencies(this: Compiler, filepath: Filepath): Filepath[];

package/dist/src/compiler/queries/files/reachableFiles.d.ts

@@ -0,0 +1,4 @@
+import { default as Compiler } from '../../index';
+import { Filepath } from '../../../core/types/filepath';
+export declare function walkDependencies(compiler: Compiler, roots: Filepath[]): Filepath[];
+export declare function reachableFiles(this: Compiler, entry?: Filepath): Filepath[];

package/dist/src/compiler/queries/files/usableMembers.d.ts

@@ -0,0 +1,34 @@
+import { default as Compiler } from '../..';
+import { Filepath } from '../../../core/types/filepath';
+import { ElementDeclarationNode, UseSpecifierNode, WildcardNode } from '../../../core/types/nodes';
+import { default as Report } from '../../../core/types/report';
+import { NodeSymbol, SchemaSymbol, ProgramSymbol } from '../../../core/types/symbol';
+type UsableResult = {
+    nonSchemaMembers: NodeSymbol[];
+    schemaMembers: SchemaSymbol[];
+    reuses: {
+        selective: UseSpecifierNode[];
+        wildcard: {
+            importPath: Filepath;
+            node: WildcardNode;
+        }[];
+    };
+    uses: {
+        selective: UseSpecifierNode[];
+        wildcard: {
+            importPath: Filepath;
+            node: WildcardNode;
+        }[];
+    };
+};
+export declare function usableMembers(this: Compiler, symbolOrFilepath: SchemaSymbol | ProgramSymbol | Filepath): Report<UsableResult>;
+export type SchemaMembership = {
+    kind: 'direct';
+} | {
+    kind: 'child';
+    schemaName: string;
+} | {
+    kind: 'none';
+};
+export declare function schemaMembership(compiler: Compiler, schema: SchemaSymbol, element: ElementDeclarationNode | UseSpecifierNode): SchemaMembership;
+export {};

package/dist/src/compiler/queries/legacy/parse.d.ts

@@ -1,12 +1,13 @@
+import { default as Compiler } from '../..';
+import { Database } from '../../../core/types';
 import { CompileError, CompileWarning } from '../../../core/types/errors';
+import { Filepath } from '../../../core/types/filepath';
 import { ProgramNode } from '../../../core/types/nodes';
-import { Database } from '../../../core/types/schemaJson';
-import { default as SymbolTable } from '../../../core/types/symbol/symbolTable';
+import { NodeSymbol } from '../../../core/types/symbol';
 import { SyntaxToken } from '../../../core/types/tokens';
-import { default as Compiler } from '../../index';
-export declare function ast(this: Compiler): Readonly<ProgramNode>;
-export declare function errors(this: Compiler): readonly Readonly<CompileError>[];
-export declare function warnings(this: Compiler): readonly Readonly<CompileWarning>[];
-export declare function tokens(this: Compiler): Readonly<SyntaxToken>[];
-export declare function rawDb(this: Compiler): Readonly<Database> | undefined;
-export declare function publicSymbolTable(this: Compiler): Readonly<SymbolTable>;
+export declare function ast(this: Compiler, filepath: Filepath): Readonly<ProgramNode>;
+export declare function errors(this: Compiler, filepath: Filepath): readonly Readonly<CompileError>[];
+export declare function warnings(this: Compiler, filepath: Filepath): readonly Readonly<CompileWarning>[];
+export declare function tokens(this: Compiler, filepath: Filepath): readonly Readonly<SyntaxToken>[];
+export declare function rawDb(this: Compiler, filepath: Filepath): Readonly<Database> | undefined;
+export declare function publicSymbolTable(this: Compiler, filepath: Filepath): readonly Readonly<NodeSymbol>[] | undefined;

package/dist/src/compiler/queries/legacy/symbol.d.ts

@@ -1,17 +1,8 @@
 import { ElementDeclarationNode, ProgramNode } from '../../../core/types/nodes';
-import { SymbolKind } from '../../../core/types/symbol';
-import { NodeSymbol } from '../../../core/types/symbol/symbols';
+import { NodeSymbol, SymbolKind } from '../../../core/types/symbol';
 import { default as Compiler } from '../../index';
-export declare function symbolMembers(this: Compiler, ownerSymbol: NodeSymbol): {
-    symbol: NodeSymbol;
-    name: string;
-    kind: SymbolKind;
-}[];
 export declare function symbolOfName(this: Compiler, nameStack: string[], owner: ElementDeclarationNode | ProgramNode): {
     symbol: NodeSymbol;
     kind: SymbolKind;
     name: string;
 }[];
-export declare function symbolOfNameToKey(nameStack: string[], owner: {
-    id: number;
-}): string;

package/dist/src/compiler/queries/legacy/token.d.ts

@@ -1,4 +1,5 @@
+import { Filepath } from '../../../core/types';
 import { SyntaxToken } from '../../../core/types/tokens';
 import { default as Compiler } from '../../index';
-export declare function flatStream(this: Compiler): readonly SyntaxToken[];
-export declare function invalidStream(this: Compiler): readonly SyntaxToken[];
+export declare function flatStream(this: Compiler, filepath: Filepath): readonly SyntaxToken[];
+export declare function invalidStream(this: Compiler, filepath: Filepath): readonly SyntaxToken[];

package/dist/src/compiler/queries/nodeAtPosition.d.ts

@@ -0,0 +1,5 @@
+import { Filepath } from '../../core/types/filepath';
+import { SyntaxNode } from '../../core/types/nodes';
+import { SyntaxToken } from '../../core/types/tokens';
+import { default as Compiler } from '../index';
+export declare function nodeAtPosition(this: Compiler, filepath: Filepath, offset: number): SyntaxNode | SyntaxToken | undefined;

package/dist/src/compiler/queries/pipeline/bind.d.ts

@@ -0,0 +1,5 @@
+import { Filepath } from '../../../core/types/filepath';
+import { default as Report } from '../../../core/types/report';
+import { default as Compiler } from '../../index';
+export declare function bindFile(this: Compiler, filepath: Filepath): Report<void>;
+export declare function bindProject(this: Compiler): Map<string, Report<void>>;

package/dist/src/compiler/queries/pipeline/index.d.ts

@@ -0,0 +1,2 @@
+export { parseFile } from './parse';
+export { interpretFile } from './interpret';

package/dist/src/compiler/queries/pipeline/interpret.d.ts

@@ -0,0 +1,6 @@
+import { default as Compiler } from '../..';
+import { Database, MasterDatabase } from '../../../core/types/schemaJson';
+import { Filepath } from '../../../core/types/filepath';
+import { default as Report } from '../../../core/types/report';
+export declare function interpretFile(this: Compiler, filepath: Filepath): Report<Readonly<Database> | undefined>;
+export declare function interpretProject(this: Compiler): Report<MasterDatabase>;

package/dist/src/compiler/queries/pipeline/parse.d.ts

@@ -0,0 +1,12 @@
+import { Filepath } from '../../../core/types/filepath';
+import { ProgramNode } from '../../../core/types/nodes';
+import { default as Report } from '../../../core/types/report';
+import { SyntaxToken } from '../../../core/types/tokens';
+import { default as Compiler } from '../../index';
+export type FileParseIndex = {
+    readonly path: Readonly<Filepath>;
+    readonly ast: Readonly<ProgramNode>;
+    readonly tokens: readonly Readonly<SyntaxToken>[];
+};
+export declare function parseFile(this: Compiler, filepath: Filepath): Report<FileParseIndex>;
+export declare function parseProject(this: Compiler): Map<string, Report<FileParseIndex>>;

package/dist/src/compiler/queries/pipeline/validate.d.ts

@@ -0,0 +1,4 @@
+import { Filepath } from '../../../core/types/filepath';
+import { default as Report } from '../../../core/types/report';
+import { default as Compiler } from '../../index';
+export declare function validateFile(this: Compiler, filepath: Filepath): Report<void>;

package/dist/src/compiler/queries/resolutionIndex.d.ts

@@ -0,0 +1,13 @@
+import { NodeMetadata } from '../../core/types/symbol/metadata';
+import { SyntaxNode } from '../../core/types/nodes';
+import { InternedNodeSymbol, NodeSymbol } from '../../core/types/symbol';
+import { default as Compiler } from '../index';
+export interface ResolutionIndex {
+    references: Map<InternedNodeSymbol, SyntaxNode[]>;
+    metadata: Map<InternedNodeSymbol, NodeMetadata[]>;
+    parents: Map<InternedNodeSymbol, NodeSymbol[]>;
+}
+export declare function resolutionIndex(this: Compiler): ResolutionIndex;
+export declare function symbolParent(this: Compiler, symbol: NodeSymbol): NodeSymbol[];
+export declare function symbolReferences(this: Compiler, symbol: NodeSymbol): SyntaxNode[];
+export declare function symbolMetadata(this: Compiler, symbol: NodeSymbol): NodeMetadata[];

package/dist/src/compiler/queries/symbol/lookupMembers.d.ts

@@ -0,0 +1,4 @@
+import { SyntaxNode } from '../../../core/types/nodes';
+import { NodeSymbol, SymbolKind } from '../../../core/types/symbol';
+import { default as Compiler } from '../../index';
+export declare function lookupMembers(this: Compiler, symbolOrNode: NodeSymbol | SyntaxNode, targetKinds: SymbolKind | SymbolKind[], targetName: string): NodeSymbol | undefined;

package/dist/src/compiler/queries/symbol/symbolAliases.d.ts

@@ -0,0 +1,4 @@
+import { default as Report } from '../../../core/types/report';
+import { AliasSymbol, NodeSymbol } from '../../../core/types/symbol';
+import { default as Compiler } from '../../index';
+export declare function symbolAliases(this: Compiler, symbol: NodeSymbol): Report<AliasSymbol[]>;

package/dist/src/compiler/queries/symbol/symbolUses.d.ts

@@ -0,0 +1,4 @@
+import { default as Report } from '../../../core/types/report';
+import { NodeSymbol, UseSymbol } from '../../../core/types/symbol';
+import { default as Compiler } from '../../index';
+export declare function symbolUses(this: Compiler, symbol: NodeSymbol): Report<UseSymbol[]>;

package/dist/src/compiler/queries/transform/index.d.ts

@@ -1,4 +1,4 @@
-export { renameTable, } from './renameTable';
-export { applyTextEdits, type TextEdit, } from './applyTextEdits';
-export { type TableNameInput, } from './utils';
+export { renameTable } from './renameTable';
 export { syncDiagramView, findDiagramViewBlocks, type DiagramViewSyncOperation, type DiagramViewBlock, } from './syncDiagramView';
+export { applyTextEdits, type TextEdit } from './applyTextEdits';
+export { type TableNameInput } from './utils';

package/dist/src/compiler/queries/transform/renameTable.d.ts

@@ -1,23 +1,26 @@
+import { Filepath } from '../../../core/types/filepath';
 import { default as Compiler } from '../../index';
 import { TableNameInput } from './utils';
 /**
- * Renames a table in the DBML source code.
+ * Renames a table across every file in the project layout.
  *
- * @param oldName - The current table name as string or object (schema defaults to 'public')
- * @param newName - The new table name as string or object (schema defaults to 'public')
- * @returns The updated DBML source code with the table renamed
+ * Resolution starts in `filepath`'s scope. Two paths:
  *
- * @example
- * // String format
- * compiler.renameTable('users', 'customers');
- * compiler.renameTable('public.users', 'auth.customers');
+ *   1. **Alias rename.** `filepath` introduces a use specifier with an alias
+ *      whose name matches `oldName` (e.g. `use { table users as u }` and
+ *      `oldName === 'u'`). Only `filepath` is rewritten - the alias token is
+ *      replaced and every reference to the alias inside `filepath` is updated.
+ *      The original declaration in another file is left alone.
  *
- * @example
- * // Object format
- * compiler.renameTable({ table: 'users' }, { table: 'customers' });
- * compiler.renameTable(
- *   { schema: 'auth', table: 'users' },
- *   { schema: 'auth', table: 'customers' }
- * );
+ *   2. **Real-declaration rename.** Otherwise the resolved symbol is the real
+ *      table (or a `UseSymbol` that imports the source name without an alias).
+ *      Both the declaring file and every file that imports the table by its
+ *      direct name are rewritten - declaration name, in-scope refs, use
+ *      specifier source-name tokens, and refs that flow through unaliased
+ *      imports.
+ *
+ * Returns a map of absolute file paths to new source content, containing
+ * only the files that were actually changed by the rename. An empty map
+ * indicates a no-op (lookup miss, name collision, or alias rename attempt).
  */
-export declare function renameTable(this: Compiler, oldName: TableNameInput, newName: TableNameInput): string;
+export declare function renameTable(this: Compiler, filepath: Filepath, oldName: TableNameInput, newName: TableNameInput): Map<string, string>;

package/dist/src/compiler/queries/transform/syncDiagramView.d.ts

@@ -1,3 +1,5 @@
+import { Filepath } from '../../../core/types/filepath';
+import { default as Compiler } from '../../index';
 import { TextEdit } from './applyTextEdits';
 export interface DiagramViewSyncOperation {
     operation: 'create' | 'update' | 'delete';
@@ -24,16 +26,27 @@ export interface DiagramViewBlock {
     startIndex: number;
     endIndex: number;
 }
+/**
+ * Returns the start/end byte positions of every DiagramView block in `source`.
+ *
+ * Returns an empty array on any lex or parse error - callers cannot
+ * distinguish "no DiagramView blocks present" from "malformed DBML" based on
+ * the return value alone. If you need to detect malformed input, lex/parse
+ * the source separately and check for errors before calling this function.
+ */
 export declare function findDiagramViewBlocks(source: string): DiagramViewBlock[];
 /**
- * Synchronizes DiagramView blocks in DBML source code.
+ * Synchronizes DiagramView blocks in the DBML source at `filepath`.
  *
- * @param dbml - The original DBML source code
- * @param operations - Array of operations to apply (create, update, delete)
- * @param blocks - Optional pre-parsed blocks from findDiagramViewBlocks. If not provided, parses internally.
- * @returns Object containing the new DBML source code and the text edits applied
+ * @param filepath   The file whose source should be rewritten. Source is
+ *                   read from the compiler's project layout, which makes the
+ *                   query multifile-aware.
+ * @param operations Array of operations to apply (create, update, delete).
+ * @param blocks     Optional pre-parsed blocks from findDiagramViewBlocks. If
+ *                   not provided, parses internally.
+ * @returns Object containing the new DBML source code and the text edits applied.
  */
-export declare function syncDiagramView(dbml: string, operations: DiagramViewSyncOperation[], blocks?: DiagramViewBlock[]): {
+export declare function syncDiagramView(this: Compiler, filepath: Filepath, operations: DiagramViewSyncOperation[], blocks?: DiagramViewBlock[]): {
     newDbml: string;
     edits: TextEdit[];
 };

package/dist/src/compiler/queries/transform/utils.d.ts

@@ -1,5 +1,6 @@
-import { default as SymbolTable } from '../../../core/types/symbol/symbolTable';
-import { TableSymbol } from '../../../core/types/symbol/symbols';
+import { Filepath } from '../../../core/types/filepath';
+import { NodeSymbol } from '../../../core/types/symbol';
+import { default as Compiler } from '../../index';
 export type TableNameInput = string | {
     schema?: string;
     table: string;
@@ -13,9 +14,9 @@ export declare function normalizeTableName(input: TableNameInput): {
     table: string;
 };
 /**
- * Looks up a table symbol from the symbol table.
+ * Looks up a table symbol by matching its full qualified name.
  */
-export declare function lookupTableSymbol(symbolTable: Readonly<SymbolTable>, schema: string, table: string): TableSymbol | null;
+export declare function lookupTableSymbol(compiler: Compiler, filepath: Filepath, schema: string, table: string): NodeSymbol | null;
 /**
  * Removes surrounding double quotes from a string if present.
  */

package/dist/src/compiler/queries/utils.d.ts

@@ -1,3 +1,7 @@
+import { Filepath } from '../../core/types/filepath';
+import { default as Report } from '../../core/types/report';
+import { NodeSymbol } from '../../core/types/symbol';
+import { default as Compiler } from '..';
 /**
  * Checks if an identifier is valid (can be used without quotes in DBML).
  * Valid identifiers must:
@@ -93,3 +97,5 @@ export declare function formatRecordValue(recordValue: {
  * @returns Array of unquoted identifier components
  */
 export declare function splitQualifiedIdentifier(identifier: string): string[];
+export declare function collectTransitiveDependencies(compiler: Compiler, entrypoints: Filepath[]): Filepath[];
+export declare function allVisibleMembers(compiler: Compiler): Report<NodeSymbol[]>;

package/dist/src/constants.d.ts

@@ -2,6 +2,5 @@ import { Filepath } from './core/types/filepath';
 export declare const KEYWORDS_OF_DEFAULT_SETTING: readonly string[];
 export declare const DBML_EXT = ".dbml";
 export declare const NUMERIC_LITERAL_PREFIX: readonly string[];
-export declare const DEFAULT_SCHEMA_NAME = "public";
+export declare const DEFAULT_SCHEMA_NAME: "public";
 export declare const DEFAULT_ENTRY: Filepath;
-export declare const ROOT: Filepath;

package/dist/src/core/global_modules/checks/bind.d.ts

@@ -0,0 +1,9 @@
+import { default as Compiler } from '../../../compiler';
+import { CompileError } from '../../types/errors';
+import { ElementDeclarationNode } from '../../types/nodes';
+export default class ChecksBinder {
+    private compiler;
+    private declarationNode;
+    constructor(compiler: Compiler, declarationNode: ElementDeclarationNode);
+    bind(): CompileError[];
+}

package/dist/src/core/global_modules/checks/index.d.ts

@@ -0,0 +1,2 @@
+import { GlobalModule } from '../types';
+export declare const checksModule: GlobalModule;

package/dist/src/core/global_modules/checks/interpret.d.ts

@@ -0,0 +1,10 @@
+import { default as Compiler } from '../../../compiler/index';
+import { ElementDeclarationNode } from '../../types/nodes';
+import { default as Report } from '../../types/report';
+import { SchemaElement } from '../../types/schemaJson';
+export default class ChecksInterpreter {
+    private compiler;
+    private declarationNode;
+    constructor(compiler: Compiler, declarationNode: ElementDeclarationNode);
+    interpret(): Report<SchemaElement | SchemaElement[] | undefined>;
+}