@dbml/parse 7.1.2 → 8.0.0-alpha.10

package/dist/src/core/analyzer/validator/elementValidators/note.d.ts

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

package/dist/src/core/analyzer/validator/elementValidators/project.d.ts

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

package/dist/src/core/analyzer/validator/elementValidators/records.d.ts

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

package/dist/src/core/analyzer/validator/elementValidators/ref.d.ts

@@ -1,26 +0,0 @@
-import { ElementValidator } from '../types';
-import { CompileError, CompileWarning } from '../../../types/errors';
-import { BlockExpressionNode, ElementDeclarationNode, FunctionApplicationNode, ListExpressionNode } from '../../../types/nodes';
-import { default as SymbolFactory } from '../../../types/symbol/factory';
-import { default as SymbolTable } from '../../../types/symbol/symbolTable';
-import { SyntaxToken } from '../../../types/tokens';
-export default class RefValidator implements ElementValidator {
-    private declarationNode;
-    private publicSymbolTable;
-    private symbolFactory;
-    constructor(declarationNode: ElementDeclarationNode & {
-        type: SyntaxToken;
-    }, publicSymbolTable: SymbolTable, symbolFactory: SymbolFactory);
-    validate(): {
-        errors: CompileError[];
-        warnings: CompileWarning[];
-    };
-    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/src/core/analyzer/validator/elementValidators/table.d.ts

@@ -1,28 +0,0 @@
-import { ElementValidator } from '../types';
-import { CompileError, CompileWarning } from '../../../types/errors';
-import { BlockExpressionNode, ElementDeclarationNode, ExpressionNode, FunctionApplicationNode } from '../../../types/nodes';
-import { default as SymbolFactory } from '../../../types/symbol/factory';
-import { default as SymbolTable } from '../../../types/symbol/symbolTable';
-import { SyntaxToken } from '../../../types/tokens';
-export default class TableValidator implements ElementValidator {
-    private declarationNode;
-    private symbolFactory;
-    private publicSymbolTable;
-    constructor(declarationNode: ElementDeclarationNode & {
-        type: SyntaxToken;
-    }, publicSymbolTable: SymbolTable, symbolFactory: SymbolFactory);
-    validate(): {
-        errors: CompileError[];
-        warnings: CompileWarning[];
-    };
-    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/src/core/analyzer/validator/elementValidators/tableGroup.d.ts

@@ -1,27 +0,0 @@
-import { ElementValidator } from '../types';
-import { CompileError, CompileWarning } from '../../../types/errors';
-import { BlockExpressionNode, ElementDeclarationNode, FunctionApplicationNode } from '../../../types/nodes';
-import { default as SymbolFactory } from '../../../types/symbol/factory';
-import { default as SymbolTable } from '../../../types/symbol/symbolTable';
-import { SyntaxToken } from '../../../types/tokens';
-export default class TableGroupValidator implements ElementValidator {
-    private declarationNode;
-    private publicSymbolTable;
-    private symbolFactory;
-    constructor(declarationNode: ElementDeclarationNode & {
-        type: SyntaxToken;
-    }, publicSymbolTable: SymbolTable, symbolFactory: SymbolFactory);
-    validate(): {
-        errors: CompileError[];
-        warnings: CompileWarning[];
-    };
-    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/src/core/analyzer/validator/elementValidators/tablePartial.d.ts

@@ -1,28 +0,0 @@
-import { ElementValidator } from '../types';
-import { CompileError, CompileWarning } from '../../../types/errors';
-import { BlockExpressionNode, ElementDeclarationNode, ExpressionNode, FunctionApplicationNode } from '../../../types/nodes';
-import { default as SymbolFactory } from '../../../types/symbol/factory';
-import { default as SymbolTable } from '../../../types/symbol/symbolTable';
-import { SyntaxToken } from '../../../types/tokens';
-export default class TablePartialValidator implements ElementValidator {
-    private declarationNode;
-    private symbolFactory;
-    private publicSymbolTable;
-    constructor(declarationNode: ElementDeclarationNode & {
-        type: SyntaxToken;
-    }, publicSymbolTable: SymbolTable, symbolFactory: SymbolFactory);
-    validate(): {
-        errors: CompileError[];
-        warnings: CompileWarning[];
-    };
-    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/src/core/analyzer/validator/types.d.ts

@@ -1,7 +0,0 @@
-import { CompileError, CompileWarning } from '../../types/errors';
-export interface ElementValidator {
-    validate(): {
-        errors: CompileError[];
-        warnings: CompileWarning[];
-    };
-}

package/dist/src/core/analyzer/validator/utils.d.ts

@@ -1,65 +0,0 @@
-import { AttributeNode, BlockExpressionNode, ElementDeclarationNode, ListExpressionNode, LiteralNode, PrefixExpressionNode, PrimaryExpressionNode, SyntaxNode, TupleExpressionNode, VariableNode } from '../../types/nodes';
-import { default as Report } from '../../types/report';
-import { default as SymbolFactory } from '../../types/symbol/factory';
-import { default as SymbolTable } from '../../types/symbol/symbolTable';
-import { SyntaxToken, SyntaxTokenKind } from '../../types/tokens';
-import { default as ChecksValidator } from './elementValidators/checks';
-import { default as CustomValidator } from './elementValidators/custom';
-import { default as DiagramViewValidator } from './elementValidators/diagramView';
-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 RecordsValidator } from './elementValidators/records';
-import { default as RefValidator } from './elementValidators/ref';
-import { default as TableValidator } from './elementValidators/table';
-import { default as TableGroupValidator } from './elementValidators/tableGroup';
-import { default as TablePartialValidator } from './elementValidators/tablePartial';
-export declare function pickValidator(element: ElementDeclarationNode & {
-    type: SyntaxToken;
-}): typeof ChecksValidator | typeof EnumValidator | typeof TableValidator | typeof TableGroupValidator | typeof ProjectValidator | typeof RefValidator | typeof NoteValidator | typeof IndexesValidator | typeof TablePartialValidator | typeof RecordsValidator | typeof DiagramViewValidator | typeof CustomValidator;
-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 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 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 declare function aggregateSettingList(settingList?: ListExpressionNode): Report<{
-    [index: string]: AttributeNode[];
-}>;

package/dist/src/core/analyzer/validator/validator.d.ts

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

package/dist/src/core/interpreter/elementInterpreter/diagramView.d.ts

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

package/dist/src/core/interpreter/elementInterpreter/enum.d.ts

@@ -1,12 +0,0 @@
-import { CompileError } from '../../types/errors';
-import { ElementDeclarationNode } from '../../types/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/src/core/interpreter/elementInterpreter/project.d.ts

@@ -1,12 +0,0 @@
-import { CompileError } from '../../types/errors';
-import { ElementDeclarationNode } from '../../types/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/src/core/interpreter/elementInterpreter/ref.d.ts

@@ -1,14 +0,0 @@
-import { CompileError } from '../../types/errors';
-import { ElementDeclarationNode } from '../../types/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/src/core/interpreter/elementInterpreter/sticky_note.d.ts

@@ -1,14 +0,0 @@
-import { CompileError } from '../../types/errors';
-import { ElementDeclarationNode } from '../../types/nodes';
-import { ElementInterpreter, InterpreterDatabase } from '../types';
-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/src/core/interpreter/elementInterpreter/table.d.ts

@@ -1,22 +0,0 @@
-import { CompileError } from '../../types/errors';
-import { ElementDeclarationNode } from '../../types/nodes';
-import { ElementInterpreter, InterpreterDatabase } from '../types';
-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 interpretInjection;
-    private interpretFields;
-    private interpretColumn;
-    private interpretIndexes;
-    private interpretChecks;
-    private registerInlineRefToEnv;
-}

package/dist/src/core/interpreter/elementInterpreter/tableGroup.d.ts

@@ -1,15 +0,0 @@
-import { CompileError } from '../../types/errors';
-import { ElementDeclarationNode } from '../../types/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;
-    private interpretSubElements;
-    private interpretFields;
-    private interpretSettingList;
-}

package/dist/src/core/interpreter/elementInterpreter/tablePartial.d.ts

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

package/dist/src/core/interpreter/interpreter.d.ts

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

package/dist/src/core/interpreter/records/index.d.ts

@@ -1,10 +0,0 @@
-import { ElementDeclarationNode } from '../../types/nodes';
-import { default as Report } from '../../types/report';
-import { InterpreterDatabase } from '../types';
-export declare class RecordsInterpreter {
-    private env;
-    private tableToRecordMap;
-    constructor(env: InterpreterDatabase);
-    interpret(elements: ElementDeclarationNode[]): Report<void>;
-    private validateConstraints;
-}

package/dist/src/core/interpreter/records/utils/constraints/fk.d.ts

@@ -1,3 +0,0 @@
-import { InterpreterDatabase } from '../../../types';
-import { CompileError } from '../../../../types/errors';
-export declare function validateForeignKeys(env: InterpreterDatabase): CompileError[];

package/dist/src/core/interpreter/records/utils/constraints/helper.d.ts

@@ -1,11 +0,0 @@
-import { TableRecordRow } from '../../../types';
-import { CompileError } from '../../../../types/errors';
-import { Column, RecordValue } from '../../../../types/schemaJson';
-export declare function extractKeyValueWithDefault(row: Record<string, RecordValue>, columnNames: string[], columns?: (Column | undefined)[]): string;
-export declare function hasNullWithoutDefaultInKey(row: Record<string, RecordValue>, columnNames: string[], columns?: (Column | undefined)[]): boolean;
-export declare function isAutoIncrementColumn(column: Column): boolean;
-export declare function hasNotNullWithDefault(column: Column): boolean;
-export declare function formatFullColumnName(schemaName: string | null, tableName: string, columnName: string): string;
-export declare function formatFullColumnNames(schemaName: string | null, tableName: string, columnNames: string[]): string;
-export declare function formatValues(row: Record<string, RecordValue>, columnNames: string[]): string;
-export declare function createConstraintErrors(row: TableRecordRow, columnNames: string[], message: string): CompileError[];

package/dist/src/core/interpreter/records/utils/constraints/pk.d.ts

@@ -1,3 +0,0 @@
-import { InterpreterDatabase } from '../../../types';
-import { CompileError } from '../../../../types/errors';
-export declare function validatePrimaryKey(env: InterpreterDatabase): CompileError[];

package/dist/src/core/interpreter/records/utils/constraints/unique.d.ts

@@ -1,3 +0,0 @@
-import { InterpreterDatabase } from '../../../types';
-import { CompileError } from '../../../../types/errors';
-export declare function validateUnique(env: InterpreterDatabase): CompileError[];

package/dist/src/core/interpreter/types.d.ts

@@ -1,47 +0,0 @@
-import { CompileError } from '../types/errors';
-import { ElementDeclarationNode, FunctionApplicationNode, SyntaxNode } from '../types/nodes';
-import { Alias, DiagramView, Enum, FilterConfig, Note, Project, RecordValueType, Ref, Table, TableGroup, TablePartial } from '../types/schemaJson';
-export type { DiagramView, FilterConfig, };
-export interface ElementInterpreter {
-    interpret(): CompileError[];
-}
-export interface InterpreterDatabase {
-    schema: [];
-    tables: Map<ElementDeclarationNode, Table>;
-    notes: Map<ElementDeclarationNode, Note>;
-    refIds: {
-        [refid: string]: SyntaxNode;
-    };
-    ref: Map<SyntaxNode, Ref>;
-    enums: Map<ElementDeclarationNode, Enum>;
-    tableOwnerGroup: {
-        [tableid: string]: ElementDeclarationNode;
-    };
-    tableGroups: Map<ElementDeclarationNode, TableGroup>;
-    tablePartials: Map<ElementDeclarationNode, TablePartial>;
-    aliases: Alias[];
-    project: Map<ElementDeclarationNode, Project>;
-    records: Map<Table, {
-        element: ElementDeclarationNode;
-        rows: TableRecordRow[];
-    }>;
-    recordsElements: ElementDeclarationNode[];
-    cachedMergedTables: Map<Table, Table>;
-    source: string;
-    diagramViews: Map<ElementDeclarationNode, DiagramView>;
-    diagramViewWildcards: Map<DiagramView, Set<string>>;
-    diagramViewExplicitlySet: Map<DiagramView, Set<string>>;
-}
-export interface TableRecordRow {
-    values: Record<string, {
-        value: any;
-        type: RecordValueType;
-        node?: SyntaxNode;
-    }>;
-    node: FunctionApplicationNode;
-    columnNodes: Record<string, SyntaxNode>;
-}
-export interface TableRecordsData {
-    table: Table;
-    rows: TableRecordRow[];
-}

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

@@ -1,37 +0,0 @@
-import { LiteralNode, PrimaryExpressionNode, SyntaxNode } from '../types/nodes';
-import { default as Report } from '../types/report';
-import { ColumnType, Ref, RelationCardinality, Table, TokenPosition } from '../types/schemaJson';
-import { ColumnSymbol } from '../types/symbol/symbols';
-import { SyntaxTokenKind } from '../types/tokens';
-import { InterpreterDatabase } from './types';
-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;
-export declare function processDefaultValue(valueNode?: SyntaxNode): {
-    type: 'string' | 'number' | 'boolean' | 'expression';
-    value: string | number;
-} | undefined;
-export declare function processColumnType(typeNode: SyntaxNode, env: InterpreterDatabase): Report<ColumnType>;
-export declare function mergeTableAndPartials(table: Table, env: InterpreterDatabase): Table;
-export declare function extractInlineRefsFromTablePartials(table: Table, env: InterpreterDatabase): Ref[];

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

@@ -1,33 +0,0 @@
-export type NodeSymbolIndex = string;
-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",
-    DiagramViewField = "DiagramView field"
-}
-export declare function createSchemaSymbolIndex(key: string): NodeSymbolIndex;
-export declare function createTableSymbolIndex(key: string): NodeSymbolIndex;
-export declare function createColumnSymbolIndex(key: string): NodeSymbolIndex;
-export declare function createEnumSymbolIndex(key: string): NodeSymbolIndex;
-export declare function createEnumFieldSymbolIndex(key: string): NodeSymbolIndex;
-export declare function createTableGroupSymbolIndex(key: string): NodeSymbolIndex;
-export declare function createTableGroupFieldSymbolIndex(key: string): NodeSymbolIndex;
-export declare function createStickyNoteSymbolIndex(key: string): NodeSymbolIndex;
-export declare function createTablePartialSymbolIndex(key: string): NodeSymbolIndex;
-export declare function createPartialInjectionSymbolIndex(key: string): NodeSymbolIndex;
-export declare function createDiagramViewSymbolIndex(key: string): NodeSymbolIndex;
-export declare function createDiagramViewFieldSymbolIndex(key: string): NodeSymbolIndex;
-export declare function createNodeSymbolIndex(key: string, symbolKind: SymbolKind): NodeSymbolIndex;
-export declare function destructureIndex(id: NodeSymbolIndex): {
-    name: string;
-    kind: SymbolKind;
-} | undefined;
-export declare function isPublicSchemaIndex(id: NodeSymbolIndex): boolean;

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

@@ -1,12 +0,0 @@
-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]>;
-    forEach(callback: (value: NodeSymbol, key: NodeSymbolIndex) => void): void;
-}

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

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

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

@@ -1 +0,0 @@
-export declare function alternateLists<T, S>(firstList: T[], secondList: S[]): (T | S)[];

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

@@ -1 +0,0 @@
-export declare function convertStringToEnum<T extends Record<string, string>>(enumObj: T, value: string): T[keyof T] | undefined;