@zenstackhq/sdk 3.0.0-beta.2 → 3.0.0-beta.21

package/dist/index.cjs

@@ -33,8 +33,7 @@ var src_exports = {};
 __export(src_exports, {
   ModelUtils: () => model_utils_exports,
   PrismaSchemaGenerator: () => PrismaSchemaGenerator,
-  TsSchemaGenerator: () => TsSchemaGenerator,
-  ZModelCodeGenerator: () => ZModelCodeGenerator
+  TsSchemaGenerator: () => TsSchemaGenerator
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -121,7 +120,7 @@ function resolved(ref) {
 }
 __name(resolved, "resolved");
 function getAuthDecl(model) {
-  let found = model.declarations.find((d) => (0, import_ast.isDataModel)(d) && d.attributes.some((attr) => attr.decl.$refText === "@@auth"));
+  let found = model.declarations.find((d) => ((0, import_ast.isDataModel)(d) || (0, import_ast.isTypeDef)(d)) && d.attributes.some((attr) => attr.decl.$refText === "@@auth"));
   if (!found) {
     found = model.declarations.find((d) => (0, import_ast.isDataModel)(d) && d.name === "User");
   }
@@ -136,6 +135,7 @@ var DELEGATE_AUX_RELATION_PREFIX = "delegate_aux";
 
 // src/prisma/prisma-schema-generator.ts
 var import_common_helpers = require("@zenstackhq/common-helpers");
+var import_language = require("@zenstackhq/language");
 var import_ast2 = require("@zenstackhq/language/ast");
 var import_utils2 = require("@zenstackhq/language/utils");
 var import_langium = require("langium");
@@ -533,6 +533,9 @@ var EnumField = class extends DeclarationBase {
 
 // src/prisma/prisma-schema-generator.ts
 var IDENTIFIER_NAME_MAX_LENGTH = 50 - DELEGATE_AUX_RELATION_PREFIX.length;
+var NON_PRISMA_DATASOURCE_FIELDS = [
+  "defaultSchema"
+];
 var PrismaSchemaGenerator = class {
   static {
     __name(this, "PrismaSchemaGenerator");
@@ -570,7 +573,7 @@ var PrismaSchemaGenerator = class {
     return this.PRELUDE + prisma.toString();
   }
   generateDataSource(prisma, dataSource) {
-    const fields = dataSource.fields.map((f) => ({
+    const fields = dataSource.fields.filter((f) => !NON_PRISMA_DATASOURCE_FIELDS.includes(f.name)).map((f) => ({
       name: f.name,
       text: this.configExprToText(f.value)
     }));
@@ -618,14 +621,37 @@ var PrismaSchemaGenerator = class {
         this.generateModelField(model, field, decl);
       }
     }
-    const allAttributes = (0, import_utils2.getAllAttributes)(decl);
-    for (const attr of allAttributes.filter((attr2) => this.isPrismaAttribute(attr2))) {
+    const allAttributes = (0, import_utils2.getAllAttributes)(decl).filter((attr) => this.isPrismaAttribute(attr) && !this.isInheritedMapAttribute(attr, decl));
+    for (const attr of allAttributes) {
       this.generateContainerAttribute(model, attr);
     }
+    if (this.datasourceHasSchemasSetting(decl.$container) && !allAttributes.some((attr) => attr.decl.ref?.name === "@@schema")) {
+      model.addAttribute("@@schema", [
+        new AttributeArg(void 0, new AttributeArgValue("String", this.getDefaultPostgresSchemaName(decl.$container)))
+      ]);
+    }
     decl.comments.forEach((c) => model.addComment(c));
     this.generateDelegateRelationForBase(model, decl);
     this.generateDelegateRelationForConcrete(model, decl);
   }
+  getDatasourceField(zmodel, fieldName) {
+    const dataSource = zmodel.declarations.find(import_ast2.isDataSource);
+    return dataSource?.fields.find((f) => f.name === fieldName);
+  }
+  datasourceHasSchemasSetting(zmodel) {
+    return !!this.getDatasourceField(zmodel, "schemas");
+  }
+  getDefaultPostgresSchemaName(zmodel) {
+    const defaultSchemaField = this.getDatasourceField(zmodel, "defaultSchema");
+    return (0, import_utils2.getStringLiteral)(defaultSchemaField?.value) ?? "public";
+  }
+  isInheritedMapAttribute(attr, contextModel) {
+    if (attr.$container === contextModel) {
+      return false;
+    }
+    const attrName = attr.decl.ref?.name ?? attr.decl.$refText;
+    return attrName === "@@map";
+  }
   isPrismaAttribute(attr) {
     if (!attr.decl.ref) {
       return false;
@@ -634,7 +660,7 @@ var PrismaSchemaGenerator = class {
   }
   getUnsupportedFieldType(fieldType) {
     if (fieldType.unsupported) {
-      const value = this.getStringLiteral(fieldType.unsupported.value);
+      const value = (0, import_utils2.getStringLiteral)(fieldType.unsupported.value);
       if (value) {
         return `Unsupported("${value}")`;
       } else {
@@ -644,9 +670,6 @@ var PrismaSchemaGenerator = class {
       return void 0;
     }
   }
-  getStringLiteral(node) {
-    return (0, import_ast2.isStringLiteral)(node) ? node.value : void 0;
-  }
   generateModelField(model, field, contextModel, addToFront = false) {
     let fieldType;
     if (field.type.type) {
@@ -671,7 +694,7 @@ var PrismaSchemaGenerator = class {
       (0, import_ast2.isTypeDef)(field.type.reference?.ref) ? false : field.type.array
     );
     const type = new ModelFieldType(fieldType, isArray, field.type.optional);
-    const attributes = field.attributes.filter((attr) => this.isPrismaAttribute(attr)).filter((attr) => !this.isDefaultWithPluginInvocation(attr)).filter((attr) => (
+    const attributes = field.attributes.filter((attr) => this.isPrismaAttribute(attr)).filter((attr) => !this.isDefaultWithAuthInvocation(attr)).filter((attr) => (
       // when building physical schema, exclude `@default` for id fields inherited from delegate base
       !(model_utils_exports.isIdField(field, contextModel) && this.isInheritedFromDelegate(field, contextModel) && attr.decl.$refText === "@default")
     )).map((attr) => this.makeFieldAttribute(attr));
@@ -681,7 +704,7 @@ var PrismaSchemaGenerator = class {
     const result = model.addField(field.name, type, attributes, docs, addToFront);
     return result;
   }
-  isDefaultWithPluginInvocation(attr) {
+  isDefaultWithAuthInvocation(attr) {
     if (attr.decl.ref?.name !== "@default") {
       return false;
     }
@@ -689,11 +712,7 @@ var PrismaSchemaGenerator = class {
     if (!expr) {
       return false;
     }
-    return import_langium.AstUtils.streamAst(expr).some((node) => (0, import_ast2.isInvocationExpr)(node) && this.isFromPlugin(node.function.ref));
-  }
-  isFromPlugin(node) {
-    const model = import_langium.AstUtils.getContainerOfType(node, import_ast2.isModel);
-    return !!model && !!model.$document && model.$document.uri.path.endsWith("plugin.zmodel");
+    return import_langium.AstUtils.streamAst(expr).some(import_utils2.isAuthInvocation);
   }
   isInheritedFromDelegate(field, contextModel) {
     return field.$container !== contextModel && model_utils_exports.isDelegateModel(field.$container);
@@ -720,7 +739,7 @@ var PrismaSchemaGenerator = class {
     }
   }
   exprToText(expr) {
-    return new ZModelCodeGenerator({
+    return new import_language.ZModelCodeGenerator({
       quote: "double"
     }).generate(expr);
   }
@@ -821,38 +840,58 @@ var TsSchemaGenerator = class {
   static {
     __name(this, "TsSchemaGenerator");
   }
-  async generate(model, outputDir) {
-    import_node_fs.default.mkdirSync(outputDir, {
+  usedExpressionUtils = false;
+  async generate(model, options) {
+    import_node_fs.default.mkdirSync(options.outDir, {
       recursive: true
     });
-    this.generateSchema(model, outputDir);
-    this.generateModelsAndTypeDefs(model, outputDir);
-    this.generateInputTypes(model, outputDir);
-  }
-  generateSchema(model, outputDir) {
-    const statements = [];
-    this.generateSchemaStatements(model, statements);
-    this.generateBannerComments(statements);
-    const schemaOutputFile = import_node_path.default.join(outputDir, "schema.ts");
-    const sourceFile = ts.createSourceFile(schemaOutputFile, "", ts.ScriptTarget.ESNext, false, ts.ScriptKind.TS);
-    const printer = ts.createPrinter();
-    const result = printer.printList(ts.ListFormat.MultiLine, ts.factory.createNodeArray(statements), sourceFile);
-    import_node_fs.default.writeFileSync(schemaOutputFile, result);
+    this.usedExpressionUtils = false;
+    this.generateSchema(model, options);
+    this.generateModelsAndTypeDefs(model, options);
+    this.generateInputTypes(model, options);
+  }
+  generateSchema(model, options) {
+    const targets = [];
+    if (!options.liteOnly) {
+      targets.push({
+        lite: false,
+        file: "schema.ts"
+      });
+    }
+    if (options.lite || options.liteOnly) {
+      targets.push({
+        lite: true,
+        file: "schema-lite.ts"
+      });
+    }
+    for (const { lite, file } of targets) {
+      const statements = [];
+      this.generateSchemaStatements(model, statements, lite);
+      this.generateBannerComments(statements);
+      const schemaOutputFile = import_node_path.default.join(options.outDir, file);
+      const sourceFile = ts.createSourceFile(schemaOutputFile, "", ts.ScriptTarget.ESNext, false, ts.ScriptKind.TS);
+      const printer = ts.createPrinter();
+      const result = printer.printList(ts.ListFormat.MultiLine, ts.factory.createNodeArray(statements), sourceFile);
+      import_node_fs.default.writeFileSync(schemaOutputFile, result);
+    }
   }
-  generateSchemaStatements(model, statements) {
+  generateSchemaStatements(model, statements, lite) {
     const hasComputedFields = model.declarations.some((d) => (0, import_ast3.isDataModel)(d) && d.fields.some((f) => hasAttribute(f, "@computed")));
+    const schemaObject = this.createSchemaObject(model, lite);
     const runtimeImportDecl = ts.factory.createImportDeclaration(void 0, ts.factory.createImportClause(false, void 0, ts.factory.createNamedImports([
       ts.factory.createImportSpecifier(true, void 0, ts.factory.createIdentifier("SchemaDef")),
       ...hasComputedFields ? [
         ts.factory.createImportSpecifier(true, void 0, ts.factory.createIdentifier("OperandExpression"))
       ] : [],
-      ts.factory.createImportSpecifier(false, void 0, ts.factory.createIdentifier("ExpressionUtils"))
-    ])), ts.factory.createStringLiteral("@zenstackhq/runtime/schema"));
+      ...this.usedExpressionUtils ? [
+        ts.factory.createImportSpecifier(false, void 0, ts.factory.createIdentifier("ExpressionUtils"))
+      ] : []
+    ])), ts.factory.createStringLiteral("@zenstackhq/orm/schema"));
     statements.push(runtimeImportDecl);
     const declaration = ts.factory.createVariableStatement([
       ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)
     ], ts.factory.createVariableDeclarationList([
-      ts.factory.createVariableDeclaration("schema", void 0, void 0, ts.factory.createSatisfiesExpression(ts.factory.createAsExpression(this.createSchemaObject(model), ts.factory.createTypeReferenceNode("const")), ts.factory.createTypeReferenceNode("SchemaDef")))
+      ts.factory.createVariableDeclaration("schema", void 0, void 0, ts.factory.createSatisfiesExpression(ts.factory.createAsExpression(schemaObject, ts.factory.createTypeReferenceNode("const")), ts.factory.createTypeReferenceNode("SchemaDef")))
     ], ts.NodeFlags.Const));
     statements.push(declaration);
     const typeDeclaration = ts.factory.createTypeAliasDeclaration([
@@ -860,15 +899,19 @@ var TsSchemaGenerator = class {
     ], "SchemaType", void 0, ts.factory.createTypeReferenceNode("typeof schema"));
     statements.push(typeDeclaration);
   }
-  createSchemaObject(model) {
+  createExpressionUtilsCall(method, args) {
+    this.usedExpressionUtils = true;
+    return ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("ExpressionUtils"), method), void 0, args || []);
+  }
+  createSchemaObject(model, lite) {
     const properties = [
       // provider
       ts.factory.createPropertyAssignment("provider", this.createProviderObject(model)),
       // models
-      ts.factory.createPropertyAssignment("models", this.createModelsObject(model)),
+      ts.factory.createPropertyAssignment("models", this.createModelsObject(model, lite)),
       // typeDefs
       ...model.declarations.some(import_ast3.isTypeDef) ? [
-        ts.factory.createPropertyAssignment("typeDefs", this.createTypeDefsObject(model))
+        ts.factory.createPropertyAssignment("typeDefs", this.createTypeDefsObject(model, lite))
       ] : []
     ];
     const enums = model.declarations.filter(import_ast3.isEnum);
@@ -888,19 +931,23 @@ var TsSchemaGenerator = class {
   }
   createProviderObject(model) {
     const dsProvider = this.getDataSourceProvider(model);
+    const defaultSchema = this.getDataSourceDefaultSchema(model);
     return ts.factory.createObjectLiteralExpression([
-      ts.factory.createPropertyAssignment("type", ts.factory.createStringLiteral(dsProvider.type))
+      ts.factory.createPropertyAssignment("type", ts.factory.createStringLiteral(dsProvider)),
+      ...defaultSchema ? [
+        ts.factory.createPropertyAssignment("defaultSchema", ts.factory.createStringLiteral(defaultSchema))
+      ] : []
     ], true);
   }
-  createModelsObject(model) {
-    return ts.factory.createObjectLiteralExpression(model.declarations.filter((d) => (0, import_ast3.isDataModel)(d) && !hasAttribute(d, "@@ignore")).map((dm) => ts.factory.createPropertyAssignment(dm.name, this.createDataModelObject(dm))), true);
+  createModelsObject(model, lite) {
+    return ts.factory.createObjectLiteralExpression(model.declarations.filter((d) => (0, import_ast3.isDataModel)(d) && !hasAttribute(d, "@@ignore")).map((dm) => ts.factory.createPropertyAssignment(dm.name, this.createDataModelObject(dm, lite))), true);
   }
-  createTypeDefsObject(model) {
-    return ts.factory.createObjectLiteralExpression(model.declarations.filter((d) => (0, import_ast3.isTypeDef)(d)).map((td) => ts.factory.createPropertyAssignment(td.name, this.createTypeDefObject(td))), true);
+  createTypeDefsObject(model, lite) {
+    return ts.factory.createObjectLiteralExpression(model.declarations.filter((d) => (0, import_ast3.isTypeDef)(d)).map((td) => ts.factory.createPropertyAssignment(td.name, this.createTypeDefObject(td, lite))), true);
   }
-  createDataModelObject(dm) {
+  createDataModelObject(dm, lite) {
     const allFields = (0, import_utils3.getAllFields)(dm);
-    const allAttributes = (0, import_utils3.getAllAttributes)(dm).filter((attr) => {
+    const allAttributes = lite ? [] : (0, import_utils3.getAllAttributes)(dm).filter((attr) => {
       if (attr.decl.$refText === "@@delegate" && attr.$container !== dm) {
         return false;
       }
@@ -915,7 +962,7 @@ var TsSchemaGenerator = class {
         ts.factory.createPropertyAssignment("baseModel", ts.factory.createStringLiteral(dm.baseModel.$refText))
       ] : [],
       // fields
-      ts.factory.createPropertyAssignment("fields", ts.factory.createObjectLiteralExpression(allFields.map((field) => ts.factory.createPropertyAssignment(field.name, this.createDataFieldObject(field, dm))), true)),
+      ts.factory.createPropertyAssignment("fields", ts.factory.createObjectLiteralExpression(allFields.map((field) => ts.factory.createPropertyAssignment(field.name, this.createDataFieldObject(field, dm, lite))), true)),
       // attributes
       ...allAttributes.length > 0 ? [
         ts.factory.createPropertyAssignment("attributes", ts.factory.createArrayLiteralExpression(allAttributes.map((attr) => this.createAttributeObject(attr)), true))
@@ -931,6 +978,9 @@ var TsSchemaGenerator = class {
       // subModels
       ...subModels.length > 0 ? [
         ts.factory.createPropertyAssignment("subModels", ts.factory.createArrayLiteralExpression(subModels.map((subModel) => ts.factory.createStringLiteral(subModel))))
+      ] : [],
+      ...dm.isView ? [
+        ts.factory.createPropertyAssignment("isView", ts.factory.createTrue())
       ] : []
     ];
     const computedFields = dm.fields.filter((f) => hasAttribute(f, "@computed"));
@@ -942,14 +992,14 @@ var TsSchemaGenerator = class {
   getSubModels(dm) {
     return dm.$container.declarations.filter(import_ast3.isDataModel).filter((d) => d.baseModel?.ref === dm).map((d) => d.name);
   }
-  createTypeDefObject(td) {
+  createTypeDefObject(td, lite) {
     const allFields = (0, import_utils3.getAllFields)(td);
     const allAttributes = (0, import_utils3.getAllAttributes)(td);
     const fields = [
       // name
       ts.factory.createPropertyAssignment("name", ts.factory.createStringLiteral(td.name)),
       // fields
-      ts.factory.createPropertyAssignment("fields", ts.factory.createObjectLiteralExpression(allFields.map((field) => ts.factory.createPropertyAssignment(field.name, this.createDataFieldObject(field, void 0))), true)),
+      ts.factory.createPropertyAssignment("fields", ts.factory.createObjectLiteralExpression(allFields.map((field) => ts.factory.createPropertyAssignment(field.name, this.createDataFieldObject(field, void 0, lite))), true)),
       // attributes
       ...allAttributes.length > 0 ? [
         ts.factory.createPropertyAssignment("attributes", ts.factory.createArrayLiteralExpression(allAttributes.map((attr) => this.createAttributeObject(attr)), true))
@@ -959,9 +1009,9 @@ var TsSchemaGenerator = class {
   }
   createComputedFieldsObject(fields) {
     return ts.factory.createObjectLiteralExpression(fields.map((field) => ts.factory.createMethodDeclaration(void 0, void 0, field.name, void 0, void 0, [
-      // parameter: `context: { currentModel: string }`
+      // parameter: `context: { modelAlias: string }`
       ts.factory.createParameterDeclaration(void 0, void 0, "_context", void 0, ts.factory.createTypeLiteralNode([
-        ts.factory.createPropertySignature(void 0, "currentModel", void 0, ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword))
+        ts.factory.createPropertySignature(void 0, "modelAlias", void 0, ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword))
       ]), void 0)
     ], ts.factory.createTypeReferenceNode("OperandExpression", [
       ts.factory.createTypeReferenceNode(this.mapFieldTypeToTSType(field.type))
@@ -981,7 +1031,7 @@ var TsSchemaGenerator = class {
     }
     return result;
   }
-  createDataFieldObject(field, contextModel) {
+  createDataFieldObject(field, contextModel, lite) {
     const objectFields = [
       // name
       ts.factory.createPropertyAssignment("name", ts.factory.createStringLiteral(field.name)),
@@ -1010,22 +1060,24 @@ var TsSchemaGenerator = class {
     if (this.isDiscriminatorField(field)) {
       objectFields.push(ts.factory.createPropertyAssignment("isDiscriminator", ts.factory.createTrue()));
     }
-    if (field.attributes.length > 0) {
+    if (!lite && field.attributes.length > 0) {
       objectFields.push(ts.factory.createPropertyAssignment("attributes", ts.factory.createArrayLiteralExpression(field.attributes.map((attr) => this.createAttributeObject(attr)))));
     }
     const defaultValue = this.getFieldMappedDefault(field);
     if (defaultValue !== void 0) {
       if (typeof defaultValue === "object" && !Array.isArray(defaultValue)) {
         if ("call" in defaultValue) {
-          objectFields.push(ts.factory.createPropertyAssignment("default", ts.factory.createCallExpression(ts.factory.createIdentifier("ExpressionUtils.call"), void 0, [
+          objectFields.push(ts.factory.createPropertyAssignment("default", this.createExpressionUtilsCall("call", [
             ts.factory.createStringLiteral(defaultValue.call),
             ...defaultValue.args.length > 0 ? [
-              ts.factory.createArrayLiteralExpression(defaultValue.args.map((arg) => this.createLiteralNode(arg)))
+              ts.factory.createArrayLiteralExpression(defaultValue.args.map((arg) => this.createExpressionUtilsCall("literal", [
+                this.createLiteralNode(arg)
+              ])))
             ] : []
           ])));
         } else if ("authMember" in defaultValue) {
-          objectFields.push(ts.factory.createPropertyAssignment("default", ts.factory.createCallExpression(ts.factory.createIdentifier("ExpressionUtils.member"), void 0, [
-            ts.factory.createCallExpression(ts.factory.createIdentifier("ExpressionUtils.call"), void 0, [
+          objectFields.push(ts.factory.createPropertyAssignment("default", this.createExpressionUtilsCall("member", [
+            this.createExpressionUtilsCall("call", [
               ts.factory.createStringLiteral("auth")
             ]),
             ts.factory.createArrayLiteralExpression(defaultValue.authMember.map((m) => ts.factory.createStringLiteral(m)))
@@ -1061,11 +1113,18 @@ var TsSchemaGenerator = class {
     const dataSource = model.declarations.find(import_ast3.isDataSource);
     (0, import_common_helpers2.invariant)(dataSource, "No data source found in the model");
     const providerExpr = dataSource.fields.find((f) => f.name === "provider")?.value;
-    (0, import_common_helpers2.invariant)((0, import_ast3.isLiteralExpr)(providerExpr), "Provider must be a literal");
-    const type = providerExpr.value;
-    return {
-      type
-    };
+    (0, import_common_helpers2.invariant)((0, import_ast3.isLiteralExpr)(providerExpr) && typeof providerExpr.value === "string", "Provider must be a string literal");
+    return providerExpr.value;
+  }
+  getDataSourceDefaultSchema(model) {
+    const dataSource = model.declarations.find(import_ast3.isDataSource);
+    (0, import_common_helpers2.invariant)(dataSource, "No data source found in the model");
+    const defaultSchemaExpr = dataSource.fields.find((f) => f.name === "defaultSchema")?.value;
+    if (!defaultSchemaExpr) {
+      return void 0;
+    }
+    (0, import_common_helpers2.invariant)((0, import_ast3.isLiteralExpr)(defaultSchemaExpr) && typeof defaultSchemaExpr.value === "string", "Default schema must be a string literal");
+    return defaultSchemaExpr.value;
   }
   getFieldMappedDefault(field) {
     const defaultAttr = getAttribute(field, "@default");
@@ -1135,12 +1194,16 @@ var TsSchemaGenerator = class {
       relationFields.push(ts.factory.createPropertyAssignment("name", ts.factory.createStringLiteral(relationName)));
     }
     const relation = getAttribute(field, "@relation");
+    const fkFields = [];
     if (relation) {
       for (const arg of relation.args) {
         const param = arg.$resolvedParam.name;
         if (param === "fields" || param === "references") {
           const fieldNames = this.getReferenceNames(arg.value);
           if (fieldNames) {
+            if (param === "fields") {
+              fkFields.push(...fieldNames);
+            }
             relationFields.push(ts.factory.createPropertyAssignment(param, ts.factory.createArrayLiteralExpression(fieldNames.map((el) => ts.factory.createStringLiteral(el)))));
           }
         }
@@ -1150,6 +1213,15 @@ var TsSchemaGenerator = class {
         }
       }
     }
+    if (fkFields.length > 0) {
+      const allHaveDefault = fkFields.every((fieldName) => {
+        const fieldDef = field.$container.fields.find((f) => f.name === fieldName);
+        return fieldDef && hasAttribute(fieldDef, "@default");
+      });
+      if (allHaveDefault) {
+        relationFields.push(ts.factory.createPropertyAssignment("hasDefault", ts.factory.createTrue()));
+      }
+    }
     return ts.factory.createObjectLiteralExpression(relationFields);
   }
   getReferenceNames(expr) {
@@ -1218,7 +1290,11 @@ var TsSchemaGenerator = class {
     const seenKeys = /* @__PURE__ */ new Set();
     for (const attr of allAttributes) {
       if (attr.decl.$refText === "@@id" || attr.decl.$refText === "@@unique") {
-        const fieldNames = this.getReferenceNames(attr.args[0].value);
+        const fieldsArg = (0, import_utils3.getAttributeArg)(attr, "fields");
+        if (!fieldsArg) {
+          continue;
+        }
+        const fieldNames = this.getReferenceNames(fieldsArg);
         if (!fieldNames) {
           continue;
         }
@@ -1257,7 +1333,21 @@ var TsSchemaGenerator = class {
     return field.type.type ? ts.factory.createStringLiteral(field.type.type) : field.type.reference ? ts.factory.createStringLiteral(field.type.reference.$refText) : ts.factory.createStringLiteral("Unsupported");
   }
   createEnumObject(e) {
-    return ts.factory.createObjectLiteralExpression(e.fields.map((field) => ts.factory.createPropertyAssignment(field.name, ts.factory.createStringLiteral(field.name))), true);
+    return ts.factory.createObjectLiteralExpression([
+      ts.factory.createPropertyAssignment("values", ts.factory.createObjectLiteralExpression(e.fields.map((f) => ts.factory.createPropertyAssignment(f.name, ts.factory.createStringLiteral(f.name))), true)),
+      // only generate `fields` if there are attributes on the fields
+      ...e.fields.some((f) => f.attributes.length > 0) ? [
+        ts.factory.createPropertyAssignment("fields", ts.factory.createObjectLiteralExpression(e.fields.map((field) => ts.factory.createPropertyAssignment(field.name, ts.factory.createObjectLiteralExpression([
+          ts.factory.createPropertyAssignment("name", ts.factory.createStringLiteral(field.name)),
+          ...field.attributes.length > 0 ? [
+            ts.factory.createPropertyAssignment("attributes", ts.factory.createArrayLiteralExpression(field.attributes?.map((attr) => this.createAttributeObject(attr)) ?? [], true))
+          ] : []
+        ], true))), true))
+      ] : [],
+      ...e.attributes.length > 0 ? [
+        ts.factory.createPropertyAssignment("attributes", ts.factory.createArrayLiteralExpression(e.attributes.map((attr) => this.createAttributeObject(attr)), true))
+      ] : []
+    ], true);
   }
   getLiteral(expr) {
     if (!(0, import_ast3.isLiteralExpr)(expr)) {
@@ -1339,7 +1429,7 @@ var TsSchemaGenerator = class {
     });
   }
   createThisExpression() {
-    return ts.factory.createCallExpression(ts.factory.createIdentifier("ExpressionUtils._this"), void 0, []);
+    return this.createExpressionUtilsCall("_this");
   }
   createMemberExpression(expr) {
     const members = [];
@@ -1353,32 +1443,32 @@ var TsSchemaGenerator = class {
       this.createExpression(receiver),
       ts.factory.createArrayLiteralExpression(members.map((m) => ts.factory.createStringLiteral(m)))
     ];
-    return ts.factory.createCallExpression(ts.factory.createIdentifier("ExpressionUtils.member"), void 0, args);
+    return this.createExpressionUtilsCall("member", args);
   }
   createNullExpression() {
-    return ts.factory.createCallExpression(ts.factory.createIdentifier("ExpressionUtils._null"), void 0, []);
+    return this.createExpressionUtilsCall("_null");
   }
   createBinaryExpression(expr) {
-    return ts.factory.createCallExpression(ts.factory.createIdentifier("ExpressionUtils.binary"), void 0, [
+    return this.createExpressionUtilsCall("binary", [
       this.createExpression(expr.left),
       this.createLiteralNode(expr.operator),
       this.createExpression(expr.right)
     ]);
   }
   createUnaryExpression(expr) {
-    return ts.factory.createCallExpression(ts.factory.createIdentifier("ExpressionUtils.unary"), void 0, [
+    return this.createExpressionUtilsCall("unary", [
       this.createLiteralNode(expr.operator),
       this.createExpression(expr.operand)
     ]);
   }
   createArrayExpression(expr) {
-    return ts.factory.createCallExpression(ts.factory.createIdentifier("ExpressionUtils.array"), void 0, [
+    return this.createExpressionUtilsCall("array", [
       ts.factory.createArrayLiteralExpression(expr.items.map((item) => this.createExpression(item)))
     ]);
   }
   createRefExpression(expr) {
     if ((0, import_ast3.isDataField)(expr.target.ref)) {
-      return ts.factory.createCallExpression(ts.factory.createIdentifier("ExpressionUtils.field"), void 0, [
+      return this.createExpressionUtilsCall("field", [
         this.createLiteralNode(expr.target.$refText)
       ]);
     } else if ((0, import_ast3.isEnumField)(expr.target.ref)) {
@@ -1388,7 +1478,7 @@ var TsSchemaGenerator = class {
     }
   }
   createCallExpression(expr) {
-    return ts.factory.createCallExpression(ts.factory.createIdentifier("ExpressionUtils.call"), void 0, [
+    return this.createExpressionUtilsCall("call", [
       ts.factory.createStringLiteral(expr.function.$refText),
       ...expr.args.length > 0 ? [
         ts.factory.createArrayLiteralExpression(expr.args.map((arg) => this.createExpression(arg.value)))
@@ -1396,25 +1486,25 @@ var TsSchemaGenerator = class {
     ]);
   }
   createLiteralExpression(type, value) {
-    return (0, import_ts_pattern2.match)(type).with("BooleanLiteral", () => ts.factory.createCallExpression(ts.factory.createIdentifier("ExpressionUtils.literal"), void 0, [
+    return (0, import_ts_pattern2.match)(type).with("BooleanLiteral", () => this.createExpressionUtilsCall("literal", [
       this.createLiteralNode(value)
-    ])).with("NumberLiteral", () => ts.factory.createCallExpression(ts.factory.createIdentifier("ExpressionUtils.literal"), void 0, [
+    ])).with("NumberLiteral", () => this.createExpressionUtilsCall("literal", [
       ts.factory.createIdentifier(value)
-    ])).with("StringLiteral", () => ts.factory.createCallExpression(ts.factory.createIdentifier("ExpressionUtils.literal"), void 0, [
+    ])).with("StringLiteral", () => this.createExpressionUtilsCall("literal", [
       this.createLiteralNode(value)
     ])).otherwise(() => {
       throw new Error(`Unsupported literal type: ${type}`);
     });
   }
-  generateModelsAndTypeDefs(model, outputDir) {
+  generateModelsAndTypeDefs(model, options) {
     const statements = [];
-    statements.push(this.generateSchemaImport(model, true, true));
+    statements.push(this.generateSchemaImport(model, true, true, !!(options.lite || options.liteOnly)));
     statements.push(ts.factory.createImportDeclaration(void 0, ts.factory.createImportClause(false, void 0, ts.factory.createNamedImports([
       ts.factory.createImportSpecifier(true, void 0, ts.factory.createIdentifier(`ModelResult as $ModelResult`)),
       ...model.declarations.some(import_ast3.isTypeDef) ? [
         ts.factory.createImportSpecifier(true, void 0, ts.factory.createIdentifier(`TypeDefResult as $TypeDefResult`))
       ] : []
-    ])), ts.factory.createStringLiteral("@zenstackhq/runtime")));
+    ])), ts.factory.createStringLiteral("@zenstackhq/orm")));
     const dataModels = model.declarations.filter(import_ast3.isDataModel);
     for (const dm of dataModels) {
       let modelType = ts.factory.createTypeAliasDeclaration([
@@ -1446,7 +1536,7 @@ var TsSchemaGenerator = class {
       let enumDecl = ts.factory.createVariableStatement([
         ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)
       ], ts.factory.createVariableDeclarationList([
-        ts.factory.createVariableDeclaration(e.name, void 0, void 0, ts.factory.createPropertyAccessExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("$schema"), ts.factory.createIdentifier("enums")), ts.factory.createIdentifier(e.name)))
+        ts.factory.createVariableDeclaration(e.name, void 0, void 0, ts.factory.createPropertyAccessExpression(ts.factory.createPropertyAccessExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("$schema"), ts.factory.createIdentifier("enums")), ts.factory.createIdentifier(e.name)), ts.factory.createIdentifier("values")))
       ], ts.NodeFlags.Const));
       if (e.comments.length > 0) {
         enumDecl = this.generateDocs(enumDecl, e);
@@ -1461,13 +1551,13 @@ var TsSchemaGenerator = class {
       statements.push(typeAlias);
     }
     this.generateBannerComments(statements);
-    const outputFile = import_node_path.default.join(outputDir, "models.ts");
+    const outputFile = import_node_path.default.join(options.outDir, "models.ts");
     const sourceFile = ts.createSourceFile(outputFile, "", ts.ScriptTarget.ESNext, false, ts.ScriptKind.TS);
     const printer = ts.createPrinter();
     const result = printer.printList(ts.ListFormat.MultiLine, ts.factory.createNodeArray(statements), sourceFile);
     import_node_fs.default.writeFileSync(outputFile, result);
   }
-  generateSchemaImport(model, schemaObject, schemaType) {
+  generateSchemaImport(model, schemaObject, schemaType, useLite) {
     const importSpecifiers = [];
     if (schemaObject) {
       if (model.declarations.some(import_ast3.isEnum)) {
@@ -1477,17 +1567,17 @@ var TsSchemaGenerator = class {
     if (schemaType) {
       importSpecifiers.push(ts.factory.createImportSpecifier(true, ts.factory.createIdentifier("SchemaType"), ts.factory.createIdentifier("$Schema")));
     }
-    return ts.factory.createImportDeclaration(void 0, ts.factory.createImportClause(false, void 0, ts.factory.createNamedImports(importSpecifiers)), ts.factory.createStringLiteral("./schema"));
+    return ts.factory.createImportDeclaration(void 0, ts.factory.createImportClause(false, void 0, ts.factory.createNamedImports(importSpecifiers)), ts.factory.createStringLiteral(useLite ? "./schema-lite" : "./schema"));
   }
   generateDocs(tsDecl, decl) {
     return ts.addSyntheticLeadingComment(tsDecl, ts.SyntaxKind.MultiLineCommentTrivia, `*
  * ${decl.comments.map((c) => c.replace(/^\s*\/*\s*/, "")).join("\n * ")}
  `, true);
   }
-  generateInputTypes(model, outputDir) {
+  generateInputTypes(model, options) {
     const dataModels = model.declarations.filter(import_ast3.isDataModel);
     const statements = [];
-    statements.push(this.generateSchemaImport(model, false, true));
+    statements.push(this.generateSchemaImport(model, false, true, !!(options.lite || options.liteOnly)));
     const inputTypes = [
       "FindManyArgs",
       "FindUniqueArgs",
@@ -1514,11 +1604,11 @@ var TsSchemaGenerator = class {
       IncludeInput: "Include",
       OmitInput: "Omit"
     };
-    statements.push(ts.factory.createImportDeclaration(void 0, ts.factory.createImportClause(true, void 0, ts.factory.createNamedImports(inputTypes.map((inputType) => ts.factory.createImportSpecifier(false, void 0, ts.factory.createIdentifier(`${inputType} as $${inputType}`))))), ts.factory.createStringLiteral("@zenstackhq/runtime")));
+    statements.push(ts.factory.createImportDeclaration(void 0, ts.factory.createImportClause(true, void 0, ts.factory.createNamedImports(inputTypes.map((inputType) => ts.factory.createImportSpecifier(false, void 0, ts.factory.createIdentifier(`${inputType} as $${inputType}`))))), ts.factory.createStringLiteral("@zenstackhq/orm")));
     statements.push(ts.factory.createImportDeclaration(void 0, ts.factory.createImportClause(true, void 0, ts.factory.createNamedImports([
       ts.factory.createImportSpecifier(false, void 0, ts.factory.createIdentifier("SimplifiedModelResult as $SimplifiedModelResult")),
       ts.factory.createImportSpecifier(false, void 0, ts.factory.createIdentifier("SelectIncludeOmit as $SelectIncludeOmit"))
-    ])), ts.factory.createStringLiteral("@zenstackhq/runtime")));
+    ])), ts.factory.createStringLiteral("@zenstackhq/orm")));
     for (const dm of dataModels) {
       for (const inputType of inputTypes) {
         const exportName = inputTypeNameFixes[inputType] ? `${dm.name}${inputTypeNameFixes[inputType]}` : `${dm.name}${inputType}`;
@@ -1544,518 +1634,17 @@ var TsSchemaGenerator = class {
       ])));
     }
     this.generateBannerComments(statements);
-    const outputFile = import_node_path.default.join(outputDir, "input.ts");
+    const outputFile = import_node_path.default.join(options.outDir, "input.ts");
     const sourceFile = ts.createSourceFile(outputFile, "", ts.ScriptTarget.ESNext, false, ts.ScriptKind.TS);
     const printer = ts.createPrinter();
     const result = printer.printList(ts.ListFormat.MultiLine, ts.factory.createNodeArray(statements), sourceFile);
     import_node_fs.default.writeFileSync(outputFile, result);
   }
 };
-
-// src/zmodel-code-generator.ts
-var import_ast4 = require("@zenstackhq/language/ast");
-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);
-  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_decorate, "_ts_decorate");
-function _ts_metadata(k, v) {
-  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-__name(_ts_metadata, "_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.ref?.name).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 `${resolved(ast.decl).name}${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 isCollectionPredicate = this.isCollectionPredicateOperator(operator);
-    const rightExpr = this.generate(ast.right);
-    const { left: isLeftParenthesis, right: isRightParenthesis } = this.isParenthesesNeededForBinaryExpr(ast);
-    return `${isLeftParenthesis ? "(" : ""}${this.generate(ast.left)}${isLeftParenthesis ? ")" : ""}${isCollectionPredicate ? "" : this.binaryExprSpace}${operator}${isCollectionPredicate ? "" : this.binaryExprSpace}${isRightParenthesis ? "(" : ""}${isCollectionPredicate ? `[${rightExpr}]` : rightExpr}${isRightParenthesis ? ")" : ""}`;
-  }
-  _generateReferenceExpr(ast) {
-    const args = ast.args.length ? `(${ast.args.map((x) => this.generate(x)).join(", ")})` : "";
-    return `${ast.target.ref?.name}${args}`;
-  }
-  _generateReferenceArg(ast) {
-    return `${ast.name}:${this.generate(ast.value)}`;
-  }
-  _generateMemberExpr(ast) {
-    return `${this.generate(ast.operand)}.${ast.member.ref?.name}`;
-  }
-  _generateInvocationExpr(ast) {
-    return `${ast.function.ref?.name}(${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 isCollectionPredicate = this.isCollectionPredicateOperator(operator);
-    const currentPriority = import_ast4.BinaryExprOperatorPriority[operator];
-    if (ast.left.$type === import_ast4.BinaryExpr && import_ast4.BinaryExprOperatorPriority[ast.left["operator"]] < currentPriority) {
-      result.left = true;
-    }
-    if (!isCollectionPredicate && ast.right.$type === import_ast4.BinaryExpr && import_ast4.BinaryExprOperatorPriority[ast.right["operator"]] <= currentPriority) {
-      result.right = true;
-    }
-    return result;
-  }
-  isCollectionPredicateOperator(op) {
-    return [
-      "?",
-      "!",
-      "^"
-    ].includes(op);
-  }
-};
-_ts_decorate([
-  gen(import_ast4.Model),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof import_ast4.Model === "undefined" ? Object : import_ast4.Model
-  ]),
-  _ts_metadata("design:returntype", void 0)
-], ZModelCodeGenerator.prototype, "_generateModel", null);
-_ts_decorate([
-  gen(import_ast4.DataSource),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof import_ast4.DataSource === "undefined" ? Object : import_ast4.DataSource
-  ]),
-  _ts_metadata("design:returntype", void 0)
-], ZModelCodeGenerator.prototype, "_generateDataSource", null);
-_ts_decorate([
-  gen(import_ast4.Enum),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof import_ast4.Enum === "undefined" ? Object : import_ast4.Enum
-  ]),
-  _ts_metadata("design:returntype", void 0)
-], ZModelCodeGenerator.prototype, "_generateEnum", null);
-_ts_decorate([
-  gen(import_ast4.EnumField),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof import_ast4.EnumField === "undefined" ? Object : import_ast4.EnumField
-  ]),
-  _ts_metadata("design:returntype", void 0)
-], ZModelCodeGenerator.prototype, "_generateEnumField", null);
-_ts_decorate([
-  gen(import_ast4.GeneratorDecl),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof import_ast4.GeneratorDecl === "undefined" ? Object : import_ast4.GeneratorDecl
-  ]),
-  _ts_metadata("design:returntype", void 0)
-], ZModelCodeGenerator.prototype, "_generateGenerator", null);
-_ts_decorate([
-  gen(import_ast4.ConfigField),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof import_ast4.ConfigField === "undefined" ? Object : import_ast4.ConfigField
-  ]),
-  _ts_metadata("design:returntype", void 0)
-], ZModelCodeGenerator.prototype, "_generateConfigField", null);
-_ts_decorate([
-  gen(import_ast4.ConfigArrayExpr),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof import_ast4.ConfigArrayExpr === "undefined" ? Object : import_ast4.ConfigArrayExpr
-  ]),
-  _ts_metadata("design:returntype", void 0)
-], ZModelCodeGenerator.prototype, "_generateConfigArrayExpr", null);
-_ts_decorate([
-  gen(import_ast4.ConfigInvocationExpr),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof import_ast4.ConfigInvocationExpr === "undefined" ? Object : import_ast4.ConfigInvocationExpr
-  ]),
-  _ts_metadata("design:returntype", void 0)
-], ZModelCodeGenerator.prototype, "_generateConfigInvocationExpr", null);
-_ts_decorate([
-  gen(import_ast4.Plugin),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof import_ast4.Plugin === "undefined" ? Object : import_ast4.Plugin
-  ]),
-  _ts_metadata("design:returntype", void 0)
-], ZModelCodeGenerator.prototype, "_generatePlugin", null);
-_ts_decorate([
-  gen(import_ast4.PluginField),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof import_ast4.PluginField === "undefined" ? Object : import_ast4.PluginField
-  ]),
-  _ts_metadata("design:returntype", void 0)
-], ZModelCodeGenerator.prototype, "_generatePluginField", null);
-_ts_decorate([
-  gen(import_ast4.DataModel),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof import_ast4.DataModel === "undefined" ? Object : import_ast4.DataModel
-  ]),
-  _ts_metadata("design:returntype", void 0)
-], ZModelCodeGenerator.prototype, "_generateDataModel", null);
-_ts_decorate([
-  gen(import_ast4.DataField),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof import_ast4.DataField === "undefined" ? Object : import_ast4.DataField
-  ]),
-  _ts_metadata("design:returntype", void 0)
-], ZModelCodeGenerator.prototype, "_generateDataField", null);
-_ts_decorate([
-  gen(import_ast4.DataModelAttribute),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof import_ast4.DataModelAttribute === "undefined" ? Object : import_ast4.DataModelAttribute
-  ]),
-  _ts_metadata("design:returntype", void 0)
-], ZModelCodeGenerator.prototype, "_generateDataModelAttribute", null);
-_ts_decorate([
-  gen(import_ast4.DataFieldAttribute),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof import_ast4.DataFieldAttribute === "undefined" ? Object : import_ast4.DataFieldAttribute
-  ]),
-  _ts_metadata("design:returntype", void 0)
-], ZModelCodeGenerator.prototype, "_generateDataFieldAttribute", null);
-_ts_decorate([
-  gen(import_ast4.AttributeArg),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof import_ast4.AttributeArg === "undefined" ? Object : import_ast4.AttributeArg
-  ]),
-  _ts_metadata("design:returntype", void 0)
-], ZModelCodeGenerator.prototype, "_generateAttributeArg", null);
-_ts_decorate([
-  gen(import_ast4.ObjectExpr),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof import_ast4.ObjectExpr === "undefined" ? Object : import_ast4.ObjectExpr
-  ]),
-  _ts_metadata("design:returntype", void 0)
-], ZModelCodeGenerator.prototype, "_generateObjectExpr", null);
-_ts_decorate([
-  gen(import_ast4.ArrayExpr),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof import_ast4.ArrayExpr === "undefined" ? Object : import_ast4.ArrayExpr
-  ]),
-  _ts_metadata("design:returntype", void 0)
-], ZModelCodeGenerator.prototype, "_generateArrayExpr", null);
-_ts_decorate([
-  gen(import_ast4.StringLiteral),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof import_ast4.LiteralExpr === "undefined" ? Object : import_ast4.LiteralExpr
-  ]),
-  _ts_metadata("design:returntype", void 0)
-], ZModelCodeGenerator.prototype, "_generateLiteralExpr", null);
-_ts_decorate([
-  gen(import_ast4.NumberLiteral),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof import_ast4.NumberLiteral === "undefined" ? Object : import_ast4.NumberLiteral
-  ]),
-  _ts_metadata("design:returntype", void 0)
-], ZModelCodeGenerator.prototype, "_generateNumberLiteral", null);
-_ts_decorate([
-  gen(import_ast4.BooleanLiteral),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof import_ast4.BooleanLiteral === "undefined" ? Object : import_ast4.BooleanLiteral
-  ]),
-  _ts_metadata("design:returntype", void 0)
-], ZModelCodeGenerator.prototype, "_generateBooleanLiteral", null);
-_ts_decorate([
-  gen(import_ast4.UnaryExpr),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof import_ast4.UnaryExpr === "undefined" ? Object : import_ast4.UnaryExpr
-  ]),
-  _ts_metadata("design:returntype", void 0)
-], ZModelCodeGenerator.prototype, "_generateUnaryExpr", null);
-_ts_decorate([
-  gen(import_ast4.BinaryExpr),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof import_ast4.BinaryExpr === "undefined" ? Object : import_ast4.BinaryExpr
-  ]),
-  _ts_metadata("design:returntype", void 0)
-], ZModelCodeGenerator.prototype, "_generateBinaryExpr", null);
-_ts_decorate([
-  gen(import_ast4.ReferenceExpr),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof import_ast4.ReferenceExpr === "undefined" ? Object : import_ast4.ReferenceExpr
-  ]),
-  _ts_metadata("design:returntype", void 0)
-], ZModelCodeGenerator.prototype, "_generateReferenceExpr", null);
-_ts_decorate([
-  gen(import_ast4.ReferenceArg),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof import_ast4.ReferenceArg === "undefined" ? Object : import_ast4.ReferenceArg
-  ]),
-  _ts_metadata("design:returntype", void 0)
-], ZModelCodeGenerator.prototype, "_generateReferenceArg", null);
-_ts_decorate([
-  gen(import_ast4.MemberAccessExpr),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof import_ast4.MemberAccessExpr === "undefined" ? Object : import_ast4.MemberAccessExpr
-  ]),
-  _ts_metadata("design:returntype", void 0)
-], ZModelCodeGenerator.prototype, "_generateMemberExpr", null);
-_ts_decorate([
-  gen(import_ast4.InvocationExpr),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof import_ast4.InvocationExpr === "undefined" ? Object : import_ast4.InvocationExpr
-  ]),
-  _ts_metadata("design:returntype", void 0)
-], ZModelCodeGenerator.prototype, "_generateInvocationExpr", null);
-_ts_decorate([
-  gen(import_ast4.NullExpr),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", []),
-  _ts_metadata("design:returntype", void 0)
-], ZModelCodeGenerator.prototype, "_generateNullExpr", null);
-_ts_decorate([
-  gen(import_ast4.ThisExpr),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", []),
-  _ts_metadata("design:returntype", void 0)
-], ZModelCodeGenerator.prototype, "_generateThisExpr", null);
-_ts_decorate([
-  gen(import_ast4.Attribute),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof import_ast4.Attribute === "undefined" ? Object : import_ast4.Attribute
-  ]),
-  _ts_metadata("design:returntype", void 0)
-], ZModelCodeGenerator.prototype, "_generateAttribute", null);
-_ts_decorate([
-  gen(import_ast4.AttributeParam),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof import_ast4.AttributeParam === "undefined" ? Object : import_ast4.AttributeParam
-  ]),
-  _ts_metadata("design:returntype", void 0)
-], ZModelCodeGenerator.prototype, "_generateAttributeParam", null);
-_ts_decorate([
-  gen(import_ast4.AttributeParamType),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof import_ast4.AttributeParamType === "undefined" ? Object : import_ast4.AttributeParamType
-  ]),
-  _ts_metadata("design:returntype", void 0)
-], ZModelCodeGenerator.prototype, "_generateAttributeParamType", null);
-_ts_decorate([
-  gen(import_ast4.FunctionDecl),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof import_ast4.FunctionDecl === "undefined" ? Object : import_ast4.FunctionDecl
-  ]),
-  _ts_metadata("design:returntype", void 0)
-], ZModelCodeGenerator.prototype, "_generateFunctionDecl", null);
-_ts_decorate([
-  gen(import_ast4.FunctionParam),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof import_ast4.FunctionParam === "undefined" ? Object : import_ast4.FunctionParam
-  ]),
-  _ts_metadata("design:returntype", void 0)
-], ZModelCodeGenerator.prototype, "_generateFunctionParam", null);
-_ts_decorate([
-  gen(import_ast4.FunctionParamType),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof import_ast4.FunctionParamType === "undefined" ? Object : import_ast4.FunctionParamType
-  ]),
-  _ts_metadata("design:returntype", void 0)
-], ZModelCodeGenerator.prototype, "_generateFunctionParamType", null);
-_ts_decorate([
-  gen(import_ast4.TypeDef),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof import_ast4.TypeDef === "undefined" ? Object : import_ast4.TypeDef
-  ]),
-  _ts_metadata("design:returntype", void 0)
-], ZModelCodeGenerator.prototype, "_generateTypeDef", null);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ModelUtils,
   PrismaSchemaGenerator,
-  TsSchemaGenerator,
-  ZModelCodeGenerator
+  TsSchemaGenerator
 });
 //# sourceMappingURL=index.cjs.map