@dbml/core 6.0.0 → 6.2.0-alpha.0

package/lib/parse/ANTLR/ASTGeneration/oraclesql/OracleSQLASTGen.js

@@ -989,13 +989,15 @@ var OracleSqlASTGen = exports["default"] = /*#__PURE__*/function (_OracleSqlPars
     }
 
     // insert_statement
-    //   : INSERT (single_table_insert | <other rules>)
+    //   : INSERT (single_table_insert | multi_table_insert)
     //   ;
   }, {
     key: "visitInsert_statement",
     value: function visitInsert_statement(ctx) {
       if (ctx.single_table_insert()) {
         ctx.single_table_insert().accept(this);
+      } else if (ctx.multi_table_insert()) {
+        ctx.multi_table_insert().accept(this);
       }
     }
 
@@ -1022,18 +1024,97 @@ var OracleSqlASTGen = exports["default"] = /*#__PURE__*/function (_OracleSqlPars
       }
     }
 
+    // multi_table_insert
+    //   : (ALL multi_table_element+ | conditional_insert_clause) select_statement
+    //   ;
+  }, {
+    key: "visitMulti_table_insert",
+    value: function visitMulti_table_insert(ctx) {
+      var _this14 = this;
+      if (!ctx.multi_table_element()) {
+        // conditional_insert_clause is not supported yet
+        return;
+      }
+
+      // Collect all insert elements from INSERT ALL statement
+      var elements = ctx.multi_table_element().map(function (element) {
+        return element.accept(_this14);
+      }).filter(Boolean);
+
+      // Group elements by table, schema, and columns to combine multiple rows into single records
+      var recordsMap = new Map();
+      elements.forEach(function (element) {
+        var tableName = element.tableName,
+          schemaName = element.schemaName,
+          columns = element.columns,
+          values = element.values;
+        var key = "".concat(schemaName || '', ".").concat(tableName, ".").concat(columns.join(','));
+        if (recordsMap.has(key)) {
+          var _recordsMap$get$value;
+          // Same table and columns - append values to existing record
+          (_recordsMap$get$value = recordsMap.get(key).values).push.apply(_recordsMap$get$value, _toConsumableArray(values));
+        } else {
+          // New combination - create new record entry
+          recordsMap.set(key, {
+            tableName: tableName,
+            schemaName: schemaName,
+            columns: columns,
+            values: values
+          });
+        }
+      });
+
+      // Create TableRecord objects for each unique table/column combination
+      recordsMap.forEach(function (recordData) {
+        var record = new _AST.TableRecord({
+          schemaName: recordData.schemaName,
+          tableName: recordData.tableName,
+          columns: recordData.columns,
+          values: recordData.values
+        });
+        _this14.data.records.push(record);
+      });
+    }
+
+    // multi_table_element
+    //   : insert_into_clause values_clause? error_logging_clause?
+    //   ;
+  }, {
+    key: "visitMulti_table_element",
+    value: function visitMulti_table_element(ctx) {
+      var _ctx$values_clause;
+      var intoClause = ctx.insert_into_clause().accept(this);
+      var valuesClause = (_ctx$values_clause = ctx.values_clause()) === null || _ctx$values_clause === void 0 ? void 0 : _ctx$values_clause.accept(this);
+      if (intoClause && valuesClause) {
+        var tableName = intoClause.tableName,
+          schemaName = intoClause.schemaName,
+          columns = intoClause.columns;
+        var values = valuesClause.values;
+        return {
+          tableName: tableName,
+          schemaName: schemaName,
+          columns: columns,
+          values: values
+        };
+      }
+      return null;
+    }
+
     // insert_into_clause
     //   : INTO general_table_ref paren_column_list?
     //   ;
   }, {
     key: "visitInsert_into_clause",
     value: function visitInsert_into_clause(ctx) {
+      var _findTable;
       var names = ctx.general_table_ref().accept(this);
       var tableName = (0, _lodash.last)(names);
       var schemaName = names.length > 1 ? names[names.length - 2] : undefined;
       var columns = ctx.paren_column_list() ? ctx.paren_column_list().accept(this).map(function (c) {
         return (0, _lodash.last)(c);
-      }) : [];
+      }) : (_findTable = findTable(this.data.tables, schemaName, tableName)) === null || _findTable === void 0 ? void 0 : _findTable.fields.map(function (field) {
+        return field.name;
+      });
       return {
         tableName: tableName,
         schemaName: schemaName,
@@ -1078,9 +1159,9 @@ var OracleSqlASTGen = exports["default"] = /*#__PURE__*/function (_OracleSqlPars
   }, {
     key: "visitExpressions_",
     value: function visitExpressions_(ctx) {
-      var _this14 = this;
+      var _this15 = this;
       return ctx.expression().map(function (e) {
-        return e.accept(_this14);
+        return e.accept(_this15);
       });
     }
   }, {

package/lib/parse/ANTLR/ASTGeneration/oraclesql/README.md

@@ -177,13 +177,13 @@ This module provides SQL parsing capabilities for Oracle databases, enabling con
 | Feature | Status | Notes |
 |---------|---------|-------|
 | Basic `INSERT` ... VALUES | ✓ | `INSERT INTO t (col) VALUES (1)` |
-| Multi-row `INSERT` | — | Oracle uses `INSERT ALL` syntax |
+| Multi-row `INSERT` | ✓ | Supported via `INSERT ALL` syntax |
 | `INSERT` ... SELECT | ✗ | Subquery as data source |
 | WITH clause (CTE) | ✗ | CTE before `INSERT` |
 | Target table alias | ✗ | `INSERT INTO t alias ...` |
 | `INSERT` ... RETURNING | ◐ | Returns inserted rows - clause is ignored |
-| `INSERT ALL` (multi-table insert) | ✗ | Oracle-specific multi-table insert |
-| Conditional `INSERT` (WHEN/FIRST/ALL) | ✗ | Oracle syntax for conditional inserts |
+| `INSERT ALL` (multi-table insert) | ✓ | Oracle-specific multi-table insert - fully supported |
+| Conditional `INSERT` (WHEN/FIRST/ALL) | ◐ | Conditional inserts with WHEN clauses not yet supported |
 | `INSERT` OVERWRITE | — | Snowflake/Hive syntax - not valid in Oracle |
 
 ---
@@ -243,7 +243,7 @@ This module provides SQL parsing capabilities for Oracle databases, enabling con
 ## Known Limitations
 
 - **`ON UPDATE` for `FOREIGN KEY`**: Oracle does not support `ON UPDATE` actions for foreign keys; only `ON DELETE` is available
-- **Multi-row `INSERT`**: Oracle uses `INSERT ALL` syntax which is not currently supported
+- **Conditional `INSERT ALL`**: Basic `INSERT ALL` is fully supported, but conditional inserts with WHEN/FIRST clauses are not yet supported
 - **DDL modification statements**: `DROP TABLE`, `DROP INDEX`, `ALTER INDEX` not supported
 - **`INSERT` ... SELECT**: Subqueries in `INSERT` statements not supported
 - **`CREATE VIEW`**: View definitions are not parsed
@@ -257,5 +257,5 @@ This module provides SQL parsing capabilities for Oracle databases, enabling con
 3. **Function-based Indexes**: Oracle's function-based indexes (e.g., `CREATE INDEX ON t (UPPER(col))`) are fully supported
 4. **`ON DELETE` Only**: Oracle foreign keys only support `ON DELETE` actions (`CASCADE`, `SET NULL`, `NO ACTION`). There is no `ON UPDATE` support
 5. **Comments**: Use `COMMENT ON TABLE/COLUMN` statements. These are separate DDL statements, not inline with `CREATE TABLE`
-6. **No Multi-row `INSERT`**: Oracle uses `INSERT ALL ... SELECT` syntax for multi-row inserts, which differs from other databases
+6. **`INSERT ALL` Support**: Oracle's `INSERT ALL ... SELECT * FROM dual` syntax for multi-row and multi-table inserts is fully supported. Rows with the same table and columns are automatically grouped together. Conditional inserts with WHEN clauses are not yet supported
 7. **`VARCHAR2`**: Oracle uses `VARCHAR2` (not `VARCHAR`) as the standard variable-length string type

package/lib/parse/ANTLR/ASTGeneration/postgres/PostgresASTGen.js

@@ -1230,6 +1230,16 @@ var PostgresASTGen = exports["default"] = /*#__PURE__*/function (_PostgreSQLPars
       var _ctx$insert_rest$acce = ctx.insert_rest().accept(this),
         columns = _ctx$insert_rest$acce.columns,
         values = _ctx$insert_rest$acce.values;
+
+      // When no columns are specified, lookup table and use all its columns
+      if (columns.length === 0) {
+        var table = findTable(this.data.tables, schemaName, tableName);
+        if (table && table.fields) {
+          columns = table.fields.map(function (field) {
+            return field.name;
+          });
+        }
+      }
       var record = new _AST.TableRecord({
         schemaName: schemaName,
         tableName: tableName,

package/lib/parse/ANTLR/ASTGeneration/snowflake/SnowflakeASTGen.js

@@ -33,6 +33,7 @@ function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.
 function _getPrototypeOf(t) { return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) { return t.__proto__ || Object.getPrototypeOf(t); }, _getPrototypeOf(t); }
 function _inherits(t, e) { if ("function" != typeof e && null !== e) throw new TypeError("Super expression must either be null or a function"); t.prototype = Object.create(e && e.prototype, { constructor: { value: t, writable: !0, configurable: !0 } }), Object.defineProperty(t, "prototype", { writable: !1 }), e && _setPrototypeOf(t, e); }
 function _setPrototypeOf(t, e) { return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) { return t.__proto__ = e, t; }, _setPrototypeOf(t, e); }
+var DEFAULT_SCHEMA = 'public';
 var sanitizeComment = function sanitizeComment(stringContext) {
   return (0, _helpers.getOriginalText)(stringContext).replace(/''/g, "'").slice(1, -1);
 };
@@ -48,14 +49,25 @@ var SnowflakeASTGen = exports["default"] = /*#__PURE__*/function (_SnowflakePars
       enums: [],
       tableGroups: [],
       aliases: [],
-      project: {}
+      project: {},
+      records: []
     };
     return _this;
   }
-
-  // batch? EOF
   _inherits(SnowflakeASTGen, _SnowflakeParserVisit);
   return _createClass(SnowflakeASTGen, [{
+    key: "findTable",
+    value: function findTable(schemaName, tableName) {
+      var realSchemaName = schemaName || DEFAULT_SCHEMA;
+      var table = this.data.tables.find(function (t) {
+        var targetSchemaName = t.schemaName || DEFAULT_SCHEMA;
+        return targetSchemaName === realSchemaName && t.name === tableName;
+      });
+      return table;
+    }
+
+    // batch? EOF
+  }, {
     key: "visitSnowflake_file",
     value: function visitSnowflake_file(ctx) {
       var _ctx$batch;
@@ -79,6 +91,8 @@ var SnowflakeASTGen = exports["default"] = /*#__PURE__*/function (_SnowflakePars
     value: function visitSql_command(ctx) {
       if (ctx.ddl_command()) {
         ctx.ddl_command().accept(this);
+      } else if (ctx.dml_command()) {
+        ctx.dml_command().accept(this);
       }
     }
 
@@ -93,6 +107,22 @@ var SnowflakeASTGen = exports["default"] = /*#__PURE__*/function (_SnowflakePars
       }
     }
 
+    // dml_command
+    //   : query_statement
+    //   | insert_statement
+    //   | insert_multi_table_statement
+    //   | update_statement
+    //   | delete_statement
+    //   | merge_statement
+    //   ;
+  }, {
+    key: "visitDml_command",
+    value: function visitDml_command(ctx) {
+      if (ctx.insert_statement()) {
+        ctx.insert_statement().accept(this);
+      }
+    }
+
     // check SnowflakeParser.g4 line 1442
   }, {
     key: "visitCreate_command",
@@ -171,7 +201,7 @@ var SnowflakeASTGen = exports["default"] = /*#__PURE__*/function (_SnowflakePars
         var field = fieldData.field,
           inlineRefs = fieldData.inlineRefs;
         if (((_field$type$type_name = field.type.type_name) === null || _field$type$type_name === void 0 ? void 0 : _field$type$type_name.toLowerCase()) === 'enum') {
-          var _values = field.type.args.map(function (arg) {
+          var values = field.type.args.map(function (arg) {
             var newValue = arg.replace(/'|"|`/g, '').trim();
             return {
               name: newValue
@@ -180,7 +210,7 @@ var SnowflakeASTGen = exports["default"] = /*#__PURE__*/function (_SnowflakePars
           var _enum = new _AST.Enum({
             name: "".concat(tableName, "_").concat(field.name, "_enum"),
             schemaName: schemaName,
-            values: _values
+            values: values
           });
           field.type.type_name = _enum.name;
           field.type.schemaName = _enum.schemaName;
@@ -743,5 +773,60 @@ var SnowflakeASTGen = exports["default"] = /*#__PURE__*/function (_SnowflakePars
       }
       return null;
     }
+
+    // insert_statement
+    //   : INSERT OVERWRITE? INTO object_name column_list_in_parentheses? (
+    //       values_builder
+    //       | query_statement
+    //   )
+    //   ;
+  }, {
+    key: "visitInsert_statement",
+    value: function visitInsert_statement(ctx) {
+      var _this$findTable;
+      var _ctx$object_name$acce7 = ctx.object_name().accept(this),
+        _ctx$object_name$acce8 = _slicedToArray(_ctx$object_name$acce7, 3),
+        databaseName = _ctx$object_name$acce8[0],
+        schemaName = _ctx$object_name$acce8[1],
+        tableName = _ctx$object_name$acce8[2];
+      var columns = ctx.column_list_in_parentheses() ? ctx.column_list_in_parentheses().accept(this) : ((_this$findTable = this.findTable(schemaName, tableName)) === null || _this$findTable === void 0 ? void 0 : _this$findTable.fields.map(function (field) {
+        return field.name;
+      })) || [];
+
+      // Only handle values_builder, not query_statement
+      var values = ctx.values_builder() ? ctx.values_builder().accept(this) : [];
+      var record = new _AST.TableRecord({
+        schemaName: schemaName,
+        tableName: tableName,
+        columns: columns,
+        values: values
+      });
+      this.data.records.push(record);
+    }
+
+    // values_builder
+    //   : VALUES '(' expr_list ')' (COMMA '(' expr_list ')')?
+    //   ;
+  }, {
+    key: "visitValues_builder",
+    value: function visitValues_builder(ctx) {
+      var _this0 = this;
+      return ctx.expr_list().map(function (exprList) {
+        var rowValues = exprList.accept(_this0);
+        return (0, _lodash.flattenDepth)(rowValues, 1);
+      });
+    }
+
+    // expr_list
+    //   : expr (COMMA expr)*
+    //   ;
+  }, {
+    key: "visitExpr_list",
+    value: function visitExpr_list(ctx) {
+      var _this1 = this;
+      return ctx.expr().map(function (expr) {
+        return expr.accept(_this1);
+      });
+    }
   }]);
 }(_SnowflakeParserVisitor["default"]);

package/lib/parse/ANTLR/parsers/mysql/MySqlLexerBase.js

@@ -45,7 +45,7 @@ var MySqlLexerBase = exports["default"] = /*#__PURE__*/function (_antlr4$Lexer)
     key: "nextToken",
     value: function nextToken() {
       // See the comment above HIGH_PRIORITY_MODE in the Lexer grammar G4 file
-      this.mode(MySqlLexerBase.DEFAULT_MODE); // always start in DEFAULT_MODE, which will automatically switch to high priority mode
+      this.setMode(MySqlLexerBase.DEFAULT_MODE); // always start in DEFAULT_MODE, which will automatically switch to high priority mode
       return _superPropGet(MySqlLexerBase, "nextToken", this, 3)([]);
     }
   }]);

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package",
   "name": "@dbml/core",
-  "version": "6.0.0",
+  "version": "6.2.0-alpha.0",
   "description": "> TODO: description",
   "author": "Holistics <dev@holistics.io>",
   "license": "Apache-2.0",
@@ -36,7 +36,7 @@
     "lint:fix": "eslint --fix ."
   },
   "dependencies": {
-    "@dbml/parse": "^6.0.0",
+    "@dbml/parse": "^6.2.0-alpha.0",
     "antlr4": "^4.13.1",
     "lodash": "^4.17.15",
     "parsimmon": "^1.13.0",
@@ -63,7 +63,7 @@
     "typescript": "^5.9.3",
     "typescript-eslint": "^8.46.3"
   },
-  "gitHead": "75a218687814d8b1c538b26908745e0d0ee8b35a",
+  "gitHead": "00865dc46e1cbab39233ad010c6b5e120131476c",
   "engines": {
     "node": ">=16"
   }

package/types/export/index.d.ts

@@ -1,4 +1,5 @@
 import { ExportFormatOption } from './ModelExporter';
+import { RecordValueType } from '../model_structure/database';
 
 declare function _export(str: string, format: ExportFormatOption): string;
 declare const _default: {

package/types/index.d.ts

@@ -2,6 +2,72 @@ import ModelExporter from './export/ModelExporter';
 import Parser from './parse/Parser';
 import importer from './import';
 import exporter from './export';
-import { renameTable } from './transform';
-export { renameTable, importer, exporter, ModelExporter, Parser };
+import {
+  renameTable,
+} from './transform';
+export {
+  renameTable,
+  importer,
+  exporter,
+  ModelExporter,
+  Parser,
+};
 export { CompilerDiagnostic, CompilerError as CompilerDiagnostics, EditorPosition, ErrorCode, WarningLevel, } from './parse/error';
+
+// Export normalized types
+export type {
+    NormalizedDatabase,
+    NormalizedDatabaseIdMap,
+    NormalizedModel,
+    NormalizedSchema,
+    NormalizedSchemaIdMap,
+    NormalizedTable,
+    NormalizedTableIdMap,
+    NormalizedField,
+    NormalizedFieldIdMap,
+    NormalizedIndex,
+    NormalizedIndexIdMap,
+    NormalizedIndexColumn,
+    NormalizedIndexColumnIdMap,
+    NormalizedEnum,
+    NormalizedEnumIdMap,
+    NormalizedEnumValue,
+    NormalizedEnumValueIdMap,
+    NormalizedRef,
+    NormalizedRefIdMap,
+    NormalizedEndpoint,
+    NormalizedEndpointIdMap,
+    NormalizedTableGroup,
+    NormalizedTableGroupIdMap,
+    NormalizedNote,
+    NormalizedNoteIdMap,
+    NormalizedCheck,
+    NormalizedCheckIdMap,
+    NormalizedTablePartial,
+    NormalizedTablePartialIdMap,
+    Project,
+    RawDatabase,
+    TableRecord,
+    NormalizedRecords,
+    RawSchema,
+} from './model_structure';
+export { RecordValueType, RecordValue } from './model_structure/database';
+export {
+  SqlDialect,
+  isIntegerType,
+  isFloatType,
+  isNumericType,
+  isBooleanType,
+  isStringType,
+  isBinaryType,
+  isDateTimeType,
+  isSerialType,
+  tryExtractBoolean,
+  tryExtractNumeric,
+  tryExtractInteger,
+  tryExtractString,
+  tryExtractDateTime,
+  tryExtractEnum,
+  addDoubleQuoteIfNeeded,
+  formatRecordValue,
+} from '@dbml/parse';

package/types/model_structure/check.d.ts

@@ -1,4 +1,4 @@
-import { NormalizedDatabase } from './database';
+import { NormalizedModel } from './database';
 import Element, { Token } from './element';
 import Field from './field';
 import Table from './table';
@@ -35,18 +35,20 @@ declare class Check extends Element {
         name: string;
         expression: string;
     };
-    normalize(model: NormalizedDatabase): void;
+    normalize(model: NormalizedModel): void;
 }
 
 export interface NormalizedCheck {
-    [_id: number]: {
-        id: number;
-        name: string;
-        expression: string;
-        tableId: number;
-        columnId: number | null;
-        injectedPartialId: number | null;
-    };
+    id: number;
+    name: string;
+    expression: string;
+    tableId: number;
+    columnId: number | null;
+    injectedPartialId: number | null;
+}
+
+export interface NormalizedCheckIdMap {
+    [_id: number]: NormalizedCheck;
 }
 
 export default Check;

package/types/model_structure/database.d.ts

@@ -1,31 +1,38 @@
-import Schema, { NormalizedSchema, RawSchema } from './schema';
-import Ref, { NormalizedRef } from './ref';
-import Enum, { NormalizedEnum } from './enum';
-import TableGroup, { NormalizedTableGroup } from './tableGroup';
-import Table, { NormalizedTable } from './table';
-import StickyNote, { NormalizedStickyNote } from './stickyNote';
+import Schema, { NormalizedSchemaIdMap, RawSchema } from './schema';
+import Ref, { NormalizedRefIdMap } from './ref';
+import Enum, { NormalizedEnumIdMap } from './enum';
+import TableGroup, { NormalizedTableGroupIdMap } from './tableGroup';
+import Table, { NormalizedTableIdMap } from './table';
+import StickyNote, { NormalizedNoteIdMap } from './stickyNote';
 import Element, { RawNote, Token } from './element';
 import DbState from './dbState';
-import { NormalizedEndpoint } from './endpoint';
-import { NormalizedEnumValue } from './enumValue';
-import { NormalizedField } from './field';
-import { NormalizedIndexColumn } from './indexColumn';
-import { NormalizedIndex } from './indexes';
-import { NormalizedCheck } from './check';
-import TablePartial, { NormalizedTablePartial } from './tablePartial';
+import { NormalizedEndpointIdMap } from './endpoint';
+import { NormalizedEnumValueIdMap } from './enumValue';
+import { NormalizedFieldIdMap } from './field';
+import { NormalizedIndexColumnIdMap } from './indexColumn';
+import { NormalizedIndexIdMap } from './indexes';
+import { NormalizedCheckIdMap } from './check';
+import TablePartial, { NormalizedTablePartialIdMap } from './tablePartial';
 export interface Project {
     note: RawNote;
     database_type: string;
     name: string;
 }
 
-interface RawTableRecord {
+export type RecordValueType = 'string' | 'bool' | 'integer' | 'real' | 'date' | 'time' | 'datetime' | string;
+
+export interface RecordValue {
+    value: any;
+    type: RecordValueType;
+}
+
+export interface RawTableRecord {
     schemaName: string | undefined;
     tableName: string;
     columns: string[];
     values: {
         value: any;
-        type: string;
+        type: RecordValueType;
     }[][];
 }
 
@@ -276,33 +283,36 @@ declare class Database extends Element {
         schemaIds: number[];
         noteIds: number[];
     };
-    normalize(): NormalizedDatabase;
+    normalize(): NormalizedModel;
 }
 export interface NormalizedDatabase {
-    database: {
-        [_id: number]: {
-            id: number;
-            hasDefaultSchema: boolean;
-            note: string;
-            databaseType: string;
-            name: string;
-            schemaIds: number[];
-            noteIds: number[];
-        };
-    };
-    schemas: NormalizedSchema;
-    notes: NormalizedStickyNote;
-    refs: NormalizedRef;
-    enums: NormalizedEnum;
-    tableGroups: NormalizedTableGroup;
-    tables: NormalizedTable;
-    endpoints: NormalizedEndpoint;
-    enumValues: NormalizedEnumValue;
-    indexes: NormalizedIndex;
-    indexColumns: NormalizedIndexColumn;
-    checks: NormalizedCheck;
-    fields: NormalizedField;
-    records: NormalizedRecords;
-    tablePartials: NormalizedTablePartial;
+    id: number;
+    hasDefaultSchema: boolean;
+    note: string | null;
+    databaseType: string;
+    name: string;
+    schemaIds: number[];
+    noteIds: number[];
+}
+
+export interface NormalizedDatabaseIdMap {
+    [_id: number]: NormalizedDatabase;
+}
+
+export interface NormalizedModel {
+    database: NormalizedDatabaseIdMap;
+    schemas: NormalizedSchemaIdMap;
+    endpoints: NormalizedEndpointIdMap;
+    refs: NormalizedRefIdMap;
+    fields: NormalizedFieldIdMap;
+    tables: NormalizedTableIdMap;
+    tableGroups: NormalizedTableGroupIdMap;
+    enums: NormalizedEnumIdMap;
+    enumValues: NormalizedEnumValueIdMap;
+    indexes: NormalizedIndexIdMap;
+    indexColumns: NormalizedIndexColumnIdMap;
+    notes: NormalizedNoteIdMap;
+    checks: NormalizedCheckIdMap;
+    tablePartials: NormalizedTablePartialIdMap;
 }
 export default Database;

package/types/model_structure/endpoint.d.ts

@@ -2,7 +2,17 @@ import Element from './element';
 import Field from './field';
 import Ref from './ref';
 import DbState from './dbState';
-import { NormalizedDatabase } from './database';
+import { NormalizedModel } from './database';
+import { Token } from 'antlr4';
+
+export interface RawEndpoint {
+    schemaName: string | null;
+    tableName: string;
+    fieldNames: string[];
+    relation: '1' | '*';
+    token: Token;
+}
+
 declare class Endpoint extends Element {
     relation: any;
     schemaName: string;
@@ -39,17 +49,20 @@ declare class Endpoint extends Element {
         relation: any;
     };
     setFields(fieldNames: any, table: any): void;
-    normalize(model: NormalizedDatabase): void;
+    normalize(model: NormalizedModel): void;
 }
 export interface NormalizedEndpoint {
-    [_id: number]: {
-        id: number;
-        schemaName: string;
-        tableName: string;
-        fieldNames: string[];
-        relation: any;
-        refId: number;
-        fieldIds: number[];
-    };
+    id: number;
+    schemaName: string | null;
+    tableName: string;
+    fieldNames: string[];
+    fieldIds: number[];
+    relation: string;
+    refId: number;
+}
+
+export interface NormalizedEndpointIdMap {
+    [_id: number]: NormalizedEndpoint;
 }
+
 export default Endpoint;