@zenstackhq/sdk 3.0.0-alpha.3 → 3.0.0-alpha.30

package/dist/index.cjs

@@ -41,12 +41,11 @@ module.exports = __toCommonJS(src_exports);
 // src/model-utils.ts
 var model_utils_exports = {};
 __export(model_utils_exports, {
+  DELEGATE_AUX_RELATION_PREFIX: () => DELEGATE_AUX_RELATION_PREFIX,
   getAttribute: () => getAttribute,
   getAuthDecl: () => getAuthDecl,
   getContainingModel: () => getContainingModel,
-  getModelIdFields: () => getModelIdFields,
-  getModelUniqueFields: () => getModelUniqueFields,
-  getRecursiveBases: () => getRecursiveBases,
+  getIdFields: () => getIdFields,
   hasAttribute: () => hasAttribute,
   isDelegateModel: () => isDelegateModel,
   isFromStdlib: () => isFromStdlib,
@@ -55,23 +54,24 @@ __export(model_utils_exports, {
   resolved: () => resolved
 });
 var import_ast = require("@zenstackhq/language/ast");
-function isIdField(field) {
+var import_utils = require("@zenstackhq/language/utils");
+function isIdField(field, contextModel) {
   if (hasAttribute(field, "@id")) {
     return true;
   }
-  const model = field.$container;
-  const modelLevelIds = getModelIdFields(model);
+  const modelLevelIds = (0, import_utils.getModelIdFields)(contextModel);
   if (modelLevelIds.map((f) => f.name).includes(field.name)) {
     return true;
   }
-  if (model.fields.some((f) => hasAttribute(f, "@id")) || modelLevelIds.length > 0) {
+  const allFields = (0, import_utils.getAllFields)(contextModel);
+  if (allFields.some((f) => hasAttribute(f, "@id")) || modelLevelIds.length > 0) {
     return false;
   }
-  const firstUniqueField = model.fields.find((f) => hasAttribute(f, "@unique"));
+  const firstUniqueField = allFields.find((f) => hasAttribute(f, "@unique"));
   if (firstUniqueField) {
     return firstUniqueField.name === field.name;
   }
-  const modelLevelUnique = getModelUniqueFields(model);
+  const modelLevelUnique = (0, import_utils.getModelUniqueFields)(contextModel);
   if (modelLevelUnique.map((f) => f.name).includes(field.name)) {
     return true;
   }
@@ -86,67 +86,6 @@ function getAttribute(decl, name) {
   return decl.attributes.find((attr) => attr.decl.$refText === name);
 }
 __name(getAttribute, "getAttribute");
-function getModelIdFields(model) {
-  const modelsToCheck = model.$baseMerged ? [
-    model
-  ] : [
-    model,
-    ...getRecursiveBases(model)
-  ];
-  for (const modelToCheck of modelsToCheck) {
-    const idAttr = modelToCheck.attributes.find((attr) => attr.decl.$refText === "@@id");
-    if (!idAttr) {
-      continue;
-    }
-    const fieldsArg = idAttr.args.find((a) => a.$resolvedParam?.name === "fields");
-    if (!fieldsArg || !(0, import_ast.isArrayExpr)(fieldsArg.value)) {
-      continue;
-    }
-    return fieldsArg.value.items.filter((item) => (0, import_ast.isReferenceExpr)(item)).map((item) => item.target.ref);
-  }
-  return [];
-}
-__name(getModelIdFields, "getModelIdFields");
-function getModelUniqueFields(model) {
-  const modelsToCheck = model.$baseMerged ? [
-    model
-  ] : [
-    model,
-    ...getRecursiveBases(model)
-  ];
-  for (const modelToCheck of modelsToCheck) {
-    const uniqueAttr = modelToCheck.attributes.find((attr) => attr.decl.$refText === "@@unique");
-    if (!uniqueAttr) {
-      continue;
-    }
-    const fieldsArg = uniqueAttr.args.find((a) => a.$resolvedParam?.name === "fields");
-    if (!fieldsArg || !(0, import_ast.isArrayExpr)(fieldsArg.value)) {
-      continue;
-    }
-    return fieldsArg.value.items.filter((item) => (0, import_ast.isReferenceExpr)(item)).map((item) => item.target.ref);
-  }
-  return [];
-}
-__name(getModelUniqueFields, "getModelUniqueFields");
-function getRecursiveBases(dataModel, includeDelegate = true, seen = /* @__PURE__ */ new Set()) {
-  const result = [];
-  if (seen.has(dataModel)) {
-    return result;
-  }
-  seen.add(dataModel);
-  dataModel.superTypes.forEach((superType) => {
-    const baseDecl = superType.ref;
-    if (baseDecl) {
-      if (!includeDelegate && isDelegateModel(baseDecl)) {
-        return;
-      }
-      result.push(baseDecl);
-      result.push(...getRecursiveBases(baseDecl, includeDelegate, seen));
-    }
-  });
-  return result;
-}
-__name(getRecursiveBases, "getRecursiveBases");
 function isDelegateModel(node) {
   return (0, import_ast.isDataModel)(node) && hasAttribute(node, "@@delegate");
 }
@@ -189,9 +128,16 @@ function getAuthDecl(model) {
   return found;
 }
 __name(getAuthDecl, "getAuthDecl");
+function getIdFields(dm) {
+  return (0, import_utils.getAllFields)(dm).filter((f) => isIdField(f, dm)).map((f) => f.name);
+}
+__name(getIdFields, "getIdFields");
+var DELEGATE_AUX_RELATION_PREFIX = "delegate_aux";
 
 // src/prisma/prisma-schema-generator.ts
+var import_common_helpers = require("@zenstackhq/common-helpers");
 var import_ast2 = require("@zenstackhq/language/ast");
+var import_utils2 = require("@zenstackhq/language/utils");
 var import_langium = require("langium");
 var import_ts_pattern = require("ts-pattern");
 
@@ -318,9 +264,9 @@ var Model = class extends ContainerDeclaration {
   }
   name;
   isView;
-  fields;
+  fields = [];
   constructor(name, isView, documentations = []) {
-    super(documentations), this.name = name, this.isView = isView, this.fields = [];
+    super(documentations), this.name = name, this.isView = isView;
   }
   addField(name, type, attributes = [], documentations = [], addToFront = false) {
     const field = new ModelField(name, type, attributes, documentations);
@@ -540,9 +486,9 @@ var Enum = class extends ContainerDeclaration {
     __name(this, "Enum");
   }
   name;
-  fields;
+  fields = [];
   constructor(name, documentations = []) {
-    super(documentations), this.name = name, this.fields = [];
+    super(documentations), this.name = name;
   }
   addField(name, attributes = [], documentations = []) {
     const field = new EnumField(name, attributes, documentations);
@@ -586,20 +532,22 @@ var EnumField = class extends DeclarationBase {
 };
 
 // src/prisma/prisma-schema-generator.ts
+var IDENTIFIER_NAME_MAX_LENGTH = 50 - DELEGATE_AUX_RELATION_PREFIX.length;
 var PrismaSchemaGenerator = class {
   static {
     __name(this, "PrismaSchemaGenerator");
   }
   zmodel;
-  PRELUDE;
-  constructor(zmodel) {
-    this.zmodel = zmodel;
-    this.PRELUDE = `//////////////////////////////////////////////////////////////////////////////////////////////
+  PRELUDE = `//////////////////////////////////////////////////////////////////////////////////////////////
 // DO NOT MODIFY THIS FILE                                                                  //
 // This file is automatically generated by ZenStack CLI and should not be manually updated. //
 //////////////////////////////////////////////////////////////////////////////////////////////
 
 `;
+  // a mapping from full names to shortened names
+  shortNameMap = /* @__PURE__ */ new Map();
+  constructor(zmodel) {
+    this.zmodel = zmodel;
   }
   async generate() {
     const prisma = new PrismaModel();
@@ -661,16 +609,22 @@ var PrismaSchemaGenerator = class {
   }
   generateModel(prisma, decl) {
     const model = decl.isView ? prisma.addView(decl.name) : prisma.addModel(decl.name);
-    for (const field of decl.fields) {
+    const allFields = (0, import_utils2.getAllFields)(decl, true);
+    for (const field of allFields) {
       if (model_utils_exports.hasAttribute(field, "@computed")) {
         continue;
       }
-      this.generateModelField(model, field);
+      if (model_utils_exports.isIdField(field, decl) || !this.isInheritedFromDelegate(field, decl)) {
+        this.generateModelField(model, field, decl);
+      }
     }
-    for (const attr of decl.attributes.filter((attr2) => this.isPrismaAttribute(attr2))) {
+    const allAttributes = (0, import_utils2.getAllAttributes)(decl);
+    for (const attr of allAttributes.filter((attr2) => this.isPrismaAttribute(attr2))) {
       this.generateContainerAttribute(model, attr);
     }
     decl.comments.forEach((c) => model.addComment(c));
+    this.generateDelegateRelationForBase(model, decl);
+    this.generateDelegateRelationForConcrete(model, decl);
   }
   isPrismaAttribute(attr) {
     if (!attr.decl.ref) {
@@ -693,7 +647,7 @@ var PrismaSchemaGenerator = class {
   getStringLiteral(node) {
     return (0, import_ast2.isStringLiteral)(node) ? node.value : void 0;
   }
-  generateModelField(model, field, addToFront = false) {
+  generateModelField(model, field, contextModel, addToFront = false) {
     let fieldType;
     if (field.type.type) {
       fieldType = field.type.type;
@@ -719,7 +673,7 @@ var PrismaSchemaGenerator = class {
     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) => (
       // when building physical schema, exclude `@default` for id fields inherited from delegate base
-      !(model_utils_exports.isIdField(field) && this.isInheritedFromDelegate(field) && attr.decl.$refText === "@default")
+      !(model_utils_exports.isIdField(field, contextModel) && this.isInheritedFromDelegate(field, contextModel) && attr.decl.$refText === "@default")
     )).map((attr) => this.makeFieldAttribute(attr));
     const docs = [
       ...field.comments
@@ -741,16 +695,8 @@ var PrismaSchemaGenerator = class {
     const model = import_langium.AstUtils.getContainerOfType(node, import_ast2.isModel);
     return !!model && !!model.$document && model.$document.uri.path.endsWith("plugin.zmodel");
   }
-  setDummyDefault(result, field) {
-    const dummyDefaultValue = (0, import_ts_pattern.match)(field.type.type).with("String", () => new AttributeArgValue("String", "")).with(import_ts_pattern.P.union("Int", "BigInt", "Float", "Decimal"), () => new AttributeArgValue("Number", "0")).with("Boolean", () => new AttributeArgValue("Boolean", "false")).with("DateTime", () => new AttributeArgValue("FunctionCall", new FunctionCall("now"))).with("Json", () => new AttributeArgValue("String", "{}")).with("Bytes", () => new AttributeArgValue("String", "")).otherwise(() => {
-      throw new Error(`Unsupported field type with default value: ${field.type.type}`);
-    });
-    result.attributes.push(new FieldAttribute("@default", [
-      new AttributeArg(void 0, dummyDefaultValue)
-    ]));
-  }
-  isInheritedFromDelegate(field) {
-    return field.$inheritedFrom && model_utils_exports.isDelegateModel(field.$inheritedFrom);
+  isInheritedFromDelegate(field, contextModel) {
+    return field.$container !== contextModel && model_utils_exports.isDelegateModel(field.$container);
   }
   makeFieldAttribute(attr) {
     const attrName = attr.decl.ref.name;
@@ -807,40 +753,91 @@ var PrismaSchemaGenerator = class {
     ];
     _enum.addField(field.name, attributes, docs);
   }
+  generateDelegateRelationForBase(model, decl) {
+    if (!(0, import_utils2.isDelegateModel)(decl)) {
+      return;
+    }
+    const concreteModels = this.getConcreteModels(decl);
+    concreteModels.forEach((concrete) => {
+      const auxName = this.truncate(`${DELEGATE_AUX_RELATION_PREFIX}_${(0, import_common_helpers.lowerCaseFirst)(concrete.name)}`);
+      model.addField(auxName, new ModelFieldType(concrete.name, false, true));
+    });
+  }
+  generateDelegateRelationForConcrete(model, concreteDecl) {
+    const base = concreteDecl.baseModel?.ref;
+    if (!base) {
+      return;
+    }
+    const idFields = getIdFields(base);
+    const relationField = this.truncate(`${DELEGATE_AUX_RELATION_PREFIX}_${(0, import_common_helpers.lowerCaseFirst)(base.name)}`);
+    model.addField(relationField, base.name, [
+      new FieldAttribute("@relation", [
+        new AttributeArg("fields", new AttributeArgValue("Array", idFields.map((idField) => new AttributeArgValue("FieldReference", new FieldReference(idField))))),
+        new AttributeArg("references", new AttributeArgValue("Array", idFields.map((idField) => new AttributeArgValue("FieldReference", new FieldReference(idField))))),
+        new AttributeArg("onDelete", new AttributeArgValue("FieldReference", new FieldReference("Cascade"))),
+        new AttributeArg("onUpdate", new AttributeArgValue("FieldReference", new FieldReference("Cascade")))
+      ])
+    ]);
+  }
+  getConcreteModels(dataModel) {
+    if (!(0, import_utils2.isDelegateModel)(dataModel)) {
+      return [];
+    }
+    return dataModel.$container.declarations.filter((d) => (0, import_ast2.isDataModel)(d) && d !== dataModel && d.baseModel?.ref === dataModel);
+  }
+  truncate(name) {
+    if (name.length <= IDENTIFIER_NAME_MAX_LENGTH) {
+      return name;
+    }
+    const existing = this.shortNameMap.get(name);
+    if (existing) {
+      return existing;
+    }
+    const baseName = name.slice(0, IDENTIFIER_NAME_MAX_LENGTH);
+    let index = 0;
+    let shortName = `${baseName}_${index}`;
+    while (true) {
+      const conflict = Array.from(this.shortNameMap.values()).find((v) => v === shortName);
+      if (!conflict) {
+        this.shortNameMap.set(name, shortName);
+        break;
+      }
+      index++;
+      shortName = `${baseName}_${index}`;
+    }
+    return shortName;
+  }
 };
 
 // src/ts-schema-generator.ts
-var import_language = require("@zenstackhq/language");
+var import_common_helpers2 = require("@zenstackhq/common-helpers");
 var import_ast3 = require("@zenstackhq/language/ast");
+var import_utils3 = require("@zenstackhq/language/utils");
 var import_node_fs = __toESM(require("fs"), 1);
 var import_node_path = __toESM(require("path"), 1);
-var import_tiny_invariant = __toESM(require("tiny-invariant"), 1);
 var import_ts_pattern2 = require("ts-pattern");
 var ts = __toESM(require("typescript"), 1);
 var TsSchemaGenerator = class {
   static {
     __name(this, "TsSchemaGenerator");
   }
-  async generate(schemaFile, pluginModelFiles, outputFile) {
-    const loaded = await (0, import_language.loadDocument)(schemaFile, pluginModelFiles);
-    if (!loaded.success) {
-      throw new Error(`Error loading schema:${loaded.errors.join("\n")}`);
-    }
-    const { model, warnings } = loaded;
+  async generate(model, outputDir) {
+    import_node_fs.default.mkdirSync(outputDir, {
+      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 sourceFile = ts.createSourceFile(outputFile, "", ts.ScriptTarget.ESNext, false, ts.ScriptKind.TS);
+    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.mkdirSync(import_node_path.default.dirname(outputFile), {
-      recursive: true
-    });
-    import_node_fs.default.writeFileSync(outputFile, result);
-    return {
-      model,
-      warnings
-    };
+    import_node_fs.default.writeFileSync(schemaOutputFile, result);
   }
   generateSchemaStatements(model, statements) {
     const hasComputedFields = model.declarations.some((d) => (0, import_ast3.isDataModel)(d) && d.fields.some((f) => hasAttribute(f, "@computed")));
@@ -868,7 +865,11 @@ var TsSchemaGenerator = class {
       // provider
       ts.factory.createPropertyAssignment("provider", this.createProviderObject(model)),
       // models
-      ts.factory.createPropertyAssignment("models", this.createModelsObject(model))
+      ts.factory.createPropertyAssignment("models", this.createModelsObject(model)),
+      // typeDefs
+      ...model.declarations.some(import_ast3.isTypeDef) ? [
+        ts.factory.createPropertyAssignment("typeDefs", this.createTypeDefsObject(model))
+      ] : []
     ];
     const enums = model.declarations.filter(import_ast3.isEnum);
     if (enums.length > 0) {
@@ -894,18 +895,43 @@ var TsSchemaGenerator = class {
   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);
   }
+  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);
+  }
   createDataModelObject(dm) {
+    const allFields = (0, import_utils3.getAllFields)(dm);
+    const allAttributes = (0, import_utils3.getAllAttributes)(dm).filter((attr) => {
+      if (attr.decl.$refText === "@@delegate" && attr.$container !== dm) {
+        return false;
+      }
+      return true;
+    });
+    const subModels = this.getSubModels(dm);
     const fields = [
+      // name
+      ts.factory.createPropertyAssignment("name", ts.factory.createStringLiteral(dm.name)),
+      // baseModel
+      ...dm.baseModel ? [
+        ts.factory.createPropertyAssignment("baseModel", ts.factory.createStringLiteral(dm.baseModel.$refText))
+      ] : [],
       // fields
-      ts.factory.createPropertyAssignment("fields", ts.factory.createObjectLiteralExpression(dm.fields.filter((field) => !hasAttribute(field, "@ignore")).map((field) => ts.factory.createPropertyAssignment(field.name, this.createDataModelFieldObject(field))), true)),
+      ts.factory.createPropertyAssignment("fields", ts.factory.createObjectLiteralExpression(allFields.map((field) => ts.factory.createPropertyAssignment(field.name, this.createDataFieldObject(field, dm))), true)),
       // attributes
-      ...dm.attributes.length > 0 ? [
-        ts.factory.createPropertyAssignment("attributes", ts.factory.createArrayLiteralExpression(dm.attributes.map((attr) => this.createAttributeObject(attr)), true))
+      ...allAttributes.length > 0 ? [
+        ts.factory.createPropertyAssignment("attributes", ts.factory.createArrayLiteralExpression(allAttributes.map((attr) => this.createAttributeObject(attr)), true))
       ] : [],
       // idFields
-      ts.factory.createPropertyAssignment("idFields", ts.factory.createArrayLiteralExpression(this.getIdFields(dm).map((idField) => ts.factory.createStringLiteral(idField)))),
+      ts.factory.createPropertyAssignment("idFields", ts.factory.createArrayLiteralExpression(getIdFields(dm).map((idField) => ts.factory.createStringLiteral(idField)))),
       // uniqueFields
-      ts.factory.createPropertyAssignment("uniqueFields", this.createUniqueFieldsObject(dm))
+      ts.factory.createPropertyAssignment("uniqueFields", this.createUniqueFieldsObject(dm)),
+      // isDelegate
+      ...isDelegateModel(dm) ? [
+        ts.factory.createPropertyAssignment("isDelegate", ts.factory.createTrue())
+      ] : [],
+      // subModels
+      ...subModels.length > 0 ? [
+        ts.factory.createPropertyAssignment("subModels", ts.factory.createArrayLiteralExpression(subModels.map((subModel) => ts.factory.createStringLiteral(subModel))))
+      ] : []
     ];
     const computedFields = dm.fields.filter((f) => hasAttribute(f, "@computed"));
     if (computedFields.length > 0) {
@@ -913,23 +939,56 @@ var TsSchemaGenerator = class {
     }
     return ts.factory.createObjectLiteralExpression(fields, true);
   }
+  getSubModels(dm) {
+    return dm.$container.declarations.filter(import_ast3.isDataModel).filter((d) => d.baseModel?.ref === dm).map((d) => d.name);
+  }
+  createTypeDefObject(td) {
+    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)),
+      // attributes
+      ...allAttributes.length > 0 ? [
+        ts.factory.createPropertyAssignment("attributes", ts.factory.createArrayLiteralExpression(allAttributes.map((attr) => this.createAttributeObject(attr)), true))
+      ] : []
+    ];
+    return ts.factory.createObjectLiteralExpression(fields, true);
+  }
   createComputedFieldsObject(fields) {
-    return ts.factory.createObjectLiteralExpression(fields.map((field) => ts.factory.createMethodDeclaration(void 0, void 0, field.name, void 0, void 0, [], ts.factory.createTypeReferenceNode("OperandExpression", [
-      ts.factory.createKeywordTypeNode(this.mapTypeToTSSyntaxKeyword(field.type.type))
+    return ts.factory.createObjectLiteralExpression(fields.map((field) => ts.factory.createMethodDeclaration(void 0, void 0, field.name, void 0, void 0, [
+      // parameter: `context: { currentModel: 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))
+      ]), void 0)
+    ], ts.factory.createTypeReferenceNode("OperandExpression", [
+      ts.factory.createTypeReferenceNode(this.mapFieldTypeToTSType(field.type))
     ]), ts.factory.createBlock([
       ts.factory.createThrowStatement(ts.factory.createNewExpression(ts.factory.createIdentifier("Error"), void 0, [
         ts.factory.createStringLiteral("This is a stub for computed field")
       ]))
     ], true))), true);
   }
-  mapTypeToTSSyntaxKeyword(type) {
-    return (0, import_ts_pattern2.match)(type).with("String", () => ts.SyntaxKind.StringKeyword).with("Boolean", () => ts.SyntaxKind.BooleanKeyword).with("Int", () => ts.SyntaxKind.NumberKeyword).with("Float", () => ts.SyntaxKind.NumberKeyword).with("BigInt", () => ts.SyntaxKind.BigIntKeyword).with("Decimal", () => ts.SyntaxKind.NumberKeyword).otherwise(() => ts.SyntaxKind.UnknownKeyword);
+  mapFieldTypeToTSType(type) {
+    let result = (0, import_ts_pattern2.match)(type.type).with("String", () => "string").with("Boolean", () => "boolean").with("Int", () => "number").with("Float", () => "number").with("BigInt", () => "bigint").with("Decimal", () => "number").otherwise(() => "unknown");
+    if (type.array) {
+      result = `${result}[]`;
+    }
+    if (type.optional) {
+      result = `${result} | null`;
+    }
+    return result;
   }
-  createDataModelFieldObject(field) {
+  createDataFieldObject(field, contextModel) {
     const objectFields = [
-      ts.factory.createPropertyAssignment("type", ts.factory.createStringLiteral(field.type.type ?? field.type.reference.$refText))
+      // name
+      ts.factory.createPropertyAssignment("name", ts.factory.createStringLiteral(field.name)),
+      // type
+      ts.factory.createPropertyAssignment("type", this.generateFieldTypeLiteral(field))
     ];
-    if (isIdField(field)) {
+    if (contextModel && model_utils_exports.isIdField(field, contextModel)) {
       objectFields.push(ts.factory.createPropertyAssignment("id", ts.factory.createTrue()));
     }
     if (isUniqueField(field)) {
@@ -944,12 +1003,19 @@ var TsSchemaGenerator = class {
     if (hasAttribute(field, "@updatedAt")) {
       objectFields.push(ts.factory.createPropertyAssignment("updatedAt", ts.factory.createTrue()));
     }
+    if (contextModel && // id fields are duplicated in inherited models
+    !isIdField(field, contextModel) && field.$container !== contextModel && isDelegateModel(field.$container)) {
+      objectFields.push(ts.factory.createPropertyAssignment("originModel", ts.factory.createStringLiteral(field.$container.name)));
+    }
+    if (this.isDiscriminatorField(field)) {
+      objectFields.push(ts.factory.createPropertyAssignment("isDiscriminator", ts.factory.createTrue()));
+    }
     if (field.attributes.length > 0) {
       objectFields.push(ts.factory.createPropertyAssignment("attributes", ts.factory.createArrayLiteralExpression(field.attributes.map((attr) => this.createAttributeObject(attr)))));
     }
-    const defaultValue = this.getMappedDefault(field);
+    const defaultValue = this.getFieldMappedDefault(field);
     if (defaultValue !== void 0) {
-      if (typeof defaultValue === "object") {
+      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, [
             ts.factory.createStringLiteral(defaultValue.call),
@@ -968,7 +1034,11 @@ var TsSchemaGenerator = class {
           throw new Error(`Unsupported default value type for field ${field.name}`);
         }
       } else {
-        objectFields.push(ts.factory.createPropertyAssignment("default", typeof defaultValue === "string" ? ts.factory.createStringLiteral(defaultValue) : typeof defaultValue === "number" ? ts.factory.createNumericLiteral(defaultValue) : defaultValue === true ? ts.factory.createTrue() : ts.factory.createFalse()));
+        if (Array.isArray(defaultValue)) {
+          objectFields.push(ts.factory.createPropertyAssignment("default", ts.factory.createArrayLiteralExpression(defaultValue.map((item) => this.createLiteralNode(item)))));
+        } else {
+          objectFields.push(ts.factory.createPropertyAssignment("default", this.createLiteralNode(defaultValue)));
+        }
       }
     }
     if (hasAttribute(field, "@computed")) {
@@ -983,60 +1053,53 @@ var TsSchemaGenerator = class {
     }
     return ts.factory.createObjectLiteralExpression(objectFields, true);
   }
+  isDiscriminatorField(field) {
+    const origin = field.$container;
+    return getAttribute(origin, "@@delegate")?.args.some((arg) => arg.$resolvedParam.name === "discriminator" && (0, import_utils3.isDataFieldReference)(arg.value) && arg.value.target.ref === field);
+  }
   getDataSourceProvider(model) {
     const dataSource = model.declarations.find(import_ast3.isDataSource);
-    (0, import_tiny_invariant.default)(dataSource, "No data source found in the model");
+    (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_tiny_invariant.default)((0, import_ast3.isLiteralExpr)(providerExpr), "Provider must be a literal");
+    (0, import_common_helpers2.invariant)((0, import_ast3.isLiteralExpr)(providerExpr), "Provider must be a literal");
     const type = providerExpr.value;
-    const urlExpr = dataSource.fields.find((f) => f.name === "url")?.value;
-    (0, import_tiny_invariant.default)((0, import_ast3.isLiteralExpr)(urlExpr) || (0, import_ast3.isInvocationExpr)(urlExpr), "URL must be a literal or env function");
-    if ((0, import_ast3.isLiteralExpr)(urlExpr)) {
-      return {
-        type,
-        url: urlExpr.value,
-        env: void 0
-      };
-    } else if ((0, import_ast3.isInvocationExpr)(urlExpr)) {
-      (0, import_tiny_invariant.default)(urlExpr.function.$refText === "env", 'only "env" function is supported');
-      (0, import_tiny_invariant.default)(urlExpr.args.length === 1, "env function must have one argument");
-      return {
-        type,
-        env: urlExpr.args[0].value.value,
-        url: void 0
-      };
-    } else {
-      throw new Error("Unsupported URL type");
-    }
+    return {
+      type
+    };
   }
-  getMappedDefault(field) {
+  getFieldMappedDefault(field) {
     const defaultAttr = getAttribute(field, "@default");
     if (!defaultAttr) {
       return void 0;
     }
     const defaultValue = defaultAttr.args[0]?.value;
-    (0, import_tiny_invariant.default)(defaultValue, "Expected a default value");
-    if ((0, import_ast3.isLiteralExpr)(defaultValue)) {
-      const lit = defaultValue.value;
-      return field.type.type === "Boolean" ? lit : [
+    (0, import_common_helpers2.invariant)(defaultValue, "Expected a default value");
+    return this.getMappedValue(defaultValue, field.type);
+  }
+  getMappedValue(expr, fieldType) {
+    if ((0, import_ast3.isLiteralExpr)(expr)) {
+      const lit = expr.value;
+      return fieldType.type === "Boolean" ? lit : [
         "Int",
         "Float",
         "Decimal",
         "BigInt"
-      ].includes(field.type.type) ? Number(lit) : lit;
-    } else if ((0, import_ast3.isReferenceExpr)(defaultValue) && (0, import_ast3.isEnumField)(defaultValue.target.ref)) {
-      return defaultValue.target.ref.name;
-    } else if ((0, import_ast3.isInvocationExpr)(defaultValue)) {
+      ].includes(fieldType.type) ? Number(lit) : lit;
+    } else if ((0, import_ast3.isArrayExpr)(expr)) {
+      return expr.items.map((item) => this.getMappedValue(item, fieldType));
+    } else if ((0, import_ast3.isReferenceExpr)(expr) && (0, import_ast3.isEnumField)(expr.target.ref)) {
+      return expr.target.ref.name;
+    } else if ((0, import_ast3.isInvocationExpr)(expr)) {
       return {
-        call: defaultValue.function.$refText,
-        args: defaultValue.args.map((arg) => this.getLiteral(arg.value))
+        call: expr.function.$refText,
+        args: expr.args.map((arg) => this.getLiteral(arg.value))
       };
-    } else if (this.isAuthMemberAccess(defaultValue)) {
+    } else if (this.isAuthMemberAccess(expr)) {
       return {
-        authMember: this.getMemberAccessChain(defaultValue)
+        authMember: this.getMemberAccessChain(expr)
       };
     } else {
-      throw new Error(`Unsupported default value type for field ${field.name}`);
+      throw new Error(`Unsupported default value type for ${expr.$type}`);
     }
   }
   getMemberAccessChain(expr) {
@@ -1135,40 +1198,45 @@ var TsSchemaGenerator = class {
     if (relation) {
       const nameArg = relation.args.find((arg) => arg.$resolvedParam.name === "name");
       if (nameArg) {
-        (0, import_tiny_invariant.default)((0, import_ast3.isLiteralExpr)(nameArg.value), "name must be a literal");
+        (0, import_common_helpers2.invariant)((0, import_ast3.isLiteralExpr)(nameArg.value), "name must be a literal");
         return nameArg.value.value;
       }
     }
     return void 0;
   }
-  getIdFields(dm) {
-    return dm.fields.filter(isIdField).map((f) => f.name);
-  }
   createUniqueFieldsObject(dm) {
     const properties = [];
-    for (const field of dm.fields) {
+    const allFields = (0, import_utils3.getAllFields)(dm);
+    for (const field of allFields) {
       if (hasAttribute(field, "@id") || hasAttribute(field, "@unique")) {
         properties.push(ts.factory.createPropertyAssignment(field.name, ts.factory.createObjectLiteralExpression([
-          ts.factory.createPropertyAssignment("type", ts.factory.createStringLiteral(field.type.type))
+          ts.factory.createPropertyAssignment("type", this.generateFieldTypeLiteral(field))
         ])));
       }
     }
-    for (const attr of dm.attributes) {
+    const allAttributes = (0, import_utils3.getAllAttributes)(dm);
+    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);
         if (!fieldNames) {
           continue;
         }
         if (fieldNames.length === 1) {
-          const fieldDef = dm.fields.find((f) => f.name === fieldNames[0]);
+          const fieldDef = allFields.find((f) => f.name === fieldNames[0]);
           properties.push(ts.factory.createPropertyAssignment(fieldNames[0], ts.factory.createObjectLiteralExpression([
-            ts.factory.createPropertyAssignment("type", ts.factory.createStringLiteral(fieldDef.type.type))
+            ts.factory.createPropertyAssignment("type", this.generateFieldTypeLiteral(fieldDef))
           ])));
         } else {
+          const key = fieldNames.join("_");
+          if (seenKeys.has(key)) {
+            continue;
+          }
+          seenKeys.add(key);
           properties.push(ts.factory.createPropertyAssignment(fieldNames.join("_"), ts.factory.createObjectLiteralExpression(fieldNames.map((field) => {
-            const fieldDef = dm.fields.find((f) => f.name === field);
+            const fieldDef = allFields.find((f) => f.name === field);
             return ts.factory.createPropertyAssignment(field, ts.factory.createObjectLiteralExpression([
-              ts.factory.createPropertyAssignment("type", ts.factory.createStringLiteral(fieldDef.type.type))
+              ts.factory.createPropertyAssignment("type", this.generateFieldTypeLiteral(fieldDef))
             ]));
           }))));
         }
@@ -1176,6 +1244,10 @@ var TsSchemaGenerator = class {
     }
     return ts.factory.createObjectLiteralExpression(properties, true);
   }
+  generateFieldTypeLiteral(field) {
+    (0, import_common_helpers2.invariant)(field.type.type || field.type.reference || field.type.unsupported, "Field type must be a primitive, reference, or Unsupported");
+    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);
   }
@@ -1230,6 +1302,8 @@ var TsSchemaGenerator = class {
 // This file is automatically generated by ZenStack CLI and should not be manually updated. //
 //////////////////////////////////////////////////////////////////////////////////////////////
 
+/* eslint-disable */
+
 `;
     ts.addSyntheticLeadingComment(statements[0], ts.SyntaxKind.SingleLineCommentTrivia, banner);
   }
@@ -1295,7 +1369,7 @@ var TsSchemaGenerator = class {
     ]);
   }
   createRefExpression(expr) {
-    if ((0, import_ast3.isDataModelField)(expr.target.ref)) {
+    if ((0, import_ast3.isDataField)(expr.target.ref)) {
       return ts.factory.createCallExpression(ts.factory.createIdentifier("ExpressionUtils.field"), void 0, [
         this.createLiteralNode(expr.target.$refText)
       ]);
@@ -1324,6 +1398,150 @@ var TsSchemaGenerator = class {
       throw new Error(`Unsupported literal type: ${type}`);
     });
   }
+  generateModelsAndTypeDefs(model, outputDir) {
+    const statements = [];
+    statements.push(this.generateSchemaImport(model, true, true));
+    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")));
+    const dataModels = model.declarations.filter(import_ast3.isDataModel);
+    for (const dm of dataModels) {
+      let modelType = ts.factory.createTypeAliasDeclaration([
+        ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)
+      ], dm.name, void 0, ts.factory.createTypeReferenceNode("$ModelResult", [
+        ts.factory.createTypeReferenceNode("$Schema"),
+        ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral(dm.name))
+      ]));
+      if (dm.comments.length > 0) {
+        modelType = this.generateDocs(modelType, dm);
+      }
+      statements.push(modelType);
+    }
+    const typeDefs = model.declarations.filter(import_ast3.isTypeDef);
+    for (const td of typeDefs) {
+      let typeDef = ts.factory.createTypeAliasDeclaration([
+        ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)
+      ], td.name, void 0, ts.factory.createTypeReferenceNode("$TypeDefResult", [
+        ts.factory.createTypeReferenceNode("$Schema"),
+        ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral(td.name))
+      ]));
+      if (td.comments.length > 0) {
+        typeDef = this.generateDocs(typeDef, td);
+      }
+      statements.push(typeDef);
+    }
+    const enums = model.declarations.filter(import_ast3.isEnum);
+    for (const e of enums) {
+      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.NodeFlags.Const));
+      if (e.comments.length > 0) {
+        enumDecl = this.generateDocs(enumDecl, e);
+      }
+      statements.push(enumDecl);
+      let typeAlias = ts.factory.createTypeAliasDeclaration([
+        ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)
+      ], e.name, void 0, ts.factory.createIndexedAccessTypeNode(ts.factory.createTypeQueryNode(ts.factory.createIdentifier(e.name)), ts.factory.createTypeOperatorNode(ts.SyntaxKind.KeyOfKeyword, ts.factory.createTypeQueryNode(ts.factory.createIdentifier(e.name)))));
+      if (e.comments.length > 0) {
+        typeAlias = this.generateDocs(typeAlias, e);
+      }
+      statements.push(typeAlias);
+    }
+    this.generateBannerComments(statements);
+    const outputFile = import_node_path.default.join(outputDir, "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) {
+    const importSpecifiers = [];
+    if (schemaObject) {
+      if (model.declarations.some(import_ast3.isEnum)) {
+        importSpecifiers.push(ts.factory.createImportSpecifier(false, ts.factory.createIdentifier("schema"), ts.factory.createIdentifier("$schema")));
+      }
+    }
+    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"));
+  }
+  generateDocs(tsDecl, decl) {
+    return ts.addSyntheticLeadingComment(tsDecl, ts.SyntaxKind.MultiLineCommentTrivia, `*
+ * ${decl.comments.map((c) => c.replace(/^\s*\/*\s*/, "")).join("\n * ")}
+ `, true);
+  }
+  generateInputTypes(model, outputDir) {
+    const dataModels = model.declarations.filter(import_ast3.isDataModel);
+    const statements = [];
+    statements.push(this.generateSchemaImport(model, false, true));
+    const inputTypes = [
+      "FindManyArgs",
+      "FindUniqueArgs",
+      "FindFirstArgs",
+      "CreateArgs",
+      "CreateManyArgs",
+      "CreateManyAndReturnArgs",
+      "UpdateArgs",
+      "UpdateManyArgs",
+      "UpdateManyAndReturnArgs",
+      "UpsertArgs",
+      "DeleteArgs",
+      "DeleteManyArgs",
+      "CountArgs",
+      "AggregateArgs",
+      "GroupByArgs",
+      "WhereInput",
+      "SelectInput",
+      "IncludeInput",
+      "OmitInput"
+    ];
+    const inputTypeNameFixes = {
+      SelectInput: "Select",
+      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([
+      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")));
+    for (const dm of dataModels) {
+      for (const inputType of inputTypes) {
+        const exportName = inputTypeNameFixes[inputType] ? `${dm.name}${inputTypeNameFixes[inputType]}` : `${dm.name}${inputType}`;
+        statements.push(ts.factory.createTypeAliasDeclaration([
+          ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)
+        ], exportName, void 0, ts.factory.createTypeReferenceNode(`$${inputType}`, [
+          ts.factory.createTypeReferenceNode("$Schema"),
+          ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral(dm.name))
+        ])));
+      }
+      statements.push(ts.factory.createTypeAliasDeclaration([
+        ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)
+      ], `${dm.name}GetPayload`, [
+        ts.factory.createTypeParameterDeclaration(void 0, "Args", ts.factory.createTypeReferenceNode("$SelectIncludeOmit", [
+          ts.factory.createTypeReferenceNode("$Schema"),
+          ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral(dm.name)),
+          ts.factory.createLiteralTypeNode(ts.factory.createTrue())
+        ]))
+      ], ts.factory.createTypeReferenceNode("$SimplifiedModelResult", [
+        ts.factory.createTypeReferenceNode("$Schema"),
+        ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral(dm.name)),
+        ts.factory.createTypeReferenceNode("Args")
+      ])));
+    }
+    this.generateBannerComments(statements);
+    const outputFile = import_node_path.default.join(outputDir, "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
@@ -1415,21 +1633,21 @@ ${ast.fields.map((x) => this.indent + this.generate(x)).join("\n")}
     return `${ast.name} = ${this.generate(ast.value)}`;
   }
   _generateDataModel(ast) {
-    return `${ast.isAbstract ? "abstract " : ""}${ast.isView ? "view" : "model"} ${ast.name}${ast.superTypes.length > 0 ? " extends " + ast.superTypes.map((x) => x.ref?.name).join(", ") : ""} {
+    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") : ""}
 }`;
   }
-  _generateDataModelField(ast) {
+  _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 == "DataModelFieldType" && type.unsupported ? "Unsupported(" + this.generate(type.unsupported.value) + ")" : type.reference?.$refText;
+    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);
   }
-  _generateDataModelFieldAttribute(ast) {
+  _generateDataFieldAttribute(ast) {
     return this.attribute(ast);
   }
   attribute(ast) {
@@ -1513,9 +1731,6 @@ ${ast.fields.map((x) => this.indent + this.generate(x)).join("\n")}${ast.attribu
 ${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") : ""}
 }`;
   }
-  _generateTypeDefField(ast) {
-    return `${ast.name} ${this.fieldType(ast.type)}${ast.attributes.length > 0 ? " " + ast.attributes.map((x) => this.generate(x)).join(" ") : ""}`;
-  }
   argument(ast) {
     return this.generate(ast.value);
   }
@@ -1641,13 +1856,13 @@ _ts_decorate([
   _ts_metadata("design:returntype", void 0)
 ], ZModelCodeGenerator.prototype, "_generateDataModel", null);
 _ts_decorate([
-  gen(import_ast4.DataModelField),
+  gen(import_ast4.DataField),
   _ts_metadata("design:type", Function),
   _ts_metadata("design:paramtypes", [
-    typeof import_ast4.DataModelField === "undefined" ? Object : import_ast4.DataModelField
+    typeof import_ast4.DataField === "undefined" ? Object : import_ast4.DataField
   ]),
   _ts_metadata("design:returntype", void 0)
-], ZModelCodeGenerator.prototype, "_generateDataModelField", null);
+], ZModelCodeGenerator.prototype, "_generateDataField", null);
 _ts_decorate([
   gen(import_ast4.DataModelAttribute),
   _ts_metadata("design:type", Function),
@@ -1657,13 +1872,13 @@ _ts_decorate([
   _ts_metadata("design:returntype", void 0)
 ], ZModelCodeGenerator.prototype, "_generateDataModelAttribute", null);
 _ts_decorate([
-  gen(import_ast4.DataModelFieldAttribute),
+  gen(import_ast4.DataFieldAttribute),
   _ts_metadata("design:type", Function),
   _ts_metadata("design:paramtypes", [
-    typeof import_ast4.DataModelFieldAttribute === "undefined" ? Object : import_ast4.DataModelFieldAttribute
+    typeof import_ast4.DataFieldAttribute === "undefined" ? Object : import_ast4.DataFieldAttribute
   ]),
   _ts_metadata("design:returntype", void 0)
-], ZModelCodeGenerator.prototype, "_generateDataModelFieldAttribute", null);
+], ZModelCodeGenerator.prototype, "_generateDataFieldAttribute", null);
 _ts_decorate([
   gen(import_ast4.AttributeArg),
   _ts_metadata("design:type", Function),
@@ -1828,14 +2043,6 @@ _ts_decorate([
   ]),
   _ts_metadata("design:returntype", void 0)
 ], ZModelCodeGenerator.prototype, "_generateTypeDef", null);
-_ts_decorate([
-  gen(import_ast4.TypeDefField),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof import_ast4.TypeDefField === "undefined" ? Object : import_ast4.TypeDefField
-  ]),
-  _ts_metadata("design:returntype", void 0)
-], ZModelCodeGenerator.prototype, "_generateTypeDefField", null);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ModelUtils,