@dbml/parse 3.6.1 → 3.7.0

package/dist/lib/analyzer/symbol/symbolTable.d.ts

@@ -0,0 +1,12 @@
+import { NodeSymbolIndex } from './symbolIndex';
+import { NodeSymbol } from './symbols';
+
+export default class SymbolTable {
+    private table;
+    constructor();
+    has(id: NodeSymbolIndex): boolean;
+    set(id: NodeSymbolIndex, value: NodeSymbol): void;
+    get(id: NodeSymbolIndex): NodeSymbol | undefined;
+    get(id: NodeSymbolIndex, defaultValue: NodeSymbol): NodeSymbol;
+    entries(): IterableIterator<[NodeSymbolIndex, NodeSymbol]>;
+}

package/dist/lib/analyzer/symbol/symbols.d.ts

@@ -0,0 +1,77 @@
+import { default as SymbolTable } from './symbolTable';
+import { SyntaxNode } from '../../parser/nodes';
+
+export type NodeSymbolId = number;
+export declare class NodeSymbolIdGenerator {
+    private id;
+    reset(): void;
+    nextId(): NodeSymbolId;
+}
+export interface NodeSymbol {
+    id: NodeSymbolId;
+    symbolTable?: SymbolTable;
+    declaration?: SyntaxNode;
+    references: SyntaxNode[];
+}
+export declare class SchemaSymbol implements NodeSymbol {
+    id: NodeSymbolId;
+    symbolTable: SymbolTable;
+    references: SyntaxNode[];
+    constructor({ symbolTable }: {
+        symbolTable: SymbolTable;
+    }, id: NodeSymbolId);
+}
+export declare class EnumSymbol implements NodeSymbol {
+    id: NodeSymbolId;
+    symbolTable: SymbolTable;
+    declaration: SyntaxNode;
+    references: SyntaxNode[];
+    constructor({ symbolTable, declaration }: {
+        symbolTable: SymbolTable;
+        declaration: SyntaxNode;
+    }, id: NodeSymbolId);
+}
+export declare class EnumFieldSymbol implements NodeSymbol {
+    id: NodeSymbolId;
+    declaration: SyntaxNode;
+    references: SyntaxNode[];
+    constructor({ declaration }: {
+        declaration: SyntaxNode;
+    }, id: NodeSymbolId);
+}
+export declare class TableSymbol implements NodeSymbol {
+    id: NodeSymbolId;
+    symbolTable: SymbolTable;
+    declaration: SyntaxNode;
+    references: SyntaxNode[];
+    constructor({ symbolTable, declaration }: {
+        symbolTable: SymbolTable;
+        declaration: SyntaxNode;
+    }, id: NodeSymbolId);
+}
+export declare class ColumnSymbol implements NodeSymbol {
+    id: NodeSymbolId;
+    declaration: SyntaxNode;
+    references: SyntaxNode[];
+    constructor({ declaration }: {
+        declaration: SyntaxNode;
+    }, id: NodeSymbolId);
+}
+export declare class TableGroupSymbol implements NodeSymbol {
+    id: NodeSymbolId;
+    symbolTable: SymbolTable;
+    declaration: SyntaxNode;
+    references: SyntaxNode[];
+    constructor({ symbolTable, declaration }: {
+        symbolTable: SymbolTable;
+        declaration: SyntaxNode;
+    }, id: NodeSymbolId);
+}
+export declare class TableGroupFieldSymbol implements NodeSymbol {
+    id: NodeSymbolId;
+    declaration: SyntaxNode;
+    references: SyntaxNode[];
+    constructor({ declaration }: {
+        declaration: SyntaxNode;
+    }, id: NodeSymbolId);
+}

package/dist/lib/analyzer/symbol/utils.d.ts

@@ -0,0 +1,3 @@
+import { NodeSymbolIndex } from './symbolIndex';
+
+export declare function generatePossibleIndexes(name: string): NodeSymbolIndex[];

package/dist/lib/analyzer/types.d.ts

@@ -0,0 +1,9 @@
+export declare enum ElementKind {
+    Table = "table",
+    Enum = "enum",
+    Ref = "ref",
+    Note = "note",
+    Project = "project",
+    Indexes = "indexes",
+    TableGroup = "tablegroup"
+}

package/dist/lib/analyzer/utils.d.ts

@@ -0,0 +1,38 @@
+import { Option } from '../option';
+import { ElementDeclarationNode, FunctionExpressionNode, InfixExpressionNode, PrimaryExpressionNode, SyntaxNode, VariableNode } from '../parser/nodes';
+import { NodeSymbolIndex } from './symbol/symbolIndex';
+import { NodeSymbol } from './symbol/symbols';
+import { SyntaxToken } from '../lexer/tokens';
+import { ElementKind } from './types';
+
+export declare function getElementKind(node?: ElementDeclarationNode): Option<ElementKind>;
+export declare function destructureMemberAccessExpression(node: SyntaxNode): Option<SyntaxNode[]>;
+export declare function destructureComplexVariable(node?: SyntaxNode): Option<string[]>;
+export declare function destructureComplexTuple(node?: SyntaxNode): Option<{
+    variables: string[];
+    tupleElements?: string[];
+}>;
+export declare function extractVariableFromExpression(node?: SyntaxNode): Option<string>;
+export declare function destructureIndexNode(node: SyntaxNode): Option<{
+    functional: FunctionExpressionNode[];
+    nonFunctional: (PrimaryExpressionNode & {
+        expression: VariableNode;
+    })[];
+}>;
+export declare function extractVarNameFromPrimaryVariable(node?: PrimaryExpressionNode & {
+    expression: VariableNode;
+}): Option<string>;
+export declare function extractQuotedStringToken(value?: SyntaxNode): Option<string>;
+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 findSymbol(id: NodeSymbolIndex, startElement: ElementDeclarationNode): NodeSymbol | undefined;

package/dist/lib/analyzer/validator/elementValidators/custom.d.ts

@@ -0,0 +1,21 @@
+import { CompileError } from '../../../errors';
+import { BlockExpressionNode, ElementDeclarationNode, FunctionApplicationNode } from '../../../parser/nodes';
+import { default as SymbolFactory } from '../../symbol/factory';
+import { SyntaxToken } from '../../../lexer/tokens';
+import { ElementValidator } from '../types';
+import { default as SymbolTable } from '../../../analyzer/symbol/symbolTable';
+
+export default class CustomValidator implements ElementValidator {
+    private declarationNode;
+    private publicSymbolTable;
+    private symbolFactory;
+    constructor(declarationNode: ElementDeclarationNode & {
+        type: SyntaxToken;
+    }, publicSymbolTable: SymbolTable, symbolFactory: SymbolFactory);
+    validate(): CompileError[];
+    private validateContext;
+    private validateName;
+    private validateAlias;
+    private validateSettingList;
+    validateBody(body?: FunctionApplicationNode | BlockExpressionNode): CompileError[];
+}

package/dist/lib/analyzer/validator/elementValidators/enum.d.ts

@@ -0,0 +1,26 @@
+import { default as SymbolFactory } from '../../symbol/factory';
+import { CompileError } from '../../../errors';
+import { BlockExpressionNode, ElementDeclarationNode, FunctionApplicationNode, ListExpressionNode } from '../../../parser/nodes';
+import { SyntaxToken } from '../../../lexer/tokens';
+import { ElementValidator } from '../types';
+import { default as SymbolTable } from '../../../analyzer/symbol/symbolTable';
+
+export default class EnumValidator implements ElementValidator {
+    private declarationNode;
+    private publicSymbolTable;
+    private symbolFactory;
+    constructor(declarationNode: ElementDeclarationNode & {
+        type: SyntaxToken;
+    }, publicSymbolTable: SymbolTable, symbolFactory: SymbolFactory);
+    validate(): CompileError[];
+    private validateContext;
+    private validateName;
+    private validateAlias;
+    registerElement(): CompileError[];
+    private validateSettingList;
+    validateBody(body?: FunctionApplicationNode | BlockExpressionNode): CompileError[];
+    validateFields(fields: FunctionApplicationNode[]): CompileError[];
+    validateFieldSettings(settings: ListExpressionNode): CompileError[];
+    private validateSubElements;
+    registerField(field: FunctionApplicationNode): CompileError[];
+}

package/dist/lib/analyzer/validator/elementValidators/indexes.d.ts

@@ -0,0 +1,25 @@
+import { default as SymbolFactory } from '../../symbol/factory';
+import { CompileError } from '../../../errors';
+import { ElementDeclarationNode, SyntaxNode } from '../../../parser/nodes';
+import { SyntaxToken } from '../../../lexer/tokens';
+import { ElementValidator } from '../types';
+import { default as SymbolTable } from '../../../analyzer/symbol/symbolTable';
+
+export default class IndexesValidator implements ElementValidator {
+    private declarationNode;
+    private publicSymbolTable;
+    private symbolFactory;
+    constructor(declarationNode: ElementDeclarationNode & {
+        type: SyntaxToken;
+    }, publicSymbolTable: SymbolTable, symbolFactory: SymbolFactory);
+    validate(): CompileError[];
+    private validateContext;
+    private validateName;
+    private validateAlias;
+    private validateSettingList;
+    private validateBody;
+    private validateFields;
+    private validateFieldSetting;
+    private validateSubElements;
+}
+export declare function isValidIndexesType(value?: SyntaxNode): boolean;

package/dist/lib/analyzer/validator/elementValidators/note.d.ts

@@ -0,0 +1,23 @@
+import { default as SymbolFactory } from '../../symbol/factory';
+import { CompileError } from '../../../errors';
+import { BlockExpressionNode, ElementDeclarationNode, FunctionApplicationNode } from '../../../parser/nodes';
+import { SyntaxToken } from '../../../lexer/tokens';
+import { ElementValidator } from '../types';
+import { default as SymbolTable } from '../../../analyzer/symbol/symbolTable';
+
+export default class NoteValidator implements ElementValidator {
+    private declarationNode;
+    private publicSymbolTable;
+    private symbolFactory;
+    constructor(declarationNode: ElementDeclarationNode & {
+        type: SyntaxToken;
+    }, publicSymbolTable: SymbolTable, symbolFactory: SymbolFactory);
+    validate(): CompileError[];
+    private validateContext;
+    private validateName;
+    private validateAlias;
+    private validateSettingList;
+    validateBody(body?: FunctionApplicationNode | BlockExpressionNode): CompileError[];
+    validateFields(fields: FunctionApplicationNode[]): CompileError[];
+    private validateSubElements;
+}

package/dist/lib/analyzer/validator/elementValidators/project.d.ts

@@ -0,0 +1,22 @@
+import { default as SymbolFactory } from '../../symbol/factory';
+import { CompileError } from '../../../errors';
+import { BlockExpressionNode, ElementDeclarationNode, FunctionApplicationNode } from '../../../parser/nodes';
+import { SyntaxToken } from '../../../lexer/tokens';
+import { ElementValidator } from '../types';
+import { default as SymbolTable } from '../../../analyzer/symbol/symbolTable';
+
+export default class ProjectValidator implements ElementValidator {
+    private declarationNode;
+    private publicSymbolTable;
+    private symbolFactory;
+    constructor(declarationNode: ElementDeclarationNode & {
+        type: SyntaxToken;
+    }, publicSymbolTable: SymbolTable, symbolFactory: SymbolFactory);
+    validate(): CompileError[];
+    private validateContext;
+    private validateName;
+    private validateAlias;
+    private validateSettingList;
+    validateBody(body?: FunctionApplicationNode | BlockExpressionNode): CompileError[];
+    private validateSubElements;
+}

package/dist/lib/analyzer/validator/elementValidators/ref.d.ts

@@ -0,0 +1,24 @@
+import { SyntaxToken } from '../../../lexer/tokens';
+import { default as SymbolFactory } from '../../symbol/factory';
+import { CompileError } from '../../../errors';
+import { BlockExpressionNode, ElementDeclarationNode, FunctionApplicationNode, ListExpressionNode } from '../../../parser/nodes';
+import { ElementValidator } from '../types';
+import { default as SymbolTable } from '../../../analyzer/symbol/symbolTable';
+
+export default class RefValidator implements ElementValidator {
+    private declarationNode;
+    private publicSymbolTable;
+    private symbolFactory;
+    constructor(declarationNode: ElementDeclarationNode & {
+        type: SyntaxToken;
+    }, publicSymbolTable: SymbolTable, symbolFactory: SymbolFactory);
+    validate(): CompileError[];
+    private validateContext;
+    private validateName;
+    private validateAlias;
+    private validateSettingList;
+    validateBody(body?: FunctionApplicationNode | BlockExpressionNode): CompileError[];
+    validateFields(fields: FunctionApplicationNode[]): CompileError[];
+    validateFieldSettings(settings: ListExpressionNode): CompileError[];
+    private validateSubElements;
+}

package/dist/lib/analyzer/validator/elementValidators/table.d.ts

@@ -0,0 +1,26 @@
+import { default as SymbolFactory } from '../../symbol/factory';
+import { CompileError } from '../../../errors';
+import { BlockExpressionNode, ElementDeclarationNode, ExpressionNode, FunctionApplicationNode } from '../../../parser/nodes';
+import { ElementValidator } from '../types';
+import { SyntaxToken } from '../../../lexer/tokens';
+import { default as SymbolTable } from '../../../analyzer/symbol/symbolTable';
+
+export default class TableValidator implements ElementValidator {
+    private declarationNode;
+    private symbolFactory;
+    private publicSymbolTable;
+    constructor(declarationNode: ElementDeclarationNode & {
+        type: SyntaxToken;
+    }, publicSymbolTable: SymbolTable, symbolFactory: SymbolFactory);
+    validate(): CompileError[];
+    private validateContext;
+    private validateName;
+    private validateAlias;
+    private validateSettingList;
+    registerElement(): CompileError[];
+    validateBody(body?: FunctionApplicationNode | BlockExpressionNode): CompileError[];
+    validateFields(fields: FunctionApplicationNode[]): CompileError[];
+    registerField(field: FunctionApplicationNode): CompileError[];
+    validateFieldSetting(parts: ExpressionNode[]): CompileError[];
+    private validateSubElements;
+}

package/dist/lib/analyzer/validator/elementValidators/tableGroup.d.ts

@@ -0,0 +1,25 @@
+import { CompileError } from '../../../errors';
+import { ElementValidator } from '../types';
+import { default as SymbolTable } from '../../../analyzer/symbol/symbolTable';
+import { SyntaxToken } from '../../../lexer/tokens';
+import { BlockExpressionNode, ElementDeclarationNode, FunctionApplicationNode } from '../../../parser/nodes';
+import { default as SymbolFactory } from '../../../analyzer/symbol/factory';
+
+export default class TableGroupValidator implements ElementValidator {
+    private declarationNode;
+    private publicSymbolTable;
+    private symbolFactory;
+    constructor(declarationNode: ElementDeclarationNode & {
+        type: SyntaxToken;
+    }, publicSymbolTable: SymbolTable, symbolFactory: SymbolFactory);
+    validate(): CompileError[];
+    private validateContext;
+    private validateName;
+    private validateAlias;
+    registerElement(): CompileError[];
+    private validateSettingList;
+    validateBody(body?: FunctionApplicationNode | BlockExpressionNode): CompileError[];
+    validateFields(fields: FunctionApplicationNode[]): CompileError[];
+    private validateSubElements;
+    registerField(field: FunctionApplicationNode): CompileError[];
+}

package/dist/lib/analyzer/validator/utils.d.ts

@@ -0,0 +1,54 @@
+import { SyntaxToken, SyntaxTokenKind } from '../../lexer/tokens';
+import { AttributeNode, BlockExpressionNode, ElementDeclarationNode, ListExpressionNode, LiteralNode, PrefixExpressionNode, PrimaryExpressionNode, SyntaxNode, TupleExpressionNode, VariableNode } from '../../parser/nodes';
+import { default as CustomValidator } from './elementValidators/custom';
+import { default as EnumValidator } from './elementValidators/enum';
+import { default as IndexesValidator } from './elementValidators/indexes';
+import { default as NoteValidator } from './elementValidators/note';
+import { default as ProjectValidator } from './elementValidators/project';
+import { default as RefValidator } from './elementValidators/ref';
+import { default as TableValidator } from './elementValidators/table';
+import { default as TableGroupValidator } from './elementValidators/tableGroup';
+import { default as SymbolTable } from '../symbol/symbolTable';
+import { default as SymbolFactory } from '../symbol/factory';
+import { default as Report } from '../../report';
+import { CompileError } from '../../errors';
+
+export declare function pickValidator(element: ElementDeclarationNode & {
+    type: SyntaxToken;
+}): typeof CustomValidator | typeof EnumValidator | typeof TableValidator | typeof TableGroupValidator | typeof ProjectValidator | typeof RefValidator | typeof NoteValidator | typeof IndexesValidator;
+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 registerSchemaStack(variables: string[], globalSchema: SymbolTable, symbolFactory: SymbolFactory): SymbolTable;
+export declare function isRelationshipOp(op?: string): boolean;
+export declare function isValidColor(value?: SyntaxNode): boolean;
+export declare function isVoid(value?: SyntaxNode): boolean;
+export declare function isValidDefaultValue(value?: SyntaxNode): boolean;
+export declare function isExpressionANumber(value?: SyntaxNode): value is PrimaryExpressionNode & {
+    expression: LiteralNode & {
+        literal: {
+            kind: SyntaxTokenKind.NUMERIC_LITERAL;
+        };
+    };
+};
+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 aggregateSettingList(settingList?: ListExpressionNode): Report<{
+    [index: string]: AttributeNode[];
+}, CompileError>;

package/dist/lib/analyzer/validator/validator.d.ts

@@ -0,0 +1,12 @@
+import { default as Report } from '../../report';
+import { CompileError } from '../../errors';
+import { ProgramNode } from '../../parser/nodes';
+import { default as SymbolFactory } from '../symbol/factory';
+
+export default class Validator {
+    private ast;
+    private publicSchemaSymbol;
+    private symbolFactory;
+    constructor(ast: ProgramNode, symbolFactory: SymbolFactory);
+    validate(): Report<ProgramNode, CompileError>;
+}

package/dist/lib/errors.d.ts

@@ -0,0 +1,92 @@
+import { SyntaxToken } from './lexer/tokens';
+import { SyntaxNode } from './parser/nodes';
+
+export declare enum CompileErrorCode {
+    UNKNOWN_SYMBOL = 1000,
+    UNEXPECTED_SYMBOL = 1001,
+    UNEXPECTED_EOF = 1002,
+    UNEXPECTED_NEWLINE = 1003,
+    UNKNOWN_TOKEN = 1004,
+    UNEXPECTED_TOKEN = 1005,
+    UNEXPECTED_ELEMENT_DECLARATION = 1006,
+    MISSING_SPACES = 1007,
+    UNKNOWN_PREFIX_OP = 1008,
+    INVALID_OPERAND = 1009,
+    EMPTY_ATTRIBUTE_NAME = 1010,
+    INVALID_ESCAPE_SEQUENCE = 1011,
+    INVALID_NAME = 3000,
+    UNEXPECTED_NAME = 3001,
+    NAME_NOT_FOUND = 3002,
+    DUPLICATE_NAME = 3003,
+    INVALID_ALIAS = 3004,
+    UNEXPECTED_ALIAS = 3005,
+    UNEXPECTED_SETTINGS = 3006,
+    INVALID_SETTINGS = 3007,
+    UNEXPECTED_SIMPLE_BODY = 3008,
+    UNEXPECTED_COMPLEX_BODY = 3009,
+    INVALID_TABLE_CONTEXT = 3010,
+    INVALID_TABLE_SETTING = 3011,
+    DUPLICATE_TABLE_SETTING = 3012,
+    INVALID_TABLEGROUP_CONTEXT = 3013,
+    INVALID_TABLEGROUP_ELEMENT_NAME = 3014,
+    DUPLICATE_TABLEGROUP_ELEMENT_NAME = 3015,
+    DUPLICATE_TABLEGROUP_FIELD_NAME = 3016,
+    INVALID_TABLEGROUP_FIELD = 3017,
+    EMPTY_TABLE = 3018,
+    INVALID_COLUMN = 3019,
+    INVALID_COLUMN_NAME = 3020,
+    UNKNOWN_COLUMN_SETTING = 3021,
+    INVALID_COLUMN_TYPE = 3022,
+    DUPLICATE_COLUMN_NAME = 3023,
+    DUPLICATE_COLUMN_SETTING = 3024,
+    INVALID_COLUMN_SETTING_VALUE = 3025,
+    INVALID_ENUM_CONTEXT = 3026,
+    INVALID_ENUM_ELEMENT_NAME = 3027,
+    INVALID_ENUM_ELEMENT = 3028,
+    DUPLICATE_ENUM_ELEMENT_NAME = 3029,
+    UNKNOWN_ENUM_ELEMENT_SETTING = 3030,
+    DUPLICATE_ENUM_ELEMENT_SETTING = 3031,
+    INVALID_ENUM_ELEMENT_SETTING = 3032,
+    EMPTY_ENUM = 3033,
+    INVALID_REF_CONTEXT = 3034,
+    UNKNOWN_REF_SETTING = 3035,
+    DUPLICATE_REF_SETTING = 3036,
+    INVALID_REF_SETTING_VALUE = 3037,
+    INVALID_REF_RELATIONSHIP = 3038,
+    INVALID_REF_FIELD = 3039,
+    EMPTY_REF = 3040,
+    REF_REDEFINED = 3041,
+    INVALID_NOTE_CONTEXT = 3042,
+    INVALID_NOTE = 3043,
+    NOTE_REDEFINED = 3044,
+    NOTE_CONTENT_REDEFINED = 3045,
+    EMPTY_NOTE = 3046,
+    INVALID_INDEXES_CONTEXT = 3047,
+    INVALID_INDEXES_FIELD = 3048,
+    INVALID_INDEX = 3049,
+    UNKNOWN_INDEX_SETTING = 3050,
+    DUPLICATE_INDEX_SETTING = 3051,
+    UNEXPECTED_INDEX_SETTING_VALUE = 3052,
+    INVALID_INDEX_SETTING_VALUE = 3053,
+    INVALID_PROJECT_CONTEXT = 3054,
+    PROJECT_REDEFINED = 3055,
+    INVALID_PROJECT_FIELD = 3056,
+    INVALID_CUSTOM_CONTEXT = 3057,
+    INVALID_CUSTOM_ELEMENT_VALUE = 3058,
+    INVALID_ELEMENT_IN_SIMPLE_BODY = 3059,
+    BINDING_ERROR = 4000,
+    UNSUPPORTED = 5000,
+    CIRCULAR_REF = 5001,
+    SAME_ENDPOINT = 5002,
+    UNEQUAL_FIELDS_BINARY_REF = 5003,
+    CONFLICTING_SETTING = 5004,
+    TABLE_REAPPEAR_IN_TABLEGROUP = 5005
+}
+export declare class CompileError extends Error {
+    code: Readonly<CompileErrorCode>;
+    diagnostic: Readonly<string>;
+    nodeOrToken: Readonly<SyntaxNode | SyntaxToken | readonly (SyntaxNode | SyntaxToken)[]>;
+    start: Readonly<number>;
+    end: Readonly<number>;
+    constructor(code: number, message: string, nodeOrToken: SyntaxNode | SyntaxToken);
+}

package/dist/lib/interpreter/elementInterpreter/enum.d.ts

@@ -0,0 +1,13 @@
+import { CompileError } from '../../errors';
+import { ElementDeclarationNode } from '../../parser/nodes';
+import { ElementInterpreter, InterpreterDatabase } from '../types';
+
+export declare class EnumInterpreter implements ElementInterpreter {
+    private declarationNode;
+    private env;
+    private enum;
+    constructor(declarationNode: ElementDeclarationNode, env: InterpreterDatabase);
+    interpret(): CompileError[];
+    private interpretName;
+    private interpretBody;
+}

package/dist/lib/interpreter/elementInterpreter/project.d.ts

@@ -0,0 +1,13 @@
+import { CompileError } from '../../errors';
+import { ElementDeclarationNode } from '../../parser/nodes';
+import { ElementInterpreter, InterpreterDatabase } from '../types';
+
+export declare class ProjectInterpreter implements ElementInterpreter {
+    private declarationNode;
+    private env;
+    private project;
+    constructor(declarationNode: ElementDeclarationNode, env: InterpreterDatabase);
+    interpret(): CompileError[];
+    private interpretName;
+    private interpretBody;
+}

package/dist/lib/interpreter/elementInterpreter/ref.d.ts

@@ -0,0 +1,15 @@
+import { CompileError } from '../../errors';
+import { ElementDeclarationNode } from '../../parser/nodes';
+import { ElementInterpreter, InterpreterDatabase } from '../types';
+
+export declare class RefInterpreter implements ElementInterpreter {
+    private declarationNode;
+    private env;
+    private container;
+    private ref;
+    constructor(declarationNode: ElementDeclarationNode, env: InterpreterDatabase);
+    interpret(): CompileError[];
+    private interpretName;
+    private interpretBody;
+    private interpretField;
+}

package/dist/lib/interpreter/elementInterpreter/sticky_note.d.ts

@@ -0,0 +1,15 @@
+import { ElementInterpreter, InterpreterDatabase } from '../types';
+import { ElementDeclarationNode } from '../../parser/nodes';
+import { CompileError } from '../../errors';
+
+export declare class StickyNoteInterpreter implements ElementInterpreter {
+    private declarationNode;
+    private env;
+    private note;
+    constructor(declarationNode: ElementDeclarationNode, env: InterpreterDatabase);
+    interpret(): CompileError[];
+    private interpretName;
+    private interpretSettingList;
+    private interpretBody;
+    private interpretNote;
+}

package/dist/lib/interpreter/elementInterpreter/table.d.ts

@@ -0,0 +1,21 @@
+import { ElementInterpreter, InterpreterDatabase } from '../types';
+import { ElementDeclarationNode } from '../../parser/nodes';
+import { CompileError } from '../../errors';
+
+export declare class TableInterpreter implements ElementInterpreter {
+    private declarationNode;
+    private env;
+    private table;
+    private pkColumns;
+    constructor(declarationNode: ElementDeclarationNode, env: InterpreterDatabase);
+    interpret(): CompileError[];
+    private interpretName;
+    private interpretAlias;
+    private interpretSettingList;
+    private interpretBody;
+    private interpretSubElements;
+    private interpretFields;
+    private interpretColumn;
+    private interpretIndexes;
+    private registerInlineRefToEnv;
+}

package/dist/lib/interpreter/elementInterpreter/tableGroup.d.ts

@@ -0,0 +1,13 @@
+import { CompileError } from '../../errors';
+import { ElementDeclarationNode } from '../../parser/nodes';
+import { ElementInterpreter, InterpreterDatabase } from '../types';
+
+export declare class TableGroupInterpreter implements ElementInterpreter {
+    private declarationNode;
+    private env;
+    private tableGroup;
+    constructor(declarationNode: ElementDeclarationNode, env: InterpreterDatabase);
+    interpret(): CompileError[];
+    private interpretName;
+    private interpretBody;
+}

package/dist/lib/interpreter/interpreter.d.ts

@@ -0,0 +1,11 @@
+import { ProgramNode } from '../parser/nodes';
+import { CompileError } from '../errors';
+import { Database, InterpreterDatabase } from './types';
+import { default as Report } from '../report';
+
+export default class Interpreter {
+    ast: ProgramNode;
+    env: InterpreterDatabase;
+    constructor(ast: ProgramNode);
+    interpret(): Report<Database, CompileError>;
+}

package/dist/lib/interpreter/utils.d.ts

@@ -0,0 +1,29 @@
+import { ColumnSymbol } from '../analyzer/symbol/symbols';
+import { LiteralNode, PrimaryExpressionNode, SyntaxNode } from '../parser/nodes';
+import { RelationCardinality, Table, TokenPosition } from './types';
+import { SyntaxTokenKind } from '../lexer/tokens';
+
+export declare function extractNamesFromRefOperand(operand: SyntaxNode, owner?: Table): {
+    schemaName: string | null;
+    tableName: string;
+    fieldNames: string[];
+};
+export declare function getMultiplicities(op: string): [RelationCardinality, RelationCardinality];
+export declare function getTokenPosition(node: SyntaxNode): TokenPosition;
+export declare function getColumnSymbolsOfRefOperand(ref: SyntaxNode): ColumnSymbol[];
+export declare function extractElementName(nameNode: SyntaxNode): {
+    schemaName: string[];
+    name: string;
+};
+export declare function extractColor(node: PrimaryExpressionNode & {
+    expression: LiteralNode;
+} & {
+    literal: {
+        kind: SyntaxTokenKind.COLOR_LITERAL;
+    };
+}): string;
+export declare function getRefId(sym1: ColumnSymbol, sym2: ColumnSymbol): string;
+export declare function getRefId(sym1: ColumnSymbol[], sym2: ColumnSymbol[]): string;
+export declare function isSameEndpoint(sym1: ColumnSymbol, sym2: ColumnSymbol): boolean;
+export declare function isSameEndpoint(sym1: ColumnSymbol[], sym2: ColumnSymbol[]): boolean;
+export declare function normalizeNoteContent(content: string): string;