@dbml/parse 7.1.2 → 8.0.0-alpha.4

package/dist/src/core/types/symbol/symbols.d.ts

@@ -1,122 +1,313 @@
+import { DEFAULT_SCHEMA_NAME } from '../../../constants';
 import { Filepath } from '../filepath';
-import { SyntaxNode } from '../nodes';
-import { SymbolKind } from './symbolIndex';
-import { default as SymbolTable } from './symbolTable';
-export type NodeSymbolId = number;
+import { Internable } from '../internable';
+import { default as Compiler } from '../../../compiler';
+import { TableChecksMetadata, NodeMetadata, IndexesMetadata } from './metadata';
+import { TokenPosition } from '../schemaJson';
+import { Settings } from '../../utils/validate';
+import { ProgramNode, SyntaxNode, UseSpecifierNode, WildcardNode, ElementDeclarationNode } from '../nodes';
+export declare enum SymbolKind {
+    Schema = "Schema",
+    Table = "Table",
+    Column = "Column",
+    TableGroup = "TableGroup",
+    TableGroupField = "TableGroup field",
+    Enum = "Enum",
+    EnumField = "Enum field",
+    StickyNote = "Note",
+    TablePartial = "TablePartial",
+    PartialInjection = "PartialInjection",
+    DiagramView = "DiagramView",
+    DiagramViewTopLevelWildcard = "DiagramView top-level wildcard",
+    DiagramViewTable = "DiagramView table",
+    DiagramViewTableGroup = "DiagramView tablegroup",
+    DiagramViewNote = "DiagramView note",
+    DiagramViewSchema = "DiagramView schema",
+    Program = "Program"
+}
+export declare const ImportKind: {
+    Table: SymbolKind;
+    Enum: SymbolKind;
+    TableGroup: SymbolKind;
+    TablePartial: SymbolKind;
+    Note: SymbolKind;
+    Schema: SymbolKind;
+};
+export type ImportKind = (typeof ImportKind)[keyof typeof ImportKind];
+declare const __nodeSymbolBrand: unique symbol;
+export type NodeSymbolId = number & {
+    readonly [__nodeSymbolBrand]: true;
+};
+declare const __internedNodeSymbolBrand: unique symbol;
+export type InternedNodeSymbol = string & {
+    readonly [__internedNodeSymbolBrand]: true;
+};
 export declare class NodeSymbolIdGenerator {
     private id;
     reset(): void;
     nextId(): NodeSymbolId;
 }
-export declare class NodeSymbol {
+export declare abstract class NodeSymbol implements Internable<InternedNodeSymbol> {
     id: NodeSymbolId;
     kind: SymbolKind;
-    filepath: Filepath;
-    symbolTable?: SymbolTable;
     declaration?: SyntaxNode;
-    references: SyntaxNode[];
-    constructor({ kind, declaration, symbolTable, filepath, }: {
+    filepath: Filepath;
+    name?: string;
+    constructor({ kind, declaration, name, }: {
         kind: SymbolKind;
         declaration?: SyntaxNode;
-        symbolTable?: SymbolTable;
-        filepath?: Filepath;
-    }, id: NodeSymbolId);
-    isKind(kind: SymbolKind): boolean;
+        name?: string;
+    }, id: NodeSymbolId, filepath: Filepath);
+    abstract get canBeImported(): boolean;
+    abstract get originalSymbol(): NodeSymbol;
+    get originalFilepath(): Filepath;
+    intern(): InternedNodeSymbol;
+    isKind(...kinds: SymbolKind[]): boolean;
+    canonicalName(compiler: Compiler, filepath: Filepath): {
+        schema: string;
+        name: string;
+    } | undefined;
+    interpretedName(compiler: Compiler, filepath: Filepath): {
+        schema: string | null;
+        name: string;
+    };
+    settings(compiler: Compiler): Settings | undefined;
+    get token(): TokenPosition | undefined;
+    references(compiler: Compiler): SyntaxNode[];
+    metadata(compiler: Compiler): NodeMetadata[];
+    members(compiler: Compiler): NodeSymbol[];
 }
 export declare class SchemaSymbol extends NodeSymbol {
-    symbolTable: SymbolTable;
-    name?: string;
-    constructor({ symbolTable, name, }: {
-        symbolTable: SymbolTable;
+    kind: SymbolKind.Schema;
+    name: string;
+    parent?: SchemaSymbol;
+    constructor({ name, parent, }: {
         name?: string;
-    }, id: NodeSymbolId);
+        parent?: SchemaSymbol;
+    }, id: NodeSymbolId, filepath: Filepath);
+    get canBeImported(): boolean;
+    get originalSymbol(): NodeSymbol;
+    get qualifiedName(): string[];
+    isPublicSchema(): this is SchemaSymbol & {
+        name: typeof DEFAULT_SCHEMA_NAME;
+    };
+    inNestedSchema(compiler: Compiler, nodeSymbol: NodeSymbol): boolean;
 }
 export declare class EnumSymbol extends NodeSymbol {
-    symbolTable: SymbolTable;
-    declaration: SyntaxNode;
-    constructor({ symbolTable, declaration, }: {
-        symbolTable: SymbolTable;
-        declaration: SyntaxNode;
-    }, id: NodeSymbolId);
+    constructor({ declaration, name, }: {
+        declaration?: SyntaxNode;
+        name?: string;
+    }, id: NodeSymbolId, filepath: Filepath);
+    get canBeImported(): boolean;
+    get originalSymbol(): NodeSymbol;
 }
 export declare class EnumFieldSymbol extends NodeSymbol {
-    declaration: SyntaxNode;
-    constructor({ declaration, }: {
-        declaration: SyntaxNode;
-    }, id: NodeSymbolId);
+    constructor({ declaration, name, }: {
+        declaration?: SyntaxNode;
+        name?: string;
+    }, id: NodeSymbolId, filepath: Filepath);
+    get canBeImported(): boolean;
+    get originalSymbol(): NodeSymbol;
+    note(compiler: Compiler): {
+        value: string;
+        token: TokenPosition;
+    } | undefined;
 }
 export declare class TableSymbol extends NodeSymbol {
-    symbolTable: SymbolTable;
-    declaration: SyntaxNode;
-    constructor({ symbolTable, declaration, }: {
-        symbolTable: SymbolTable;
-        declaration: SyntaxNode;
-    }, id: NodeSymbolId);
+    constructor({ declaration, name, }: {
+        declaration?: SyntaxNode;
+        name?: string;
+    }, id: NodeSymbolId, filepath: Filepath);
+    get canBeImported(): boolean;
+    get originalSymbol(): NodeSymbol;
+    schema(compiler: Compiler): string | null;
+    columns(compiler: Compiler): ColumnSymbol[];
+    mergedColumns(compiler: Compiler): (ColumnSymbol | InjectedColumnSymbol)[];
+    partialInjections(compiler: Compiler): NodeSymbol[];
+    note(compiler: Compiler): {
+        value: string;
+        token: TokenPosition;
+    } | undefined;
+    headercolor(compiler: Compiler): string | undefined;
+    refs(compiler: Compiler): never[];
+    checks(compiler: Compiler): never[];
+    indexes(compiler: Compiler): never[];
+    records(compiler: Compiler): never[];
+    resolvedPartials(compiler: Compiler): NodeSymbol[];
+    mergedIndexes(compiler: Compiler): IndexesMetadata[];
+    mergedChecks(compiler: Compiler): TableChecksMetadata[];
+    mergedHeadercolor(compiler: Compiler): string | undefined;
+    mergedNote(compiler: Compiler): {
+        value: string;
+        token: TokenPosition;
+    } | undefined;
 }
 export declare class ColumnSymbol extends NodeSymbol {
-    declaration: SyntaxNode;
-    constructor({ declaration, }: {
-        declaration: SyntaxNode;
-    }, id: NodeSymbolId);
+    constructor({ declaration, name, }: {
+        declaration?: SyntaxNode;
+        name?: string;
+    }, id: NodeSymbolId, filepath: Filepath);
+    get canBeImported(): boolean;
+    get originalSymbol(): NodeSymbol;
+    pk(compiler: Compiler): boolean;
+    unique(compiler: Compiler): boolean;
+    nullable(compiler: Compiler): boolean | undefined;
+    increment(compiler: Compiler): boolean;
+    default(compiler: Compiler): {
+        type: 'number' | 'string' | 'boolean' | 'expression';
+        value: string | number;
+    } | undefined;
+    type(compiler: Compiler): {
+        name: string;
+        enumSymbol?: EnumSymbol;
+        args?: (string | number)[];
+        schema?: string;
+        array?: (string | number | undefined)[];
+    } | undefined;
+    checks(compiler: Compiler): TableChecksMetadata[];
+    note(compiler: Compiler): {
+        value: string;
+        token: TokenPosition;
+    } | undefined;
 }
 export declare class TableGroupSymbol extends NodeSymbol {
-    symbolTable: SymbolTable;
-    declaration: SyntaxNode;
-    constructor({ symbolTable, declaration, }: {
-        symbolTable: SymbolTable;
-        declaration: SyntaxNode;
-    }, id: NodeSymbolId);
+    constructor({ declaration, name, }: {
+        declaration?: SyntaxNode;
+        name?: string;
+    }, id: NodeSymbolId, filepath: Filepath);
+    get canBeImported(): boolean;
+    get originalSymbol(): NodeSymbol;
+    fields(compiler: Compiler): TableGroupFieldSymbol[];
+    color(compiler: Compiler): string | undefined;
+    note(compiler: Compiler): {
+        value: string;
+        token: TokenPosition;
+    } | undefined;
 }
 export declare class TableGroupFieldSymbol extends NodeSymbol {
-    declaration: SyntaxNode;
-    constructor({ declaration, }: {
-        declaration: SyntaxNode;
-    }, id: NodeSymbolId);
+    constructor({ declaration, name, }: {
+        declaration?: SyntaxNode;
+        name?: string;
+    }, id: NodeSymbolId, filepath: Filepath);
+    get canBeImported(): boolean;
+    get originalSymbol(): NodeSymbol;
+}
+export declare class NoteSymbol extends NodeSymbol {
+    constructor({ declaration, name, }: {
+        declaration?: SyntaxNode;
+        name?: string;
+    }, id: NodeSymbolId, filepath: Filepath);
+    get canBeImported(): boolean;
+    get originalSymbol(): NodeSymbol;
 }
 export declare class TablePartialSymbol extends NodeSymbol {
-    symbolTable: SymbolTable;
-    declaration: SyntaxNode;
-    constructor({ symbolTable, declaration, }: {
-        symbolTable: SymbolTable;
-        declaration: SyntaxNode;
-    }, id: NodeSymbolId);
+    constructor({ declaration, name, }: {
+        declaration?: SyntaxNode;
+        name?: string;
+    }, id: NodeSymbolId, filepath: Filepath);
+    get canBeImported(): boolean;
+    get originalSymbol(): NodeSymbol;
 }
 export declare class PartialInjectionSymbol extends NodeSymbol {
-    symbolTable: SymbolTable;
-    declaration: SyntaxNode;
-    constructor({ symbolTable, declaration, }: {
-        symbolTable: SymbolTable;
-        declaration: SyntaxNode;
-    }, id: NodeSymbolId);
-}
-export declare class TablePartialInjectedColumnSymbol extends NodeSymbol {
-    declaration: SyntaxNode;
-    tablePartialSymbol: TablePartialSymbol;
-    constructor({ declaration, tablePartialSymbol, }: {
-        declaration: SyntaxNode;
-        tablePartialSymbol: TablePartialSymbol;
-    }, id: NodeSymbolId);
+    constructor({ declaration, name, }: {
+        declaration?: SyntaxNode;
+        name?: string;
+    }, id: NodeSymbolId, filepath: Filepath);
+    get canBeImported(): boolean;
+    get originalSymbol(): NodeSymbol;
 }
 export declare class DiagramViewSymbol extends NodeSymbol {
-    symbolTable: SymbolTable;
-    declaration: SyntaxNode;
-    filepath: Filepath;
-    constructor({ symbolTable, declaration, }: {
-        symbolTable: SymbolTable;
-        declaration: SyntaxNode;
-    }, id: NodeSymbolId);
+    constructor({ declaration, name, }: {
+        declaration?: SyntaxNode;
+        name?: string;
+    }, id: NodeSymbolId, filepath: Filepath);
+    get canBeImported(): boolean;
+    get originalSymbol(): NodeSymbol;
 }
-export declare class DiagramViewFieldSymbol extends NodeSymbol {
-    declaration: SyntaxNode;
-    filepath: Filepath;
-    constructor({ declaration, }: {
-        declaration: SyntaxNode;
-    }, id: NodeSymbolId);
+export declare class DiagramViewTopLevelWildcardSymbol extends NodeSymbol {
+    constructor({ declaration, name, }: {
+        declaration?: SyntaxNode;
+        name?: string;
+    }, id: NodeSymbolId, filepath: Filepath);
+    get canBeImported(): boolean;
+    get originalSymbol(): NodeSymbol;
 }
-export declare class StickyNoteSymbol extends NodeSymbol {
-    declaration: SyntaxNode;
-    filepath: Filepath;
-    constructor({ declaration, }: {
+export declare class DiagramViewTableSymbol extends NodeSymbol {
+    constructor({ declaration, name, }: {
+        declaration?: SyntaxNode;
+        name?: string;
+    }, id: NodeSymbolId, filepath: Filepath);
+    get canBeImported(): boolean;
+    get originalSymbol(): NodeSymbol;
+}
+export declare class DiagramViewTableGroupSymbol extends NodeSymbol {
+    constructor({ declaration, name, }: {
+        declaration?: SyntaxNode;
+        name?: string;
+    }, id: NodeSymbolId, filepath: Filepath);
+    get canBeImported(): boolean;
+    get originalSymbol(): NodeSymbol;
+}
+export declare class DiagramViewNoteSymbol extends NodeSymbol {
+    constructor({ declaration, name, }: {
+        declaration?: SyntaxNode;
+        name?: string;
+    }, id: NodeSymbolId, filepath: Filepath);
+    get canBeImported(): boolean;
+    get originalSymbol(): NodeSymbol;
+}
+export declare class DiagramViewSchemaSymbol extends NodeSymbol {
+    constructor({ declaration, name, }: {
+        declaration?: SyntaxNode;
+        name?: string;
+    }, id: NodeSymbolId, filepath: Filepath);
+    get canBeImported(): boolean;
+    get originalSymbol(): NodeSymbol;
+}
+export declare class ProgramSymbol extends NodeSymbol {
+    declaration: ProgramNode;
+    constructor({ declaration, name, }: {
+        declaration?: SyntaxNode;
+        name?: string;
+    }, id: NodeSymbolId, filepath: Filepath);
+    get canBeImported(): boolean;
+    get originalSymbol(): NodeSymbol;
+    inNestedSchema(compiler: Compiler, nodeSymbol: NodeSymbol): boolean;
+}
+export declare class AliasSymbol extends NodeSymbol {
+    declaration: ElementDeclarationNode;
+    name: string;
+    aliasedSymbol: NodeSymbol;
+    constructor({ kind, declaration, aliasedSymbol, name, }: {
+        kind: SymbolKind;
+        declaration?: ElementDeclarationNode;
+        aliasedSymbol: NodeSymbol;
+        name: string;
+    }, id: NodeSymbolId, filepath: Filepath);
+    get canBeImported(): boolean;
+    get originalSymbol(): NodeSymbol;
+}
+export declare class UseSymbol extends NodeSymbol {
+    useSpecifierDeclaration: UseSpecifierNode | WildcardNode | undefined;
+    usedSymbol?: NodeSymbol;
+    constructor({ kind, declaration, useSpecifierDeclaration, usedSymbol, name, }: {
+        kind: SymbolKind;
+        declaration?: SyntaxNode;
+        useSpecifierDeclaration: UseSpecifierNode | WildcardNode | undefined;
+        usedSymbol?: NodeSymbol;
+        name?: string;
+    }, id: NodeSymbolId, filepath: Filepath);
+    get canBeImported(): boolean;
+    get originalSymbol(): NodeSymbol;
+}
+export declare class InjectedColumnSymbol extends ColumnSymbol {
+    name: string;
+    injectionDeclaration: SyntaxNode;
+    constructor({ declaration, name, injectionDeclaration, }: {
+        kind: SymbolKind;
         declaration: SyntaxNode;
-    }, id: NodeSymbolId);
+        injectionDeclaration: SyntaxNode;
+        name: string;
+    }, id: NodeSymbolId, filepath: Filepath);
 }
+export {};

package/dist/src/core/{analyzer/utils.d.ts → utils/expression.d.ts}

@@ -1,7 +1,10 @@
-import { ElementDeclarationNode, FunctionExpressionNode, InfixExpressionNode, PrimaryExpressionNode, SyntaxNode, VariableNode } from '../types/nodes';
-import { NodeSymbolIndex } from '../types/symbol';
-import { NodeSymbol } from '../types/symbol/symbols';
+import { ElementDeclarationNode, FunctionApplicationNode, FunctionExpressionNode, IdentifierStreamNode, PrimaryExpressionNode, SyntaxNode, TupleExpressionNode, VariableNode } from '../types/nodes';
 import { SyntaxToken } from '../types/tokens';
+export declare function extractVariableNode(value?: unknown): SyntaxToken | undefined;
+export declare function extractStringFromIdentifierStream(stream?: IdentifierStreamNode): string | undefined;
+export declare function getElementNameString(element?: SyntaxNode): string | undefined;
+export declare function isTupleEmpty(tuple: TupleExpressionNode): boolean;
+export declare function getBody(node?: ElementDeclarationNode): (FunctionApplicationNode | ElementDeclarationNode)[];
 export declare function destructureMemberAccessExpression(node?: SyntaxNode): SyntaxNode[] | undefined;
 export declare function destructureComplexVariable(node?: SyntaxNode): string[] | undefined;
 export declare function destructureComplexVariableTuple(node?: SyntaxNode): {
@@ -12,31 +15,14 @@ export declare function destructureComplexVariableTuple(node?: SyntaxNode): {
         expression: VariableNode;
     })[];
 } | undefined;
-export declare function extractVariableFromExpression(node?: SyntaxNode): string | undefined;
 export declare function destructureIndexNode(node?: SyntaxNode): {
     functional: FunctionExpressionNode[];
     nonFunctional: (PrimaryExpressionNode & {
         expression: VariableNode;
     })[];
 } | undefined;
-export declare function extractVarNameFromPrimaryVariable(node?: PrimaryExpressionNode & {
-    expression: VariableNode;
-}): string | undefined;
 export declare function extractQuotedStringToken(value?: SyntaxNode): string | undefined;
 export declare function extractNumericLiteral(node?: SyntaxNode): number | null;
-export declare function extractReferee(node?: SyntaxNode): NodeSymbol | undefined;
-export declare function isBinaryRelationship(value?: SyntaxNode): value is InfixExpressionNode;
-export declare function isEqualTupleOperands(value: InfixExpressionNode): value is InfixExpressionNode;
-export declare function isValidIndexName(value?: SyntaxNode): value is (PrimaryExpressionNode & {
-    expression: VariableNode;
-}) | FunctionExpressionNode;
-export declare function extractIndexName(value: (PrimaryExpressionNode & {
-    expression: VariableNode & {
-        variable: SyntaxToken;
-    };
-}) | (FunctionExpressionNode & {
-    value: SyntaxToken;
-})): string;
 export declare function destructureCallExpression(node?: SyntaxNode): {
     variables: (PrimaryExpressionNode & {
         expression: VariableNode;
@@ -45,4 +31,7 @@ export declare function destructureCallExpression(node?: SyntaxNode): {
         expression: VariableNode;
     })[];
 } | undefined;
-export declare function findSymbol(id: NodeSymbolIndex, startElement: ElementDeclarationNode): NodeSymbol | undefined;
+export declare function extractVariableFromExpression(node?: SyntaxNode): string | undefined;
+export declare function extractVarNameFromPrimaryVariable(node?: PrimaryExpressionNode & {
+    expression: VariableNode;
+}): string | undefined;

package/dist/src/core/utils/interpret.d.ts

@@ -0,0 +1,16 @@
+import { default as Compiler } from '../../compiler';
+import { ColumnType, TokenPosition } from '../types/schemaJson';
+import { SyntaxNode } from '../types/nodes';
+import { default as Report } from '../types/report';
+export declare function getTokenPosition(node: SyntaxNode): TokenPosition;
+export declare function normalizeNote(content: string): string;
+export declare function extractElementName(nameNode: SyntaxNode): {
+    schemaName: string[];
+    name: string;
+};
+export declare function extractColor(node: unknown): string | undefined;
+export declare function processDefaultValue(valueNode?: SyntaxNode): {
+    type: 'number' | 'string' | 'boolean' | 'expression';
+    value: string | number;
+} | undefined;
+export declare function processColumnType(compiler: Compiler, typeNode: SyntaxNode): Report<ColumnType>;

package/dist/src/core/utils/numbers.d.ts

@@ -1,3 +1,3 @@
 import { PrefixExpressionNode, PrimaryExpressionNode } from '../types/nodes';
 export declare function getNumberTextFromExpression(node: PrimaryExpressionNode | PrefixExpressionNode): string;
-export declare function parseNumber(node: PrefixExpressionNode | PrimaryExpressionNode): number;
+export declare function extractNumber(node: PrefixExpressionNode | PrimaryExpressionNode): number;

package/dist/src/core/utils/span.d.ts

@@ -1,6 +1,4 @@
-import { SyntaxNode } from '../types/nodes';
+import { ElementDeclarationNode, SyntaxNode } from '../types/nodes';
 import { SyntaxToken } from '../types/tokens';
-export declare function isOffsetWithinFullSpan(offset: number, nodeOrToken: SyntaxNode | SyntaxToken): boolean;
 export declare function isOffsetWithinSpan(offset: number, nodeOrToken: SyntaxNode | SyntaxToken): boolean;
-export declare function returnIfIsOffsetWithinFullSpan(offset: number, node?: SyntaxNode): SyntaxNode | undefined;
-export declare function returnIfIsOffsetWithinFullSpan(offset: number, token?: SyntaxToken): SyntaxToken | undefined;
+export declare function isOffsetWithinElementHeader(offset: number, element: ElementDeclarationNode): boolean;

package/dist/src/core/utils/tokens.d.ts

@@ -0,0 +1,15 @@
+import { SyntaxToken, SyntaxTokenKind } from '../types/tokens';
+export declare function isAsKeyword(token?: SyntaxToken): token is SyntaxToken & {
+    kind: SyntaxTokenKind.IDENTIFIER;
+    value: 'as';
+};
+export declare function isUseKeyword(token?: SyntaxToken): token is SyntaxToken & {
+    kind: SyntaxTokenKind.IDENTIFIER;
+};
+export declare function isFromKeyword(token?: SyntaxToken): token is SyntaxToken & {
+    kind: SyntaxTokenKind.IDENTIFIER;
+};
+export declare function isReuseKeyword(token?: SyntaxToken): token is SyntaxToken & {
+    kind: SyntaxTokenKind.IDENTIFIER;
+};
+export declare function isInvalidToken(token?: SyntaxToken): boolean;

package/dist/src/core/utils/validate.d.ts

@@ -0,0 +1,103 @@
+import { AttributeNode, BlockExpressionNode, ElementDeclarationNode, FunctionApplicationNode, FunctionExpressionNode, InfixExpressionNode, ListExpressionNode, LiteralNode, PrefixExpressionNode, PrimaryExpressionNode, ProgramNode, SyntaxNode, TupleExpressionNode, UseDeclarationNode, UseSpecifierNode, VariableNode, WildcardNode } from '../types/nodes';
+import { default as Report } from '../types/report';
+import { SyntaxToken, SyntaxTokenKind } from '../types/tokens';
+import { ElementKind, SettingName } from '../types/keywords';
+import { ImportKind } from '../types/symbol';
+export declare function isValidName(nameNode: SyntaxNode): boolean;
+export declare function isValidAlias(aliasNode: SyntaxNode): aliasNode is PrimaryExpressionNode & {
+    expression: VariableNode;
+};
+export declare function isSimpleName(nameNode: SyntaxNode): nameNode is PrimaryExpressionNode & {
+    expression: VariableNode;
+};
+export declare function isValidSettingList(settingListNode: SyntaxNode): settingListNode is ListExpressionNode;
+export declare function hasComplexBody(node: ElementDeclarationNode): node is ElementDeclarationNode & {
+    body: BlockExpressionNode;
+    bodyColon: undefined;
+};
+export declare function hasSimpleBody(node: ElementDeclarationNode): node is ElementDeclarationNode & {
+    bodyColon: SyntaxToken;
+};
+export declare function isValidPartialInjection(node?: SyntaxNode): node is PrefixExpressionNode & {
+    op: {
+        value: '~';
+    };
+};
+export declare function isRelationshipOp(op?: string): boolean;
+export declare function isValidColor(value?: SyntaxNode): boolean;
+export declare function isValidDefaultValue(value?: SyntaxNode): boolean;
+export type SignedNumberExpression = (PrimaryExpressionNode & {
+    expression: LiteralNode & {
+        literal: {
+            kind: SyntaxTokenKind.NUMERIC_LITERAL;
+        };
+    };
+}) | (PrefixExpressionNode & {
+    op: '-' | '+';
+    expression: SignedNumberExpression;
+});
+export declare function isExpressionASignedNumberExpression(value?: SyntaxNode): value is SignedNumberExpression;
+export declare function isUnaryRelationship(value?: SyntaxNode): value is PrefixExpressionNode;
+export declare function isTupleOfVariables(value?: SyntaxNode): value is TupleExpressionNode & {
+    elementList: (PrimaryExpressionNode & {
+        expression: VariableNode;
+    })[];
+};
+export declare function isValidColumnType(type: SyntaxNode): boolean;
+export type Settings = Record<SettingName | string, AttributeNode[]>;
+export declare function aggregateSettingList(settingList?: ListExpressionNode): Report<Settings>;
+export declare function isExpressionAQuotedString(value?: unknown): value is PrimaryExpressionNode & ({
+    expression: VariableNode & {
+        variable: SyntaxToken & {
+            kind: SyntaxTokenKind.QUOTED_STRING;
+        };
+    };
+} | {
+    expression: LiteralNode & {
+        literal: SyntaxToken & {
+            kind: SyntaxTokenKind.STRING_LITERAL;
+        };
+    };
+});
+export declare function isExpressionAVariableNode(value?: unknown): value is PrimaryExpressionNode & {
+    expression: VariableNode & {
+        variable: SyntaxToken;
+    };
+};
+export declare function isWildcardExpression(node: SyntaxNode | undefined): boolean;
+export declare function isExpressionAnIdentifierNode(value?: unknown): value is PrimaryExpressionNode & {
+    expression: VariableNode & {
+        variable: {
+            kind: SyntaxTokenKind.IDENTIFIER;
+        };
+    };
+};
+type AccessExpression = InfixExpressionNode & {
+    leftExpression: SyntaxNode;
+    rightExpression: SyntaxNode;
+    op: SyntaxToken & {
+        value: '.';
+    };
+};
+type DotDelimitedIdentifier = PrimaryExpressionNode | (AccessExpression & {
+    rightExpression: AccessExpression | PrimaryExpressionNode;
+});
+export declare function isAccessExpression(node?: SyntaxNode): node is AccessExpression;
+export declare function isDotDelimitedIdentifier(node?: SyntaxNode): node is DotDelimitedIdentifier;
+export declare function isElementNode(node: SyntaxNode | undefined, kind: ElementKind): node is ElementDeclarationNode;
+export declare function isUseDeclaration(node: SyntaxNode): node is UseDeclarationNode;
+export declare function isUseSpecifier(node: SyntaxNode, kind?: ImportKind): node is UseSpecifierNode;
+export declare function isWildcardSpecifier(node: SyntaxNode): node is WildcardNode;
+export declare function isProgramNode(node: SyntaxNode | undefined): node is ProgramNode;
+export declare function isElementFieldNode(node: SyntaxNode | undefined, ...kinds: ElementKind[]): node is FunctionApplicationNode;
+export declare function isInsideElementBody(node: SyntaxNode, kind: ElementKind): boolean;
+export declare function isWithinNthArgOfField(node: SyntaxNode, nth: number): boolean;
+export declare function isInsideSettingList(node: SyntaxNode): boolean;
+export declare function isInsideSettingValue(node: SyntaxNode, settingName: SettingName): boolean;
+export declare function isBinaryRelationship(value?: SyntaxNode): value is InfixExpressionNode;
+export declare function isEqualTupleOperands(value: InfixExpressionNode): boolean;
+export declare function isValidIndexName(value?: SyntaxNode): value is (PrimaryExpressionNode & {
+    expression: VariableNode;
+}) | FunctionExpressionNode;
+export declare function isTerminalAccessFragment(node: SyntaxNode): boolean;
+export {};

package/dist/src/index.d.ts

@@ -1,14 +1,18 @@
 import { default as Compiler } from './compiler/index';
-import * as services from '@/services/index';
-export { ElementKind, } from './core/analyzer/types';
-export * from './core/interpreter/records/utils';
-export { SyntaxNode, ElementDeclarationNode, ProgramNode, SyntaxNodeKind, type SyntaxNodeId, } from './core/types/nodes';
-export { SyntaxToken, SyntaxTokenKind, } from './core/types/tokens';
+export { DEFAULT_ENTRY, } from './constants';
+export { Filepath, } from './core/types/filepath';
+export { UNHANDLED, type Unhandled, } from './core/types/module';
+export { ElementKind, } from './core/types/keywords';
+export { type NodeSymbol, SymbolKind, } from './core/types/symbol';
+export * from './core/global_modules/records/utils';
+export * from './core/types/nodes';
+export { SyntaxToken, SyntaxTokenKind, isTriviaToken, isOp, isOpToken, } from './core/types/tokens';
 export { CompileError, CompileErrorCode, } from './core/types/errors';
 export type { Position, } from './core/types';
 export { ScopeKind, splitQualifiedIdentifier, unescapeString, escapeString, formatRecordValue, isValidIdentifier, addDoubleQuoteIfNeeded, } from './compiler/index';
 export { type Database, type MasterDatabase, type Table, type Note, type Column, type ColumnType, type Index, type Check, type InlineRef, type Ref, type RefEndpointPair, type RefEndpoint, type RelationCardinality, type Enum, type EnumField, type TableGroup, type TableGroupField, type Alias, type AliasKind, type TablePartial, type TablePartialInjection, type RecordValue, type RecordValueType, type TableRecord, type Project, type SchemaElement, type TokenPosition, type ElementRef, type FilterConfig, type DiagramView, } from './core/types/schemaJson';
-export type { DiagramViewSyncOperation, DiagramViewBlock, } from './compiler/queries/transform/syncDiagramView';
-export type { TextEdit, } from './compiler/queries/transform/applyTextEdits';
-export { dbmlMonarchTokensProvider, } from './services/monarch';
-export { Compiler, services, };
+export type { DiagramViewSyncOperation, DiagramViewBlock, TextEdit, } from './compiler/queries/transform';
+export { dbmlLanguageConfig, dbmlMonarchTokensProvider, } from './services/monarch';
+export * from './compiler/projectLayout/layout';
+export { Compiler, };
+export * from './services';