@zenstackhq/language 3.0.0-alpha.2 → 3.0.0-alpha.20

package/dist/index.js

@@ -8,47 +8,14 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 });
 
 // src/index.ts
-import { URI as URI3 } from "langium";
+import { isAstNode, URI as URI3 } from "langium";
 import { NodeFileSystem } from "langium/node";
-import fs3 from "node:fs";
-import path3 from "node:path";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
-
-// src/constants.ts
-var SUPPORTED_PROVIDERS = [
-  "sqlite",
-  "postgresql"
-];
-var SCALAR_TYPES = [
-  "String",
-  "Int",
-  "Float",
-  "Decimal",
-  "BigInt",
-  "Boolean",
-  "Bytes",
-  "DateTime"
-];
-var STD_LIB_MODULE_NAME = "stdlib.zmodel";
-var PLUGIN_MODULE_NAME = "plugin.zmodel";
-var IssueCodes = /* @__PURE__ */ function(IssueCodes2) {
-  IssueCodes2["MissingOppositeRelation"] = "miss-opposite-relation";
-  return IssueCodes2;
-}({});
-var ExpressionContext = /* @__PURE__ */ function(ExpressionContext2) {
-  ExpressionContext2["DefaultValue"] = "DefaultValue";
-  ExpressionContext2["AccessPolicy"] = "AccessPolicy";
-  ExpressionContext2["ValidationRule"] = "ValidationRule";
-  ExpressionContext2["Index"] = "Index";
-  return ExpressionContext2;
-}({});
-
-// src/module.ts
-import { inject } from "langium";
-import { createDefaultModule, createDefaultSharedModule } from "langium/lsp";
+import fs3 from "fs";
+import path3 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/generated/ast.ts
-import { AbstractAstReflection } from "langium";
+import * as langium from "langium";
 var AbstractDeclaration = "AbstractDeclaration";
 var ConfigExpr = "ConfigExpr";
 var Expression = "Expression";
@@ -64,7 +31,6 @@ __name(isLiteralExpr, "isLiteralExpr");
 var MemberAccessTarget = "MemberAccessTarget";
 var ReferenceTarget = "ReferenceTarget";
 var TypeDeclaration = "TypeDeclaration";
-var TypeDefFieldTypes = "TypeDefFieldTypes";
 var Argument = "Argument";
 var ArrayExpr = "ArrayExpr";
 function isArrayExpr(item) {
@@ -97,6 +63,21 @@ __name(isConfigArrayExpr, "isConfigArrayExpr");
 var ConfigField = "ConfigField";
 var ConfigInvocationArg = "ConfigInvocationArg";
 var ConfigInvocationExpr = "ConfigInvocationExpr";
+var DataField = "DataField";
+function isDataField(item) {
+  return reflection.isInstance(item, DataField);
+}
+__name(isDataField, "isDataField");
+var DataFieldAttribute = "DataFieldAttribute";
+function isDataFieldAttribute(item) {
+  return reflection.isInstance(item, DataFieldAttribute);
+}
+__name(isDataFieldAttribute, "isDataFieldAttribute");
+var DataFieldType = "DataFieldType";
+function isDataFieldType(item) {
+  return reflection.isInstance(item, DataFieldType);
+}
+__name(isDataFieldType, "isDataFieldType");
 var DataModel = "DataModel";
 function isDataModel(item) {
   return reflection.isInstance(item, DataModel);
@@ -107,21 +88,6 @@ function isDataModelAttribute(item) {
   return reflection.isInstance(item, DataModelAttribute);
 }
 __name(isDataModelAttribute, "isDataModelAttribute");
-var DataModelField = "DataModelField";
-function isDataModelField(item) {
-  return reflection.isInstance(item, DataModelField);
-}
-__name(isDataModelField, "isDataModelField");
-var DataModelFieldAttribute = "DataModelFieldAttribute";
-function isDataModelFieldAttribute(item) {
-  return reflection.isInstance(item, DataModelFieldAttribute);
-}
-__name(isDataModelFieldAttribute, "isDataModelFieldAttribute");
-var DataModelFieldType = "DataModelFieldType";
-function isDataModelFieldType(item) {
-  return reflection.isInstance(item, DataModelFieldType);
-}
-__name(isDataModelFieldType, "isDataModelFieldType");
 var DataSource = "DataSource";
 function isDataSource(item) {
   return reflection.isInstance(item, DataSource);
@@ -175,6 +141,10 @@ function isObjectExpr(item) {
 }
 __name(isObjectExpr, "isObjectExpr");
 var Plugin = "Plugin";
+function isPlugin(item) {
+  return reflection.isInstance(item, Plugin);
+}
+__name(isPlugin, "isPlugin");
 var PluginField = "PluginField";
 var Procedure = "Procedure";
 var ProcedureParam = "ProcedureParam";
@@ -199,15 +169,9 @@ function isTypeDef(item) {
   return reflection.isInstance(item, TypeDef);
 }
 __name(isTypeDef, "isTypeDef");
-var TypeDefField = "TypeDefField";
-function isTypeDefField(item) {
-  return reflection.isInstance(item, TypeDefField);
-}
-__name(isTypeDefField, "isTypeDefField");
-var TypeDefFieldType = "TypeDefFieldType";
 var UnaryExpr = "UnaryExpr";
 var UnsupportedFieldType = "UnsupportedFieldType";
-var ZModelAstReflection = class extends AbstractAstReflection {
+var ZModelAstReflection = class extends langium.AbstractAstReflection {
   static {
     __name(this, "ZModelAstReflection");
   }
@@ -227,11 +191,11 @@ var ZModelAstReflection = class extends AbstractAstReflection {
       ConfigField,
       ConfigInvocationArg,
       ConfigInvocationExpr,
+      DataField,
+      DataFieldAttribute,
+      DataFieldType,
       DataModel,
       DataModelAttribute,
-      DataModelField,
-      DataModelFieldAttribute,
-      DataModelFieldType,
       DataSource,
       Enum,
       EnumField,
@@ -262,9 +226,6 @@ var ZModelAstReflection = class extends AbstractAstReflection {
       ThisExpr,
       TypeDeclaration,
       TypeDef,
-      TypeDefField,
-      TypeDefFieldType,
-      TypeDefFieldTypes,
       UnaryExpr,
       UnsupportedFieldType
     ];
@@ -297,16 +258,13 @@ var ZModelAstReflection = class extends AbstractAstReflection {
       case ConfigArrayExpr: {
         return this.isSubtype(ConfigExpr, supertype);
       }
-      case DataModel: {
-        return this.isSubtype(AbstractDeclaration, supertype) || this.isSubtype(TypeDeclaration, supertype);
-      }
-      case DataModelField:
-      case TypeDefField: {
+      case DataField: {
         return this.isSubtype(MemberAccessTarget, supertype) || this.isSubtype(ReferenceTarget, supertype);
       }
+      case DataModel:
       case Enum:
       case TypeDef: {
-        return this.isSubtype(AbstractDeclaration, supertype) || this.isSubtype(TypeDeclaration, supertype) || this.isSubtype(TypeDefFieldTypes, supertype);
+        return this.isSubtype(AbstractDeclaration, supertype) || this.isSubtype(TypeDeclaration, supertype);
       }
       case EnumField:
       case FunctionParam: {
@@ -325,18 +283,22 @@ var ZModelAstReflection = class extends AbstractAstReflection {
     const referenceId = `${refInfo.container.$type}:${refInfo.property}`;
     switch (referenceId) {
       case "AttributeParamType:reference":
-      case "DataModelFieldType:reference":
+      case "DataFieldType:reference":
       case "FunctionParamType:reference": {
         return TypeDeclaration;
       }
-      case "DataModel:superTypes": {
-        return DataModel;
-      }
+      case "DataFieldAttribute:decl":
       case "DataModelAttribute:decl":
-      case "DataModelFieldAttribute:decl":
       case "InternalAttribute:decl": {
         return Attribute;
       }
+      case "DataModel:baseModel": {
+        return DataModel;
+      }
+      case "DataModel:mixins":
+      case "TypeDef:mixins": {
+        return TypeDef;
+      }
       case "InvocationExpr:function": {
         return FunctionDecl;
       }
@@ -346,9 +308,6 @@ var ZModelAstReflection = class extends AbstractAstReflection {
       case "ReferenceExpr:target": {
         return ReferenceTarget;
       }
-      case "TypeDefFieldType:reference": {
-        return TypeDefFieldTypes;
-      }
       default: {
         throw new Error(`${referenceId} is not a valid reference id.`);
       }
@@ -535,9 +494,9 @@ var ZModelAstReflection = class extends AbstractAstReflection {
           ]
         };
       }
-      case DataModel: {
+      case DataField: {
         return {
-          name: DataModel,
+          name: DataField,
           properties: [
             {
               name: "attributes",
@@ -547,31 +506,18 @@ var ZModelAstReflection = class extends AbstractAstReflection {
               name: "comments",
               defaultValue: []
             },
-            {
-              name: "fields",
-              defaultValue: []
-            },
-            {
-              name: "isAbstract",
-              defaultValue: false
-            },
-            {
-              name: "isView",
-              defaultValue: false
-            },
             {
               name: "name"
             },
             {
-              name: "superTypes",
-              defaultValue: []
+              name: "type"
             }
           ]
         };
       }
-      case DataModelAttribute: {
+      case DataFieldAttribute: {
         return {
-          name: DataModelAttribute,
+          name: DataFieldAttribute,
           properties: [
             {
               name: "args",
@@ -583,61 +529,73 @@ var ZModelAstReflection = class extends AbstractAstReflection {
           ]
         };
       }
-      case DataModelField: {
+      case DataFieldType: {
         return {
-          name: DataModelField,
+          name: DataFieldType,
           properties: [
             {
-              name: "attributes",
-              defaultValue: []
+              name: "array",
+              defaultValue: false
             },
             {
-              name: "comments",
-              defaultValue: []
+              name: "optional",
+              defaultValue: false
             },
             {
-              name: "name"
+              name: "reference"
             },
             {
               name: "type"
+            },
+            {
+              name: "unsupported"
             }
           ]
         };
       }
-      case DataModelFieldAttribute: {
+      case DataModel: {
         return {
-          name: DataModelFieldAttribute,
+          name: DataModel,
           properties: [
             {
-              name: "args",
+              name: "attributes",
               defaultValue: []
             },
             {
-              name: "decl"
-            }
-          ]
-        };
-      }
-      case DataModelFieldType: {
-        return {
-          name: DataModelFieldType,
-          properties: [
+              name: "baseModel"
+            },
             {
-              name: "array",
-              defaultValue: false
+              name: "comments",
+              defaultValue: []
             },
             {
-              name: "optional",
+              name: "fields",
+              defaultValue: []
+            },
+            {
+              name: "isView",
               defaultValue: false
             },
             {
-              name: "reference"
+              name: "mixins",
+              defaultValue: []
             },
             {
-              name: "type"
+              name: "name"
+            }
+          ]
+        };
+      }
+      case DataModelAttribute: {
+        return {
+          name: DataModelAttribute,
+          properties: [
+            {
+              name: "args",
+              defaultValue: []
             },
             {
-              name: "unsupported"
+              name: "decl"
             }
           ]
         };
@@ -1011,49 +969,11 @@ var ZModelAstReflection = class extends AbstractAstReflection {
               defaultValue: []
             },
             {
-              name: "name"
-            }
-          ]
-        };
-      }
-      case TypeDefField: {
-        return {
-          name: TypeDefField,
-          properties: [
-            {
-              name: "attributes",
-              defaultValue: []
-            },
-            {
-              name: "comments",
+              name: "mixins",
               defaultValue: []
             },
             {
               name: "name"
-            },
-            {
-              name: "type"
-            }
-          ]
-        };
-      }
-      case TypeDefFieldType: {
-        return {
-          name: TypeDefFieldType,
-          properties: [
-            {
-              name: "array",
-              defaultValue: false
-            },
-            {
-              name: "optional",
-              defaultValue: false
-            },
-            {
-              name: "reference"
-            },
-            {
-              name: "type"
             }
           ]
         };
@@ -1092,6 +1012,39 @@ var ZModelAstReflection = class extends AbstractAstReflection {
 };
 var reflection = new ZModelAstReflection();
 
+// src/constants.ts
+var SUPPORTED_PROVIDERS = [
+  "sqlite",
+  "postgresql"
+];
+var SCALAR_TYPES = [
+  "String",
+  "Int",
+  "Float",
+  "Decimal",
+  "BigInt",
+  "Boolean",
+  "Bytes",
+  "DateTime"
+];
+var STD_LIB_MODULE_NAME = "stdlib.zmodel";
+var PLUGIN_MODULE_NAME = "plugin.zmodel";
+var IssueCodes = /* @__PURE__ */ function(IssueCodes2) {
+  IssueCodes2["MissingOppositeRelation"] = "miss-opposite-relation";
+  return IssueCodes2;
+}({});
+var ExpressionContext = /* @__PURE__ */ function(ExpressionContext2) {
+  ExpressionContext2["DefaultValue"] = "DefaultValue";
+  ExpressionContext2["AccessPolicy"] = "AccessPolicy";
+  ExpressionContext2["ValidationRule"] = "ValidationRule";
+  ExpressionContext2["Index"] = "Index";
+  return ExpressionContext2;
+}({});
+
+// src/module.ts
+import { inject } from "langium";
+import { createDefaultModule, createDefaultSharedModule } from "langium/lsp";
+
 // src/generated/grammar.ts
 import { loadGrammarFromJson } from "langium";
 var loadedZModelGrammar;
@@ -1102,8 +1055,8 @@ var ZModelGrammar = /* @__PURE__ */ __name(() => loadedZModelGrammar ?? (loadedZ
   "rules": [
     {
       "$type": "ParserRule",
-      "name": "Model",
       "entry": true,
+      "name": "Model",
       "definition": {
         "$type": "Group",
         "elements": [
@@ -1214,7 +1167,7 @@ var ZModelGrammar = /* @__PURE__ */ __name(() => loadedZModelGrammar ?? (loadedZ
           {
             "$type": "RuleCall",
             "rule": {
-              "$ref": "#/rules@40"
+              "$ref": "#/rules@42"
             },
             "arguments": []
           },
@@ -1789,8 +1742,8 @@ var ZModelGrammar = /* @__PURE__ */ __name(() => loadedZModelGrammar ?? (loadedZ
     },
     {
       "$type": "ParserRule",
-      "name": "ConfigInvocationArgList",
       "fragment": true,
+      "name": "ConfigInvocationArgList",
       "definition": {
         "$type": "Group",
         "elements": [
@@ -2097,8 +2050,8 @@ var ZModelGrammar = /* @__PURE__ */ __name(() => loadedZModelGrammar ?? (loadedZ
     },
     {
       "$type": "ParserRule",
-      "name": "ReferenceArgList",
       "fragment": true,
+      "name": "ReferenceArgList",
       "definition": {
         "$type": "Group",
         "elements": [
@@ -2914,8 +2867,8 @@ var ZModelGrammar = /* @__PURE__ */ __name(() => loadedZModelGrammar ?? (loadedZ
     },
     {
       "$type": "ParserRule",
-      "name": "ArgumentList",
       "fragment": true,
+      "name": "ArgumentList",
       "definition": {
         "$type": "Group",
         "elements": [
@@ -3008,16 +2961,6 @@ var ZModelGrammar = /* @__PURE__ */ __name(() => loadedZModelGrammar ?? (loadedZ
               {
                 "$type": "Group",
                 "elements": [
-                  {
-                    "$type": "Assignment",
-                    "feature": "isAbstract",
-                    "operator": "?=",
-                    "terminal": {
-                      "$type": "Keyword",
-                      "value": "abstract"
-                    },
-                    "cardinality": "?"
-                  },
                   {
                     "$type": "Keyword",
                     "value": "model"
@@ -3035,45 +2978,59 @@ var ZModelGrammar = /* @__PURE__ */ __name(() => loadedZModelGrammar ?? (loadedZ
                     }
                   },
                   {
-                    "$type": "Group",
+                    "$type": "Alternatives",
                     "elements": [
                       {
-                        "$type": "Keyword",
-                        "value": "extends"
+                        "$type": "RuleCall",
+                        "rule": {
+                          "$ref": "#/rules@38"
+                        },
+                        "arguments": []
+                      },
+                      {
+                        "$type": "RuleCall",
+                        "rule": {
+                          "$ref": "#/rules@39"
+                        },
+                        "arguments": []
                       },
                       {
-                        "$type": "Assignment",
-                        "feature": "superTypes",
-                        "operator": "+=",
-                        "terminal": {
-                          "$type": "CrossReference",
-                          "type": {
-                            "$ref": "#/rules@37"
+                        "$type": "Group",
+                        "elements": [
+                          {
+                            "$type": "RuleCall",
+                            "rule": {
+                              "$ref": "#/rules@39"
+                            },
+                            "arguments": []
                           },
-                          "deprecatedSyntax": false
-                        }
+                          {
+                            "$type": "RuleCall",
+                            "rule": {
+                              "$ref": "#/rules@38"
+                            },
+                            "arguments": []
+                          }
+                        ]
                       },
                       {
                         "$type": "Group",
                         "elements": [
                           {
-                            "$type": "Keyword",
-                            "value": ","
+                            "$type": "RuleCall",
+                            "rule": {
+                              "$ref": "#/rules@38"
+                            },
+                            "arguments": []
                           },
                           {
-                            "$type": "Assignment",
-                            "feature": "superTypes",
-                            "operator": "+=",
-                            "terminal": {
-                              "$type": "CrossReference",
-                              "type": {
-                                "$ref": "#/rules@37"
-                              },
-                              "deprecatedSyntax": false
-                            }
+                            "$type": "RuleCall",
+                            "rule": {
+                              "$ref": "#/rules@39"
+                            },
+                            "arguments": []
                           }
-                        ],
-                        "cardinality": "*"
+                        ]
                       }
                     ],
                     "cardinality": "?"
@@ -3122,7 +3079,7 @@ var ZModelGrammar = /* @__PURE__ */ __name(() => loadedZModelGrammar ?? (loadedZ
                 "terminal": {
                   "$type": "RuleCall",
                   "rule": {
-                    "$ref": "#/rules@38"
+                    "$ref": "#/rules@40"
                   },
                   "arguments": []
                 }
@@ -3157,7 +3114,92 @@ var ZModelGrammar = /* @__PURE__ */ __name(() => loadedZModelGrammar ?? (loadedZ
     },
     {
       "$type": "ParserRule",
-      "name": "DataModelField",
+      "fragment": true,
+      "name": "WithClause",
+      "definition": {
+        "$type": "Group",
+        "elements": [
+          {
+            "$type": "Keyword",
+            "value": "with"
+          },
+          {
+            "$type": "Assignment",
+            "feature": "mixins",
+            "operator": "+=",
+            "terminal": {
+              "$type": "CrossReference",
+              "type": {
+                "$ref": "#/rules@42"
+              },
+              "deprecatedSyntax": false
+            }
+          },
+          {
+            "$type": "Group",
+            "elements": [
+              {
+                "$type": "Keyword",
+                "value": ",",
+                "cardinality": "?"
+              },
+              {
+                "$type": "Assignment",
+                "feature": "mixins",
+                "operator": "+=",
+                "terminal": {
+                  "$type": "CrossReference",
+                  "type": {
+                    "$ref": "#/rules@42"
+                  },
+                  "deprecatedSyntax": false
+                }
+              }
+            ],
+            "cardinality": "*"
+          }
+        ]
+      },
+      "definesHiddenTokens": false,
+      "entry": false,
+      "hiddenTokens": [],
+      "parameters": [],
+      "wildcard": false
+    },
+    {
+      "$type": "ParserRule",
+      "fragment": true,
+      "name": "ExtendsClause",
+      "definition": {
+        "$type": "Group",
+        "elements": [
+          {
+            "$type": "Keyword",
+            "value": "extends"
+          },
+          {
+            "$type": "Assignment",
+            "feature": "baseModel",
+            "operator": "=",
+            "terminal": {
+              "$type": "CrossReference",
+              "type": {
+                "$ref": "#/rules@37"
+              },
+              "deprecatedSyntax": false
+            }
+          }
+        ]
+      },
+      "definesHiddenTokens": false,
+      "entry": false,
+      "hiddenTokens": [],
+      "parameters": [],
+      "wildcard": false
+    },
+    {
+      "$type": "ParserRule",
+      "name": "DataField",
       "definition": {
         "$type": "Group",
         "elements": [
@@ -3193,7 +3235,7 @@ var ZModelGrammar = /* @__PURE__ */ __name(() => loadedZModelGrammar ?? (loadedZ
             "terminal": {
               "$type": "RuleCall",
               "rule": {
-                "$ref": "#/rules@39"
+                "$ref": "#/rules@41"
               },
               "arguments": []
             }
@@ -3222,7 +3264,7 @@ var ZModelGrammar = /* @__PURE__ */ __name(() => loadedZModelGrammar ?? (loadedZ
     },
     {
       "$type": "ParserRule",
-      "name": "DataModelFieldType",
+      "name": "DataFieldType",
       "definition": {
         "$type": "Group",
         "elements": [
@@ -3260,7 +3302,7 @@ var ZModelGrammar = /* @__PURE__ */ __name(() => loadedZModelGrammar ?? (loadedZ
                 "terminal": {
                   "$type": "CrossReference",
                   "type": {
-                    "$ref": "#/types@3"
+                    "$ref": "#/types@2"
                   },
                   "terminal": {
                     "$type": "RuleCall",
@@ -3348,187 +3390,50 @@ var ZModelGrammar = /* @__PURE__ */ __name(() => loadedZModelGrammar ?? (loadedZ
             }
           },
           {
-            "$type": "Keyword",
-            "value": "{"
-          },
-          {
-            "$type": "Alternatives",
-            "elements": [
-              {
-                "$type": "Assignment",
-                "feature": "fields",
-                "operator": "+=",
-                "terminal": {
-                  "$type": "RuleCall",
-                  "rule": {
-                    "$ref": "#/rules@41"
-                  },
-                  "arguments": []
-                }
-              },
-              {
-                "$type": "Assignment",
-                "feature": "attributes",
-                "operator": "+=",
-                "terminal": {
-                  "$type": "RuleCall",
-                  "rule": {
-                    "$ref": "#/rules@57"
-                  },
-                  "arguments": []
-                }
-              }
-            ],
-            "cardinality": "*"
-          },
-          {
-            "$type": "Keyword",
-            "value": "}"
-          }
-        ]
-      },
-      "definesHiddenTokens": false,
-      "entry": false,
-      "fragment": false,
-      "hiddenTokens": [],
-      "parameters": [],
-      "wildcard": false
-    },
-    {
-      "$type": "ParserRule",
-      "name": "TypeDefField",
-      "definition": {
-        "$type": "Group",
-        "elements": [
-          {
-            "$type": "Assignment",
-            "feature": "comments",
-            "operator": "+=",
-            "terminal": {
-              "$type": "RuleCall",
-              "rule": {
-                "$ref": "#/rules@71"
-              },
-              "arguments": []
+            "$type": "RuleCall",
+            "rule": {
+              "$ref": "#/rules@38"
             },
-            "cardinality": "*"
-          },
-          {
-            "$type": "Assignment",
-            "feature": "name",
-            "operator": "=",
-            "terminal": {
-              "$type": "RuleCall",
-              "rule": {
-                "$ref": "#/rules@52"
-              },
-              "arguments": []
-            }
+            "arguments": [],
+            "cardinality": "?"
           },
           {
-            "$type": "Assignment",
-            "feature": "type",
-            "operator": "=",
-            "terminal": {
-              "$type": "RuleCall",
-              "rule": {
-                "$ref": "#/rules@42"
-              },
-              "arguments": []
-            }
+            "$type": "Keyword",
+            "value": "{"
           },
-          {
-            "$type": "Assignment",
-            "feature": "attributes",
-            "operator": "+=",
-            "terminal": {
-              "$type": "RuleCall",
-              "rule": {
-                "$ref": "#/rules@56"
-              },
-              "arguments": []
-            },
-            "cardinality": "*"
-          }
-        ]
-      },
-      "definesHiddenTokens": false,
-      "entry": false,
-      "fragment": false,
-      "hiddenTokens": [],
-      "parameters": [],
-      "wildcard": false
-    },
-    {
-      "$type": "ParserRule",
-      "name": "TypeDefFieldType",
-      "definition": {
-        "$type": "Group",
-        "elements": [
           {
             "$type": "Alternatives",
             "elements": [
               {
                 "$type": "Assignment",
-                "feature": "type",
-                "operator": "=",
-                "terminal": {
-                  "$type": "RuleCall",
-                  "rule": {
-                    "$ref": "#/rules@62"
-                  },
-                  "arguments": []
-                }
-              },
-              {
-                "$type": "Assignment",
-                "feature": "reference",
-                "operator": "=",
-                "terminal": {
-                  "$type": "CrossReference",
-                  "type": {
-                    "$ref": "#/types@2"
-                  },
-                  "terminal": {
-                    "$type": "RuleCall",
-                    "rule": {
-                      "$ref": "#/rules@51"
-                    },
-                    "arguments": []
-                  },
-                  "deprecatedSyntax": false
-                }
-              }
-            ]
-          },
-          {
-            "$type": "Group",
-            "elements": [
-              {
-                "$type": "Assignment",
-                "feature": "array",
-                "operator": "?=",
+                "feature": "fields",
+                "operator": "+=",
                 "terminal": {
-                  "$type": "Keyword",
-                  "value": "["
+                  "$type": "RuleCall",
+                  "rule": {
+                    "$ref": "#/rules@40"
+                  },
+                  "arguments": []
                 }
               },
               {
-                "$type": "Keyword",
-                "value": "]"
+                "$type": "Assignment",
+                "feature": "attributes",
+                "operator": "+=",
+                "terminal": {
+                  "$type": "RuleCall",
+                  "rule": {
+                    "$ref": "#/rules@57"
+                  },
+                  "arguments": []
+                }
               }
             ],
-            "cardinality": "?"
+            "cardinality": "*"
           },
           {
-            "$type": "Assignment",
-            "feature": "optional",
-            "operator": "?=",
-            "terminal": {
-              "$type": "Keyword",
-              "value": "?"
-            },
-            "cardinality": "?"
+            "$type": "Keyword",
+            "value": "}"
           }
         ]
       },
@@ -3939,7 +3844,7 @@ var ZModelGrammar = /* @__PURE__ */ __name(() => loadedZModelGrammar ?? (loadedZ
                 "terminal": {
                   "$type": "CrossReference",
                   "type": {
-                    "$ref": "#/types@3"
+                    "$ref": "#/types@2"
                   },
                   "terminal": {
                     "$type": "RuleCall",
@@ -4553,7 +4458,7 @@ var ZModelGrammar = /* @__PURE__ */ __name(() => loadedZModelGrammar ?? (loadedZ
                 "terminal": {
                   "$type": "CrossReference",
                   "type": {
-                    "$ref": "#/types@3"
+                    "$ref": "#/types@2"
                   },
                   "terminal": {
                     "$type": "RuleCall",
@@ -4607,7 +4512,7 @@ var ZModelGrammar = /* @__PURE__ */ __name(() => loadedZModelGrammar ?? (loadedZ
     },
     {
       "$type": "ParserRule",
-      "name": "DataModelFieldAttribute",
+      "name": "DataFieldAttribute",
       "definition": {
         "$type": "Group",
         "elements": [
@@ -4783,8 +4688,8 @@ var ZModelGrammar = /* @__PURE__ */ __name(() => loadedZModelGrammar ?? (loadedZ
     },
     {
       "$type": "ParserRule",
-      "name": "AttributeArgList",
       "fragment": true,
+      "name": "AttributeArgList",
       "definition": {
         "$type": "Group",
         "elements": [
@@ -5124,13 +5029,7 @@ var ZModelGrammar = /* @__PURE__ */ __name(() => loadedZModelGrammar ?? (loadedZ
           {
             "$type": "SimpleType",
             "typeRef": {
-              "$ref": "#/rules@38"
-            }
-          },
-          {
-            "$type": "SimpleType",
-            "typeRef": {
-              "$ref": "#/rules@41"
+              "$ref": "#/rules@40"
             }
           },
           {
@@ -5146,42 +5045,10 @@ var ZModelGrammar = /* @__PURE__ */ __name(() => loadedZModelGrammar ?? (loadedZ
       "$type": "Type",
       "name": "MemberAccessTarget",
       "type": {
-        "$type": "UnionType",
-        "types": [
-          {
-            "$type": "SimpleType",
-            "typeRef": {
-              "$ref": "#/rules@38"
-            }
-          },
-          {
-            "$type": "SimpleType",
-            "typeRef": {
-              "$ref": "#/rules@41"
-            }
-          }
-        ]
-      }
-    },
-    {
-      "$type": "Type",
-      "name": "TypeDefFieldTypes",
-      "type": {
-        "$type": "UnionType",
-        "types": [
-          {
-            "$type": "SimpleType",
-            "typeRef": {
-              "$ref": "#/rules@40"
-            }
-          },
-          {
-            "$type": "SimpleType",
-            "typeRef": {
-              "$ref": "#/rules@44"
-            }
-          }
-        ]
+        "$type": "SimpleType",
+        "typeRef": {
+          "$ref": "#/rules@40"
+        }
       }
     },
     {
@@ -5199,7 +5066,7 @@ var ZModelGrammar = /* @__PURE__ */ __name(() => loadedZModelGrammar ?? (loadedZ
           {
             "$type": "SimpleType",
             "typeRef": {
-              "$ref": "#/rules@40"
+              "$ref": "#/rules@42"
             }
           },
           {
@@ -5242,9 +5109,10 @@ import { AstUtils as AstUtils2 } from "langium";
 import pluralize from "pluralize";
 
 // src/utils.ts
+import { invariant } from "@zenstackhq/common-helpers";
 import { AstUtils, URI } from "langium";
+import fs from "fs";
 import path from "path";
-import fs from "node:fs";
 function hasAttribute(decl, name) {
   return !!getAttribute(decl, name);
 }
@@ -5316,10 +5184,10 @@ function isEnumFieldReference(node) {
   return isReferenceExpr(node) && isEnumField(node.target.ref);
 }
 __name(isEnumFieldReference, "isEnumFieldReference");
-function isDataModelFieldReference(node) {
-  return isReferenceExpr(node) && isDataModelField(node.target.ref);
+function isDataFieldReference(node) {
+  return isReferenceExpr(node) && isDataField(node.target.ref);
 }
-__name(isDataModelFieldReference, "isDataModelFieldReference");
+__name(isDataFieldReference, "isDataFieldReference");
 function isRelationshipField(field) {
   return isDataModel(field.type.reference?.ref);
 }
@@ -5339,43 +5207,14 @@ function resolved(ref) {
   return ref.ref;
 }
 __name(resolved, "resolved");
-function findUpInheritance(start, target) {
-  for (const base of start.superTypes) {
-    if (base.ref === target) {
-      return [
-        base.ref
-      ];
-    }
-    const path4 = findUpInheritance(base.ref, target);
-    if (path4) {
-      return [
-        base.ref,
-        ...path4
-      ];
-    }
-  }
-  return void 0;
-}
-__name(findUpInheritance, "findUpInheritance");
-function getModelFieldsWithBases(model, includeDelegate = true) {
-  if (model.$baseMerged) {
-    return model.fields;
-  } else {
-    return [
-      ...model.fields,
-      ...getRecursiveBases(model, includeDelegate).flatMap((base) => base.fields)
-    ];
-  }
-}
-__name(getModelFieldsWithBases, "getModelFieldsWithBases");
-function getRecursiveBases(dataModel, includeDelegate = true, seen = /* @__PURE__ */ new Set()) {
+function getRecursiveBases(decl, includeDelegate = true, seen = /* @__PURE__ */ new Set()) {
   const result = [];
-  if (seen.has(dataModel)) {
+  if (seen.has(decl)) {
     return result;
   }
-  seen.add(dataModel);
-  dataModel.superTypes.forEach((superType) => {
-    const baseDecl = superType.ref;
+  seen.add(decl);
+  decl.mixins.forEach((mixin) => {
+    const baseDecl = mixin.ref;
     if (baseDecl) {
       if (!includeDelegate && isDelegateModel(baseDecl)) {
         return;
@@ -5388,14 +5227,13 @@ function getRecursiveBases(dataModel, includeDelegate = true, seen = /* @__PURE_
 }
 __name(getRecursiveBases, "getRecursiveBases");
 function getModelIdFields(model) {
-  const modelsToCheck = model.$baseMerged ? [
-    model
-  ] : [
+  const modelsToCheck = [
     model,
     ...getRecursiveBases(model)
   ];
   for (const modelToCheck of modelsToCheck) {
-    const idAttr = modelToCheck.attributes.find((attr) => attr.decl.$refText === "@@id");
+    const allAttributes = getAllAttributes(modelToCheck);
+    const idAttr = allAttributes.find((attr) => attr.decl.$refText === "@@id");
     if (!idAttr) {
       continue;
     }
@@ -5409,14 +5247,13 @@ function getModelIdFields(model) {
 }
 __name(getModelIdFields, "getModelIdFields");
 function getModelUniqueFields(model) {
-  const modelsToCheck = model.$baseMerged ? [
-    model
-  ] : [
+  const modelsToCheck = [
     model,
     ...getRecursiveBases(model)
   ];
   for (const modelToCheck of modelsToCheck) {
-    const uniqueAttr = modelToCheck.attributes.find((attr) => attr.decl.$refText === "@@unique");
+    const allAttributes = getAllAttributes(modelToCheck);
+    const uniqueAttr = allAttributes.find((attr) => attr.decl.$refText === "@@unique");
     if (!uniqueAttr) {
       continue;
     }
@@ -5563,34 +5400,24 @@ function resolveImport(documents, imp) {
 }
 __name(resolveImport, "resolveImport");
 function resolveImportUri(imp) {
-  if (!imp.path) return void 0;
-  if (!imp.path.endsWith(".zmodel")) {
-    imp.path += ".zmodel";
-  }
-  if (!imp.path.startsWith(".") && // Respect relative paths
-  !path.isAbsolute(imp.path)) {
-    const contextPath = imp.$container.$document ? path.dirname(imp.$container.$document.uri.fsPath) : process.cwd();
-    imp.path = findNodeModulesFile(imp.path, contextPath) ?? imp.path;
+  if (!imp.path) {
+    return void 0;
   }
   const doc = AstUtils.getDocument(imp);
   const dir = path.dirname(doc.uri.fsPath);
-  return URI.file(path.resolve(dir, imp.path));
+  const importPath = imp.path.endsWith(".zmodel") ? imp.path : `${imp.path}.zmodel`;
+  return URI.file(path.resolve(dir, importPath));
 }
 __name(resolveImportUri, "resolveImportUri");
-function findNodeModulesFile(name, cwd = process.cwd()) {
-  if (!name) return void 0;
-  try {
-    const resolvedPath = __require.resolve(name, {
-      paths: [
-        cwd
-      ]
-    });
-    return resolvedPath;
-  } catch (error) {
-    return void 0;
+function getDataModelAndTypeDefs(model, includeIgnored = false) {
+  const r = model.declarations.filter((d) => isDataModel(d) || isTypeDef(d));
+  if (includeIgnored) {
+    return r;
+  } else {
+    return r.filter((model2) => !hasAttribute(model2, "@@ignore"));
   }
 }
-__name(findNodeModulesFile, "findNodeModulesFile");
+__name(getDataModelAndTypeDefs, "getDataModelAndTypeDefs");
 function getAllDeclarationsIncludingImports(documents, model) {
   const imports = resolveTransitiveImports(documents, model);
   return model.declarations.concat(...imports.map((imp) => imp.declarations));
@@ -5655,6 +5482,58 @@ function isMemberContainer(node) {
   return isDataModel(node) || isTypeDef(node);
 }
 __name(isMemberContainer, "isMemberContainer");
+function getAllFields(decl, includeIgnored = false, seen = /* @__PURE__ */ new Set()) {
+  if (seen.has(decl)) {
+    return [];
+  }
+  seen.add(decl);
+  const fields = [];
+  for (const mixin of decl.mixins) {
+    invariant(mixin.ref, `Mixin ${mixin.$refText} is not resolved`);
+    fields.push(...getAllFields(mixin.ref, includeIgnored, seen));
+  }
+  if (isDataModel(decl) && decl.baseModel) {
+    invariant(decl.baseModel.ref, `Base model ${decl.baseModel.$refText} is not resolved`);
+    fields.push(...getAllFields(decl.baseModel.ref, includeIgnored, seen));
+  }
+  fields.push(...decl.fields.filter((f) => includeIgnored || !hasAttribute(f, "@ignore")));
+  return fields;
+}
+__name(getAllFields, "getAllFields");
+function getAllAttributes(decl, seen = /* @__PURE__ */ new Set()) {
+  if (seen.has(decl)) {
+    return [];
+  }
+  seen.add(decl);
+  const attributes = [];
+  for (const mixin of decl.mixins) {
+    invariant(mixin.ref, `Mixin ${mixin.$refText} is not resolved`);
+    attributes.push(...getAllAttributes(mixin.ref, seen));
+  }
+  if (isDataModel(decl) && decl.baseModel) {
+    invariant(decl.baseModel.ref, `Base model ${decl.baseModel.$refText} is not resolved`);
+    attributes.push(...getAllAttributes(decl.baseModel.ref, seen));
+  }
+  attributes.push(...decl.attributes);
+  return attributes;
+}
+__name(getAllAttributes, "getAllAttributes");
+function getDocument(node) {
+  const rootNode = findRootNode(node);
+  const result = rootNode.$document;
+  if (!result) {
+    throw new Error("AST node has no document.");
+  }
+  return result;
+}
+__name(getDocument, "getDocument");
+function findRootNode(node) {
+  while (node.$container) {
+    node = node.$container;
+  }
+  return node;
+}
+__name(findRootNode, "findRootNode");
 
 // src/validators/attribute-application-validator.ts
 function _ts_decorate(decorators, target, key, desc) {
@@ -5682,7 +5561,7 @@ var AttributeApplicationValidator = class {
   static {
     __name(this, "AttributeApplicationValidator");
   }
-  validate(attr, accept) {
+  validate(attr, accept, contextDataModel) {
     const decl = attr.decl.ref;
     if (!decl) {
       return;
@@ -5694,21 +5573,13 @@ var AttributeApplicationValidator = class {
       });
       return;
     }
-    if (isDataModelField(targetDecl) && !isValidAttributeTarget(decl, targetDecl)) {
+    if (isDataField(targetDecl) && !isValidAttributeTarget(decl, targetDecl)) {
       accept("error", `attribute "${decl.name}" cannot be used on this type of field`, {
         node: attr
       });
     }
-    if (isTypeDefField(targetDecl) && !hasAttribute(decl, "@@@supportTypeDef")) {
-      accept("error", `attribute "${decl.name}" cannot be used on type declaration fields`, {
-        node: attr
-      });
-    }
-    if (isTypeDef(targetDecl) && !hasAttribute(decl, "@@@supportTypeDef")) {
-      accept("error", `attribute "${decl.name}" cannot be used on type declarations`, {
-        node: attr
-      });
-    }
+    this.checkDeprecation(attr, accept);
+    this.checkDuplicatedAttributes(attr, accept, contextDataModel);
     const filledParams = /* @__PURE__ */ new Set();
     for (const arg of attr.args) {
       let paramDecl;
@@ -5756,6 +5627,28 @@ var AttributeApplicationValidator = class {
       checker.value.call(this, attr, accept);
     }
   }
+  checkDeprecation(attr, accept) {
+    const deprecateAttr = attr.decl.ref?.attributes.find((a) => a.decl.ref?.name === "@@@deprecated");
+    if (deprecateAttr) {
+      const message = getStringLiteral(deprecateAttr.args[0]?.value) ?? `Attribute "${attr.decl.ref?.name}" is deprecated`;
+      accept("warning", message, {
+        node: attr
+      });
+    }
+  }
+  checkDuplicatedAttributes(attr, accept, contextDataModel) {
+    const attrDecl = attr.decl.ref;
+    if (!attrDecl?.attributes.some((a) => a.decl.ref?.name === "@@@once")) {
+      return;
+    }
+    const allAttributes = contextDataModel ? getAllAttributes(contextDataModel) : attr.$container.attributes;
+    const duplicates = allAttributes.filter((a) => a.decl.ref === attrDecl && a !== attr);
+    if (duplicates.length > 0) {
+      accept("error", `Attribute "${attrDecl.name}" can only be applied once`, {
+        node: attr
+      });
+    }
+  }
   _checkModelLevelPolicy(attr, accept) {
     const kind = getStringLiteral(attr.args[0]?.value);
     if (!kind) {
@@ -5804,7 +5697,7 @@ var AttributeApplicationValidator = class {
   }
   _checkValidate(attr, accept) {
     const condition = attr.args[0]?.value;
-    if (condition && AstUtils2.streamAst(condition).some((node) => isDataModelFieldReference(node) && isDataModel(node.$resolvedType?.decl))) {
+    if (condition && AstUtils2.streamAst(condition).some((node) => isDataFieldReference(node) && isDataModel(node.$resolvedType?.decl))) {
       accept("error", `\`@@validate\` condition cannot use relation fields`, {
         node: condition
       });
@@ -5813,9 +5706,18 @@ var AttributeApplicationValidator = class {
   _checkUnique(attr, accept) {
     const fields = attr.args[0]?.value;
     if (!fields) {
+      accept("error", `expects an array of field references`, {
+        node: attr.args[0]
+      });
       return;
     }
     if (isArrayExpr(fields)) {
+      if (fields.items.length === 0) {
+        accept("error", `\`@@unique\` expects at least one field reference`, {
+          node: fields
+        });
+        return;
+      }
       fields.items.forEach((item) => {
         if (!isReferenceExpr(item)) {
           accept("error", `Expecting a field reference`, {
@@ -5823,7 +5725,7 @@ var AttributeApplicationValidator = class {
           });
           return;
         }
-        if (!isDataModelField(item.target.ref)) {
+        if (!isDataField(item.target.ref)) {
           accept("error", `Expecting a field reference`, {
             node: item
           });
@@ -5843,7 +5745,7 @@ var AttributeApplicationValidator = class {
   }
   rejectEncryptedFields(attr, accept) {
     AstUtils2.streamAllContents(attr).forEach((node) => {
-      if (isDataModelFieldReference(node) && hasAttribute(node.target.ref, "@encrypted")) {
+      if (isDataFieldReference(node) && hasAttribute(node.target.ref, "@encrypted")) {
         accept("error", `Encrypted fields cannot be used in policy rules`, {
           node
         });
@@ -5893,6 +5795,7 @@ _ts_decorate([
 ], AttributeApplicationValidator.prototype, "_checkValidate", null);
 _ts_decorate([
   check("@@unique"),
+  check("@@id"),
   _ts_metadata("design:type", Function),
   _ts_metadata("design:paramtypes", [
     typeof AttributeApplication === "undefined" ? Object : AttributeApplication,
@@ -5908,7 +5811,7 @@ function assignableToAttributeParam(arg, param, attr) {
   let dstType = param.type.type;
   let dstIsArray = param.type.array;
   if (dstType === "ContextType") {
-    if (isDataModelField(attr.$container)) {
+    if (isDataField(attr.$container)) {
       dstIsArray = attr.$container.type.array;
     }
   }
@@ -5925,14 +5828,14 @@ function assignableToAttributeParam(arg, param, attr) {
   }
   if (dstType === "FieldReference" || dstType === "TransitiveFieldReference") {
     if (dstIsArray) {
-      return isArrayExpr(arg.value) && !arg.value.items.find((item) => !isReferenceExpr(item) || !isDataModelField(item.target.ref));
+      return isArrayExpr(arg.value) && !arg.value.items.find((item) => !isReferenceExpr(item) || !isDataField(item.target.ref));
     } else {
-      return isReferenceExpr(arg.value) && isDataModelField(arg.value.target.ref);
+      return isReferenceExpr(arg.value) && isDataField(arg.value.target.ref);
     }
   }
   if (isEnum(argResolvedType.decl)) {
     let attrArgDeclType = dstRef?.ref;
-    if (dstType === "ContextType" && isDataModelField(attr.$container) && attr.$container?.type?.reference) {
+    if (dstType === "ContextType" && isDataField(attr.$container) && attr.$container?.type?.reference) {
       attrArgDeclType = resolved(attr.$container.type.reference);
       dstIsArray = attr.$container.type.array;
     }
@@ -5942,7 +5845,7 @@ function assignableToAttributeParam(arg, param, attr) {
       return false;
     }
     if (dstType === "ContextType") {
-      if (isDataModelField(attr.$container)) {
+      if (isDataField(attr.$container)) {
         if (!attr.$container?.type?.type) {
           return false;
         }
@@ -6010,8 +5913,8 @@ function isValidAttributeTarget(attrDecl, targetDecl) {
   return allowed;
 }
 __name(isValidAttributeTarget, "isValidAttributeTarget");
-function validateAttributeApplication(attr, accept) {
-  new AttributeApplicationValidator().validate(attr, accept);
+function validateAttributeApplication(attr, accept, contextDataModel) {
+  new AttributeApplicationValidator().validate(attr, accept, contextDataModel);
 }
 __name(validateAttributeApplication, "validateAttributeApplication");
 
@@ -6026,6 +5929,7 @@ var AttributeValidator = class {
 };
 
 // src/validators/datamodel-validator.ts
+import { invariant as invariant2 } from "@zenstackhq/common-helpers";
 import { AstUtils as AstUtils3 } from "langium";
 
 // src/validators/common.ts
@@ -6038,8 +5942,8 @@ function validateDuplicatedDeclarations(container, decls, accept) {
   for (const [name, decls2] of Object.entries(groupByName)) {
     if (decls2.length > 1) {
       let errorField = decls2[1];
-      if (isDataModelField(decls2[0])) {
-        const nonInheritedFields = decls2.filter((x) => !(isDataModelField(x) && x.$container !== container));
+      if (isDataField(decls2[0])) {
+        const nonInheritedFields = decls2.filter((x) => !(isDataField(x) && x.$container !== container));
         if (nonInheritedFields.length > 0) {
           errorField = nonInheritedFields.slice(-1)[0];
         }
@@ -6058,22 +5962,21 @@ var DataModelValidator = class {
     __name(this, "DataModelValidator");
   }
   validate(dm, accept) {
-    this.validateBaseAbstractModel(dm, accept);
-    this.validateBaseDelegateModel(dm, accept);
-    validateDuplicatedDeclarations(dm, getModelFieldsWithBases(dm), accept);
+    validateDuplicatedDeclarations(dm, getAllFields(dm), accept);
     this.validateAttributes(dm, accept);
     this.validateFields(dm, accept);
-    if (dm.superTypes.length > 0) {
-      this.validateInheritance(dm, accept);
+    if (dm.mixins.length > 0) {
+      this.validateMixins(dm, accept);
     }
+    this.validateInherits(dm, accept);
   }
   validateFields(dm, accept) {
-    const allFields = getModelFieldsWithBases(dm);
+    const allFields = getAllFields(dm);
     const idFields = allFields.filter((f) => f.attributes.find((attr) => attr.decl.ref?.name === "@id"));
     const uniqueFields = allFields.filter((f) => f.attributes.find((attr) => attr.decl.ref?.name === "@unique"));
     const modelLevelIds = getModelIdFields(dm);
     const modelUniqueFields = getModelUniqueFields(dm);
-    if (!dm.isAbstract && idFields.length === 0 && modelLevelIds.length === 0 && uniqueFields.length === 0 && modelUniqueFields.length === 0) {
+    if (idFields.length === 0 && modelLevelIds.length === 0 && uniqueFields.length === 0 && modelUniqueFields.length === 0) {
       accept("error", "Model must have at least one unique criteria. Either mark a single field with `@id`, `@unique` or add a multi field criterion with `@@id([])` or `@@unique([])` to the model.", {
         node: dm
       });
@@ -6104,11 +6007,9 @@ var DataModelValidator = class {
       });
     }
     dm.fields.forEach((field) => this.validateField(field, accept));
-    if (!dm.isAbstract) {
-      allFields.filter((x) => isDataModel(x.type.reference?.ref)).forEach((y) => {
-        this.validateRelationField(dm, y, accept);
-      });
-    }
+    allFields.filter((x) => isDataModel(x.type.reference?.ref)).forEach((y) => {
+      this.validateRelationField(dm, y, accept);
+    });
   }
   validateField(field, accept) {
     if (field.type.array && field.type.optional) {
@@ -6124,7 +6025,7 @@ var DataModelValidator = class {
     if (field.type.array && !isDataModel(field.type.reference?.ref)) {
       const provider = this.getDataSourceProvider(AstUtils3.getContainerOfType(field, isModel));
       if (provider === "sqlite") {
-        accept("error", `Array type is not supported for "${provider}" provider.`, {
+        accept("error", `List type is not supported for "${provider}" provider.`, {
           node: field.type
         });
       }
@@ -6150,7 +6051,7 @@ var DataModelValidator = class {
     return getLiteral(provider.value);
   }
   validateAttributes(dm, accept) {
-    dm.attributes.forEach((attr) => validateAttributeApplication(attr, accept));
+    getAllAttributes(dm).forEach((attr) => validateAttributeApplication(attr, accept, dm));
   }
   parseRelation(field, accept) {
     const relAttr = field.attributes.find((attr) => attr.decl.ref?.name === "@relation");
@@ -6269,11 +6170,20 @@ var DataModelValidator = class {
     if (!thisRelation.valid) {
       return;
     }
-    if (this.isFieldInheritedFromDelegateModel(field, contextModel)) {
+    if (this.isFieldInheritedFromDelegateModel(field)) {
       return;
     }
+    if (this.isSelfRelation(field)) {
+      if (!thisRelation.name) {
+        accept("error", "Self-relation field must have a name in @relation attribute", {
+          node: field
+        });
+        return;
+      }
+    }
     const oppositeModel = field.type.reference.ref;
-    let oppositeFields = getModelFieldsWithBases(oppositeModel, false).filter((f) => f.type.reference?.ref?.name === contextModel.name);
+    let oppositeFields = getAllFields(oppositeModel, false).filter((f) => f !== field && // exclude self in case of self relation
+    f.type.reference?.ref?.name === contextModel.name);
     oppositeFields = oppositeFields.filter((f) => {
       const fieldRel = this.parseRelation(f);
       return fieldRel.valid && fieldRel.name === thisRelation.name;
@@ -6310,26 +6220,37 @@ var DataModelValidator = class {
     const oppositeField = oppositeFields[0];
     const oppositeRelation = this.parseRelation(oppositeField);
     let relationOwner;
-    if (thisRelation?.references?.length && thisRelation.fields?.length) {
-      if (oppositeRelation?.references || oppositeRelation?.fields) {
-        accept("error", '"fields" and "references" must be provided only on one side of relation field', {
-          node: oppositeField
-        });
-        return;
-      } else {
-        relationOwner = oppositeField;
-      }
-    } else if (oppositeRelation?.references?.length && oppositeRelation.fields?.length) {
-      if (thisRelation?.references || thisRelation?.fields) {
-        accept("error", '"fields" and "references" must be provided only on one side of relation field', {
-          node: field
-        });
-        return;
-      } else {
-        relationOwner = field;
+    if (field.type.array && oppositeField.type.array) {
+      for (const r of [
+        thisRelation,
+        oppositeRelation
+      ]) {
+        if (r.fields?.length || r.references?.length) {
+          accept("error", 'Implicit many-to-many relation cannot have "fields" or "references" in @relation attribute', {
+            node: r === thisRelation ? field : oppositeField
+          });
+        }
       }
     } else {
-      if (!(field.type.array && oppositeField.type.array)) {
+      if (thisRelation?.references?.length && thisRelation.fields?.length) {
+        if (oppositeRelation?.references || oppositeRelation?.fields) {
+          accept("error", '"fields" and "references" must be provided only on one side of relation field', {
+            node: oppositeField
+          });
+          return;
+        } else {
+          relationOwner = oppositeField;
+        }
+      } else if (oppositeRelation?.references?.length && oppositeRelation.fields?.length) {
+        if (thisRelation?.references || thisRelation?.fields) {
+          accept("error", '"fields" and "references" must be provided only on one side of relation field', {
+            node: field
+          });
+          return;
+        } else {
+          relationOwner = field;
+        }
+      } else {
         [
           field,
           oppositeField
@@ -6340,78 +6261,85 @@ var DataModelValidator = class {
             });
           }
         });
+        return;
       }
-      return;
-    }
-    if (!relationOwner.type.array && !relationOwner.type.optional) {
-      accept("error", "Relation field needs to be list or optional", {
-        node: relationOwner
-      });
-      return;
-    }
-    if (relationOwner !== field && !relationOwner.type.array) {
-      const containingModel = field.$container;
-      const uniqueFieldList = getUniqueFields(containingModel);
-      if (containingModel !== contextModel) {
-        uniqueFieldList.push(...getUniqueFields(contextModel));
+      if (!relationOwner.type.array && !relationOwner.type.optional) {
+        accept("error", "Relation field needs to be list or optional", {
+          node: relationOwner
+        });
+        return;
       }
-      thisRelation.fields?.forEach((ref) => {
-        const refField = ref.target.ref;
-        if (refField) {
-          if (refField.attributes.find((a) => a.decl.ref?.name === "@id" || a.decl.ref?.name === "@unique")) {
-            return;
-          }
-          if (uniqueFieldList.some((list) => list.includes(refField))) {
-            return;
-          }
-          accept("error", `Field "${refField.name}" on model "${containingModel.name}" is part of a one-to-one relation and must be marked as @unique or be part of a model-level @@unique attribute`, {
-            node: refField
-          });
+      if (relationOwner !== field && !relationOwner.type.array) {
+        const containingModel = field.$container;
+        const uniqueFieldList = getUniqueFields(containingModel);
+        if (containingModel !== contextModel) {
+          uniqueFieldList.push(...getUniqueFields(contextModel));
         }
-      });
+        thisRelation.fields?.forEach((ref) => {
+          const refField = ref.target.ref;
+          if (refField) {
+            if (refField.attributes.find((a) => a.decl.ref?.name === "@id" || a.decl.ref?.name === "@unique")) {
+              return;
+            }
+            if (uniqueFieldList.some((list) => list.includes(refField))) {
+              return;
+            }
+            accept("error", `Field "${refField.name}" on model "${containingModel.name}" is part of a one-to-one relation and must be marked as @unique or be part of a model-level @@unique attribute`, {
+              node: refField
+            });
+          }
+        });
+      }
     }
   }
   // checks if the given field is inherited directly or indirectly from a delegate model
-  isFieldInheritedFromDelegateModel(field, contextModel) {
-    const basePath = findUpInheritance(contextModel, field.$container);
-    if (basePath && basePath.some(isDelegateModel)) {
-      return true;
-    } else {
-      return false;
-    }
-  }
-  validateBaseAbstractModel(model, accept) {
-    model.superTypes.forEach((superType, index) => {
-      if (!superType.ref?.isAbstract && !superType.ref?.attributes.some((attr) => attr.decl.ref?.name === "@@delegate")) accept("error", `Model ${superType.$refText} cannot be extended because it's neither abstract nor marked as "@@delegate"`, {
-        node: model,
-        property: "superTypes",
-        index
-      });
-    });
+  isFieldInheritedFromDelegateModel(field) {
+    return isDelegateModel(field.$container);
   }
-  validateBaseDelegateModel(model, accept) {
-    if (model.superTypes.filter((base) => base.ref && isDelegateModel(base.ref)).length > 1) {
-      accept("error", "Extending from multiple delegate models is not supported", {
+  validateInherits(model, accept) {
+    if (!model.baseModel) {
+      return;
+    }
+    invariant2(model.baseModel.ref, "baseModel must be resolved");
+    if (!isDelegateModel(model.baseModel.ref)) {
+      accept("error", `Model ${model.baseModel.$refText} cannot be extended because it's not a delegate model`, {
         node: model,
-        property: "superTypes"
+        property: "baseModel"
       });
+      return;
     }
-  }
-  validateInheritance(dm, accept) {
-    const seen = [
-      dm
+    const seen = [];
+    const todo = [
+      model.baseModel.ref
     ];
-    const todo = dm.superTypes.map((superType) => superType.ref);
     while (todo.length > 0) {
       const current = todo.shift();
       if (seen.includes(current)) {
-        accept("error", `Circular inheritance detected: ${seen.map((m) => m.name).join(" -> ")} -> ${current.name}`, {
+        accept("error", `Cyclic inheritance detected: ${seen.map((m) => m.name).join(" -> ")} -> ${current.name}`, {
+          node: model
+        });
+        return;
+      }
+      seen.push(current);
+      if (current.baseModel) {
+        invariant2(current.baseModel.ref, "baseModel must be resolved");
+        todo.push(current.baseModel.ref);
+      }
+    }
+  }
+  validateMixins(dm, accept) {
+    const seen = [];
+    const todo = dm.mixins.map((mixin) => mixin.ref);
+    while (todo.length > 0) {
+      const current = todo.shift();
+      if (seen.includes(current)) {
+        accept("error", `Cyclic mixin detected: ${seen.map((m) => m.name).join(" -> ")} -> ${current.name}`, {
           node: dm
         });
         return;
       }
       seen.push(current);
-      todo.push(...current.superTypes.map((superType) => superType.ref));
+      todo.push(...current.mixins.map((mixin) => mixin.ref));
     }
   }
 };
@@ -6447,26 +6375,15 @@ var DataSourceValidator = class {
     }
   }
   validateUrl(ds, accept) {
-    const url = ds.fields.find((f) => f.name === "url");
-    if (!url) {
-      accept("error", 'datasource must include a "url" field', {
-        node: ds
-      });
+    const urlField = ds.fields.find((f) => f.name === "url");
+    if (!urlField) {
+      return;
     }
-    for (const fieldName of [
-      "url",
-      "shadowDatabaseUrl"
-    ]) {
-      const field = ds.fields.find((f) => f.name === fieldName);
-      if (!field) {
-        continue;
-      }
-      const value = getStringLiteral(field.value);
-      if (!value && !(isInvocationExpr(field.value) && field.value.function.ref?.name === "env")) {
-        accept("error", `"${fieldName}" must be set to a string literal or an invocation of "env" function`, {
-          node: field.value
-        });
-      }
+    const value = getStringLiteral(urlField.value);
+    if (!value && !(isInvocationExpr(urlField.value) && urlField.value.function.ref?.name === "env")) {
+      accept("error", `"${urlField.name}" must be set to a string literal or an invocation of "env" function`, {
+        node: urlField.value
+      });
     }
   }
   validateRelationMode(ds, accept) {
@@ -6490,7 +6407,6 @@ var EnumValidator = class {
   static {
     __name(this, "EnumValidator");
   }
-  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
   validate(_enum, accept) {
     validateDuplicatedDeclarations(_enum, _enum.fields, accept);
     this.validateAttributes(_enum, accept);
@@ -6619,7 +6535,7 @@ var ExpressionValidator = class {
       case "==":
       case "!=": {
         if (this.isInValidationContext(expr)) {
-          if (isDataModelFieldReference(expr.left) && isNullExpr(expr.right) || isDataModelFieldReference(expr.right) && isNullExpr(expr.left)) {
+          if (isDataFieldReference(expr.left) && isNullExpr(expr.right) || isDataFieldReference(expr.right) && isNullExpr(expr.left)) {
             return;
           }
         }
@@ -6648,11 +6564,11 @@ var ExpressionValidator = class {
               node: expr
             });
           }
-          if (isDataModelFieldReference(expr.left) && (isThisExpr(expr.right) || isDataModelFieldReference(expr.right))) {
+          if (isDataFieldReference(expr.left) && (isThisExpr(expr.right) || isDataFieldReference(expr.right))) {
             accept("error", "comparison between model-typed fields are not supported", {
               node: expr
             });
-          } else if (isDataModelFieldReference(expr.right) && (isThisExpr(expr.left) || isDataModelFieldReference(expr.left))) {
+          } else if (isDataFieldReference(expr.right) && (isThisExpr(expr.left) || isDataFieldReference(expr.left))) {
             accept("error", "comparison between model-typed fields are not supported", {
               node: expr
             });
@@ -6747,7 +6663,7 @@ var FunctionInvocationValidator = class {
       let curr = expr.$container;
       let containerAttribute;
       while (curr) {
-        if (isDataModelAttribute(curr) || isDataModelFieldAttribute(curr)) {
+        if (isDataModelAttribute(curr) || isDataFieldAttribute(curr)) {
           containerAttribute = curr;
           break;
         }
@@ -6848,7 +6764,7 @@ var FunctionInvocationValidator = class {
   _checkCheck(expr, accept) {
     let valid = true;
     const fieldArg = expr.args[0].value;
-    if (!isDataModelFieldReference(fieldArg) || !isDataModel(fieldArg.$resolvedType?.decl)) {
+    if (!isDataFieldReference(fieldArg) || !isDataModel(fieldArg.$resolvedType?.decl)) {
       accept("error", "argument must be a relation field", {
         node: expr.args[0]
       });
@@ -6935,10 +6851,10 @@ var SchemaValidator = class {
   constructor(documents) {
     this.documents = documents;
   }
-  async validate(model, accept) {
-    await this.validateImports(model, accept);
+  validate(model, accept) {
+    this.validateImports(model, accept);
     validateDuplicatedDeclarations(model, model.declarations, accept);
-    const importedModels = await resolveTransitiveImports(this.documents, model);
+    const importedModels = resolveTransitiveImports(this.documents, model);
     const importedNames = new Set(importedModels.flatMap((m) => m.declarations.map((d) => d.name)));
     for (const declaration of model.declarations) {
       if (importedNames.has(declaration.name)) {
@@ -6960,16 +6876,16 @@ var SchemaValidator = class {
       });
     }
   }
-  async validateImports(model, accept) {
-    await Promise.all(model.imports.map(async (imp) => {
-      const importedModel = await resolveImport(this.documents, imp);
-      const importPath = imp.path.endsWith(".zmodel") ? imp.path : `${imp.path}.zmodel`;
+  validateImports(model, accept) {
+    model.imports.forEach((imp) => {
+      const importedModel = resolveImport(this.documents, imp);
       if (!importedModel) {
+        const importPath = imp.path.endsWith(".zmodel") ? imp.path : `${imp.path}.zmodel`;
         accept("error", `Cannot find model file ${importPath}`, {
           node: imp
         });
       }
-    }));
+    });
   }
 };
 
@@ -7150,8 +7066,8 @@ var ZModelLinker = class extends DefaultLinker {
       case DataModel:
         this.resolveDataModel(node, document, extraScopes);
         break;
-      case DataModelField:
-        this.resolveDataModelField(node, document, extraScopes);
+      case DataField:
+        this.resolveDataField(node, document, extraScopes);
         break;
       default:
         this.resolveDefault(node, document, extraScopes);
@@ -7297,10 +7213,10 @@ var ZModelLinker = class extends DefaultLinker {
   resolveAttributeArg(node, document, extraScopes) {
     const attrParam = this.findAttrParamForArg(node);
     const attrAppliedOn = node.$container.$container;
-    if (attrParam?.type.type === "TransitiveFieldReference" && isDataModelField(attrAppliedOn)) {
+    if (attrParam?.type.type === "TransitiveFieldReference" && isDataField(attrAppliedOn)) {
       const transitiveDataModel = attrAppliedOn.type.reference?.ref;
       if (transitiveDataModel) {
-        const scopeProvider = /* @__PURE__ */ __name((name) => getModelFieldsWithBases(transitiveDataModel).find((f) => f.name === name), "scopeProvider");
+        const scopeProvider = /* @__PURE__ */ __name((name) => getAllFields(transitiveDataModel).find((f) => f.name === name), "scopeProvider");
         if (isArrayExpr(node.value)) {
           node.value.items.forEach((item) => {
             if (isReferenceExpr(item)) {
@@ -7356,7 +7272,7 @@ var ZModelLinker = class extends DefaultLinker {
   resolveDataModel(node, document, extraScopes) {
     return this.resolveDefault(node, document, extraScopes);
   }
-  resolveDataModelField(node, document, extraScopes) {
+  resolveDataField(node, document, extraScopes) {
     this.resolve(node.type, document, extraScopes);
     let scopes = extraScopes;
     if (node.type.reference?.ref && isEnum(node.type.reference.ref)) {
@@ -7385,7 +7301,7 @@ var ZModelLinker = class extends DefaultLinker {
   //#region Utils
   resolveToDeclaredType(node, type) {
     let nullable = false;
-    if (isDataModelFieldType(type) || isTypeDefField(type)) {
+    if (isDataFieldType(type)) {
       nullable = type.optional;
       if (type.unsupported) {
         node.$resolvedType = {
@@ -7446,6 +7362,14 @@ var ZModelScopeComputation = class extends DefaultScopeComputation {
   }
   processNode(node, document, scopes) {
     super.processNode(node, document, scopes);
+    if (isDataModel(node)) {
+      const bases = getRecursiveBases(node);
+      for (const base of bases) {
+        for (const field of base.fields) {
+          scopes.add(node, this.descriptions.createDescription(field, this.nameProvider.getName(field)));
+        }
+      }
+    }
   }
 };
 var ZModelScopeProvider = class extends DefaultScopeProvider {
@@ -7493,16 +7417,13 @@ var ZModelScopeProvider = class extends DefaultScopeProvider {
     );
     return match3(node.operand).when(isReferenceExpr, (operand) => {
       const ref = operand.target.ref;
-      if (isDataModelField(ref) || isTypeDefField(ref)) {
+      if (isDataField(ref)) {
         return this.createScopeForContainer(ref.type.reference?.ref, globalScope, allowTypeDefScope);
       }
       return EMPTY_SCOPE;
     }).when(isMemberAccessExpr, (operand) => {
       const ref = operand.member.ref;
-      if (isDataModelField(ref) && !ref.type.array) {
-        return this.createScopeForContainer(ref.type.reference?.ref, globalScope, allowTypeDefScope);
-      }
-      if (isTypeDefField(ref) && !ref.type.array) {
+      if (isDataField(ref) && !ref.type.array) {
         return this.createScopeForContainer(ref.type.reference?.ref, globalScope, allowTypeDefScope);
       }
       return EMPTY_SCOPE;
@@ -7525,13 +7446,13 @@ var ZModelScopeProvider = class extends DefaultScopeProvider {
     const allowTypeDefScope = false;
     return match3(collection).when(isReferenceExpr, (expr) => {
       const ref = expr.target.ref;
-      if (isDataModelField(ref) || isTypeDefField(ref)) {
+      if (isDataField(ref)) {
         return this.createScopeForContainer(ref.type.reference?.ref, globalScope, allowTypeDefScope);
       }
       return EMPTY_SCOPE;
     }).when(isMemberAccessExpr, (expr) => {
       const ref = expr.member.ref;
-      if (isDataModelField(ref) || isTypeDefField(ref)) {
+      if (isDataField(ref)) {
         return this.createScopeForContainer(ref.type.reference?.ref, globalScope, allowTypeDefScope);
       }
       return EMPTY_SCOPE;
@@ -7556,7 +7477,7 @@ var ZModelScopeProvider = class extends DefaultScopeProvider {
   }
   createScopeForContainer(node, globalScope, includeTypeDefScope = false) {
     if (isDataModel(node)) {
-      return this.createScopeForNodes(getModelFieldsWithBases(node), globalScope);
+      return this.createScopeForNodes(getAllFields(node), globalScope);
     } else if (includeTypeDefScope && isTypeDef(node)) {
       return this.createScopeForNodes(node.fields, globalScope);
     } else {
@@ -7586,10 +7507,10 @@ function getCollectionPredicateContext(node) {
 __name(getCollectionPredicateContext, "getCollectionPredicateContext");
 
 // src/zmodel-workspace-manager.ts
-import { DefaultWorkspaceManager, URI as URI2 } from "langium";
-import fs2 from "node:fs";
-import path2 from "node:path";
-import { fileURLToPath } from "node:url";
+import { DefaultWorkspaceManager, URI as URI2, UriUtils as UriUtils2 } from "langium";
+import fs2 from "fs";
+import path2 from "path";
+import { fileURLToPath } from "url";
 var ZModelWorkspaceManager = class extends DefaultWorkspaceManager {
   static {
     __name(this, "ZModelWorkspaceManager");
@@ -7618,7 +7539,7 @@ var ZModelWorkspaceManager = class extends DefaultWorkspaceManager {
           console.log(`Found installed zenstack package stdlib at: ${installedStdlibPath}`);
           break;
         }
-      } catch (error) {
+      } catch {
         continue;
       }
     }
@@ -7631,6 +7552,67 @@ var ZModelWorkspaceManager = class extends DefaultWorkspaceManager {
     }
     const stdlib = await this.documentFactory.fromUri(URI2.file(stdLibPath));
     collector(stdlib);
+    const documents = this.langiumDocuments.all;
+    const pluginModels = /* @__PURE__ */ new Set();
+    documents.forEach((doc) => {
+      const parsed = doc.parseResult.value;
+      parsed.declarations.forEach((decl) => {
+        if (isPlugin(decl)) {
+          const providerField = decl.fields.find((f) => f.name === "provider");
+          if (providerField) {
+            const provider = getLiteral(providerField.value);
+            if (provider) {
+              pluginModels.add(provider);
+            }
+          }
+        }
+      });
+    });
+    if (pluginModels.size > 0) {
+      console.log(`Used plugin modules: ${Array.from(pluginModels)}`);
+      const pendingPluginModules = new Set(pluginModels);
+      await Promise.all(folders.map((wf) => [
+        wf,
+        this.getRootFolder(wf)
+      ]).map(async (entry) => this.loadPluginModels(...entry, pendingPluginModules, collector)));
+    }
+  }
+  async loadPluginModels(workspaceFolder, folderPath, pendingPluginModels, collector) {
+    const content = (await this.fileSystemProvider.readDirectory(folderPath)).sort((a, b) => {
+      if (a.isDirectory && b.isDirectory) {
+        const aName = UriUtils2.basename(a.uri);
+        if (aName === "node_modules") {
+          return -1;
+        } else {
+          return 1;
+        }
+      } else {
+        return 0;
+      }
+    });
+    for (const entry of content) {
+      if (entry.isDirectory) {
+        const name = UriUtils2.basename(entry.uri);
+        if (name === "node_modules") {
+          for (const plugin of Array.from(pendingPluginModels)) {
+            const path4 = UriUtils2.joinPath(entry.uri, plugin, PLUGIN_MODULE_NAME);
+            try {
+              await this.fileSystemProvider.readFile(path4);
+              const document = await this.langiumDocuments.getOrCreateDocument(path4);
+              collector(document);
+              console.log(`Adding plugin document from ${path4.path}`);
+              pendingPluginModels.delete(plugin);
+              if (pendingPluginModels.size === 0) {
+                return;
+              }
+            } catch {
+            }
+          }
+        } else {
+          await this.loadPluginModels(workspaceFolder, entry.uri, pendingPluginModels, collector);
+        }
+      }
+    }
   }
 };
 
@@ -7706,10 +7688,16 @@ async function loadDocument(fileName, pluginModelFiles = []) {
   const pluginDocs = await Promise.all(pluginModelFiles.map((file) => services.shared.workspace.LangiumDocuments.getOrCreateDocument(URI3.file(path3.resolve(file)))));
   const langiumDocuments = services.shared.workspace.LangiumDocuments;
   const document = await langiumDocuments.getOrCreateDocument(URI3.file(path3.resolve(fileName)));
+  const importedURIs = await loadImports(document, langiumDocuments);
+  const importedDocuments = [];
+  for (const uri of importedURIs) {
+    importedDocuments.push(await langiumDocuments.getOrCreateDocument(uri));
+  }
   await services.shared.workspace.DocumentBuilder.build([
     stdLib,
     ...pluginDocs,
-    document
+    document,
+    ...importedDocuments
   ], {
     validation: true
   });
@@ -7736,6 +7724,20 @@ async function loadDocument(fileName, pluginModelFiles = []) {
       warnings
     };
   }
+  const model = document.parseResult.value;
+  const imported = mergeImportsDeclarations(langiumDocuments, model);
+  imported.forEach((model2) => {
+    langiumDocuments.deleteDocument(model2.$document.uri);
+    services.shared.workspace.IndexManager.remove(model2.$document.uri);
+  });
+  const additionalErrors = validationAfterImportMerge(model);
+  if (additionalErrors.length > 0) {
+    return {
+      success: false,
+      errors: additionalErrors,
+      warnings
+    };
+  }
   return {
     success: true,
     model: document.parseResult.value,
@@ -7743,6 +7745,68 @@ async function loadDocument(fileName, pluginModelFiles = []) {
   };
 }
 __name(loadDocument, "loadDocument");
+async function loadImports(document, documents, uris = /* @__PURE__ */ new Set()) {
+  const uriString = document.uri.toString();
+  if (!uris.has(uriString)) {
+    uris.add(uriString);
+    const model = document.parseResult.value;
+    for (const imp of model.imports) {
+      const importedModel = resolveImport(documents, imp);
+      if (importedModel) {
+        const importedDoc = getDocument(importedModel);
+        await loadImports(importedDoc, documents, uris);
+      }
+    }
+  }
+  return Array.from(uris).filter((x) => uriString != x).map((e) => URI3.parse(e));
+}
+__name(loadImports, "loadImports");
+function mergeImportsDeclarations(documents, model) {
+  const importedModels = resolveTransitiveImports(documents, model);
+  const importedDeclarations = importedModels.flatMap((m) => m.declarations);
+  model.declarations.push(...importedDeclarations);
+  model.imports = [];
+  linkContentToContainer(model);
+  return importedModels;
+}
+__name(mergeImportsDeclarations, "mergeImportsDeclarations");
+function linkContentToContainer(node) {
+  for (const [name, value] of Object.entries(node)) {
+    if (!name.startsWith("$")) {
+      if (Array.isArray(value)) {
+        value.forEach((item, index) => {
+          if (isAstNode(item)) {
+            item.$container = node;
+            item.$containerProperty = name;
+            item.$containerIndex = index;
+          }
+        });
+      } else if (isAstNode(value)) {
+        value.$container = node;
+        value.$containerProperty = name;
+      }
+    }
+  }
+}
+__name(linkContentToContainer, "linkContentToContainer");
+function validationAfterImportMerge(model) {
+  const errors = [];
+  const dataSources = model.declarations.filter((d) => isDataSource(d));
+  if (dataSources.length === 0) {
+    errors.push("Validation error: schema must have a datasource declaration");
+  } else {
+    if (dataSources.length > 1) {
+      errors.push("Validation error: multiple datasource declarations are not allowed");
+    }
+  }
+  const decls = getDataModelAndTypeDefs(model, true);
+  const authDecls = decls.filter((d) => hasAttribute(d, "@@auth"));
+  if (authDecls.length > 1) {
+    errors.push("Validation error: Multiple `@@auth` declarations are not allowed");
+  }
+  return errors;
+}
+__name(validationAfterImportMerge, "validationAfterImportMerge");
 export {
   DocumentLoadError,
   ZModelLanguageMetaData,