@zenstackhq/language 3.0.0-beta.9 → 3.0.0

package/dist/index.cjs

@@ -31,24 +31,30 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  DocumentLoadError: () => DocumentLoadError,
+  ZModelCodeGenerator: () => ZModelCodeGenerator,
   ZModelLanguageMetaData: () => ZModelLanguageMetaData,
   ZModelLanguageModule: () => ZModelLanguageModule,
   ZModelSharedModule: () => ZModelSharedModule,
   createZModelLanguageServices: () => createZModelLanguageServices,
   createZModelServices: () => createZModelServices,
+  formatDocument: () => formatDocument,
   loadDocument: () => loadDocument
 });
 module.exports = __toCommonJS(src_exports);
-var import_langium12 = require("langium");
-var import_node = require("langium/node");
-var import_node_fs3 = __toESM(require("fs"), 1);
-var import_node_path2 = __toESM(require("path"), 1);
-var import_node_url2 = require("url");
+
+// src/document.ts
+var import_langium14 = require("langium");
+var import_node_fs4 = __toESM(require("fs"), 1);
+var import_node_path4 = __toESM(require("path"), 1);
+var import_node_url4 = require("url");
 
 // src/generated/ast.ts
 var langium = __toESM(require("langium"), 1);
 var AbstractDeclaration = "AbstractDeclaration";
+function isAbstractDeclaration(item) {
+  return reflection.isInstance(item, AbstractDeclaration);
+}
+__name(isAbstractDeclaration, "isAbstractDeclaration");
 var ConfigExpr = "ConfigExpr";
 var Expression = "Expression";
 function isExpression(item) {
@@ -75,6 +81,10 @@ function isAttribute(item) {
 }
 __name(isAttribute, "isAttribute");
 var AttributeArg = "AttributeArg";
+function isAttributeArg(item) {
+  return reflection.isInstance(item, AttributeArg);
+}
+__name(isAttributeArg, "isAttributeArg");
 var AttributeParam = "AttributeParam";
 var AttributeParamType = "AttributeParamType";
 var BinaryExpr = "BinaryExpr";
@@ -93,6 +103,10 @@ function isConfigArrayExpr(item) {
 }
 __name(isConfigArrayExpr, "isConfigArrayExpr");
 var ConfigField = "ConfigField";
+function isConfigField(item) {
+  return reflection.isInstance(item, ConfigField);
+}
+__name(isConfigField, "isConfigField");
 var ConfigInvocationArg = "ConfigInvocationArg";
 var ConfigInvocationExpr = "ConfigInvocationExpr";
 var DataField = "DataField";
@@ -137,10 +151,22 @@ function isEnumField(item) {
 __name(isEnumField, "isEnumField");
 var FieldInitializer = "FieldInitializer";
 var FunctionDecl = "FunctionDecl";
+function isFunctionDecl(item) {
+  return reflection.isInstance(item, FunctionDecl);
+}
+__name(isFunctionDecl, "isFunctionDecl");
 var FunctionParam = "FunctionParam";
 var FunctionParamType = "FunctionParamType";
 var GeneratorDecl = "GeneratorDecl";
+function isGeneratorDecl(item) {
+  return reflection.isInstance(item, GeneratorDecl);
+}
+__name(isGeneratorDecl, "isGeneratorDecl");
 var InternalAttribute = "InternalAttribute";
+function isInternalAttribute(item) {
+  return reflection.isInstance(item, InternalAttribute);
+}
+__name(isInternalAttribute, "isInternalAttribute");
 var InvocationExpr = "InvocationExpr";
 function isInvocationExpr(item) {
   return reflection.isInstance(item, InvocationExpr);
@@ -157,6 +183,10 @@ function isModel(item) {
 }
 __name(isModel, "isModel");
 var ModelImport = "ModelImport";
+function isModelImport(item) {
+  return reflection.isInstance(item, ModelImport);
+}
+__name(isModelImport, "isModelImport");
 var NullExpr = "NullExpr";
 function isNullExpr(item) {
   return reflection.isInstance(item, NullExpr);
@@ -178,6 +208,10 @@ function isPlugin(item) {
 }
 __name(isPlugin, "isPlugin");
 var PluginField = "PluginField";
+function isPluginField(item) {
+  return reflection.isInstance(item, PluginField);
+}
+__name(isPluginField, "isPluginField");
 var Procedure = "Procedure";
 var ProcedureParam = "ProcedureParam";
 var ReferenceArg = "ReferenceArg";
@@ -1044,6 +1078,26 @@ var ZModelAstReflection = class extends langium.AbstractAstReflection {
 };
 var reflection = new ZModelAstReflection();
 
+// src/ast.ts
+var BinaryExprOperatorPriority = {
+  //LogicalExpr
+  "||": 1,
+  "&&": 1,
+  //EqualityExpr
+  "==": 2,
+  "!=": 2,
+  //ComparisonExpr
+  ">": 3,
+  "<": 3,
+  ">=": 3,
+  "<=": 3,
+  in: 4,
+  //CollectionPredicateExpr
+  "^": 5,
+  "?": 5,
+  "!": 5
+};
+
 // src/constants.ts
 var SUPPORTED_PROVIDERS = [
   "sqlite",
@@ -1074,8 +1128,11 @@ var ExpressionContext = /* @__PURE__ */ function(ExpressionContext2) {
 }({});
 
 // src/module.ts
-var import_langium11 = require("langium");
-var import_lsp = require("langium/lsp");
+var import_langium13 = require("langium");
+var import_lsp5 = require("langium/lsp");
+var import_node = require("langium/node");
+var import_node_path3 = __toESM(require("path"), 1);
+var import_node_url3 = require("url");
 
 // src/generated/grammar.ts
 var import_langium = require("langium");
@@ -5136,14 +5193,13 @@ var ZModelGeneratedModule = {
   parser: {}
 };
 
-// src/validators/attribute-application-validator.ts
-var import_langium3 = require("langium");
-var import_pluralize = __toESM(require("pluralize"), 1);
-
 // src/utils.ts
 var import_langium2 = require("langium");
 var import_node_fs = __toESM(require("fs"), 1);
-var import_path = __toESM(require("path"), 1);
+var import_node_module = require("module");
+var import_node_path = __toESM(require("path"), 1);
+var import_node_url = require("url");
+var import_meta = {};
 function hasAttribute(decl, name) {
   return !!getAttribute(decl, name);
 }
@@ -5247,7 +5303,7 @@ function getRecursiveBases(decl, includeDelegate = true, seen = /* @__PURE__ */
     ] : []
   ];
   bases.forEach((base) => {
-    const baseDecl = decl.$container.declarations.find((d) => isTypeDef(d) || isDataModel(d) && d.name === base.$refText);
+    const baseDecl = decl.$container.declarations.find((d) => (isTypeDef(d) || isDataModel(d)) && d.name === base.$refText);
     if (baseDecl) {
       if (!includeDelegate && isDelegateModel(baseDecl)) {
         return;
@@ -5370,6 +5426,10 @@ function getArray(expr) {
   return isArrayExpr(expr) || isConfigArrayExpr(expr) ? expr.items : void 0;
 }
 __name(getArray, "getArray");
+function getAttributeArg(attr, name) {
+  return attr.args.find((arg) => arg.$resolvedParam?.name === name)?.value;
+}
+__name(getAttributeArg, "getAttributeArg");
 function getFunctionExpressionContext(funcDecl) {
   const funcAllowedContext = [];
   const funcAttr = funcDecl.attributes.find((attr) => attr.decl.$refText === "@@@expressionContext");
@@ -5437,9 +5497,9 @@ function resolveImportUri(imp) {
     return void 0;
   }
   const doc = import_langium2.AstUtils.getDocument(imp);
-  const dir = import_path.default.dirname(doc.uri.fsPath);
+  const dir = import_node_path.default.dirname(doc.uri.fsPath);
   const importPath = imp.path.endsWith(".zmodel") ? imp.path : `${imp.path}.zmodel`;
-  return import_langium2.URI.file(import_path.default.resolve(dir, importPath));
+  return import_langium2.URI.file(import_node_path.default.resolve(dir, importPath));
 }
 __name(resolveImportUri, "resolveImportUri");
 function getDataModelAndTypeDefs(model, includeIgnored = false) {
@@ -5457,15 +5517,15 @@ function getAllDeclarationsIncludingImports(documents, model) {
 }
 __name(getAllDeclarationsIncludingImports, "getAllDeclarationsIncludingImports");
 function getAuthDecl(decls) {
-  let authModel = decls.find((m) => hasAttribute(m, "@@auth"));
+  let authModel = decls.find((d) => hasAttribute(d, "@@auth"));
   if (!authModel) {
-    authModel = decls.find((m) => m.name === "User");
+    authModel = decls.find((d) => d.name === "User");
   }
   return authModel;
 }
 __name(getAuthDecl, "getAuthDecl");
 function isBeforeInvocation(node) {
-  return isInvocationExpr(node) && node.function.ref?.name === "before" && isFromStdlib(node.function.ref);
+  return isInvocationExpr(node) && node.function.ref?.name === "before";
 }
 __name(isBeforeInvocation, "isBeforeInvocation");
 function isCollectionPredicate(node) {
@@ -5548,13 +5608,23 @@ function getAllAttributes(decl, seen = /* @__PURE__ */ new Set()) {
   }
   if (isDataModel(decl) && decl.baseModel) {
     if (decl.baseModel.ref) {
-      attributes.push(...getAllAttributes(decl.baseModel.ref, seen));
+      const attrs = getAllAttributes(decl.baseModel.ref, seen).filter((attr) => !isNonInheritableAttribute(attr));
+      attributes.push(...attrs);
     }
   }
   attributes.push(...decl.attributes);
   return attributes;
 }
 __name(getAllAttributes, "getAllAttributes");
+function isNonInheritableAttribute(attr) {
+  const attrName = attr.decl.ref?.name ?? attr.decl.$refText;
+  return [
+    "@@map",
+    "@@unique",
+    "@@index"
+  ].includes(attrName);
+}
+__name(isNonInheritableAttribute, "isNonInheritableAttribute");
 function getDocument(node) {
   const rootNode = findRootNode(node);
   const result = rootNode.$document;
@@ -5564,6 +5634,71 @@ function getDocument(node) {
   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 = import_node_path.default.resolve(import_node_path.default.dirname(schemaPath), provider);
+    if (import_node_fs.default.existsSync(providerPath)) {
+      if (import_node_fs.default.statSync(providerPath).isDirectory()) {
+        providerPath = import_node_path.default.join(providerPath, "index.js");
+      }
+      pluginModelFile = import_node_path.default.resolve(import_node_path.default.dirname(providerPath), PLUGIN_MODULE_NAME);
+      if (!import_node_fs.default.existsSync(pluginModelFile)) {
+        pluginModelFile = findUp([
+          PLUGIN_MODULE_NAME
+        ], import_node_path.default.dirname(providerPath));
+      }
+    }
+    if (!pluginModelFile) {
+      if (typeof import_meta.resolve === "function") {
+        try {
+          const resolvedUrl = import_meta.resolve(`${provider}/${PLUGIN_MODULE_NAME}`);
+          pluginModelFile = (0, import_node_url.fileURLToPath)(resolvedUrl);
+        } catch {
+        }
+      }
+    }
+    if (!pluginModelFile) {
+      try {
+        const require2 = (0, import_node_module.createRequire)((0, import_node_url.pathToFileURL)(schemaPath));
+        pluginModelFile = require2.resolve(`${provider}/${PLUGIN_MODULE_NAME}`);
+      } catch {
+      }
+    }
+    if (pluginModelFile && import_node_fs.default.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) => import_node_fs.default.existsSync(import_node_path.default.join(cwd, name)));
+  if (multiple === false && target) {
+    return import_node_path.default.join(cwd, target);
+  }
+  if (target) {
+    result.push(import_node_path.default.join(cwd, target));
+  }
+  const up = import_node_path.default.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;
@@ -5573,6 +5708,9 @@ function findRootNode(node) {
 __name(findRootNode, "findRootNode");
 
 // src/validators/attribute-application-validator.ts
+var import_common_helpers = require("@zenstackhq/common-helpers");
+var import_langium3 = require("langium");
+var import_pluralize = __toESM(require("pluralize"), 1);
 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);
@@ -5790,8 +5928,23 @@ var AttributeApplicationValidator = class {
       });
     }
   }
-  _checkUnique(attr, accept) {
-    const fields = attr.args[0]?.value;
+  _checkId(attr, accept) {
+    const dm = getContainingDataModel(attr);
+    if (dm?.isView) {
+      accept("error", `\`@id\` is not allowed for views`, {
+        node: attr
+      });
+    }
+  }
+  _checkConstraint(attr, accept) {
+    const dm = getContainingDataModel(attr);
+    if (dm?.isView && (attr.decl.$refText === "@@id" || attr.decl.$refText === "@@index")) {
+      accept("error", `\`${attr.decl.$refText}\` is not allowed for views`, {
+        node: attr
+      });
+    }
+    const fields = getAttributeArg(attr, "fields");
+    const attrName = attr.decl.ref?.name;
     if (!fields) {
       accept("error", `expects an array of field references`, {
         node: attr.args[0]
@@ -5800,7 +5953,7 @@ var AttributeApplicationValidator = class {
     }
     if (isArrayExpr(fields)) {
       if (fields.items.length === 0) {
-        accept("error", `\`@@unique\` expects at least one field reference`, {
+        accept("error", `\`${attrName}\` expects at least one field reference`, {
           node: fields
         });
         return;
@@ -5819,7 +5972,7 @@ var AttributeApplicationValidator = class {
           return;
         }
         if (item.target.ref.$container !== attr.$container && isDelegateModel(item.target.ref.$container)) {
-          accept("error", `Cannot use fields inherited from a polymorphic base model in \`@@unique\``, {
+          accept("error", `Cannot use fields inherited from a polymorphic base model in \`${attrName}\``, {
             node: item
           });
         }
@@ -5830,6 +5983,24 @@ var AttributeApplicationValidator = class {
       });
     }
   }
+  _checkSchema(attr, accept) {
+    const schemaName = getStringLiteral(attr.args[0]?.value);
+    (0, import_common_helpers.invariant)(schemaName, `@@schema expects a string literal`);
+    const zmodel = import_langium3.AstUtils.getContainerOfType(attr, isModel);
+    const datasource = zmodel.declarations.find(isDataSource);
+    if (datasource) {
+      let found = false;
+      const schemas = datasource.fields.find((f) => f.name === "schemas");
+      if (schemas && isConfigArrayExpr(schemas.value)) {
+        found = schemas.value.items.some((item) => isLiteralExpr(item) && item.value === schemaName);
+      }
+      if (!found) {
+        accept("error", `Schema "${schemaName}" is not defined in the datasource`, {
+          node: attr
+        });
+      }
+    }
+  }
   validatePolicyKinds(kind, candidates, attr, accept) {
     const items = kind.split(",").map((x) => x.trim());
     items.forEach((item) => {
@@ -5872,15 +6043,34 @@ _ts_decorate([
   _ts_metadata("design:returntype", void 0)
 ], AttributeApplicationValidator.prototype, "_checkValidate", null);
 _ts_decorate([
-  check("@@unique"),
+  check("@id"),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof AttributeApplication === "undefined" ? Object : AttributeApplication,
+    typeof ValidationAcceptor === "undefined" ? Object : ValidationAcceptor
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], AttributeApplicationValidator.prototype, "_checkId", null);
+_ts_decorate([
   check("@@id"),
+  check("@@index"),
+  check("@@unique"),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof AttributeApplication === "undefined" ? Object : AttributeApplication,
+    typeof ValidationAcceptor === "undefined" ? Object : ValidationAcceptor
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], AttributeApplicationValidator.prototype, "_checkConstraint", null);
+_ts_decorate([
+  check("@@schema"),
   _ts_metadata("design:type", Function),
   _ts_metadata("design:paramtypes", [
     typeof AttributeApplication === "undefined" ? Object : AttributeApplication,
     typeof ValidationAcceptor === "undefined" ? Object : ValidationAcceptor
   ]),
   _ts_metadata("design:returntype", void 0)
-], AttributeApplicationValidator.prototype, "_checkUnique", null);
+], AttributeApplicationValidator.prototype, "_checkSchema", null);
 function assignableToAttributeParam(arg, param, attr) {
   const argResolvedType = arg.$resolvedType;
   if (!argResolvedType) {
@@ -6014,7 +6204,7 @@ var AttributeValidator = class {
 };
 
 // src/validators/datamodel-validator.ts
-var import_common_helpers = require("@zenstackhq/common-helpers");
+var import_common_helpers2 = require("@zenstackhq/common-helpers");
 var import_langium4 = require("langium");
 
 // src/validators/common.ts
@@ -6061,7 +6251,7 @@ var DataModelValidator = class {
     const uniqueFields = allFields.filter((f) => f.attributes.find((attr) => attr.decl.ref?.name === "@unique"));
     const modelLevelIds = getModelIdFields(dm);
     const modelUniqueFields = getModelUniqueFields(dm);
-    if (idFields.length === 0 && modelLevelIds.length === 0 && uniqueFields.length === 0 && modelUniqueFields.length === 0) {
+    if (!dm.isView && 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
       });
@@ -6255,7 +6445,7 @@ var DataModelValidator = class {
     if (!thisRelation.valid) {
       return;
     }
-    if (this.isFieldInheritedFromDelegateModel(field)) {
+    if (this.isFieldInheritedFromDelegateModel(field, contextModel)) {
       return;
     }
     if (this.isSelfRelation(field)) {
@@ -6378,14 +6568,14 @@ var DataModelValidator = class {
     }
   }
   // checks if the given field is inherited directly or indirectly from a delegate model
-  isFieldInheritedFromDelegateModel(field) {
-    return isDelegateModel(field.$container);
+  isFieldInheritedFromDelegateModel(field, contextModel) {
+    return field.$container !== contextModel && isDelegateModel(field.$container);
   }
   validateInherits(model, accept) {
     if (!model.baseModel) {
       return;
     }
-    (0, import_common_helpers.invariant)(model.baseModel.ref, "baseModel must be resolved");
+    (0, import_common_helpers2.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,
@@ -6407,7 +6597,7 @@ var DataModelValidator = class {
       }
       seen.push(current);
       if (current.baseModel) {
-        (0, import_common_helpers.invariant)(current.baseModel.ref, "baseModel must be resolved");
+        (0, import_common_helpers2.invariant)(current.baseModel.ref, "baseModel must be resolved");
         todo.push(current.baseModel.ref);
       }
     }
@@ -6438,7 +6628,6 @@ var DataSourceValidator = class {
     validateDuplicatedDeclarations(ds, ds.fields, accept);
     this.validateProvider(ds, accept);
     this.validateUrl(ds, accept);
-    this.validateRelationMode(ds, accept);
   }
   validateProvider(ds, accept) {
     const provider = ds.fields.find((f) => f.name === "provider");
@@ -6448,16 +6637,61 @@ var DataSourceValidator = class {
       });
       return;
     }
-    const value = getStringLiteral(provider.value);
-    if (!value) {
+    const providerValue = getStringLiteral(provider.value);
+    if (!providerValue) {
       accept("error", '"provider" must be set to a string literal', {
         node: provider.value
       });
-    } else if (!SUPPORTED_PROVIDERS.includes(value)) {
-      accept("error", `Provider "${value}" is not supported. Choose from ${SUPPORTED_PROVIDERS.map((p) => '"' + p + '"').join(" | ")}.`, {
+    } else if (!SUPPORTED_PROVIDERS.includes(providerValue)) {
+      accept("error", `Provider "${providerValue}" is not supported. Choose from ${SUPPORTED_PROVIDERS.map((p) => '"' + p + '"').join(" | ")}.`, {
         node: provider.value
       });
     }
+    const defaultSchemaField = ds.fields.find((f) => f.name === "defaultSchema");
+    let defaultSchemaValue;
+    if (defaultSchemaField) {
+      if (providerValue !== "postgresql") {
+        accept("error", '"defaultSchema" is only supported for "postgresql" provider', {
+          node: defaultSchemaField
+        });
+      }
+      defaultSchemaValue = getStringLiteral(defaultSchemaField.value);
+      if (!defaultSchemaValue) {
+        accept("error", '"defaultSchema" must be a string literal', {
+          node: defaultSchemaField.value
+        });
+      }
+    }
+    const schemasField = ds.fields.find((f) => f.name === "schemas");
+    if (schemasField) {
+      if (providerValue !== "postgresql") {
+        accept("error", '"schemas" is only supported for "postgresql" provider', {
+          node: schemasField
+        });
+      }
+      const schemasValue = schemasField.value;
+      if (!isConfigArrayExpr(schemasValue) || !schemasValue.items.every((e) => isLiteralExpr(e) && typeof getStringLiteral(e) === "string")) {
+        accept("error", '"schemas" must be an array of string literals', {
+          node: schemasField
+        });
+      } else {
+        const schemasArray = schemasValue.items.map((e) => getStringLiteral(e));
+        if (defaultSchemaValue) {
+          if (!schemasArray.includes(defaultSchemaValue)) {
+            accept("error", `"${defaultSchemaValue}" must be included in the "schemas" array`, {
+              node: schemasField
+            });
+          }
+        } else {
+          const hasImplicitPublicSchema = ds.$container.declarations.some((d) => (isDataModel(d) || isEnum(d)) && !d.attributes.some((a) => a.decl.$refText === "@@schema"));
+          if (hasImplicitPublicSchema && !schemasArray.includes("public")) {
+            accept("error", `"public" must be included in the "schemas" array`, {
+              node: schemasField
+            });
+          }
+        }
+      }
+    }
   }
   validateUrl(ds, accept) {
     const urlField = ds.fields.find((f) => f.name === "url");
@@ -6471,20 +6705,6 @@ var DataSourceValidator = class {
       });
     }
   }
-  validateRelationMode(ds, accept) {
-    const field = ds.fields.find((f) => f.name === "relationMode");
-    if (field) {
-      const val = getStringLiteral(field.value);
-      if (!val || ![
-        "foreignKeys",
-        "prisma"
-      ].includes(val)) {
-        accept("error", '"relationMode" must be set to "foreignKeys" or "prisma"', {
-          node: field.value
-        });
-      }
-    }
-  }
 };
 
 // src/validators/enum-validator.ts
@@ -6543,6 +6763,9 @@ var ExpressionValidator = class {
       case "BinaryExpr":
         this.validateBinaryExpr(expr, accept);
         break;
+      case "UnaryExpr":
+        this.validateUnaryExpr(expr, accept);
+        break;
     }
   }
   validateMemberAccessExpr(expr, accept) {
@@ -6684,6 +6907,13 @@ var ExpressionValidator = class {
         break;
     }
   }
+  validateUnaryExpr(expr, accept) {
+    if (expr.operand.$resolvedType && expr.operand.$resolvedType.decl !== "Boolean") {
+      accept("error", `operand of "${expr.operator}" must be of Boolean type`, {
+        node: expr.operand
+      });
+    }
+  }
   validateCollectionPredicate(expr, accept) {
     if (!expr.$resolvedType) {
       accept("error", "collection predicate can only be used on an array of model type", {
@@ -6753,44 +6983,42 @@ var FunctionInvocationValidator = class {
       });
       return;
     }
-    if (!this.validateArgs(funcDecl, expr.args, accept)) {
+    if (!this.validateArgs(funcDecl, expr, accept)) {
       return;
     }
-    if (isFromStdlib(funcDecl)) {
-      let curr = expr.$container;
-      let containerAttribute;
-      while (curr) {
-        if (isDataModelAttribute(curr) || isDataFieldAttribute(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 = 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
+      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);
@@ -6810,18 +7038,18 @@ var FunctionInvocationValidator = class {
   isValidationAttribute(attr) {
     return !!attr.decl.ref?.attributes.some((attr2) => attr2.decl.$refText === "@@@validation");
   }
-  validateArgs(funcDecl, args, accept) {
+  validateArgs(funcDecl, expr, accept) {
     let success = true;
     for (let i = 0; i < funcDecl.params.length; i++) {
       const param = funcDecl.params[i];
       if (!param) {
         continue;
       }
-      const arg = args[i];
+      const arg = expr.args[i];
       if (!arg) {
         if (!param.optional) {
           accept("error", `missing argument for parameter "${param.name}"`, {
-            node: funcDecl
+            node: expr
           });
           success = false;
         }
@@ -6870,6 +7098,13 @@ var FunctionInvocationValidator = class {
     }
     return true;
   }
+  _checkAuth(expr, accept) {
+    if (!expr.$resolvedType) {
+      accept("error", 'cannot resolve `auth()` - make sure you have a model or type with `@auth` attribute or named "User"', {
+        node: expr
+      });
+    }
+  }
   _checkLength(expr, accept) {
     const msg = "argument must be a string or list field";
     const fieldArg = expr.args[0].value;
@@ -6979,6 +7214,15 @@ var FunctionInvocationValidator = class {
     }
   }
 };
+_ts_decorate2([
+  func("auth"),
+  _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, "_checkAuth", null);
 _ts_decorate2([
   func("length"),
   _ts_metadata2("design:type", Function),
@@ -7087,6 +7331,7 @@ function registerValidationChecks(services) {
   const checks = {
     Model: validator.checkModel,
     DataSource: validator.checkDataSource,
+    GeneratorDecl: validator.checkGenerator,
     DataModel: validator.checkDataModel,
     TypeDef: validator.checkTypeDef,
     Enum: validator.checkEnum,
@@ -7112,6 +7357,11 @@ var ZModelValidator = class {
   checkDataSource(node, accept) {
     new DataSourceValidator().validate(node, accept);
   }
+  checkGenerator(node, accept) {
+    accept("warning", '"generator" is not used by ZenStack and should be removed.', {
+      node
+    });
+  }
   checkDataModel(node, accept) {
     new DataModelValidator().validate(node, accept);
   }
@@ -7135,9 +7385,876 @@ var ZModelValidator = class {
   }
 };
 
-// src/zmodel-document-builder.ts
+// src/zmodel-comment-provider.ts
 var import_langium7 = require("langium");
-var ZModelDocumentBuilder = class extends import_langium7.DefaultDocumentBuilder {
+var import_ts_pattern2 = require("ts-pattern");
+var ZModelCommentProvider = class extends import_langium7.DefaultCommentProvider {
+  static {
+    __name(this, "ZModelCommentProvider");
+  }
+  getComment(node) {
+    let comment = super.getComment(node);
+    if (!comment) {
+      comment = (0, import_ts_pattern2.match)(node).when(isDataModel, (d) => `/**
+ * Model *${d.name}*
+ */`).when(isTypeDef, (d) => `/**
+ * Type *${d.name}*
+ */`).when(isEnum, (e) => `/**
+ * Enum *${e.name}*
+ */`).when(isEnumField, (f) => `/**
+ * Value of enum *${f.$container?.name}*
+ */`).when(isDataField, (f) => `/**
+ * Field of *${f.$container?.name}*
+ */`).when(isFunctionDecl, (f) => `/**
+ * Function *${f.name}*
+ */`).otherwise(() => "");
+    }
+    return comment;
+  }
+};
+
+// src/zmodel-completion-provider.ts
+var import_lsp = require("langium/lsp");
+var import_node_fs2 = __toESM(require("fs"), 1);
+var import_ts_pattern3 = require("ts-pattern");
+var import_vscode_languageserver = require("vscode-languageserver");
+
+// src/zmodel-code-generator.ts
+function _ts_decorate3(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);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate3, "_ts_decorate");
+function _ts_metadata3(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata3, "_ts_metadata");
+var generationHandlers = /* @__PURE__ */ new Map();
+function gen(name) {
+  return function(_target, _propertyKey, descriptor) {
+    if (!generationHandlers.get(name)) {
+      generationHandlers.set(name, descriptor);
+    }
+    return descriptor;
+  };
+}
+__name(gen, "gen");
+var ZModelCodeGenerator = class {
+  static {
+    __name(this, "ZModelCodeGenerator");
+  }
+  options;
+  constructor(options) {
+    this.options = {
+      binaryExprNumberOfSpaces: options?.binaryExprNumberOfSpaces ?? 1,
+      unaryExprNumberOfSpaces: options?.unaryExprNumberOfSpaces ?? 0,
+      indent: options?.indent ?? 4,
+      quote: options?.quote ?? "single"
+    };
+  }
+  /**
+   * Generates ZModel source code from AST.
+   */
+  generate(ast) {
+    const handler = generationHandlers.get(ast.$type);
+    if (!handler) {
+      throw new Error(`No generation handler found for ${ast.$type}`);
+    }
+    return handler.value.call(this, ast);
+  }
+  _generateModel(ast) {
+    return ast.declarations.map((d) => this.generate(d)).join("\n\n");
+  }
+  _generateDataSource(ast) {
+    return `datasource ${ast.name} {
+${ast.fields.map((x) => this.indent + this.generate(x)).join("\n")}
+}`;
+  }
+  _generateEnum(ast) {
+    return `enum ${ast.name} {
+${ast.fields.map((x) => this.indent + this.generate(x)).join("\n")}
+}`;
+  }
+  _generateEnumField(ast) {
+    return `${ast.name}${ast.attributes.length > 0 ? " " + ast.attributes.map((x) => this.generate(x)).join(" ") : ""}`;
+  }
+  _generateGenerator(ast) {
+    return `generator ${ast.name} {
+${ast.fields.map((x) => this.indent + this.generate(x)).join("\n")}
+}`;
+  }
+  _generateConfigField(ast) {
+    return `${ast.name} = ${this.generate(ast.value)}`;
+  }
+  _generateConfigArrayExpr(ast) {
+    return `[${ast.items.map((x) => this.generate(x)).join(", ")}]`;
+  }
+  _generateConfigInvocationExpr(ast) {
+    if (ast.args.length === 0) {
+      return ast.name;
+    } else {
+      return `${ast.name}(${ast.args.map((x) => (x.name ? x.name + ": " : "") + this.generate(x.value)).join(", ")})`;
+    }
+  }
+  _generatePlugin(ast) {
+    return `plugin ${ast.name} {
+${ast.fields.map((x) => this.indent + this.generate(x)).join("\n")}
+}`;
+  }
+  _generatePluginField(ast) {
+    return `${ast.name} = ${this.generate(ast.value)}`;
+  }
+  _generateDataModel(ast) {
+    return `${ast.isView ? "view" : "model"} ${ast.name}${ast.mixins.length > 0 ? " mixes " + ast.mixins.map((x) => x.$refText).join(", ") : ""} {
+${ast.fields.map((x) => this.indent + this.generate(x)).join("\n")}${ast.attributes.length > 0 ? "\n\n" + ast.attributes.map((x) => this.indent + this.generate(x)).join("\n") : ""}
+}`;
+  }
+  _generateDataField(ast) {
+    return `${ast.name} ${this.fieldType(ast.type)}${ast.attributes.length > 0 ? " " + ast.attributes.map((x) => this.generate(x)).join(" ") : ""}`;
+  }
+  fieldType(type) {
+    const baseType = type.type ? type.type : type.$type == "DataFieldType" && type.unsupported ? "Unsupported(" + this.generate(type.unsupported.value) + ")" : type.reference?.$refText;
+    return `${baseType}${type.array ? "[]" : ""}${type.optional ? "?" : ""}`;
+  }
+  _generateDataModelAttribute(ast) {
+    return this.attribute(ast);
+  }
+  _generateDataFieldAttribute(ast) {
+    return this.attribute(ast);
+  }
+  attribute(ast) {
+    const args = ast.args.length ? `(${ast.args.map((x) => this.generate(x)).join(", ")})` : "";
+    return `${ast.decl.$refText}${args}`;
+  }
+  _generateAttributeArg(ast) {
+    if (ast.name) {
+      return `${ast.name}: ${this.generate(ast.value)}`;
+    } else {
+      return this.generate(ast.value);
+    }
+  }
+  _generateObjectExpr(ast) {
+    return `{ ${ast.fields.map((field) => this.objectField(field)).join(", ")} }`;
+  }
+  objectField(field) {
+    return `${field.name}: ${this.generate(field.value)}`;
+  }
+  _generateArrayExpr(ast) {
+    return `[${ast.items.map((item) => this.generate(item)).join(", ")}]`;
+  }
+  _generateLiteralExpr(ast) {
+    return this.options.quote === "single" ? `'${ast.value}'` : `"${ast.value}"`;
+  }
+  _generateNumberLiteral(ast) {
+    return ast.value.toString();
+  }
+  _generateBooleanLiteral(ast) {
+    return ast.value.toString();
+  }
+  _generateUnaryExpr(ast) {
+    return `${ast.operator}${this.unaryExprSpace}${this.generate(ast.operand)}`;
+  }
+  _generateBinaryExpr(ast) {
+    const operator = ast.operator;
+    const isCollectionPredicate2 = this.isCollectionPredicateOperator(operator);
+    const rightExpr = this.generate(ast.right);
+    const { left: isLeftParenthesis, right: isRightParenthesis } = this.isParenthesesNeededForBinaryExpr(ast);
+    return `${isLeftParenthesis ? "(" : ""}${this.generate(ast.left)}${isLeftParenthesis ? ")" : ""}${isCollectionPredicate2 ? "" : this.binaryExprSpace}${operator}${isCollectionPredicate2 ? "" : this.binaryExprSpace}${isRightParenthesis ? "(" : ""}${isCollectionPredicate2 ? `[${rightExpr}]` : rightExpr}${isRightParenthesis ? ")" : ""}`;
+  }
+  _generateReferenceExpr(ast) {
+    const args = ast.args.length ? `(${ast.args.map((x) => this.generate(x)).join(", ")})` : "";
+    return `${ast.target.$refText}${args}`;
+  }
+  _generateReferenceArg(ast) {
+    return `${ast.name}:${this.generate(ast.value)}`;
+  }
+  _generateMemberExpr(ast) {
+    return `${this.generate(ast.operand)}.${ast.member.$refText}`;
+  }
+  _generateInvocationExpr(ast) {
+    return `${ast.function.$refText}(${ast.args.map((x) => this.argument(x)).join(", ")})`;
+  }
+  _generateNullExpr() {
+    return "null";
+  }
+  _generateThisExpr() {
+    return "this";
+  }
+  _generateAttribute(ast) {
+    return `attribute ${ast.name}(${ast.params.map((x) => this.generate(x)).join(", ")})`;
+  }
+  _generateAttributeParam(ast) {
+    return `${ast.default ? "_ " : ""}${ast.name}: ${this.generate(ast.type)}`;
+  }
+  _generateAttributeParamType(ast) {
+    return `${ast.type ?? ast.reference?.$refText}${ast.array ? "[]" : ""}${ast.optional ? "?" : ""}`;
+  }
+  _generateFunctionDecl(ast) {
+    return `function ${ast.name}(${ast.params.map((x) => this.generate(x)).join(", ")}) ${ast.returnType ? ": " + this.generate(ast.returnType) : ""} {}`;
+  }
+  _generateFunctionParam(ast) {
+    return `${ast.name}: ${this.generate(ast.type)}`;
+  }
+  _generateFunctionParamType(ast) {
+    return `${ast.type ?? ast.reference?.$refText}${ast.array ? "[]" : ""}`;
+  }
+  _generateTypeDef(ast) {
+    return `type ${ast.name} {
+${ast.fields.map((x) => this.indent + this.generate(x)).join("\n")}${ast.attributes.length > 0 ? "\n\n" + ast.attributes.map((x) => this.indent + this.generate(x)).join("\n") : ""}
+}`;
+  }
+  argument(ast) {
+    return this.generate(ast.value);
+  }
+  get binaryExprSpace() {
+    return " ".repeat(this.options.binaryExprNumberOfSpaces);
+  }
+  get unaryExprSpace() {
+    return " ".repeat(this.options.unaryExprNumberOfSpaces);
+  }
+  get indent() {
+    return " ".repeat(this.options.indent);
+  }
+  isParenthesesNeededForBinaryExpr(ast) {
+    const result = {
+      left: false,
+      right: false
+    };
+    const operator = ast.operator;
+    const isCollectionPredicate2 = this.isCollectionPredicateOperator(operator);
+    const currentPriority = BinaryExprOperatorPriority[operator];
+    if (ast.left.$type === BinaryExpr && BinaryExprOperatorPriority[ast.left["operator"]] < currentPriority) {
+      result.left = true;
+    }
+    if (!isCollectionPredicate2 && ast.right.$type === BinaryExpr && BinaryExprOperatorPriority[ast.right["operator"]] <= currentPriority) {
+      result.right = true;
+    }
+    return result;
+  }
+  isCollectionPredicateOperator(op) {
+    return [
+      "?",
+      "!",
+      "^"
+    ].includes(op);
+  }
+};
+_ts_decorate3([
+  gen(Model),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof Model === "undefined" ? Object : Model
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateModel", null);
+_ts_decorate3([
+  gen(DataSource),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof DataSource === "undefined" ? Object : DataSource
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateDataSource", null);
+_ts_decorate3([
+  gen(Enum),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof Enum === "undefined" ? Object : Enum
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateEnum", null);
+_ts_decorate3([
+  gen(EnumField),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof EnumField === "undefined" ? Object : EnumField
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateEnumField", null);
+_ts_decorate3([
+  gen(GeneratorDecl),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof GeneratorDecl === "undefined" ? Object : GeneratorDecl
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateGenerator", null);
+_ts_decorate3([
+  gen(ConfigField),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof ConfigField === "undefined" ? Object : ConfigField
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateConfigField", null);
+_ts_decorate3([
+  gen(ConfigArrayExpr),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof ConfigArrayExpr === "undefined" ? Object : ConfigArrayExpr
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateConfigArrayExpr", null);
+_ts_decorate3([
+  gen(ConfigInvocationExpr),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof ConfigInvocationExpr === "undefined" ? Object : ConfigInvocationExpr
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateConfigInvocationExpr", null);
+_ts_decorate3([
+  gen(Plugin),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof Plugin === "undefined" ? Object : Plugin
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generatePlugin", null);
+_ts_decorate3([
+  gen(PluginField),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof PluginField === "undefined" ? Object : PluginField
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generatePluginField", null);
+_ts_decorate3([
+  gen(DataModel),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof DataModel === "undefined" ? Object : DataModel
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateDataModel", null);
+_ts_decorate3([
+  gen(DataField),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof DataField === "undefined" ? Object : DataField
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateDataField", null);
+_ts_decorate3([
+  gen(DataModelAttribute),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof DataModelAttribute === "undefined" ? Object : DataModelAttribute
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateDataModelAttribute", null);
+_ts_decorate3([
+  gen(DataFieldAttribute),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof DataFieldAttribute === "undefined" ? Object : DataFieldAttribute
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateDataFieldAttribute", null);
+_ts_decorate3([
+  gen(AttributeArg),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof AttributeArg === "undefined" ? Object : AttributeArg
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateAttributeArg", null);
+_ts_decorate3([
+  gen(ObjectExpr),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof ObjectExpr === "undefined" ? Object : ObjectExpr
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateObjectExpr", null);
+_ts_decorate3([
+  gen(ArrayExpr),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof ArrayExpr === "undefined" ? Object : ArrayExpr
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateArrayExpr", null);
+_ts_decorate3([
+  gen(StringLiteral),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof LiteralExpr === "undefined" ? Object : LiteralExpr
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateLiteralExpr", null);
+_ts_decorate3([
+  gen(NumberLiteral),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof NumberLiteral === "undefined" ? Object : NumberLiteral
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateNumberLiteral", null);
+_ts_decorate3([
+  gen(BooleanLiteral),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof BooleanLiteral === "undefined" ? Object : BooleanLiteral
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateBooleanLiteral", null);
+_ts_decorate3([
+  gen(UnaryExpr),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof UnaryExpr === "undefined" ? Object : UnaryExpr
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateUnaryExpr", null);
+_ts_decorate3([
+  gen(BinaryExpr),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof BinaryExpr === "undefined" ? Object : BinaryExpr
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateBinaryExpr", null);
+_ts_decorate3([
+  gen(ReferenceExpr),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof ReferenceExpr === "undefined" ? Object : ReferenceExpr
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateReferenceExpr", null);
+_ts_decorate3([
+  gen(ReferenceArg),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof ReferenceArg === "undefined" ? Object : ReferenceArg
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateReferenceArg", null);
+_ts_decorate3([
+  gen(MemberAccessExpr),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof MemberAccessExpr === "undefined" ? Object : MemberAccessExpr
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateMemberExpr", null);
+_ts_decorate3([
+  gen(InvocationExpr),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof InvocationExpr === "undefined" ? Object : InvocationExpr
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateInvocationExpr", null);
+_ts_decorate3([
+  gen(NullExpr),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", []),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateNullExpr", null);
+_ts_decorate3([
+  gen(ThisExpr),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", []),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateThisExpr", null);
+_ts_decorate3([
+  gen(Attribute),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof Attribute === "undefined" ? Object : Attribute
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateAttribute", null);
+_ts_decorate3([
+  gen(AttributeParam),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof AttributeParam === "undefined" ? Object : AttributeParam
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateAttributeParam", null);
+_ts_decorate3([
+  gen(AttributeParamType),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof AttributeParamType === "undefined" ? Object : AttributeParamType
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateAttributeParamType", null);
+_ts_decorate3([
+  gen(FunctionDecl),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof FunctionDecl === "undefined" ? Object : FunctionDecl
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateFunctionDecl", null);
+_ts_decorate3([
+  gen(FunctionParam),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof FunctionParam === "undefined" ? Object : FunctionParam
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateFunctionParam", null);
+_ts_decorate3([
+  gen(FunctionParamType),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof FunctionParamType === "undefined" ? Object : FunctionParamType
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateFunctionParamType", null);
+_ts_decorate3([
+  gen(TypeDef),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof TypeDef === "undefined" ? Object : TypeDef
+  ]),
+  _ts_metadata3("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateTypeDef", null);
+
+// src/zmodel-completion-provider.ts
+var ZModelCompletionProvider = class extends import_lsp.DefaultCompletionProvider {
+  static {
+    __name(this, "ZModelCompletionProvider");
+  }
+  services;
+  constructor(services) {
+    super(services), this.services = services;
+  }
+  completionOptions = {
+    triggerCharacters: [
+      "@",
+      "(",
+      ",",
+      "."
+    ]
+  };
+  async getCompletion(document, params) {
+    try {
+      return await super.getCompletion(document, params);
+    } catch (e) {
+      console.error("Completion error:", e.message);
+      return void 0;
+    }
+  }
+  completionFor(context, next, acceptor) {
+    if (isDataModelAttribute(context.node) || isDataFieldAttribute(context.node)) {
+      const completions = this.getCompletionFromHint(context.node);
+      if (completions) {
+        completions.forEach((c) => acceptor(context, c));
+        return;
+      }
+    }
+    return super.completionFor(context, next, acceptor);
+  }
+  getCompletionFromHint(contextNode) {
+    const unfilledParams = this.getUnfilledAttributeParams(contextNode);
+    const nextParam = unfilledParams[0];
+    if (!nextParam) {
+      return void 0;
+    }
+    const hintAttr = getAttribute(nextParam, "@@@completionHint");
+    if (hintAttr) {
+      const hint = hintAttr.args[0];
+      if (hint?.value) {
+        if (isArrayExpr(hint.value)) {
+          return hint.value.items.map((item) => {
+            return {
+              label: `${item.value}`,
+              kind: import_vscode_languageserver.CompletionItemKind.Value,
+              detail: "Parameter",
+              sortText: "0"
+            };
+          });
+        }
+      }
+    }
+    return void 0;
+  }
+  // TODO: this doesn't work when the file contains parse errors
+  getUnfilledAttributeParams(contextNode) {
+    try {
+      const params = contextNode.decl.ref?.params;
+      if (params) {
+        const args = contextNode.args;
+        let unfilledParams = [
+          ...params
+        ];
+        args.forEach((arg) => {
+          if (arg.name) {
+            unfilledParams = unfilledParams.filter((p) => p.name !== arg.name);
+          } else {
+            unfilledParams.shift();
+          }
+        });
+        return unfilledParams;
+      }
+    } catch {
+    }
+    return [];
+  }
+  completionForCrossReference(context, crossRef, acceptor) {
+    if (crossRef.property === "member" && !isMemberAccessExpr(context.node)) {
+      return;
+    }
+    const customAcceptor = /* @__PURE__ */ __name((context2, item) => {
+      if (item.insertText?.startsWith("@@@") || item.label?.startsWith("@@@")) {
+        return;
+      }
+      if ("nodeDescription" in item) {
+        const node = this.getAstNode(item.nodeDescription);
+        if (!node) {
+          return;
+        }
+        if ((isEnum(node) || isEnumField(node)) && isFromStdlib(node)) {
+          return;
+        }
+        if ((isDataModelAttribute(context2.node) || isDataFieldAttribute(context2.node)) && !this.filterAttributeApplicationCompletion(context2.node, node)) {
+          return;
+        }
+      }
+      acceptor(context2, item);
+    }, "customAcceptor");
+    return super.completionForCrossReference(context, crossRef, customAcceptor);
+  }
+  completionForKeyword(context, keyword, acceptor) {
+    const customAcceptor = /* @__PURE__ */ __name((context2, item) => {
+      if (!this.filterKeywordForContext(context2, keyword.value)) {
+        return;
+      }
+      acceptor(context2, item);
+    }, "customAcceptor");
+    return super.completionForKeyword(context, keyword, customAcceptor);
+  }
+  filterKeywordForContext(context, keyword) {
+    if (isInvocationExpr(context.node)) {
+      return [
+        "true",
+        "false",
+        "null",
+        "this"
+      ].includes(keyword);
+    } else if (isDataModelAttribute(context.node) || isDataFieldAttribute(context.node)) {
+      const exprContext = this.getAttributeContextType(context.node);
+      if (exprContext === "DefaultValue") {
+        return [
+          "true",
+          "false",
+          "null"
+        ].includes(keyword);
+      } else {
+        return [
+          "true",
+          "false",
+          "null",
+          "this"
+        ].includes(keyword);
+      }
+    } else {
+      return true;
+    }
+  }
+  filterAttributeApplicationCompletion(contextNode, node) {
+    const attrContextType = this.getAttributeContextType(contextNode);
+    if (isFunctionDecl(node) && attrContextType) {
+      const funcExprContextAttr = getAttribute(node, "@@@expressionContext");
+      if (funcExprContextAttr && funcExprContextAttr.args[0]) {
+        const arg = funcExprContextAttr.args[0];
+        if (isArrayExpr(arg.value)) {
+          return arg.value.items.some((item) => isEnumFieldReference(item) && item.target.$refText === attrContextType);
+        }
+      }
+      return false;
+    }
+    if (isDataField(node)) {
+      return attrContextType !== "DefaultValue";
+    }
+    return true;
+  }
+  getAttributeContextType(node) {
+    return (0, import_ts_pattern3.match)(node.decl.$refText).with("@default", () => "DefaultValue").with(import_ts_pattern3.P.union("@@allow", "@allow", "@@deny", "@deny"), () => "AccessPolicy").with("@@validate", () => "ValidationRule").otherwise(() => void 0);
+  }
+  createReferenceCompletionItem(nodeDescription) {
+    const node = this.getAstNode(nodeDescription);
+    const documentation = this.getNodeDocumentation(node);
+    return (0, import_ts_pattern3.match)(node).when(isDataModel, () => ({
+      nodeDescription,
+      kind: import_vscode_languageserver.CompletionItemKind.Class,
+      detail: "Model",
+      sortText: "1",
+      documentation
+    })).when(isTypeDef, () => ({
+      nodeDescription,
+      kind: import_vscode_languageserver.CompletionItemKind.Class,
+      detail: "Type",
+      sortText: "1",
+      documentation
+    })).when(isDataField, () => ({
+      nodeDescription,
+      kind: import_vscode_languageserver.CompletionItemKind.Field,
+      detail: "Field",
+      sortText: "0",
+      documentation
+    })).when(isEnum, () => ({
+      nodeDescription,
+      kind: import_vscode_languageserver.CompletionItemKind.Class,
+      detail: "Enum",
+      sortText: "1",
+      documentation
+    })).when(isEnumField, (d) => {
+      const container = d.$container;
+      return {
+        nodeDescription,
+        kind: import_vscode_languageserver.CompletionItemKind.Enum,
+        detail: `Value of enum "${container.name}"`,
+        sortText: "1",
+        documentation
+      };
+    }).when(isFunctionDecl, () => ({
+      nodeDescription,
+      insertText: this.getFunctionInsertText(nodeDescription),
+      kind: import_vscode_languageserver.CompletionItemKind.Function,
+      detail: "Function",
+      sortText: "1",
+      documentation
+    })).when(isAttribute, () => ({
+      nodeDescription,
+      insertText: this.getAttributeInsertText(nodeDescription),
+      kind: import_vscode_languageserver.CompletionItemKind.Property,
+      detail: "Attribute",
+      sortText: "1",
+      documentation
+    })).otherwise(() => ({
+      nodeDescription,
+      kind: import_vscode_languageserver.CompletionItemKind.Reference,
+      detail: nodeDescription.type,
+      sortText: "2",
+      documentation
+    }));
+  }
+  getFunctionInsertText(nodeDescription) {
+    const node = this.getAstNode(nodeDescription);
+    if (isFunctionDecl(node)) {
+      if (node.params.some((p) => !p.optional)) {
+        return nodeDescription.name;
+      }
+    }
+    return `${nodeDescription.name}()`;
+  }
+  getAttributeInsertText(nodeDescription) {
+    const node = this.getAstNode(nodeDescription);
+    if (isAttribute(node)) {
+      if (node.name === "@relation") {
+        return `${nodeDescription.name}(fields: [], references: [])`;
+      }
+    }
+    return nodeDescription.name;
+  }
+  getAstNode(nodeDescription) {
+    let node = nodeDescription.node;
+    if (!node) {
+      const doc = this.getOrCreateDocumentSync(nodeDescription);
+      if (!doc) {
+        return void 0;
+      }
+      node = this.services.workspace.AstNodeLocator.getAstNode(doc.parseResult.value, nodeDescription.path);
+      if (!node) {
+        return void 0;
+      }
+    }
+    return node;
+  }
+  getOrCreateDocumentSync(nodeDescription) {
+    let doc = this.services.shared.workspace.LangiumDocuments.getDocument(nodeDescription.documentUri);
+    if (!doc) {
+      try {
+        const content = import_node_fs2.default.readFileSync(nodeDescription.documentUri.fsPath, "utf-8");
+        doc = this.services.shared.workspace.LangiumDocuments.createDocument(nodeDescription.documentUri, content);
+      } catch {
+        console.warn("Failed to read or create document:", nodeDescription.documentUri);
+        return void 0;
+      }
+    }
+    return doc;
+  }
+  getNodeDocumentation(node) {
+    if (!node) {
+      return void 0;
+    }
+    const md = this.commentsToMarkdown(node);
+    return {
+      kind: "markdown",
+      value: md
+    };
+  }
+  commentsToMarkdown(node) {
+    const md = this.services.documentation.DocumentationProvider.getDocumentation(node) ?? "";
+    const zModelGenerator = new ZModelCodeGenerator();
+    const docs = [];
+    try {
+      (0, import_ts_pattern3.match)(node).when(isAttribute, (attr) => {
+        docs.push("```prisma", zModelGenerator.generate(attr), "```");
+      }).when(isFunctionDecl, (func2) => {
+        docs.push("```ts", zModelGenerator.generate(func2), "```");
+      }).when(isDataModel, (model) => {
+        docs.push("```prisma", `model ${model.name} { ... }`, "```");
+      }).when(isEnum, (enumDecl) => {
+        docs.push("```prisma", zModelGenerator.generate(enumDecl), "```");
+      }).when(isDataField, (field) => {
+        docs.push(`${field.name}: ${field.type.type ?? field.type.reference?.$refText}`);
+      }).otherwise((ast) => {
+        const name = ast.name;
+        if (name) {
+          docs.push(name);
+        }
+      });
+    } catch {
+    }
+    if (md) {
+      docs.push("___", md);
+    }
+    return docs.join("\n");
+  }
+};
+
+// src/zmodel-definition.ts
+var import_lsp2 = require("langium/lsp");
+var import_vscode_languageserver2 = require("vscode-languageserver");
+var ZModelDefinitionProvider = class extends import_lsp2.DefaultDefinitionProvider {
+  static {
+    __name(this, "ZModelDefinitionProvider");
+  }
+  documents;
+  constructor(services) {
+    super(services);
+    this.documents = services.shared.workspace.LangiumDocuments;
+  }
+  collectLocationLinks(sourceCstNode, _params) {
+    if (isModelImport(sourceCstNode.astNode)) {
+      const importedModel = resolveImport(this.documents, sourceCstNode.astNode);
+      if (importedModel?.$document) {
+        const targetObject = importedModel;
+        const selectionRange = this.nameProvider.getNameNode(targetObject)?.range ?? import_vscode_languageserver2.Range.create(0, 0, 0, 0);
+        const previewRange = targetObject.$cstNode?.range ?? import_vscode_languageserver2.Range.create(0, 0, 0, 0);
+        return [
+          import_vscode_languageserver2.LocationLink.create(importedModel.$document.uri.toString(), previewRange, selectionRange, sourceCstNode.range)
+        ];
+      }
+      return void 0;
+    }
+    return super.collectLocationLinks(sourceCstNode, _params);
+  }
+};
+
+// src/zmodel-document-builder.ts
+var import_langium8 = require("langium");
+var ZModelDocumentBuilder = class extends import_langium8.DefaultDocumentBuilder {
   static {
     __name(this, "ZModelDocumentBuilder");
   }
@@ -7164,10 +8281,115 @@ var ZModelDocumentBuilder = class extends import_langium7.DefaultDocumentBuilder
   }
 };
 
+// src/zmodel-documentation-provider.ts
+var import_langium9 = require("langium");
+var ZModelDocumentationProvider = class extends import_langium9.JSDocDocumentationProvider {
+  static {
+    __name(this, "ZModelDocumentationProvider");
+  }
+  getDocumentation(node) {
+    if ("comments" in node && Array.isArray(node.comments) && node.comments.length > 0) {
+      return node.comments.map((c) => c.replace(/^[/]*\s*/, "")).join("\n");
+    }
+    return super.getDocumentation(node);
+  }
+};
+
+// src/zmodel-formatter.ts
+var import_lsp3 = require("langium/lsp");
+var ZModelFormatter = class extends import_lsp3.AbstractFormatter {
+  static {
+    __name(this, "ZModelFormatter");
+  }
+  formatOptions;
+  configurationProvider;
+  constructor(services) {
+    super();
+    this.configurationProvider = services.shared.workspace.ConfigurationProvider;
+  }
+  format(node) {
+    const formatter = this.getNodeFormatter(node);
+    if (isDataField(node)) {
+      if (isDataModel(node.$container) || isTypeDef(node.$container)) {
+        const dataModel = node.$container;
+        const compareFn = /* @__PURE__ */ __name((a, b) => b - a, "compareFn");
+        const maxNameLength = dataModel.fields.map((x) => x.name.length).sort(compareFn)[0] ?? 0;
+        const maxTypeLength = dataModel.fields.map(this.getFieldTypeLength).sort(compareFn)[0] ?? 0;
+        formatter.property("type").prepend(import_lsp3.Formatting.spaces(maxNameLength - node.name.length + 1));
+        if (node.attributes.length > 0) {
+          formatter.node(node.attributes[0]).prepend(import_lsp3.Formatting.spaces(maxTypeLength - this.getFieldTypeLength(node) + 1));
+          formatter.nodes(...node.attributes.slice(1)).prepend(import_lsp3.Formatting.oneSpace());
+        }
+      } else {
+        formatter.property("type").prepend(import_lsp3.Formatting.oneSpace());
+        if (node.attributes.length > 0) {
+          formatter.properties("attributes").prepend(import_lsp3.Formatting.oneSpace());
+        }
+      }
+    } else if (isDataFieldAttribute(node)) {
+      formatter.keyword("(").surround(import_lsp3.Formatting.noSpace());
+      formatter.keyword(")").prepend(import_lsp3.Formatting.noSpace());
+      formatter.keyword(",").append(import_lsp3.Formatting.oneSpace());
+      if (node.args.length > 1) {
+        formatter.nodes(...node.args.slice(1)).prepend(import_lsp3.Formatting.oneSpace());
+      }
+    } else if (isAttributeArg(node)) {
+      formatter.keyword(":").prepend(import_lsp3.Formatting.noSpace());
+      formatter.keyword(":").append(import_lsp3.Formatting.oneSpace());
+    } else if (isAbstractDeclaration(node)) {
+      const bracesOpen = formatter.keyword("{");
+      const bracesClose = formatter.keyword("}");
+      formatter.interior(bracesOpen, bracesClose).prepend(import_lsp3.Formatting.indent({
+        allowMore: true
+      }));
+      bracesOpen.prepend(import_lsp3.Formatting.oneSpace());
+      bracesClose.prepend(import_lsp3.Formatting.newLine());
+    } else if (isModel(node)) {
+      const model = node;
+      const nodes = formatter.nodes(...model.declarations);
+      nodes.prepend(import_lsp3.Formatting.noIndent());
+    }
+  }
+  formatDocument(document, params) {
+    this.formatOptions = params.options;
+    this.configurationProvider.getConfiguration(ZModelLanguageMetaData.languageId, "format").then((config) => {
+      if (config) {
+      }
+    });
+    return super.formatDocument(document, params);
+  }
+  getFormatOptions() {
+    return this.formatOptions;
+  }
+  getIndent() {
+    return 1;
+  }
+  getFieldTypeLength(field) {
+    let length;
+    if (field.type.type) {
+      length = field.type.type.length;
+    } else if (field.type.reference) {
+      length = field.type.reference.$refText.length;
+    } else if (isDataField(field) && field.type.unsupported) {
+      const name = `Unsupported("${field.type.unsupported.value.value}")`;
+      length = name.length;
+    } else {
+      length = 1;
+    }
+    if (field.type.optional) {
+      length += 1;
+    }
+    if (field.type.array) {
+      length += 2;
+    }
+    return length;
+  }
+};
+
 // src/zmodel-linker.ts
-var import_langium8 = require("langium");
-var import_ts_pattern2 = require("ts-pattern");
-var ZModelLinker = class extends import_langium8.DefaultLinker {
+var import_langium10 = require("langium");
+var import_ts_pattern4 = require("ts-pattern");
+var ZModelLinker = class extends import_langium10.DefaultLinker {
   static {
     __name(this, "ZModelLinker");
   }
@@ -7177,15 +8399,15 @@ var ZModelLinker = class extends import_langium8.DefaultLinker {
     this.descriptions = services.workspace.AstNodeDescriptionProvider;
   }
   //#region Reference linking
-  async link(document, cancelToken = import_langium8.Cancellation.CancellationToken.None) {
+  async link(document, cancelToken = import_langium10.Cancellation.CancellationToken.None) {
     if (document.parseResult.lexerErrors?.length > 0 || document.parseResult.parserErrors?.length > 0) {
       return;
     }
-    for (const node of import_langium8.AstUtils.streamContents(document.parseResult.value)) {
-      await (0, import_langium8.interruptAndCheck)(cancelToken);
+    for (const node of import_langium10.AstUtils.streamContents(document.parseResult.value)) {
+      await (0, import_langium10.interruptAndCheck)(cancelToken);
       this.resolve(node, document);
     }
-    document.state = import_langium8.DocumentState.Linked;
+    document.state = import_langium10.DocumentState.Linked;
   }
   linkReference(refInfo, document, extraScopes) {
     const defaultRef = refInfo.reference;
@@ -7337,7 +8559,7 @@ var ZModelLinker = class extends import_langium8.DefaultLinker {
     if (node.function.ref) {
       const funcDecl = node.function.ref;
       if (isAuthInvocation(node)) {
-        const allDecls = getAllLoadedAndReachableDataModelsAndTypeDefs(this.langiumDocuments(), import_langium8.AstUtils.getContainerOfType(node, isDataModel));
+        const allDecls = getAllLoadedAndReachableDataModelsAndTypeDefs(this.langiumDocuments(), import_langium10.AstUtils.getContainerOfType(node, isDataModel));
         const authDecl = getAuthDecl(allDecls);
         if (authDecl) {
           node.$resolvedType = {
@@ -7355,7 +8577,7 @@ var ZModelLinker = class extends import_langium8.DefaultLinker {
     }
   }
   resolveLiteral(node) {
-    const type = (0, import_ts_pattern2.match)(node).when(isStringLiteral, () => "String").when(isBooleanLiteral, () => "Boolean").when(isNumberLiteral, () => "Int").exhaustive();
+    const type = (0, import_ts_pattern4.match)(node).when(isStringLiteral, () => "String").when(isBooleanLiteral, () => "Boolean").when(isNumberLiteral, () => "Int").exhaustive();
     if (type) {
       this.resolveToBuiltinTypeOrDecl(node, type);
     }
@@ -7475,10 +8697,10 @@ var ZModelLinker = class extends import_langium8.DefaultLinker {
     this.resolveDefault(node, document, scopes);
   }
   resolveDefault(node, document, extraScopes) {
-    import_langium8.AstUtils.streamReferences(node).forEach((ref) => {
+    import_langium10.AstUtils.streamReferences(node).forEach((ref) => {
       this.linkReference(ref, document, extraScopes);
     });
-    for (const child of import_langium8.AstUtils.streamContents(node)) {
+    for (const child of import_langium10.AstUtils.streamContents(node)) {
       this.resolve(child, document, extraScopes);
     }
   }
@@ -7522,9 +8744,9 @@ var ZModelLinker = class extends import_langium8.DefaultLinker {
 };
 
 // src/zmodel-scope.ts
-var import_langium9 = require("langium");
-var import_ts_pattern3 = require("ts-pattern");
-var ZModelScopeComputation = class extends import_langium9.DefaultScopeComputation {
+var import_langium11 = require("langium");
+var import_ts_pattern5 = require("ts-pattern");
+var ZModelScopeComputation = class extends import_langium11.DefaultScopeComputation {
   static {
     __name(this, "ZModelScopeComputation");
   }
@@ -7534,9 +8756,9 @@ var ZModelScopeComputation = class extends import_langium9.DefaultScopeComputati
   }
   async computeExports(document, cancelToken) {
     const result = await super.computeExports(document, cancelToken);
-    for (const node of import_langium9.AstUtils.streamAllContents(document.parseResult.value)) {
+    for (const node of import_langium11.AstUtils.streamAllContents(document.parseResult.value)) {
       if (cancelToken) {
-        await (0, import_langium9.interruptAndCheck)(cancelToken);
+        await (0, import_langium11.interruptAndCheck)(cancelToken);
       }
       if (isEnumField(node)) {
         const desc = this.services.workspace.AstNodeDescriptionProvider.createDescription(node, node.name, document);
@@ -7557,7 +8779,7 @@ var ZModelScopeComputation = class extends import_langium9.DefaultScopeComputati
     }
   }
 };
-var ZModelScopeProvider = class extends import_langium9.DefaultScopeProvider {
+var ZModelScopeProvider = class extends import_langium11.DefaultScopeProvider {
   static {
     __name(this, "ZModelScopeProvider");
   }
@@ -7566,19 +8788,19 @@ var ZModelScopeProvider = class extends import_langium9.DefaultScopeProvider {
     super(services), this.services = services;
   }
   getGlobalScope(referenceType, context) {
-    const model = import_langium9.AstUtils.getContainerOfType(context.container, isModel);
+    const model = import_langium11.AstUtils.getContainerOfType(context.container, isModel);
     if (!model) {
-      return import_langium9.EMPTY_SCOPE;
+      return import_langium11.EMPTY_SCOPE;
     }
     const importedUris = model.imports.map(resolveImportUri).filter((url) => !!url);
     const importedElements = this.indexManager.allElements(referenceType).filter((des) => (
       // allow current document
-      import_langium9.UriUtils.equals(des.documentUri, model.$document?.uri) || // allow stdlib
+      import_langium11.UriUtils.equals(des.documentUri, model.$document?.uri) || // allow stdlib
       des.documentUri.path.endsWith(STD_LIB_MODULE_NAME) || // allow plugin models
       des.documentUri.path.endsWith(PLUGIN_MODULE_NAME) || // allow imported documents
-      importedUris.some((importedUri) => import_langium9.UriUtils.equals(des.documentUri, importedUri))
+      importedUris.some((importedUri) => import_langium11.UriUtils.equals(des.documentUri, importedUri))
     ));
-    return new import_langium9.StreamScope(importedElements);
+    return new import_langium11.StreamScope(importedElements);
   }
   getScope(context) {
     if (isMemberAccessExpr(context.container) && context.container.operand && context.property === "member") {
@@ -7596,22 +8818,19 @@ var ZModelScopeProvider = class extends import_langium9.DefaultScopeProvider {
     const referenceType = this.reflection.getReferenceType(context);
     const globalScope = this.getGlobalScope(referenceType, context);
     const node = context.container;
-    const allowTypeDefScope = (
-      // isAuthOrAuthMemberAccess(node.operand) ||
-      !!import_langium9.AstUtils.getContainerOfType(node, isTypeDef)
-    );
-    return (0, import_ts_pattern3.match)(node.operand).when(isReferenceExpr, (operand) => {
+    const allowTypeDefScope = isAuthOrAuthMemberAccess(node.operand) || !!import_langium11.AstUtils.getContainerOfType(node, isTypeDef);
+    return (0, import_ts_pattern5.match)(node.operand).when(isReferenceExpr, (operand) => {
       const ref = operand.target.ref;
       if (isDataField(ref)) {
         return this.createScopeForContainer(ref.type.reference?.ref, globalScope, allowTypeDefScope);
       }
-      return import_langium9.EMPTY_SCOPE;
+      return import_langium11.EMPTY_SCOPE;
     }).when(isMemberAccessExpr, (operand) => {
       const ref = operand.member.ref;
       if (isDataField(ref) && !ref.type.array) {
         return this.createScopeForContainer(ref.type.reference?.ref, globalScope, allowTypeDefScope);
       }
-      return import_langium9.EMPTY_SCOPE;
+      return import_langium11.EMPTY_SCOPE;
     }).when(isThisExpr, () => {
       return this.createScopeForContainingModel(node, globalScope);
     }).when(isInvocationExpr, (operand) => {
@@ -7621,43 +8840,43 @@ var ZModelScopeProvider = class extends import_langium9.DefaultScopeProvider {
       if (isBeforeInvocation(operand)) {
         return this.createScopeForContainingModel(node, globalScope);
       }
-      return import_langium9.EMPTY_SCOPE;
-    }).otherwise(() => import_langium9.EMPTY_SCOPE);
+      return import_langium11.EMPTY_SCOPE;
+    }).otherwise(() => import_langium11.EMPTY_SCOPE);
   }
   getCollectionPredicateScope(context, collectionPredicate) {
     const referenceType = this.reflection.getReferenceType(context);
     const globalScope = this.getGlobalScope(referenceType, context);
     const collection = collectionPredicate.left;
-    const allowTypeDefScope = false;
-    return (0, import_ts_pattern3.match)(collection).when(isReferenceExpr, (expr) => {
+    const allowTypeDefScope = isAuthOrAuthMemberAccess(collection);
+    return (0, import_ts_pattern5.match)(collection).when(isReferenceExpr, (expr) => {
       const ref = expr.target.ref;
       if (isDataField(ref)) {
         return this.createScopeForContainer(ref.type.reference?.ref, globalScope, allowTypeDefScope);
       }
-      return import_langium9.EMPTY_SCOPE;
+      return import_langium11.EMPTY_SCOPE;
     }).when(isMemberAccessExpr, (expr) => {
       const ref = expr.member.ref;
       if (isDataField(ref)) {
         return this.createScopeForContainer(ref.type.reference?.ref, globalScope, allowTypeDefScope);
       }
-      return import_langium9.EMPTY_SCOPE;
+      return import_langium11.EMPTY_SCOPE;
     }).when(isInvocationExpr, (expr) => {
       const returnTypeDecl = expr.function.ref?.returnType.reference?.ref;
       if (isDataModel(returnTypeDecl)) {
         return this.createScopeForContainer(returnTypeDecl, globalScope, allowTypeDefScope);
       } else {
-        return import_langium9.EMPTY_SCOPE;
+        return import_langium11.EMPTY_SCOPE;
       }
     }).when(isAuthInvocation, (expr) => {
       return this.createScopeForAuth(expr, globalScope);
-    }).otherwise(() => import_langium9.EMPTY_SCOPE);
+    }).otherwise(() => import_langium11.EMPTY_SCOPE);
   }
   createScopeForContainingModel(node, globalScope) {
-    const model = import_langium9.AstUtils.getContainerOfType(node, isDataModel);
+    const model = import_langium11.AstUtils.getContainerOfType(node, isDataModel);
     if (model) {
       return this.createScopeForContainer(model, globalScope);
     } else {
-      return import_langium9.EMPTY_SCOPE;
+      return import_langium11.EMPTY_SCOPE;
     }
   }
   createScopeForContainer(node, globalScope, includeTypeDefScope = false) {
@@ -7666,16 +8885,16 @@ var ZModelScopeProvider = class extends import_langium9.DefaultScopeProvider {
     } else if (includeTypeDefScope && isTypeDef(node)) {
       return this.createScopeForNodes(node.fields, globalScope);
     } else {
-      return import_langium9.EMPTY_SCOPE;
+      return import_langium11.EMPTY_SCOPE;
     }
   }
   createScopeForAuth(node, globalScope) {
-    const decls = getAllLoadedAndReachableDataModelsAndTypeDefs(this.services.shared.workspace.LangiumDocuments, import_langium9.AstUtils.getContainerOfType(node, isDataModel));
+    const decls = getAllLoadedAndReachableDataModelsAndTypeDefs(this.services.shared.workspace.LangiumDocuments, import_langium11.AstUtils.getContainerOfType(node, isDataModel));
     const authDecl = getAuthDecl(decls);
     if (authDecl) {
       return this.createScopeForContainer(authDecl, globalScope, true);
     } else {
-      return import_langium9.EMPTY_SCOPE;
+      return import_langium11.EMPTY_SCOPE;
     }
   }
 };
@@ -7691,13 +8910,97 @@ function getCollectionPredicateContext(node) {
 }
 __name(getCollectionPredicateContext, "getCollectionPredicateContext");
 
+// src/zmodel-semantic.ts
+var import_lsp4 = require("langium/lsp");
+var import_vscode_languageserver3 = require("vscode-languageserver");
+var ZModelSemanticTokenProvider = class extends import_lsp4.AbstractSemanticTokenProvider {
+  static {
+    __name(this, "ZModelSemanticTokenProvider");
+  }
+  highlightElement(node, acceptor) {
+    if (isDataModel(node)) {
+      acceptor({
+        node,
+        property: "name",
+        type: import_vscode_languageserver3.SemanticTokenTypes.type
+      });
+      acceptor({
+        node,
+        property: "mixins",
+        type: import_vscode_languageserver3.SemanticTokenTypes.type
+      });
+      acceptor({
+        node,
+        property: "baseModel",
+        type: import_vscode_languageserver3.SemanticTokenTypes.type
+      });
+    } else if (isDataSource(node) || isGeneratorDecl(node) || isPlugin(node) || isEnum(node) || isTypeDef(node)) {
+      acceptor({
+        node,
+        property: "name",
+        type: import_vscode_languageserver3.SemanticTokenTypes.type
+      });
+    } else if (isDataField(node) || isConfigField(node) || isAttributeArg(node) || isPluginField(node) || isEnumField(node)) {
+      acceptor({
+        node,
+        property: "name",
+        type: import_vscode_languageserver3.SemanticTokenTypes.variable
+      });
+    } else if (isDataFieldType(node)) {
+      if (node.type) {
+        acceptor({
+          node,
+          property: "type",
+          type: import_vscode_languageserver3.SemanticTokenTypes.type
+        });
+      } else {
+        acceptor({
+          node,
+          property: "reference",
+          type: import_vscode_languageserver3.SemanticTokenTypes.macro
+        });
+      }
+    } else if (isDataModelAttribute(node) || isDataFieldAttribute(node) || isInternalAttribute(node)) {
+      acceptor({
+        node,
+        property: "decl",
+        type: import_vscode_languageserver3.SemanticTokenTypes.function
+      });
+    } else if (isInvocationExpr(node)) {
+      acceptor({
+        node,
+        property: "function",
+        type: import_vscode_languageserver3.SemanticTokenTypes.function
+      });
+    } else if (isFunctionDecl(node) || isAttribute(node)) {
+      acceptor({
+        node,
+        property: "name",
+        type: import_vscode_languageserver3.SemanticTokenTypes.function
+      });
+    } else if (isReferenceExpr(node)) {
+      acceptor({
+        node,
+        property: "target",
+        type: import_vscode_languageserver3.SemanticTokenTypes.variable
+      });
+    } else if (isMemberAccessExpr(node)) {
+      acceptor({
+        node,
+        property: "member",
+        type: import_vscode_languageserver3.SemanticTokenTypes.property
+      });
+    }
+  }
+};
+
 // src/zmodel-workspace-manager.ts
-var import_langium10 = require("langium");
-var import_node_fs2 = __toESM(require("fs"), 1);
-var import_node_path = __toESM(require("path"), 1);
-var import_node_url = require("url");
-var import_meta = {};
-var ZModelWorkspaceManager = class extends import_langium10.DefaultWorkspaceManager {
+var import_langium12 = require("langium");
+var import_node_fs3 = __toESM(require("fs"), 1);
+var import_node_path2 = __toESM(require("path"), 1);
+var import_node_url2 = require("url");
+var import_meta2 = {};
+var ZModelWorkspaceManager = class extends import_langium12.DefaultWorkspaceManager {
   static {
     __name(this, "ZModelWorkspaceManager");
   }
@@ -7718,9 +9021,9 @@ var ZModelWorkspaceManager = class extends import_langium10.DefaultWorkspaceMana
             folderPath
           ]
         });
-        const languagePackageDir = import_node_path.default.dirname(languagePackagePath);
-        const candidateStdlibPath = import_node_path.default.join(languagePackageDir, "res", STD_LIB_MODULE_NAME);
-        if (import_node_fs2.default.existsSync(candidateStdlibPath)) {
+        const languagePackageDir = import_node_path2.default.dirname(languagePackagePath);
+        const candidateStdlibPath = import_node_path2.default.join(languagePackageDir, "res", STD_LIB_MODULE_NAME);
+        if (import_node_fs3.default.existsSync(candidateStdlibPath)) {
           installedStdlibPath = candidateStdlibPath;
           console.log(`Found installed zenstack package stdlib at: ${installedStdlibPath}`);
           break;
@@ -7732,73 +9035,12 @@ var ZModelWorkspaceManager = class extends import_langium10.DefaultWorkspaceMana
     if (installedStdlibPath) {
       stdLibPath = installedStdlibPath;
     } else {
-      const _dirname = typeof __dirname !== "undefined" ? __dirname : import_node_path.default.dirname((0, import_node_url.fileURLToPath)(import_meta.url));
-      stdLibPath = import_node_path.default.join(_dirname, "../res", STD_LIB_MODULE_NAME);
+      const _dirname = typeof __dirname !== "undefined" ? __dirname : import_node_path2.default.dirname((0, import_node_url2.fileURLToPath)(import_meta2.url));
+      stdLibPath = import_node_path2.default.join(_dirname, "../res", STD_LIB_MODULE_NAME);
       console.log(`Using bundled stdlib in extension:`, stdLibPath);
     }
-    const stdlib = await this.documentFactory.fromUri(import_langium10.URI.file(stdLibPath));
+    const stdlib = await this.documentFactory.fromUri(import_langium12.URI.file(stdLibPath));
     collector(stdlib);
-    const documents = this.langiumDocuments.all;
-    const pluginModels = /* @__PURE__ */ new Set();
-    documents.forEach((doc) => {
-      const parsed = doc.parseResult.value;
-      parsed.declarations.forEach((decl) => {
-        if (isPlugin(decl)) {
-          const providerField = decl.fields.find((f) => f.name === "provider");
-          if (providerField) {
-            const provider = getLiteral(providerField.value);
-            if (provider) {
-              pluginModels.add(provider);
-            }
-          }
-        }
-      });
-    });
-    if (pluginModels.size > 0) {
-      console.log(`Used plugin modules: ${Array.from(pluginModels)}`);
-      const pendingPluginModules = new Set(pluginModels);
-      await Promise.all(folders.map((wf) => [
-        wf,
-        this.getRootFolder(wf)
-      ]).map(async (entry) => this.loadPluginModels(...entry, pendingPluginModules, collector)));
-    }
-  }
-  async loadPluginModels(workspaceFolder, folderPath, pendingPluginModels, collector) {
-    const content = (await this.fileSystemProvider.readDirectory(folderPath)).sort((a, b) => {
-      if (a.isDirectory && b.isDirectory) {
-        const aName = import_langium10.UriUtils.basename(a.uri);
-        if (aName === "node_modules") {
-          return -1;
-        } else {
-          return 1;
-        }
-      } else {
-        return 0;
-      }
-    });
-    for (const entry of content) {
-      if (entry.isDirectory) {
-        const name = import_langium10.UriUtils.basename(entry.uri);
-        if (name === "node_modules") {
-          for (const plugin of Array.from(pendingPluginModels)) {
-            const path4 = import_langium10.UriUtils.joinPath(entry.uri, plugin, PLUGIN_MODULE_NAME);
-            try {
-              await this.fileSystemProvider.readFile(path4);
-              const document = await this.langiumDocuments.getOrCreateDocument(path4);
-              collector(document);
-              console.log(`Adding plugin document from ${path4.path}`);
-              pendingPluginModels.delete(plugin);
-              if (pendingPluginModels.size === 0) {
-                return;
-              }
-            } catch {
-            }
-          }
-        } else {
-          await this.loadPluginModels(workspaceFolder, entry.uri, pendingPluginModels, collector);
-        }
-      }
-    }
   }
 };
 
@@ -7811,6 +9053,16 @@ var ZModelLanguageModule = {
   },
   validation: {
     ZModelValidator: /* @__PURE__ */ __name((services) => new ZModelValidator(services), "ZModelValidator")
+  },
+  lsp: {
+    Formatter: /* @__PURE__ */ __name((services) => new ZModelFormatter(services), "Formatter"),
+    DefinitionProvider: /* @__PURE__ */ __name((services) => new ZModelDefinitionProvider(services), "DefinitionProvider"),
+    CompletionProvider: /* @__PURE__ */ __name((services) => new ZModelCompletionProvider(services), "CompletionProvider"),
+    SemanticTokenProvider: /* @__PURE__ */ __name((services) => new ZModelSemanticTokenProvider(services), "SemanticTokenProvider")
+  },
+  documentation: {
+    CommentProvider: /* @__PURE__ */ __name((services) => new ZModelCommentProvider(services), "CommentProvider"),
+    DocumentationProvider: /* @__PURE__ */ __name((services) => new ZModelDocumentationProvider(services), "DocumentationProvider")
   }
 };
 var ZModelSharedModule = {
@@ -7819,9 +9071,9 @@ var ZModelSharedModule = {
     WorkspaceManager: /* @__PURE__ */ __name((services) => new ZModelWorkspaceManager(services), "WorkspaceManager")
   }
 };
-function createZModelLanguageServices(context) {
-  const shared = (0, import_langium11.inject)((0, import_lsp.createDefaultSharedModule)(context), ZModelGeneratedSharedModule, ZModelSharedModule);
-  const ZModelLanguage = (0, import_langium11.inject)((0, import_lsp.createDefaultModule)({
+function createZModelLanguageServices(context, logToConsole = false) {
+  const shared = (0, import_langium13.inject)((0, import_lsp5.createDefaultSharedModule)(context), ZModelGeneratedSharedModule, ZModelSharedModule);
+  const ZModelLanguage = (0, import_langium13.inject)((0, import_lsp5.createDefaultModule)({
     shared
   }), ZModelGeneratedModule, ZModelLanguageModule);
   shared.ServiceRegistry.register(ZModelLanguage);
@@ -7829,31 +9081,48 @@ function createZModelLanguageServices(context) {
   if (!context.connection) {
     shared.workspace.ConfigurationProvider.initialized({});
   }
+  shared.workspace.DocumentBuilder.onBuildPhase(import_langium13.DocumentState.Parsed, async (documents) => {
+    for (const doc of documents) {
+      if (doc.parseResult.lexerErrors.length > 0 || doc.parseResult.parserErrors.length > 0) {
+        continue;
+      }
+      if (doc.uri.scheme !== "file") {
+        continue;
+      }
+      const schemaPath = (0, import_node_url3.fileURLToPath)(doc.uri.toString());
+      const pluginSchemas = getPluginDocuments(doc.parseResult.value, schemaPath);
+      for (const plugin of pluginSchemas) {
+        const pluginDocUri = import_langium13.URI.file(import_node_path3.default.resolve(plugin));
+        let pluginDoc = shared.workspace.LangiumDocuments.getDocument(pluginDocUri);
+        if (!pluginDoc) {
+          pluginDoc = await shared.workspace.LangiumDocuments.getOrCreateDocument(pluginDocUri);
+          if (pluginDoc) {
+            shared.workspace.IndexManager.updateContent(pluginDoc);
+            if (logToConsole) {
+              console.log(`Loaded plugin model: ${plugin}`);
+            }
+          }
+        }
+      }
+    }
+  });
   return {
     shared,
     ZModelLanguage
   };
 }
 __name(createZModelLanguageServices, "createZModelLanguageServices");
-
-// src/index.ts
-var import_meta2 = {};
-function createZModelServices() {
-  return createZModelLanguageServices(import_node.NodeFileSystem);
+function createZModelServices(logToConsole = false) {
+  return createZModelLanguageServices(import_node.NodeFileSystem, logToConsole);
 }
 __name(createZModelServices, "createZModelServices");
-var DocumentLoadError = class extends Error {
-  static {
-    __name(this, "DocumentLoadError");
-  }
-  constructor(message) {
-    super(message);
-  }
-};
+
+// src/document.ts
+var import_meta3 = {};
 async function loadDocument(fileName, additionalModelFiles = []) {
-  const { ZModelLanguage: services } = createZModelServices();
+  const { ZModelLanguage: services } = createZModelServices(false);
   const extensions = services.LanguageMetaData.fileExtensions;
-  if (!extensions.includes(import_node_path2.default.extname(fileName))) {
+  if (!extensions.includes(import_node_path4.default.extname(fileName))) {
     return {
       success: false,
       errors: [
@@ -7862,7 +9131,7 @@ async function loadDocument(fileName, additionalModelFiles = []) {
       warnings: []
     };
   }
-  if (!import_node_fs3.default.existsSync(fileName)) {
+  if (!import_node_fs4.default.existsSync(fileName)) {
     return {
       success: false,
       errors: [
@@ -7871,19 +9140,19 @@ async function loadDocument(fileName, additionalModelFiles = []) {
       warnings: []
     };
   }
-  const _dirname = typeof __dirname !== "undefined" ? __dirname : import_node_path2.default.dirname((0, import_node_url2.fileURLToPath)(import_meta2.url));
-  const stdLib = await services.shared.workspace.LangiumDocuments.getOrCreateDocument(import_langium12.URI.file(import_node_path2.default.resolve(import_node_path2.default.join(_dirname, "../res", STD_LIB_MODULE_NAME))));
-  const pluginDocs = await Promise.all(additionalModelFiles.map((file) => services.shared.workspace.LangiumDocuments.getOrCreateDocument(import_langium12.URI.file(import_node_path2.default.resolve(file)))));
+  const _dirname = typeof __dirname !== "undefined" ? __dirname : import_node_path4.default.dirname((0, import_node_url4.fileURLToPath)(import_meta3.url));
+  const stdLib = await services.shared.workspace.LangiumDocuments.getOrCreateDocument(import_langium14.URI.file(import_node_path4.default.resolve(import_node_path4.default.join(_dirname, "../res", STD_LIB_MODULE_NAME))));
   const langiumDocuments = services.shared.workspace.LangiumDocuments;
-  const document = await langiumDocuments.getOrCreateDocument(import_langium12.URI.file(import_node_path2.default.resolve(fileName)));
+  const document = await langiumDocuments.getOrCreateDocument(import_langium14.URI.file(import_node_path4.default.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(import_langium14.URI.file(import_node_path4.default.resolve(file)))));
   await services.shared.workspace.DocumentBuilder.build([
     stdLib,
-    ...pluginDocs,
+    ...additionalDocs,
     document,
     ...importedDocuments
   ], {
@@ -7901,7 +9170,7 @@ async function loadDocument(fileName, additionalModelFiles = []) {
   const warnings = [];
   if (diagnostics.length > 0) {
     for (const { doc, diag } of diagnostics) {
-      const message = `${import_node_path2.default.relative(process.cwd(), doc.uri.fsPath)}:${diag.range.start.line + 1}:${diag.range.start.character + 1} - ${diag.message}`;
+      const message = `${import_node_path4.default.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 {
@@ -7950,7 +9219,7 @@ async function loadImports(document, documents, uris = /* @__PURE__ */ new Set()
       }
     }
   }
-  return Array.from(uris).filter((x) => uriString != x).map((e) => import_langium12.URI.parse(e));
+  return Array.from(uris).filter((x) => uriString != x).map((e) => import_langium14.URI.parse(e));
 }
 __name(loadImports, "loadImports");
 function mergeImportsDeclarations(documents, model) {
@@ -7967,13 +9236,13 @@ function linkContentToContainer(node) {
     if (!name.startsWith("$")) {
       if (Array.isArray(value)) {
         value.forEach((item, index) => {
-          if ((0, import_langium12.isAstNode)(item)) {
+          if ((0, import_langium14.isAstNode)(item)) {
             item.$container = node;
             item.$containerProperty = name;
             item.$containerIndex = index;
           }
         });
-      } else if ((0, import_langium12.isAstNode)(value)) {
+      } else if ((0, import_langium14.isAstNode)(value)) {
         value.$container = node;
         value.$containerProperty = name;
       }
@@ -7999,14 +9268,34 @@ function validationAfterImportMerge(model) {
   return errors;
 }
 __name(validationAfterImportMerge, "validationAfterImportMerge");
+async function formatDocument(content) {
+  const services = createZModelServices().ZModelLanguage;
+  const langiumDocuments = services.shared.workspace.LangiumDocuments;
+  const document = langiumDocuments.createDocument(import_langium14.URI.parse("memory://schema.zmodel"), content);
+  const formatter = services.lsp.Formatter;
+  const identifier = {
+    uri: document.uri.toString()
+  };
+  const options = formatter.getFormatOptions() ?? {
+    insertSpaces: true,
+    tabSize: 4
+  };
+  const edits = await formatter.formatDocument(document, {
+    options,
+    textDocument: identifier
+  });
+  return import_langium14.TextDocument.applyEdits(document.textDocument, edits);
+}
+__name(formatDocument, "formatDocument");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  DocumentLoadError,
+  ZModelCodeGenerator,
   ZModelLanguageMetaData,
   ZModelLanguageModule,
   ZModelSharedModule,
   createZModelLanguageServices,
   createZModelServices,
+  formatDocument,
   loadDocument
 });
 //# sourceMappingURL=index.cjs.map