@zenstackhq/language 3.0.0-alpha.9 → 3.0.0-beta.10

package/dist/index.js

@@ -7,45 +7,11 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
 
-// src/index.ts
-import { URI as URI3 } from "langium";
-import { NodeFileSystem } from "langium/node";
+// src/document.ts
+import { isAstNode, URI as URI4 } from "langium";
 import fs3 from "fs";
-import path3 from "path";
-import { fileURLToPath as fileURLToPath2 } from "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 path4 from "path";
+import { fileURLToPath as fileURLToPath4 } from "url";
 
 // src/generated/ast.ts
 import * as langium from "langium";
@@ -64,7 +30,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 +62,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 +87,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 +140,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,12 +168,6 @@ 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 langium.AbstractAstReflection {
@@ -227,11 +190,11 @@ var ZModelAstReflection = class extends langium.AbstractAstReflection {
       ConfigField,
       ConfigInvocationArg,
       ConfigInvocationExpr,
+      DataField,
+      DataFieldAttribute,
+      DataFieldType,
       DataModel,
       DataModelAttribute,
-      DataModelField,
-      DataModelFieldAttribute,
-      DataModelFieldType,
       DataSource,
       Enum,
       EnumField,
@@ -262,9 +225,6 @@ var ZModelAstReflection = class extends langium.AbstractAstReflection {
       ThisExpr,
       TypeDeclaration,
       TypeDef,
-      TypeDefField,
-      TypeDefFieldType,
-      TypeDefFieldTypes,
       UnaryExpr,
       UnsupportedFieldType
     ];
@@ -297,16 +257,13 @@ var ZModelAstReflection = class extends langium.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 +282,22 @@ var ZModelAstReflection = class extends langium.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 +307,6 @@ var ZModelAstReflection = class extends langium.AbstractAstReflection {
       case "ReferenceExpr:target": {
         return ReferenceTarget;
       }
-      case "TypeDefFieldType:reference": {
-        return TypeDefFieldTypes;
-      }
       default: {
         throw new Error(`${referenceId} is not a valid reference id.`);
       }
@@ -535,9 +493,9 @@ var ZModelAstReflection = class extends langium.AbstractAstReflection {
           ]
         };
       }
-      case DataModel: {
+      case DataField: {
         return {
-          name: DataModel,
+          name: DataField,
           properties: [
             {
               name: "attributes",
@@ -547,31 +505,18 @@ var ZModelAstReflection = class extends langium.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 +528,73 @@ var ZModelAstReflection = class extends langium.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 +968,11 @@ var ZModelAstReflection = class extends langium.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 +1011,42 @@ var ZModelAstReflection = class extends langium.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 { DocumentState as DocumentState2, inject, URI as URI3 } from "langium";
+import { createDefaultModule, createDefaultSharedModule } from "langium/lsp";
+import { NodeFileSystem } from "langium/node";
+import path3 from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+
 // src/generated/grammar.ts
 import { loadGrammarFromJson } from "langium";
 var loadedZModelGrammar;
@@ -1214,7 +1169,7 @@ var ZModelGrammar = /* @__PURE__ */ __name(() => loadedZModelGrammar ?? (loadedZ
           {
             "$type": "RuleCall",
             "rule": {
-              "$ref": "#/rules@40"
+              "$ref": "#/rules@42"
             },
             "arguments": []
           },
@@ -3008,16 +2963,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 +2980,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 +3081,7 @@ var ZModelGrammar = /* @__PURE__ */ __name(() => loadedZModelGrammar ?? (loadedZ
                 "terminal": {
                   "$type": "RuleCall",
                   "rule": {
-                    "$ref": "#/rules@38"
+                    "$ref": "#/rules@40"
                   },
                   "arguments": []
                 }
@@ -3157,53 +3116,138 @@ var ZModelGrammar = /* @__PURE__ */ __name(() => loadedZModelGrammar ?? (loadedZ
     },
     {
       "$type": "ParserRule",
-      "name": "DataModelField",
+      "fragment": true,
+      "name": "WithClause",
       "definition": {
         "$type": "Group",
         "elements": [
           {
-            "$type": "Assignment",
-            "feature": "comments",
-            "operator": "+=",
-            "terminal": {
-              "$type": "RuleCall",
-              "rule": {
-                "$ref": "#/rules@71"
-              },
-              "arguments": []
-            },
-            "cardinality": "*"
+            "$type": "Keyword",
+            "value": "with"
           },
           {
             "$type": "Assignment",
-            "feature": "name",
-            "operator": "=",
+            "feature": "mixins",
+            "operator": "+=",
             "terminal": {
-              "$type": "RuleCall",
-              "rule": {
-                "$ref": "#/rules@52"
+              "$type": "CrossReference",
+              "type": {
+                "$ref": "#/rules@42"
               },
-              "arguments": []
+              "deprecatedSyntax": false
             }
           },
           {
-            "$type": "Assignment",
-            "feature": "type",
-            "operator": "=",
-            "terminal": {
-              "$type": "RuleCall",
-              "rule": {
-                "$ref": "#/rules@39"
+            "$type": "Group",
+            "elements": [
+              {
+                "$type": "Keyword",
+                "value": ",",
+                "cardinality": "?"
               },
-              "arguments": []
-            }
-          },
-          {
-            "$type": "Assignment",
-            "feature": "attributes",
-            "operator": "+=",
-            "terminal": {
-              "$type": "RuleCall",
+              {
+                "$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": [
+          {
+            "$type": "Assignment",
+            "feature": "comments",
+            "operator": "+=",
+            "terminal": {
+              "$type": "RuleCall",
+              "rule": {
+                "$ref": "#/rules@71"
+              },
+              "arguments": []
+            },
+            "cardinality": "*"
+          },
+          {
+            "$type": "Assignment",
+            "feature": "name",
+            "operator": "=",
+            "terminal": {
+              "$type": "RuleCall",
+              "rule": {
+                "$ref": "#/rules@52"
+              },
+              "arguments": []
+            }
+          },
+          {
+            "$type": "Assignment",
+            "feature": "type",
+            "operator": "=",
+            "terminal": {
+              "$type": "RuleCall",
+              "rule": {
+                "$ref": "#/rules@41"
+              },
+              "arguments": []
+            }
+          },
+          {
+            "$type": "Assignment",
+            "feature": "attributes",
+            "operator": "+=",
+            "terminal": {
+              "$type": "RuleCall",
               "rule": {
                 "$ref": "#/rules@56"
               },
@@ -3222,7 +3266,7 @@ var ZModelGrammar = /* @__PURE__ */ __name(() => loadedZModelGrammar ?? (loadedZ
     },
     {
       "$type": "ParserRule",
-      "name": "DataModelFieldType",
+      "name": "DataFieldType",
       "definition": {
         "$type": "Group",
         "elements": [
@@ -3260,7 +3304,7 @@ var ZModelGrammar = /* @__PURE__ */ __name(() => loadedZModelGrammar ?? (loadedZ
                 "terminal": {
                   "$type": "CrossReference",
                   "type": {
-                    "$ref": "#/types@3"
+                    "$ref": "#/types@2"
                   },
                   "terminal": {
                     "$type": "RuleCall",
@@ -3347,6 +3391,14 @@ var ZModelGrammar = /* @__PURE__ */ __name(() => loadedZModelGrammar ?? (loadedZ
               "arguments": []
             }
           },
+          {
+            "$type": "RuleCall",
+            "rule": {
+              "$ref": "#/rules@38"
+            },
+            "arguments": [],
+            "cardinality": "?"
+          },
           {
             "$type": "Keyword",
             "value": "{"
@@ -3361,7 +3413,7 @@ var ZModelGrammar = /* @__PURE__ */ __name(() => loadedZModelGrammar ?? (loadedZ
                 "terminal": {
                   "$type": "RuleCall",
                   "rule": {
-                    "$ref": "#/rules@41"
+                    "$ref": "#/rules@40"
                   },
                   "arguments": []
                 }
@@ -3394,151 +3446,6 @@ var ZModelGrammar = /* @__PURE__ */ __name(() => loadedZModelGrammar ?? (loadedZ
       "parameters": [],
       "wildcard": false
     },
-    {
-      "$type": "ParserRule",
-      "name": "TypeDefField",
-      "definition": {
-        "$type": "Group",
-        "elements": [
-          {
-            "$type": "Assignment",
-            "feature": "comments",
-            "operator": "+=",
-            "terminal": {
-              "$type": "RuleCall",
-              "rule": {
-                "$ref": "#/rules@71"
-              },
-              "arguments": []
-            },
-            "cardinality": "*"
-          },
-          {
-            "$type": "Assignment",
-            "feature": "name",
-            "operator": "=",
-            "terminal": {
-              "$type": "RuleCall",
-              "rule": {
-                "$ref": "#/rules@52"
-              },
-              "arguments": []
-            }
-          },
-          {
-            "$type": "Assignment",
-            "feature": "type",
-            "operator": "=",
-            "terminal": {
-              "$type": "RuleCall",
-              "rule": {
-                "$ref": "#/rules@42"
-              },
-              "arguments": []
-            }
-          },
-          {
-            "$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": "?=",
-                "terminal": {
-                  "$type": "Keyword",
-                  "value": "["
-                }
-              },
-              {
-                "$type": "Keyword",
-                "value": "]"
-              }
-            ],
-            "cardinality": "?"
-          },
-          {
-            "$type": "Assignment",
-            "feature": "optional",
-            "operator": "?=",
-            "terminal": {
-              "$type": "Keyword",
-              "value": "?"
-            },
-            "cardinality": "?"
-          }
-        ]
-      },
-      "definesHiddenTokens": false,
-      "entry": false,
-      "fragment": false,
-      "hiddenTokens": [],
-      "parameters": [],
-      "wildcard": false
-    },
     {
       "$type": "ParserRule",
       "name": "UnsupportedFieldType",
@@ -3939,7 +3846,7 @@ var ZModelGrammar = /* @__PURE__ */ __name(() => loadedZModelGrammar ?? (loadedZ
                 "terminal": {
                   "$type": "CrossReference",
                   "type": {
-                    "$ref": "#/types@3"
+                    "$ref": "#/types@2"
                   },
                   "terminal": {
                     "$type": "RuleCall",
@@ -4553,7 +4460,7 @@ var ZModelGrammar = /* @__PURE__ */ __name(() => loadedZModelGrammar ?? (loadedZ
                 "terminal": {
                   "$type": "CrossReference",
                   "type": {
-                    "$ref": "#/types@3"
+                    "$ref": "#/types@2"
                   },
                   "terminal": {
                     "$type": "RuleCall",
@@ -4607,7 +4514,7 @@ var ZModelGrammar = /* @__PURE__ */ __name(() => loadedZModelGrammar ?? (loadedZ
     },
     {
       "$type": "ParserRule",
-      "name": "DataModelFieldAttribute",
+      "name": "DataFieldAttribute",
       "definition": {
         "$type": "Group",
         "elements": [
@@ -5124,13 +5031,7 @@ var ZModelGrammar = /* @__PURE__ */ __name(() => loadedZModelGrammar ?? (loadedZ
           {
             "$type": "SimpleType",
             "typeRef": {
-              "$ref": "#/rules@38"
-            }
-          },
-          {
-            "$type": "SimpleType",
-            "typeRef": {
-              "$ref": "#/rules@41"
+              "$ref": "#/rules@40"
             }
           },
           {
@@ -5146,42 +5047,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 +5068,7 @@ var ZModelGrammar = /* @__PURE__ */ __name(() => loadedZModelGrammar ?? (loadedZ
           {
             "$type": "SimpleType",
             "typeRef": {
-              "$ref": "#/rules@40"
+              "$ref": "#/rules@42"
             }
           },
           {
@@ -5221,7 +5090,7 @@ var ZModelGrammar = /* @__PURE__ */ __name(() => loadedZModelGrammar ?? (loadedZ
 
 // src/generated/module.ts
 var ZModelLanguageMetaData = {
-  languageId: "zmodel",
+  languageId: "zmodel-v3",
   fileExtensions: [
     ".zmodel"
   ],
@@ -5237,14 +5106,12 @@ var ZModelGeneratedModule = {
   parser: {}
 };
 
-// src/validators/attribute-application-validator.ts
-import { AstUtils as AstUtils2 } from "langium";
-import pluralize from "pluralize";
-
 // src/utils.ts
 import { AstUtils, URI } from "langium";
-import path from "path";
 import fs from "fs";
+import { createRequire } from "module";
+import path from "path";
+import { fileURLToPath, pathToFileURL } from "url";
 function hasAttribute(decl, name) {
   return !!getAttribute(decl, name);
 }
@@ -5316,18 +5183,14 @@ 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);
 }
 __name(isRelationshipField, "isRelationshipField");
-function isFutureExpr(node) {
-  return isInvocationExpr(node) && node.function.ref?.name === "future" && isFromStdlib(node.function.ref);
-}
-__name(isFutureExpr, "isFutureExpr");
 function isDelegateModel(node) {
   return isDataModel(node) && hasAttribute(node, "@@delegate");
 }
@@ -5339,43 +5202,20 @@ 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);
+  const bases = [
+    ...decl.mixins,
+    ...isDataModel(decl) && decl.baseModel ? [
+      decl.baseModel
+    ] : []
+  ];
+  bases.forEach((base) => {
+    const baseDecl = decl.$container.declarations.find((d) => isTypeDef(d) || isDataModel(d) && d.name === base.$refText);
     if (baseDecl) {
       if (!includeDelegate && isDelegateModel(baseDecl)) {
         return;
@@ -5388,14 +5228,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 +5248,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;
     }
@@ -5517,7 +5355,7 @@ function getFunctionExpressionContext(funcDecl) {
 }
 __name(getFunctionExpressionContext, "getFunctionExpressionContext");
 function isCheckInvocation(node) {
-  return isInvocationExpr(node) && node.function.ref?.name === "check" && isFromStdlib(node.function.ref);
+  return isInvocationExpr(node) && node.function.ref?.name === "check";
 }
 __name(isCheckInvocation, "isCheckInvocation");
 function resolveTransitiveImports(documents, model) {
@@ -5563,34 +5401,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 {
-    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));
@@ -5604,10 +5432,10 @@ function getAuthDecl(decls) {
   return authModel;
 }
 __name(getAuthDecl, "getAuthDecl");
-function isFutureInvocation(node) {
-  return isInvocationExpr(node) && node.function.ref?.name === "future" && isFromStdlib(node.function.ref);
+function isBeforeInvocation(node) {
+  return isInvocationExpr(node) && node.function.ref?.name === "before";
 }
-__name(isFutureInvocation, "isFutureInvocation");
+__name(isBeforeInvocation, "isBeforeInvocation");
 function isCollectionPredicate(node) {
   return isBinaryExpr(node) && [
     "?",
@@ -5655,8 +5483,131 @@ 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) {
+    if (mixin.ref) {
+      fields.push(...getAllFields(mixin.ref, includeIgnored, seen));
+    }
+  }
+  if (isDataModel(decl) && decl.baseModel) {
+    if (decl.baseModel.ref) {
+      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) {
+    if (mixin.ref) {
+      attributes.push(...getAllAttributes(mixin.ref, seen));
+    }
+  }
+  if (isDataModel(decl) && decl.baseModel) {
+    if (decl.baseModel.ref) {
+      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 getPluginDocuments(model, schemaPath) {
+  const result = [];
+  for (const decl of model.declarations.filter(isPlugin)) {
+    const providerField = decl.fields.find((f) => f.name === "provider");
+    if (!providerField) {
+      continue;
+    }
+    const provider = getLiteral(providerField.value);
+    if (!provider) {
+      continue;
+    }
+    let pluginModelFile;
+    let providerPath = path.resolve(path.dirname(schemaPath), provider);
+    if (fs.existsSync(providerPath)) {
+      if (fs.statSync(providerPath).isDirectory()) {
+        providerPath = path.join(providerPath, "index.js");
+      }
+      pluginModelFile = path.resolve(path.dirname(providerPath), PLUGIN_MODULE_NAME);
+      if (!fs.existsSync(pluginModelFile)) {
+        pluginModelFile = findUp([
+          PLUGIN_MODULE_NAME
+        ], path.dirname(providerPath));
+      }
+    }
+    if (!pluginModelFile) {
+      if (typeof import.meta.resolve === "function") {
+        try {
+          const resolvedUrl = import.meta.resolve(`${provider}/${PLUGIN_MODULE_NAME}`);
+          pluginModelFile = fileURLToPath(resolvedUrl);
+        } catch {
+        }
+      }
+    }
+    if (!pluginModelFile) {
+      try {
+        const require2 = createRequire(pathToFileURL(schemaPath));
+        pluginModelFile = require2.resolve(`${provider}/${PLUGIN_MODULE_NAME}`);
+      } catch {
+      }
+    }
+    if (pluginModelFile && fs.existsSync(pluginModelFile)) {
+      result.push(pluginModelFile);
+    }
+  }
+  return result;
+}
+__name(getPluginDocuments, "getPluginDocuments");
+function findUp(names, cwd = process.cwd(), multiple = false, result = []) {
+  if (!names.some((name) => !!name)) {
+    return void 0;
+  }
+  const target = names.find((name) => fs.existsSync(path.join(cwd, name)));
+  if (multiple === false && target) {
+    return path.join(cwd, target);
+  }
+  if (target) {
+    result.push(path.join(cwd, target));
+  }
+  const up = path.resolve(cwd, "..");
+  if (up === cwd) {
+    return multiple && result.length > 0 ? result : void 0;
+  }
+  return findUp(names, up, multiple, result);
+}
+__name(findUp, "findUp");
+function findRootNode(node) {
+  while (node.$container) {
+    node = node.$container;
+  }
+  return node;
+}
+__name(findRootNode, "findRootNode");
 
 // src/validators/attribute-application-validator.ts
+import { AstUtils as AstUtils2 } from "langium";
+import pluralize from "pluralize";
 function _ts_decorate(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -5682,7 +5633,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 +5645,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 +5699,29 @@ 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
+      });
+    }
+  }
+  // TODO: design a way to let plugin register validation
   _checkModelLevelPolicy(attr, accept) {
     const kind = getStringLiteral(attr.args[0]?.value);
     if (!kind) {
@@ -5768,11 +5734,61 @@ var AttributeApplicationValidator = class {
       "create",
       "read",
       "update",
+      "post-update",
       "delete",
       "all"
     ], attr, accept);
-    this.rejectEncryptedFields(attr, accept);
+    if ((kind === "create" || kind === "all") && attr.args[1]?.value) {
+      this.rejectNonOwnedRelationInExpression(attr.args[1].value, accept);
+    }
+    if (kind !== "post-update" && attr.args[1]?.value) {
+      const beforeCall = AstUtils2.streamAst(attr.args[1]?.value).find(isBeforeInvocation);
+      if (beforeCall) {
+        accept("error", `"before()" is only allowed in "post-update" policy rules`, {
+          node: beforeCall
+        });
+      }
+    }
+  }
+  rejectNonOwnedRelationInExpression(expr, accept) {
+    const contextModel = AstUtils2.getContainerOfType(expr, isDataModel);
+    if (!contextModel) {
+      return;
+    }
+    if (AstUtils2.streamAst(expr).some((node) => {
+      if (!isDataFieldReference(node)) {
+        return false;
+      }
+      if (node.target.ref?.$container !== contextModel) {
+        return false;
+      }
+      const field = node.target.ref;
+      if (!isRelationshipField(field)) {
+        return false;
+      }
+      if (isAuthOrAuthMemberAccess(node)) {
+        return false;
+      }
+      const startNode = isCollectionPredicate(node.$container) && node.$container.left === node ? node.$container : node;
+      const collectionPredicate = AstUtils2.getContainerOfType(startNode.$container, isCollectionPredicate);
+      if (collectionPredicate && isAuthOrAuthMemberAccess(collectionPredicate.left)) {
+        return false;
+      }
+      const relationAttr = field.attributes.find((attr) => attr.decl.ref?.name === "@relation");
+      if (!relationAttr) {
+        return true;
+      }
+      if (!relationAttr.args.some((arg) => arg.name === "fields")) {
+        return true;
+      }
+      return false;
+    })) {
+      accept("error", `non-owned relation fields are not allowed in "create" rules`, {
+        node: expr
+      });
+    }
   }
+  // TODO: design a way to let plugin register validation
   _checkFieldLevelPolicy(attr, accept) {
     const kind = getStringLiteral(attr.args[0]?.value);
     if (!kind) {
@@ -5787,8 +5803,8 @@ var AttributeApplicationValidator = class {
       "all"
     ], attr, accept);
     const expr = attr.args[1]?.value;
-    if (expr && AstUtils2.streamAst(expr).some((node) => isFutureExpr(node))) {
-      accept("error", `"future()" is not allowed in field-level policy rules`, {
+    if (expr && AstUtils2.streamAst(expr).some((node) => isBeforeInvocation(node))) {
+      accept("error", `"before()" is not allowed in field-level policy rules`, {
         node: expr
       });
     }
@@ -5800,11 +5816,10 @@ var AttributeApplicationValidator = class {
         });
       }
     }
-    this.rejectEncryptedFields(attr, accept);
   }
   _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 +5828,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 +5847,7 @@ var AttributeApplicationValidator = class {
           });
           return;
         }
-        if (!isDataModelField(item.target.ref)) {
+        if (!isDataField(item.target.ref)) {
           accept("error", `Expecting a field reference`, {
             node: item
           });
@@ -5841,15 +5865,6 @@ var AttributeApplicationValidator = class {
       });
     }
   }
-  rejectEncryptedFields(attr, accept) {
-    AstUtils2.streamAllContents(attr).forEach((node) => {
-      if (isDataModelFieldReference(node) && hasAttribute(node.target.ref, "@encrypted")) {
-        accept("error", `Encrypted fields cannot be used in policy rules`, {
-          node
-        });
-      }
-    });
-  }
   validatePolicyKinds(kind, candidates, attr, accept) {
     const items = kind.split(",").map((x) => x.trim());
     items.forEach((item) => {
@@ -5893,6 +5908,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 +5924,11 @@ 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)) {
+      const dstIsTypedJson = hasAttribute(attr.$container, "@json");
+      if (dstIsTypedJson && attr.decl.ref?.name === "@default") {
+        return argResolvedType.decl === "String";
+      }
       dstIsArray = attr.$container.type.array;
     }
   }
@@ -5925,14 +5945,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 +5962,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;
         }
@@ -6000,6 +6020,9 @@ function isValidAttributeTarget(attrDecl, targetDecl) {
       case "TypeDefField":
         allowed = allowed || isTypeDef(targetDecl.type.reference?.ref);
         break;
+      case "ListField":
+        allowed = allowed || !isDataModel(targetDecl.type.reference?.ref) && targetDecl.type.array;
+        break;
       default:
         break;
     }
@@ -6010,8 +6033,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 +6049,7 @@ var AttributeValidator = class {
 };
 
 // src/validators/datamodel-validator.ts
+import { invariant } from "@zenstackhq/common-helpers";
 import { AstUtils as AstUtils3 } from "langium";
 
 // src/validators/common.ts
@@ -6038,8 +6062,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 +6082,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 +6127,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 +6145,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 +6171,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 +6290,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 +6340,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 +6381,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;
+    }
+    invariant(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) {
+        invariant(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 +6495,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) {
@@ -6535,11 +6572,21 @@ var ExpressionValidator = class {
       }
     }
     switch (expr.$type) {
+      case "MemberAccessExpr":
+        this.validateMemberAccessExpr(expr, accept);
+        break;
       case "BinaryExpr":
         this.validateBinaryExpr(expr, accept);
         break;
     }
   }
+  validateMemberAccessExpr(expr, accept) {
+    if (isBeforeInvocation(expr.operand) && isDataModel(expr.$resolvedType?.decl)) {
+      accept("error", "relation fields cannot be accessed from `before()`", {
+        node: expr
+      });
+    }
+  }
   validateBinaryExpr(expr, accept) {
     switch (expr.operator) {
       case "in": {
@@ -6592,23 +6639,25 @@ var ExpressionValidator = class {
             "Any"
           ];
         }
-        if (typeof expr.left.$resolvedType?.decl !== "string" || !supportedShapes.includes(expr.left.$resolvedType.decl)) {
+        const leftResolvedDecl = expr.left.$resolvedType?.decl;
+        const rightResolvedDecl = expr.right.$resolvedType?.decl;
+        if (leftResolvedDecl && (typeof leftResolvedDecl !== "string" || !supportedShapes.includes(leftResolvedDecl))) {
           accept("error", `invalid operand type for "${expr.operator}" operator`, {
             node: expr.left
           });
           return;
         }
-        if (typeof expr.right.$resolvedType?.decl !== "string" || !supportedShapes.includes(expr.right.$resolvedType.decl)) {
+        if (rightResolvedDecl && (typeof rightResolvedDecl !== "string" || !supportedShapes.includes(rightResolvedDecl))) {
           accept("error", `invalid operand type for "${expr.operator}" operator`, {
             node: expr.right
           });
           return;
         }
-        if (expr.left.$resolvedType.decl === "DateTime" && expr.right.$resolvedType.decl !== "DateTime") {
+        if (leftResolvedDecl === "DateTime" && rightResolvedDecl && rightResolvedDecl !== "DateTime") {
           accept("error", "incompatible operand types", {
             node: expr
           });
-        } else if (expr.right.$resolvedType.decl === "DateTime" && expr.left.$resolvedType.decl !== "DateTime") {
+        } else if (rightResolvedDecl === "DateTime" && leftResolvedDecl && leftResolvedDecl !== "DateTime") {
           accept("error", "incompatible operand types", {
             node: expr
           });
@@ -6618,7 +6667,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;
           }
         }
@@ -6647,12 +6696,12 @@ var ExpressionValidator = class {
               node: expr
             });
           }
-          if (isDataModelFieldReference(expr.left) && (isThisExpr(expr.right) || isDataModelFieldReference(expr.right))) {
-            accept("error", "comparison between model-typed fields are not supported", {
+          if (isDataFieldReference(expr.left) && (isThisExpr(expr.right) || isDataFieldReference(expr.right))) {
+            accept("error", "comparison between models is not supported", {
               node: expr
             });
-          } else if (isDataModelFieldReference(expr.right) && (isThisExpr(expr.left) || isDataModelFieldReference(expr.left))) {
-            accept("error", "comparison between model-typed fields are not supported", {
+          } else if (isDataFieldReference(expr.right) && (isThisExpr(expr.left) || isDataFieldReference(expr.left))) {
+            accept("error", "comparison between models is not supported", {
               node: expr
             });
           }
@@ -6742,41 +6791,39 @@ var FunctionInvocationValidator = class {
     if (!this.validateArgs(funcDecl, expr.args, accept)) {
       return;
     }
-    if (isFromStdlib(funcDecl)) {
-      let curr = expr.$container;
-      let containerAttribute;
-      while (curr) {
-        if (isDataModelAttribute(curr) || isDataModelFieldAttribute(curr)) {
-          containerAttribute = curr;
-          break;
-        }
-        curr = curr.$container;
+    let curr = expr.$container;
+    let containerAttribute;
+    while (curr) {
+      if (isDataModelAttribute(curr) || isDataFieldAttribute(curr)) {
+        containerAttribute = curr;
+        break;
       }
-      const exprContext = match(containerAttribute?.decl.$refText).with("@default", () => ExpressionContext.DefaultValue).with(P.union("@@allow", "@@deny", "@allow", "@deny"), () => ExpressionContext.AccessPolicy).with("@@validate", () => ExpressionContext.ValidationRule).with("@@index", () => ExpressionContext.Index).otherwise(() => void 0);
-      const funcAllowedContext = getFunctionExpressionContext(funcDecl);
-      if (exprContext && !funcAllowedContext.includes(exprContext)) {
-        accept("error", `function "${funcDecl.name}" is not allowed in the current context: ${exprContext}`, {
-          node: expr
+      curr = curr.$container;
+    }
+    const exprContext = this.getExpressionContext(containerAttribute);
+    const funcAllowedContext = getFunctionExpressionContext(funcDecl);
+    if (exprContext && !funcAllowedContext.includes(exprContext)) {
+      accept("error", `function "${funcDecl.name}" is not allowed in the current context: ${exprContext}`, {
+        node: expr
+      });
+      return;
+    }
+    const allCasing = [
+      "original",
+      "upper",
+      "lower",
+      "capitalize",
+      "uncapitalize"
+    ];
+    if ([
+      "currentModel",
+      "currentOperation"
+    ].includes(funcDecl.name)) {
+      const arg = getLiteral(expr.args[0]?.value);
+      if (arg && !allCasing.includes(arg)) {
+        accept("error", `argument must be one of: ${allCasing.map((c) => '"' + c + '"').join(", ")}`, {
+          node: expr.args[0]
         });
-        return;
-      }
-      const allCasing = [
-        "original",
-        "upper",
-        "lower",
-        "capitalize",
-        "uncapitalize"
-      ];
-      if ([
-        "currentModel",
-        "currentOperation"
-      ].includes(funcDecl.name)) {
-        const arg = getLiteral(expr.args[0]?.value);
-        if (arg && !allCasing.includes(arg)) {
-          accept("error", `argument must be one of: ${allCasing.map((c) => '"' + c + '"').join(", ")}`, {
-            node: expr.args[0]
-          });
-        }
       }
     }
     const checker = invocationCheckers.get(expr.function.$refText);
@@ -6784,6 +6831,18 @@ var FunctionInvocationValidator = class {
       checker.value.call(this, expr, accept);
     }
   }
+  getExpressionContext(containerAttribute) {
+    if (!containerAttribute) {
+      return void 0;
+    }
+    if (this.isValidationAttribute(containerAttribute)) {
+      return ExpressionContext.ValidationRule;
+    }
+    return match(containerAttribute?.decl.$refText).with("@default", () => ExpressionContext.DefaultValue).with(P.union("@@allow", "@@deny", "@allow", "@deny"), () => ExpressionContext.AccessPolicy).with("@@index", () => ExpressionContext.Index).otherwise(() => void 0);
+  }
+  isValidationAttribute(attr) {
+    return !!attr.decl.ref?.attributes.some((attr2) => attr2.decl.$refText === "@@@validation");
+  }
   validateArgs(funcDecl, args, accept) {
     let success = true;
     for (let i = 0; i < funcDecl.params.length; i++) {
@@ -6844,10 +6903,48 @@ var FunctionInvocationValidator = class {
     }
     return true;
   }
+  _checkLength(expr, accept) {
+    const msg = "argument must be a string or list field";
+    const fieldArg = expr.args[0].value;
+    if (!isDataFieldReference(fieldArg)) {
+      accept("error", msg, {
+        node: expr.args[0]
+      });
+      return;
+    }
+    if (isDataModel(fieldArg.$resolvedType?.decl)) {
+      accept("error", msg, {
+        node: expr.args[0]
+      });
+      return;
+    }
+    if (!fieldArg.$resolvedType?.array && fieldArg.$resolvedType?.decl !== "String") {
+      accept("error", msg, {
+        node: expr.args[0]
+      });
+    }
+  }
+  _checkRegex(expr, accept) {
+    const regex = expr.args[1]?.value;
+    if (!isStringLiteral(regex)) {
+      accept("error", "second argument must be a string literal", {
+        node: expr.args[1]
+      });
+      return;
+    }
+    try {
+      new RegExp(regex.value);
+    } catch (e) {
+      accept("error", "invalid regular expression: " + e.message, {
+        node: expr.args[1]
+      });
+    }
+  }
+  // TODO: move this to policy plugin
   _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]
       });
@@ -6915,6 +7012,24 @@ var FunctionInvocationValidator = class {
     }
   }
 };
+_ts_decorate2([
+  func("length"),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    typeof InvocationExpr === "undefined" ? Object : InvocationExpr,
+    typeof ValidationAcceptor === "undefined" ? Object : ValidationAcceptor
+  ]),
+  _ts_metadata2("design:returntype", void 0)
+], FunctionInvocationValidator.prototype, "_checkLength", null);
+_ts_decorate2([
+  func("regex"),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    typeof InvocationExpr === "undefined" ? Object : InvocationExpr,
+    typeof ValidationAcceptor === "undefined" ? Object : ValidationAcceptor
+  ]),
+  _ts_metadata2("design:returntype", void 0)
+], FunctionInvocationValidator.prototype, "_checkRegex", null);
 _ts_decorate2([
   func("check"),
   _ts_metadata2("design:type", Function),
@@ -6962,8 +7077,8 @@ var SchemaValidator = class {
   validateImports(model, accept) {
     model.imports.forEach((imp) => {
       const importedModel = resolveImport(this.documents, imp);
-      const importPath = imp.path.endsWith(".zmodel") ? imp.path : `${imp.path}.zmodel`;
       if (!importedModel) {
+        const importPath = imp.path.endsWith(".zmodel") ? imp.path : `${imp.path}.zmodel`;
         accept("error", `Cannot find model file ${importPath}`, {
           node: imp
         });
@@ -6989,6 +7104,11 @@ var TypeDefValidator = class {
     typeDef.fields.forEach((field) => this.validateField(field, accept));
   }
   validateField(field, accept) {
+    if (isDataModel(field.type.reference?.ref)) {
+      accept("error", "Type field cannot be a relation", {
+        node: field.type
+      });
+    }
     field.attributes.forEach((attr) => validateAttributeApplication(attr, accept));
   }
 };
@@ -7019,49 +7139,66 @@ var ZModelValidator = class {
   constructor(services) {
     this.services = services;
   }
-  shouldCheck(node) {
-    let doc;
-    let currNode = node;
-    while (currNode) {
-      if (currNode.$document) {
-        doc = currNode.$document;
-        break;
-      }
-      currNode = currNode.$container;
-    }
-    return doc?.parseResult.lexerErrors.length === 0 && doc?.parseResult.parserErrors.length === 0;
-  }
   checkModel(node, accept) {
-    this.shouldCheck(node) && new SchemaValidator(this.services.shared.workspace.LangiumDocuments).validate(node, accept);
+    new SchemaValidator(this.services.shared.workspace.LangiumDocuments).validate(node, accept);
   }
   checkDataSource(node, accept) {
-    this.shouldCheck(node) && new DataSourceValidator().validate(node, accept);
+    new DataSourceValidator().validate(node, accept);
   }
   checkDataModel(node, accept) {
-    this.shouldCheck(node) && new DataModelValidator().validate(node, accept);
+    new DataModelValidator().validate(node, accept);
   }
   checkTypeDef(node, accept) {
-    this.shouldCheck(node) && new TypeDefValidator().validate(node, accept);
+    new TypeDefValidator().validate(node, accept);
   }
   checkEnum(node, accept) {
-    this.shouldCheck(node) && new EnumValidator().validate(node, accept);
+    new EnumValidator().validate(node, accept);
   }
   checkAttribute(node, accept) {
-    this.shouldCheck(node) && new AttributeValidator().validate(node, accept);
+    new AttributeValidator().validate(node, accept);
   }
   checkExpression(node, accept) {
-    this.shouldCheck(node) && new ExpressionValidator().validate(node, accept);
+    new ExpressionValidator().validate(node, accept);
   }
   checkFunctionInvocation(node, accept) {
-    this.shouldCheck(node) && new FunctionInvocationValidator().validate(node, accept);
+    new FunctionInvocationValidator().validate(node, accept);
   }
   checkFunctionDecl(node, accept) {
-    this.shouldCheck(node) && new FunctionDeclValidator().validate(node, accept);
+    new FunctionDeclValidator().validate(node, accept);
+  }
+};
+
+// src/zmodel-document-builder.ts
+import { DefaultDocumentBuilder } from "langium";
+var ZModelDocumentBuilder = class extends DefaultDocumentBuilder {
+  static {
+    __name(this, "ZModelDocumentBuilder");
+  }
+  constructor(services) {
+    super(services);
+    let validationOptions = this.updateBuildOptions.validation;
+    const stopFlags = {
+      stopAfterLinkingErrors: true,
+      stopAfterLexingErrors: true,
+      stopAfterParsingErrors: true
+    };
+    if (validationOptions === true) {
+      validationOptions = stopFlags;
+    } else if (typeof validationOptions === "object") {
+      validationOptions = {
+        ...validationOptions,
+        ...stopFlags
+      };
+    }
+    this.updateBuildOptions = {
+      ...this.updateBuildOptions,
+      validation: validationOptions
+    };
   }
 };
 
 // src/zmodel-linker.ts
-import { AstUtils as AstUtils6, Cancellation, DefaultLinker, DocumentState, interruptAndCheck, isReference } from "langium";
+import { AstUtils as AstUtils6, Cancellation, DefaultLinker, DocumentState, interruptAndCheck } from "langium";
 import { match as match2 } from "ts-pattern";
 var ZModelLinker = class extends DefaultLinker {
   static {
@@ -7083,21 +7220,19 @@ var ZModelLinker = class extends DefaultLinker {
     }
     document.state = DocumentState.Linked;
   }
-  linkReference(container, property, document, extraScopes) {
-    if (this.resolveFromScopeProviders(container, property, document, extraScopes)) {
+  linkReference(refInfo, document, extraScopes) {
+    const defaultRef = refInfo.reference;
+    if (defaultRef._ref) {
+      return;
+    }
+    if (this.resolveFromScopeProviders(refInfo.reference, document, extraScopes)) {
       return;
     }
-    const reference = container[property];
-    this.doLink({
-      reference,
-      container,
-      property
-    }, document);
+    this.doLink(refInfo, document);
   }
   //#endregion
   //#region Expression type resolving
-  resolveFromScopeProviders(node, property, document, providers) {
-    const reference = node[property];
+  resolveFromScopeProviders(reference, document, providers) {
     for (const provider of providers) {
       const target = provider(reference.$refText);
       if (target) {
@@ -7149,8 +7284,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);
@@ -7226,7 +7361,11 @@ var ZModelLinker = class extends DefaultLinker {
     }
   }
   resolveInvocation(node, document, extraScopes) {
-    this.linkReference(node, "function", document, extraScopes);
+    this.linkReference({
+      reference: node.function,
+      container: node,
+      property: "function"
+    }, document, extraScopes);
     node.args.forEach((arg) => this.resolve(arg, document, extraScopes));
     if (node.function.ref) {
       const funcDecl = node.function.ref;
@@ -7239,7 +7378,7 @@ var ZModelLinker = class extends DefaultLinker {
             nullable: true
           };
         }
-      } else if (isFutureExpr(node)) {
+      } else if (isBeforeInvocation(node)) {
         node.$resolvedType = {
           decl: getContainingDataModel(node)
         };
@@ -7296,14 +7435,14 @@ 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)) {
-              const resolved2 = this.resolveFromScopeProviders(item, "target", document, [
+              const resolved2 = this.resolveFromScopeProviders(item.target, document, [
                 scopeProvider
               ]);
               if (resolved2) {
@@ -7317,7 +7456,7 @@ var ZModelLinker = class extends DefaultLinker {
             this.resolveToBuiltinTypeOrDecl(node.value, node.value.items[0].$resolvedType.decl, true);
           }
         } else if (isReferenceExpr(node.value)) {
-          const resolved2 = this.resolveFromScopeProviders(node.value, "target", document, [
+          const resolved2 = this.resolveFromScopeProviders(node.value.target, document, [
             scopeProvider
           ]);
           if (resolved2) {
@@ -7355,7 +7494,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)) {
@@ -7369,13 +7508,9 @@ var ZModelLinker = class extends DefaultLinker {
     this.resolveDefault(node, document, scopes);
   }
   resolveDefault(node, document, extraScopes) {
-    for (const [property, value] of Object.entries(node)) {
-      if (!property.startsWith("$")) {
-        if (isReference(value)) {
-          this.linkReference(node, property, document, extraScopes);
-        }
-      }
-    }
+    AstUtils6.streamReferences(node).forEach((ref) => {
+      this.linkReference(ref, document, extraScopes);
+    });
     for (const child of AstUtils6.streamContents(node)) {
       this.resolve(child, document, extraScopes);
     }
@@ -7384,7 +7519,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 = {
@@ -7445,6 +7580,14 @@ var ZModelScopeComputation = class extends DefaultScopeComputation {
   }
   processNode(node, document, scopes) {
     super.processNode(node, document, scopes);
+    if (isDataModel(node) || isTypeDef(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 {
@@ -7492,16 +7635,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;
@@ -7511,7 +7651,7 @@ var ZModelScopeProvider = class extends DefaultScopeProvider {
       if (isAuthInvocation(operand)) {
         return this.createScopeForAuth(node, globalScope);
       }
-      if (isFutureInvocation(operand)) {
+      if (isBeforeInvocation(operand)) {
         return this.createScopeForContainingModel(node, globalScope);
       }
       return EMPTY_SCOPE;
@@ -7524,13 +7664,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;
@@ -7555,7 +7695,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 {
@@ -7588,7 +7728,7 @@ __name(getCollectionPredicateContext, "getCollectionPredicateContext");
 import { DefaultWorkspaceManager, URI as URI2 } from "langium";
 import fs2 from "fs";
 import path2 from "path";
-import { fileURLToPath } from "url";
+import { fileURLToPath as fileURLToPath2 } from "url";
 var ZModelWorkspaceManager = class extends DefaultWorkspaceManager {
   static {
     __name(this, "ZModelWorkspaceManager");
@@ -7624,7 +7764,7 @@ var ZModelWorkspaceManager = class extends DefaultWorkspaceManager {
     if (installedStdlibPath) {
       stdLibPath = installedStdlibPath;
     } else {
-      const _dirname = typeof __dirname !== "undefined" ? __dirname : path2.dirname(fileURLToPath(import.meta.url));
+      const _dirname = typeof __dirname !== "undefined" ? __dirname : path2.dirname(fileURLToPath2(import.meta.url));
       stdLibPath = path2.join(_dirname, "../res", STD_LIB_MODULE_NAME);
       console.log(`Using bundled stdlib in extension:`, stdLibPath);
     }
@@ -7646,10 +7786,11 @@ var ZModelLanguageModule = {
 };
 var ZModelSharedModule = {
   workspace: {
+    DocumentBuilder: /* @__PURE__ */ __name((services) => new ZModelDocumentBuilder(services), "DocumentBuilder"),
     WorkspaceManager: /* @__PURE__ */ __name((services) => new ZModelWorkspaceManager(services), "WorkspaceManager")
   }
 };
-function createZModelLanguageServices(context) {
+function createZModelLanguageServices(context, logToConsole = false) {
   const shared = inject(createDefaultSharedModule(context), ZModelGeneratedSharedModule, ZModelSharedModule);
   const ZModelLanguage = inject(createDefaultModule({
     shared
@@ -7659,30 +7800,38 @@ function createZModelLanguageServices(context) {
   if (!context.connection) {
     shared.workspace.ConfigurationProvider.initialized({});
   }
+  shared.workspace.DocumentBuilder.onBuildPhase(DocumentState2.Parsed, async (documents) => {
+    for (const doc of documents) {
+      if (doc.parseResult.lexerErrors.length > 0 || doc.parseResult.parserErrors.length > 0) {
+        continue;
+      }
+      const schemaPath = fileURLToPath3(doc.uri.toString());
+      const pluginSchemas = getPluginDocuments(doc.parseResult.value, schemaPath);
+      for (const plugin of pluginSchemas) {
+        const pluginDoc = await shared.workspace.LangiumDocuments.getOrCreateDocument(URI3.file(path3.resolve(plugin)));
+        shared.workspace.IndexManager.updateContent(pluginDoc);
+        if (logToConsole) {
+          console.log(`Loaded plugin model: ${plugin}`);
+        }
+      }
+    }
+  });
   return {
     shared,
     ZModelLanguage
   };
 }
 __name(createZModelLanguageServices, "createZModelLanguageServices");
-
-// src/index.ts
-function createZModelServices() {
-  return createZModelLanguageServices(NodeFileSystem);
+function createZModelServices(logToConsole = false) {
+  return createZModelLanguageServices(NodeFileSystem, logToConsole);
 }
 __name(createZModelServices, "createZModelServices");
-var DocumentLoadError = class extends Error {
-  static {
-    __name(this, "DocumentLoadError");
-  }
-  constructor(message) {
-    super(message);
-  }
-};
-async function loadDocument(fileName, pluginModelFiles = []) {
-  const { ZModelLanguage: services } = createZModelServices();
+
+// src/document.ts
+async function loadDocument(fileName, additionalModelFiles = []) {
+  const { ZModelLanguage: services } = createZModelServices(false);
   const extensions = services.LanguageMetaData.fileExtensions;
-  if (!extensions.includes(path3.extname(fileName))) {
+  if (!extensions.includes(path4.extname(fileName))) {
     return {
       success: false,
       errors: [
@@ -7700,17 +7849,27 @@ async function loadDocument(fileName, pluginModelFiles = []) {
       warnings: []
     };
   }
-  const _dirname = typeof __dirname !== "undefined" ? __dirname : path3.dirname(fileURLToPath2(import.meta.url));
-  const stdLib = await services.shared.workspace.LangiumDocuments.getOrCreateDocument(URI3.file(path3.resolve(path3.join(_dirname, "../res", STD_LIB_MODULE_NAME))));
-  const pluginDocs = await Promise.all(pluginModelFiles.map((file) => services.shared.workspace.LangiumDocuments.getOrCreateDocument(URI3.file(path3.resolve(file)))));
+  const _dirname = typeof __dirname !== "undefined" ? __dirname : path4.dirname(fileURLToPath4(import.meta.url));
+  const stdLib = await services.shared.workspace.LangiumDocuments.getOrCreateDocument(URI4.file(path4.resolve(path4.join(_dirname, "../res", STD_LIB_MODULE_NAME))));
   const langiumDocuments = services.shared.workspace.LangiumDocuments;
-  const document = await langiumDocuments.getOrCreateDocument(URI3.file(path3.resolve(fileName)));
+  const document = await langiumDocuments.getOrCreateDocument(URI4.file(path4.resolve(fileName)));
+  const importedURIs = await loadImports(document, langiumDocuments);
+  const importedDocuments = [];
+  for (const uri of importedURIs) {
+    importedDocuments.push(await langiumDocuments.getOrCreateDocument(uri));
+  }
+  const additionalDocs = await Promise.all(additionalModelFiles.map((file) => services.shared.workspace.LangiumDocuments.getOrCreateDocument(URI4.file(path4.resolve(file)))));
   await services.shared.workspace.DocumentBuilder.build([
     stdLib,
-    ...pluginDocs,
-    document
+    ...additionalDocs,
+    document,
+    ...importedDocuments
   ], {
-    validation: true
+    validation: {
+      stopAfterLexingErrors: true,
+      stopAfterParsingErrors: true,
+      stopAfterLinkingErrors: true
+    }
   });
   const diagnostics = langiumDocuments.all.flatMap((doc) => (doc.diagnostics ?? []).map((diag) => ({
     doc,
@@ -7720,7 +7879,7 @@ async function loadDocument(fileName, pluginModelFiles = []) {
   const warnings = [];
   if (diagnostics.length > 0) {
     for (const { doc, diag } of diagnostics) {
-      const message = `${path3.relative(process.cwd(), doc.uri.fsPath)}:${diag.range.start.line + 1}:${diag.range.start.character + 1} - ${diag.message}`;
+      const message = `${path4.relative(process.cwd(), doc.uri.fsPath)}:${diag.range.start.line + 1}:${diag.range.start.character + 1} - ${diag.message}`;
       if (diag.severity === 1) {
         errors.push(message);
       } else {
@@ -7735,6 +7894,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,
@@ -7742,8 +7915,69 @@ 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) => URI4.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,
   ZModelLanguageModule,
   ZModelSharedModule,