@zenstackhq/sdk 2.16.0 → 3.0.0-alpha.1

package/dist/index.js

@@ -0,0 +1,1872 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/model-utils.ts
+var model_utils_exports = {};
+__export(model_utils_exports, {
+  getAttribute: () => getAttribute,
+  getAuthDecl: () => getAuthDecl,
+  getContainingModel: () => getContainingModel,
+  getModelIdFields: () => getModelIdFields,
+  getModelUniqueFields: () => getModelUniqueFields,
+  getRecursiveBases: () => getRecursiveBases,
+  hasAttribute: () => hasAttribute,
+  isDelegateModel: () => isDelegateModel,
+  isFromStdlib: () => isFromStdlib,
+  isIdField: () => isIdField,
+  isUniqueField: () => isUniqueField,
+  resolved: () => resolved
+});
+import { isArrayExpr, isDataModel, isLiteralExpr, isModel, isReferenceExpr } from "@zenstackhq/language/ast";
+function isIdField(field) {
+  if (hasAttribute(field, "@id")) {
+    return true;
+  }
+  const model = field.$container;
+  const modelLevelIds = getModelIdFields(model);
+  if (modelLevelIds.map((f) => f.name).includes(field.name)) {
+    return true;
+  }
+  if (model.fields.some((f) => hasAttribute(f, "@id")) || modelLevelIds.length > 0) {
+    return false;
+  }
+  const firstUniqueField = model.fields.find((f) => hasAttribute(f, "@unique"));
+  if (firstUniqueField) {
+    return firstUniqueField.name === field.name;
+  }
+  const modelLevelUnique = getModelUniqueFields(model);
+  if (modelLevelUnique.map((f) => f.name).includes(field.name)) {
+    return true;
+  }
+  return false;
+}
+__name(isIdField, "isIdField");
+function hasAttribute(decl, name) {
+  return !!getAttribute(decl, name);
+}
+__name(hasAttribute, "hasAttribute");
+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 || !isArrayExpr(fieldsArg.value)) {
+      continue;
+    }
+    return fieldsArg.value.items.filter((item) => 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 || !isArrayExpr(fieldsArg.value)) {
+      continue;
+    }
+    return fieldsArg.value.items.filter((item) => 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 isDataModel(node) && hasAttribute(node, "@@delegate");
+}
+__name(isDelegateModel, "isDelegateModel");
+function isUniqueField(field) {
+  if (hasAttribute(field, "@unique")) {
+    return true;
+  }
+  const modelIds = getAttribute(field.$container, "@@unique");
+  if (modelIds && modelIds.args.some((arg) => isLiteralExpr(arg.value) && arg.value.value === field.name)) {
+    return true;
+  }
+  return false;
+}
+__name(isUniqueField, "isUniqueField");
+function isFromStdlib(node) {
+  const model = getContainingModel(node);
+  return !!model && !!model.$document && model.$document.uri.path.endsWith("stdlib.zmodel");
+}
+__name(isFromStdlib, "isFromStdlib");
+function getContainingModel(node) {
+  if (!node) {
+    return null;
+  }
+  return isModel(node) ? node : getContainingModel(node.$container);
+}
+__name(getContainingModel, "getContainingModel");
+function resolved(ref) {
+  if (!ref.ref) {
+    throw new Error(`Reference not resolved: ${ref.$refText}`);
+  }
+  return ref.ref;
+}
+__name(resolved, "resolved");
+function getAuthDecl(model) {
+  let found = model.declarations.find((d) => isDataModel(d) && d.attributes.some((attr) => attr.decl.$refText === "@@auth"));
+  if (!found) {
+    found = model.declarations.find((d) => isDataModel(d) && d.name === "User");
+  }
+  return found;
+}
+__name(getAuthDecl, "getAuthDecl");
+
+// src/prisma/prisma-schema-generator.ts
+import { BooleanLiteral, DataModel, DataSource as DataSource2, Enum as Enum2, GeneratorDecl, isArrayExpr as isArrayExpr2, isInvocationExpr, isLiteralExpr as isLiteralExpr2, isModel as isModel2, isNullExpr, isReferenceExpr as isReferenceExpr2, isStringLiteral, isTypeDef, NumberLiteral, StringLiteral } from "@zenstackhq/language/ast";
+import { AstUtils } from "langium";
+import { match, P } from "ts-pattern";
+
+// src/prisma/indent-string.ts
+function indentString(string, count = 4) {
+  const indent = " ";
+  return string.replace(/^(?!\s*$)/gm, indent.repeat(count));
+}
+__name(indentString, "indentString");
+
+// src/prisma/prisma-builder.ts
+var PrismaModel = class {
+  static {
+    __name(this, "PrismaModel");
+  }
+  datasources = [];
+  generators = [];
+  models = [];
+  enums = [];
+  addDataSource(name, fields = []) {
+    const ds = new DataSource(name, fields);
+    this.datasources.push(ds);
+    return ds;
+  }
+  addGenerator(name, fields) {
+    const generator = new Generator(name, fields);
+    this.generators.push(generator);
+    return generator;
+  }
+  addModel(name) {
+    const model = new Model(name, false);
+    this.models.push(model);
+    return model;
+  }
+  addView(name) {
+    const model = new Model(name, true);
+    this.models.push(model);
+    return model;
+  }
+  addEnum(name) {
+    const e = new Enum(name);
+    this.enums.push(e);
+    return e;
+  }
+  toString() {
+    return [
+      ...this.datasources,
+      ...this.generators,
+      ...this.enums,
+      ...this.models
+    ].map((d) => d.toString()).join("\n\n");
+  }
+};
+var DataSource = class {
+  static {
+    __name(this, "DataSource");
+  }
+  name;
+  fields;
+  constructor(name, fields = []) {
+    this.name = name;
+    this.fields = fields;
+  }
+  toString() {
+    return `datasource ${this.name} {
+` + this.fields.map((f) => indentString(`${f.name} = ${f.text}`)).join("\n") + `
+}`;
+  }
+};
+var Generator = class {
+  static {
+    __name(this, "Generator");
+  }
+  name;
+  fields;
+  constructor(name, fields) {
+    this.name = name;
+    this.fields = fields;
+  }
+  toString() {
+    return `generator ${this.name} {
+` + this.fields.map((f) => indentString(`${f.name} = ${f.text}`)).join("\n") + `
+}`;
+  }
+};
+var DeclarationBase = class {
+  static {
+    __name(this, "DeclarationBase");
+  }
+  documentations;
+  constructor(documentations = []) {
+    this.documentations = documentations;
+  }
+  addComment(name) {
+    this.documentations.push(name);
+    return name;
+  }
+  toString() {
+    return this.documentations.map((x) => `${x}
+`).join("");
+  }
+};
+var ContainerDeclaration = class extends DeclarationBase {
+  static {
+    __name(this, "ContainerDeclaration");
+  }
+  attributes;
+  constructor(documentations = [], attributes = []) {
+    super(documentations), this.attributes = attributes;
+  }
+};
+var FieldDeclaration = class extends DeclarationBase {
+  static {
+    __name(this, "FieldDeclaration");
+  }
+  attributes;
+  constructor(documentations = [], attributes = []) {
+    super(documentations), this.attributes = attributes;
+  }
+};
+var Model = class extends ContainerDeclaration {
+  static {
+    __name(this, "Model");
+  }
+  name;
+  isView;
+  fields;
+  constructor(name, isView, documentations = []) {
+    super(documentations), this.name = name, this.isView = isView, this.fields = [];
+  }
+  addField(name, type, attributes = [], documentations = [], addToFront = false) {
+    const field = new ModelField(name, type, attributes, documentations);
+    if (addToFront) {
+      this.fields.unshift(field);
+    } else {
+      this.fields.push(field);
+    }
+    return field;
+  }
+  addAttribute(name, args = []) {
+    const attr = new ContainerAttribute(name, args);
+    this.attributes.push(attr);
+    return attr;
+  }
+  toString() {
+    const result = [
+      ...this.fields
+    ];
+    if (this.attributes.length > 0) {
+      result.push("");
+    }
+    result.push(...this.attributes);
+    return super.toString() + `${this.isView ? "view" : "model"} ${this.name} {
+` + indentString(result.map((d) => d.toString()).join("\n")) + `
+}`;
+  }
+};
+var ModelFieldType = class {
+  static {
+    __name(this, "ModelFieldType");
+  }
+  type;
+  array;
+  optional;
+  constructor(type, array, optional) {
+    this.type = type;
+    this.array = array;
+    this.optional = optional;
+  }
+  toString() {
+    return `${this.type}${this.array ? "[]" : ""}${this.optional ? "?" : ""}`;
+  }
+};
+var ModelField = class extends FieldDeclaration {
+  static {
+    __name(this, "ModelField");
+  }
+  name;
+  type;
+  constructor(name, type, attributes = [], documentations = []) {
+    super(documentations, attributes), this.name = name, this.type = type;
+  }
+  addAttribute(name, args = []) {
+    const attr = new FieldAttribute(name, args);
+    this.attributes.push(attr);
+    return attr;
+  }
+  toString() {
+    return super.toString() + `${this.name} ${this.type}` + (this.attributes.length > 0 ? " " + this.attributes.map((a) => a.toString()).join(" ") : "");
+  }
+};
+var FieldAttribute = class {
+  static {
+    __name(this, "FieldAttribute");
+  }
+  name;
+  args;
+  constructor(name, args = []) {
+    this.name = name;
+    this.args = args;
+  }
+  toString() {
+    return `${this.name}(` + this.args.map((a) => a.toString()).join(", ") + `)`;
+  }
+};
+var ContainerAttribute = class {
+  static {
+    __name(this, "ContainerAttribute");
+  }
+  name;
+  args;
+  constructor(name, args = []) {
+    this.name = name;
+    this.args = args;
+  }
+  toString() {
+    return `${this.name}(` + this.args.map((a) => a.toString()).join(", ") + `)`;
+  }
+};
+var AttributeArg = class {
+  static {
+    __name(this, "AttributeArg");
+  }
+  name;
+  value;
+  constructor(name, value) {
+    this.name = name;
+    this.value = value;
+  }
+  toString() {
+    return this.name ? `${this.name}: ${this.value}` : this.value.toString();
+  }
+};
+var AttributeArgValue = class {
+  static {
+    __name(this, "AttributeArgValue");
+  }
+  type;
+  value;
+  constructor(type, value) {
+    this.type = type;
+    this.value = value;
+    switch (type) {
+      case "String":
+        if (typeof value !== "string") throw new Error("Value must be string");
+        break;
+      case "Number":
+        if (typeof value !== "number" && typeof value !== "string") throw new Error("Value must be number or string");
+        break;
+      case "Boolean":
+        if (typeof value !== "boolean") throw new Error("Value must be boolean");
+        break;
+      case "Array":
+        if (!Array.isArray(value)) throw new Error("Value must be array");
+        break;
+      case "FieldReference":
+        if (typeof value !== "string" && !(value instanceof FieldReference)) throw new Error("Value must be string or FieldReference");
+        break;
+      case "FunctionCall":
+        if (!(value instanceof FunctionCall)) throw new Error("Value must be FunctionCall");
+        break;
+    }
+  }
+  toString() {
+    switch (this.type) {
+      case "String":
+        return JSON.stringify(this.value);
+      case "Number":
+        return this.value.toString();
+      case "FieldReference": {
+        if (typeof this.value === "string") {
+          return this.value;
+        } else {
+          const fr = this.value;
+          let r = fr.field;
+          if (fr.args.length > 0) {
+            r += "(" + fr.args.map((a) => a.toString()).join(",") + ")";
+          }
+          return r;
+        }
+      }
+      case "FunctionCall":
+        return this.value.toString();
+      case "Boolean":
+        return this.value ? "true" : "false";
+      case "Array":
+        return "[" + this.value.map((v) => v.toString()).join(", ") + "]";
+      default:
+        throw new Error(`Unknown attribute value type ${this.type}`);
+    }
+  }
+};
+var FieldReference = class {
+  static {
+    __name(this, "FieldReference");
+  }
+  field;
+  args;
+  constructor(field, args = []) {
+    this.field = field;
+    this.args = args;
+  }
+};
+var FieldReferenceArg = class {
+  static {
+    __name(this, "FieldReferenceArg");
+  }
+  name;
+  value;
+  constructor(name, value) {
+    this.name = name;
+    this.value = value;
+  }
+  toString() {
+    return `${this.name}: ${this.value}`;
+  }
+};
+var FunctionCall = class {
+  static {
+    __name(this, "FunctionCall");
+  }
+  func;
+  args;
+  constructor(func, args = []) {
+    this.func = func;
+    this.args = args;
+  }
+  toString() {
+    return `${this.func}(` + this.args.map((a) => a.toString()).join(", ") + ")";
+  }
+};
+var FunctionCallArg = class {
+  static {
+    __name(this, "FunctionCallArg");
+  }
+  value;
+  constructor(value) {
+    this.value = value;
+  }
+  toString() {
+    return this.value;
+  }
+};
+var Enum = class extends ContainerDeclaration {
+  static {
+    __name(this, "Enum");
+  }
+  name;
+  fields;
+  constructor(name, documentations = []) {
+    super(documentations), this.name = name, this.fields = [];
+  }
+  addField(name, attributes = [], documentations = []) {
+    const field = new EnumField(name, attributes, documentations);
+    this.fields.push(field);
+    return field;
+  }
+  addAttribute(name, args = []) {
+    const attr = new ContainerAttribute(name, args);
+    this.attributes.push(attr);
+    return attr;
+  }
+  addComment(name) {
+    this.documentations.push(name);
+    return name;
+  }
+  toString() {
+    return super.toString() + `enum ${this.name} {
+` + indentString([
+      ...this.fields,
+      ...this.attributes
+    ].map((d) => d.toString()).join("\n")) + "\n}";
+  }
+};
+var EnumField = class extends DeclarationBase {
+  static {
+    __name(this, "EnumField");
+  }
+  name;
+  attributes;
+  constructor(name, attributes = [], documentations = []) {
+    super(documentations), this.name = name, this.attributes = attributes;
+  }
+  addAttribute(name, args = []) {
+    const attr = new FieldAttribute(name, args);
+    this.attributes.push(attr);
+    return attr;
+  }
+  toString() {
+    return super.toString() + this.name + (this.attributes.length > 0 ? " " + this.attributes.map((a) => a.toString()).join(" ") : "");
+  }
+};
+
+// src/prisma/prisma-schema-generator.ts
+var PrismaSchemaGenerator = class {
+  static {
+    __name(this, "PrismaSchemaGenerator");
+  }
+  zmodel;
+  PRELUDE;
+  constructor(zmodel) {
+    this.zmodel = zmodel;
+    this.PRELUDE = `//////////////////////////////////////////////////////////////////////////////////////////////
+// DO NOT MODIFY THIS FILE                                                                  //
+// This file is automatically generated by ZenStack CLI and should not be manually updated. //
+//////////////////////////////////////////////////////////////////////////////////////////////
+
+`;
+  }
+  async generate() {
+    const prisma = new PrismaModel();
+    for (const decl of this.zmodel.declarations) {
+      switch (decl.$type) {
+        case DataSource2:
+          this.generateDataSource(prisma, decl);
+          break;
+        case Enum2:
+          this.generateEnum(prisma, decl);
+          break;
+        case DataModel:
+          this.generateModel(prisma, decl);
+          break;
+        case GeneratorDecl:
+          this.generateGenerator(prisma, decl);
+          break;
+      }
+    }
+    return this.PRELUDE + prisma.toString();
+  }
+  generateDataSource(prisma, dataSource) {
+    const fields = dataSource.fields.map((f) => ({
+      name: f.name,
+      text: this.configExprToText(f.value)
+    }));
+    prisma.addDataSource(dataSource.name, fields);
+  }
+  configExprToText(expr) {
+    if (isLiteralExpr2(expr)) {
+      return this.literalToText(expr);
+    } else if (isInvocationExpr(expr)) {
+      const fc = this.makeFunctionCall(expr);
+      return fc.toString();
+    } else {
+      return this.configArrayToText(expr);
+    }
+  }
+  configArrayToText(expr) {
+    return "[" + expr.items.map((item) => {
+      if (isLiteralExpr2(item)) {
+        return this.literalToText(item);
+      } else {
+        return item.name + (item.args.length > 0 ? "(" + item.args.map((arg) => this.configInvocationArgToText(arg)).join(", ") + ")" : "");
+      }
+    }).join(", ") + "]";
+  }
+  configInvocationArgToText(arg) {
+    return `${arg.name}: ${this.literalToText(arg.value)}`;
+  }
+  literalToText(expr) {
+    return JSON.stringify(expr.value);
+  }
+  generateGenerator(prisma, decl) {
+    prisma.addGenerator(decl.name, decl.fields.map((f) => ({
+      name: f.name,
+      text: this.configExprToText(f.value)
+    })));
+  }
+  generateModel(prisma, decl) {
+    const model = decl.isView ? prisma.addView(decl.name) : prisma.addModel(decl.name);
+    for (const field of decl.fields) {
+      if (model_utils_exports.hasAttribute(field, "@computed")) {
+        continue;
+      }
+      this.generateModelField(model, field);
+    }
+    for (const attr of decl.attributes.filter((attr2) => this.isPrismaAttribute(attr2))) {
+      this.generateContainerAttribute(model, attr);
+    }
+    decl.comments.forEach((c) => model.addComment(c));
+  }
+  isPrismaAttribute(attr) {
+    if (!attr.decl.ref) {
+      return false;
+    }
+    return attr.decl.ref.attributes.some((a) => a.decl.ref?.name === "@@@prisma");
+  }
+  getUnsupportedFieldType(fieldType) {
+    if (fieldType.unsupported) {
+      const value = this.getStringLiteral(fieldType.unsupported.value);
+      if (value) {
+        return `Unsupported("${value}")`;
+      } else {
+        return void 0;
+      }
+    } else {
+      return void 0;
+    }
+  }
+  getStringLiteral(node) {
+    return isStringLiteral(node) ? node.value : void 0;
+  }
+  generateModelField(model, field, addToFront = false) {
+    let fieldType;
+    if (field.type.type) {
+      fieldType = field.type.type;
+    } else if (field.type.reference?.ref) {
+      if (isTypeDef(field.type.reference.ref)) {
+        fieldType = "Json";
+      } else {
+        fieldType = field.type.reference.ref.name;
+      }
+    } else {
+      const unsupported = this.getUnsupportedFieldType(field.type);
+      if (unsupported) {
+        fieldType = unsupported;
+      }
+    }
+    if (!fieldType) {
+      throw new Error(`Field type is not resolved: ${field.$container.name}.${field.name}`);
+    }
+    const isArray = (
+      // typed-JSON fields should be translated to scalar Json type
+      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) => (
+      // 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")
+    )).map((attr) => this.makeFieldAttribute(attr));
+    const docs = [
+      ...field.comments
+    ];
+    const result = model.addField(field.name, type, attributes, docs, addToFront);
+    return result;
+  }
+  isDefaultWithPluginInvocation(attr) {
+    if (attr.decl.ref?.name !== "@default") {
+      return false;
+    }
+    const expr = attr.args[0]?.value;
+    if (!expr) {
+      return false;
+    }
+    return AstUtils.streamAst(expr).some((node) => isInvocationExpr(node) && this.isFromPlugin(node.function.ref));
+  }
+  isFromPlugin(node) {
+    const model = AstUtils.getContainerOfType(node, isModel2);
+    return !!model && !!model.$document && model.$document.uri.path.endsWith("plugin.zmodel");
+  }
+  setDummyDefault(result, field) {
+    const dummyDefaultValue = match(field.type.type).with("String", () => new AttributeArgValue("String", "")).with(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);
+  }
+  makeFieldAttribute(attr) {
+    const attrName = attr.decl.ref.name;
+    return new FieldAttribute(attrName, attr.args.map((arg) => this.makeAttributeArg(arg)));
+  }
+  makeAttributeArg(arg) {
+    return new AttributeArg(arg.name, this.makeAttributeArgValue(arg.value));
+  }
+  makeAttributeArgValue(node) {
+    if (isLiteralExpr2(node)) {
+      const argType = match(node.$type).with(StringLiteral, () => "String").with(NumberLiteral, () => "Number").with(BooleanLiteral, () => "Boolean").exhaustive();
+      return new AttributeArgValue(argType, node.value);
+    } else if (isArrayExpr2(node)) {
+      return new AttributeArgValue("Array", new Array(...node.items.map((item) => this.makeAttributeArgValue(item))));
+    } else if (isReferenceExpr2(node)) {
+      return new AttributeArgValue("FieldReference", new FieldReference(node.target.ref.name, node.args.map((arg) => new FieldReferenceArg(arg.name, this.exprToText(arg.value)))));
+    } else if (isInvocationExpr(node)) {
+      return new AttributeArgValue("FunctionCall", this.makeFunctionCall(node));
+    } else {
+      throw Error(`Unsupported attribute argument expression type: ${node.$type}`);
+    }
+  }
+  exprToText(expr) {
+    return new ZModelCodeGenerator({
+      quote: "double"
+    }).generate(expr);
+  }
+  makeFunctionCall(node) {
+    return new FunctionCall(node.function.ref.name, node.args.map((arg) => {
+      const val = match(arg.value).when(isStringLiteral, (v) => `"${v.value}"`).when(isLiteralExpr2, (v) => v.value.toString()).when(isNullExpr, () => "null").otherwise(() => {
+        throw new Error("Function call argument must be literal or null");
+      });
+      return new FunctionCallArg(val);
+    }));
+  }
+  generateContainerAttribute(container, attr) {
+    const attrName = attr.decl.ref.name;
+    container.attributes.push(new ContainerAttribute(attrName, attr.args.map((arg) => this.makeAttributeArg(arg))));
+  }
+  generateEnum(prisma, decl) {
+    const _enum = prisma.addEnum(decl.name);
+    for (const field of decl.fields) {
+      this.generateEnumField(_enum, field);
+    }
+    for (const attr of decl.attributes.filter((attr2) => this.isPrismaAttribute(attr2))) {
+      this.generateContainerAttribute(_enum, attr);
+    }
+    decl.comments.forEach((c) => _enum.addComment(c));
+  }
+  generateEnumField(_enum, field) {
+    const attributes = field.attributes.filter((attr) => this.isPrismaAttribute(attr)).map((attr) => this.makeFieldAttribute(attr));
+    const docs = [
+      ...field.comments
+    ];
+    _enum.addField(field.name, attributes, docs);
+  }
+};
+
+// src/ts-schema-generator.ts
+import { loadDocument } from "@zenstackhq/language";
+import { isArrayExpr as isArrayExpr3, isBinaryExpr, isDataModel as isDataModel2, isDataModelField, isDataSource, isEnum, isEnumField, isInvocationExpr as isInvocationExpr2, isLiteralExpr as isLiteralExpr3, isMemberAccessExpr, isNullExpr as isNullExpr2, isProcedure, isReferenceExpr as isReferenceExpr3, isThisExpr, isUnaryExpr } from "@zenstackhq/language/ast";
+import fs from "node:fs";
+import path from "node:path";
+import invariant from "tiny-invariant";
+import { match as match2 } from "ts-pattern";
+import * as ts from "typescript";
+var TsSchemaGenerator = class {
+  static {
+    __name(this, "TsSchemaGenerator");
+  }
+  async generate(schemaFile, pluginModelFiles, outputFile) {
+    const loaded = await loadDocument(schemaFile, pluginModelFiles);
+    if (!loaded.success) {
+      throw new Error(`Error loading schema:${loaded.errors.join("\n")}`);
+    }
+    const { model, warnings } = loaded;
+    const statements = [];
+    this.generateSchemaStatements(model, statements);
+    this.generateBannerComments(statements);
+    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);
+    fs.mkdirSync(path.dirname(outputFile), {
+      recursive: true
+    });
+    fs.writeFileSync(outputFile, result);
+    return {
+      model,
+      warnings
+    };
+  }
+  generateSchemaStatements(model, statements) {
+    const hasComputedFields = model.declarations.some((d) => isDataModel2(d) && d.fields.some((f) => hasAttribute(f, "@computed")));
+    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"));
+    statements.push(runtimeImportDecl);
+    const { type: providerType } = this.getDataSourceProvider(model);
+    switch (providerType) {
+      case "sqlite": {
+        const pathImportDecl = ts.factory.createImportDeclaration(void 0, ts.factory.createImportClause(false, ts.factory.createIdentifier("path"), void 0), ts.factory.createStringLiteral("node:path"));
+        statements.push(pathImportDecl);
+        const urlImportDecl = ts.factory.createImportDeclaration(void 0, ts.factory.createImportClause(false, ts.factory.createIdentifier("url"), void 0), ts.factory.createStringLiteral("node:url"));
+        statements.push(urlImportDecl);
+        const dialectConfigImportDecl = ts.factory.createImportDeclaration(void 0, ts.factory.createImportClause(false, void 0, ts.factory.createNamedImports([
+          ts.factory.createImportSpecifier(false, void 0, ts.factory.createIdentifier("toDialectConfig"))
+        ])), ts.factory.createStringLiteral("@zenstackhq/runtime/utils/sqlite-utils"));
+        statements.push(dialectConfigImportDecl);
+        break;
+      }
+      case "postgresql": {
+        const dialectConfigImportDecl = ts.factory.createImportDeclaration(void 0, ts.factory.createImportClause(false, void 0, ts.factory.createNamedImports([
+          ts.factory.createImportSpecifier(false, void 0, ts.factory.createIdentifier("toDialectConfig"))
+        ])), ts.factory.createStringLiteral("@zenstackhq/runtime/utils/pg-utils"));
+        statements.push(dialectConfigImportDecl);
+        break;
+      }
+    }
+    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.NodeFlags.Const));
+    statements.push(declaration);
+    const typeDeclaration = ts.factory.createTypeAliasDeclaration([
+      ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)
+    ], "SchemaType", void 0, ts.factory.createTypeReferenceNode("typeof schema"));
+    statements.push(typeDeclaration);
+  }
+  createSchemaObject(model) {
+    const properties = [
+      // provider
+      ts.factory.createPropertyAssignment("provider", this.createProviderObject(model)),
+      // models
+      ts.factory.createPropertyAssignment("models", this.createModelsObject(model))
+    ];
+    const enums = model.declarations.filter(isEnum);
+    if (enums.length > 0) {
+      properties.push(ts.factory.createPropertyAssignment("enums", ts.factory.createObjectLiteralExpression(enums.map((e) => ts.factory.createPropertyAssignment(e.name, this.createEnumObject(e))), true)));
+    }
+    const authType = getAuthDecl(model);
+    if (authType) {
+      properties.push(ts.factory.createPropertyAssignment("authType", this.createLiteralNode(authType.name)));
+    }
+    const procedures = model.declarations.filter(isProcedure);
+    if (procedures.length > 0) {
+      properties.push(ts.factory.createPropertyAssignment("procedures", this.createProceduresObject(procedures)));
+    }
+    properties.push(ts.factory.createPropertyAssignment("plugins", ts.factory.createObjectLiteralExpression([], true)));
+    return ts.factory.createObjectLiteralExpression(properties, true);
+  }
+  createProviderObject(model) {
+    const dsProvider = this.getDataSourceProvider(model);
+    return ts.factory.createObjectLiteralExpression([
+      ts.factory.createPropertyAssignment("type", ts.factory.createStringLiteral(dsProvider.type)),
+      ts.factory.createPropertyAssignment("dialectConfigProvider", this.createDialectConfigProvider(dsProvider))
+    ], true);
+  }
+  createModelsObject(model) {
+    return ts.factory.createObjectLiteralExpression(model.declarations.filter((d) => isDataModel2(d) && !hasAttribute(d, "@@ignore")).map((dm) => ts.factory.createPropertyAssignment(dm.name, this.createDataModelObject(dm))), true);
+  }
+  createDataModelObject(dm) {
+    const fields = [
+      // 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)),
+      // attributes
+      ...dm.attributes.length > 0 ? [
+        ts.factory.createPropertyAssignment("attributes", ts.factory.createArrayLiteralExpression(dm.attributes.map((attr) => this.createAttributeObject(attr)), true))
+      ] : [],
+      // idFields
+      ts.factory.createPropertyAssignment("idFields", ts.factory.createArrayLiteralExpression(this.getIdFields(dm).map((idField) => ts.factory.createStringLiteral(idField)))),
+      // uniqueFields
+      ts.factory.createPropertyAssignment("uniqueFields", this.createUniqueFieldsObject(dm))
+    ];
+    const computedFields = dm.fields.filter((f) => hasAttribute(f, "@computed"));
+    if (computedFields.length > 0) {
+      fields.push(ts.factory.createPropertyAssignment("computedFields", this.createComputedFieldsObject(computedFields)));
+    }
+    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))
+    ]), 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 match2(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);
+  }
+  createDataModelFieldObject(field) {
+    const objectFields = [
+      ts.factory.createPropertyAssignment("type", ts.factory.createStringLiteral(field.type.type ?? field.type.reference.$refText))
+    ];
+    if (isIdField(field)) {
+      objectFields.push(ts.factory.createPropertyAssignment("id", ts.factory.createTrue()));
+    }
+    if (isUniqueField(field)) {
+      objectFields.push(ts.factory.createPropertyAssignment("unique", ts.factory.createTrue()));
+    }
+    if (field.type.optional) {
+      objectFields.push(ts.factory.createPropertyAssignment("optional", ts.factory.createTrue()));
+    }
+    if (field.type.array) {
+      objectFields.push(ts.factory.createPropertyAssignment("array", ts.factory.createTrue()));
+    }
+    if (hasAttribute(field, "@updatedAt")) {
+      objectFields.push(ts.factory.createPropertyAssignment("updatedAt", 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);
+    if (defaultValue !== void 0) {
+      if (typeof defaultValue === "object") {
+        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),
+            ...defaultValue.args.length > 0 ? [
+              ts.factory.createArrayLiteralExpression(defaultValue.args.map((arg) => 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, [
+              ts.factory.createStringLiteral("auth")
+            ]),
+            ts.factory.createArrayLiteralExpression(defaultValue.authMember.map((m) => ts.factory.createStringLiteral(m)))
+          ])));
+        } else {
+          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 (hasAttribute(field, "@computed")) {
+      objectFields.push(ts.factory.createPropertyAssignment("computed", ts.factory.createTrue()));
+    }
+    if (isDataModel2(field.type.reference?.ref)) {
+      objectFields.push(ts.factory.createPropertyAssignment("relation", this.createRelationObject(field)));
+    }
+    const fkFor = this.getForeignKeyFor(field);
+    if (fkFor && fkFor.length > 0) {
+      objectFields.push(ts.factory.createPropertyAssignment("foreignKeyFor", ts.factory.createArrayLiteralExpression(fkFor.map((fk) => ts.factory.createStringLiteral(fk)), true)));
+    }
+    return ts.factory.createObjectLiteralExpression(objectFields, true);
+  }
+  getDataSourceProvider(model) {
+    const dataSource = model.declarations.find(isDataSource);
+    invariant(dataSource, "No data source found in the model");
+    const providerExpr = dataSource.fields.find((f) => f.name === "provider")?.value;
+    invariant(isLiteralExpr3(providerExpr), "Provider must be a literal");
+    const type = providerExpr.value;
+    const urlExpr = dataSource.fields.find((f) => f.name === "url")?.value;
+    invariant(isLiteralExpr3(urlExpr) || isInvocationExpr2(urlExpr), "URL must be a literal or env function");
+    if (isLiteralExpr3(urlExpr)) {
+      return {
+        type,
+        url: urlExpr.value,
+        env: void 0
+      };
+    } else if (isInvocationExpr2(urlExpr)) {
+      invariant(urlExpr.function.$refText === "env", 'only "env" function is supported');
+      invariant(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");
+    }
+  }
+  getMappedDefault(field) {
+    const defaultAttr = getAttribute(field, "@default");
+    if (!defaultAttr) {
+      return void 0;
+    }
+    const defaultValue = defaultAttr.args[0]?.value;
+    invariant(defaultValue, "Expected a default value");
+    if (isLiteralExpr3(defaultValue)) {
+      const lit = defaultValue.value;
+      return field.type.type === "Boolean" ? lit : [
+        "Int",
+        "Float",
+        "Decimal",
+        "BigInt"
+      ].includes(field.type.type) ? Number(lit) : lit;
+    } else if (isReferenceExpr3(defaultValue) && isEnumField(defaultValue.target.ref)) {
+      return defaultValue.target.ref.name;
+    } else if (isInvocationExpr2(defaultValue)) {
+      return {
+        call: defaultValue.function.$refText,
+        args: defaultValue.args.map((arg) => this.getLiteral(arg.value))
+      };
+    } else if (this.isAuthMemberAccess(defaultValue)) {
+      return {
+        authMember: this.getMemberAccessChain(defaultValue)
+      };
+    } else {
+      throw new Error(`Unsupported default value type for field ${field.name}`);
+    }
+  }
+  getMemberAccessChain(expr) {
+    if (!isMemberAccessExpr(expr.operand)) {
+      return [
+        expr.member.$refText
+      ];
+    } else {
+      return [
+        ...this.getMemberAccessChain(expr.operand),
+        expr.member.$refText
+      ];
+    }
+  }
+  isAuthMemberAccess(expr) {
+    if (isMemberAccessExpr(expr)) {
+      return this.isAuthInvocation(expr.operand) || this.isAuthMemberAccess(expr.operand);
+    } else {
+      return false;
+    }
+  }
+  isAuthInvocation(expr) {
+    return isInvocationExpr2(expr) && expr.function.$refText === "auth" && model_utils_exports.isFromStdlib(expr.function.ref);
+  }
+  createRelationObject(field) {
+    const relationFields = [];
+    const oppositeRelation = this.getOppositeRelationField(field);
+    if (oppositeRelation) {
+      relationFields.push(ts.factory.createPropertyAssignment("opposite", ts.factory.createStringLiteral(oppositeRelation.name)));
+    }
+    const relationName = this.getRelationName(field);
+    if (relationName) {
+      relationFields.push(ts.factory.createPropertyAssignment("name", ts.factory.createStringLiteral(relationName)));
+    }
+    const relation = getAttribute(field, "@relation");
+    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) {
+            relationFields.push(ts.factory.createPropertyAssignment(param, ts.factory.createArrayLiteralExpression(fieldNames.map((el) => ts.factory.createStringLiteral(el)))));
+          }
+        }
+        if (param === "onDelete" || param === "onUpdate") {
+          const action = arg.value.target.$refText;
+          relationFields.push(ts.factory.createPropertyAssignment(param, ts.factory.createStringLiteral(action)));
+        }
+      }
+    }
+    return ts.factory.createObjectLiteralExpression(relationFields);
+  }
+  getReferenceNames(expr) {
+    return isArrayExpr3(expr) && expr.items.map((item) => item.target.$refText);
+  }
+  getForeignKeyFor(field) {
+    const result = [];
+    for (const f of field.$container.fields) {
+      const relation = getAttribute(f, "@relation");
+      if (relation) {
+        for (const arg of relation.args) {
+          if (arg.name === "fields" && isArrayExpr3(arg.value) && arg.value.items.some((el) => isReferenceExpr3(el) && el.target.ref === field)) {
+            result.push(f.name);
+          }
+        }
+      }
+    }
+    return result;
+  }
+  getOppositeRelationField(field) {
+    if (!field.type.reference?.ref || !isDataModel2(field.type.reference?.ref)) {
+      return void 0;
+    }
+    const sourceModel = field.$container;
+    const targetModel = field.type.reference.ref;
+    const relationName = this.getRelationName(field);
+    for (const otherField of targetModel.fields) {
+      if (otherField === field) {
+        continue;
+      }
+      if (otherField.type.reference?.ref === sourceModel) {
+        if (relationName) {
+          const otherRelationName = this.getRelationName(otherField);
+          if (otherRelationName === relationName) {
+            return otherField;
+          }
+        } else {
+          return otherField;
+        }
+      }
+    }
+    return void 0;
+  }
+  getRelationName(field) {
+    const relation = getAttribute(field, "@relation");
+    if (relation) {
+      const nameArg = relation.args.find((arg) => arg.$resolvedParam.name === "name");
+      if (nameArg) {
+        invariant(isLiteralExpr3(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) {
+      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))
+        ])));
+      }
+    }
+    for (const attr of dm.attributes) {
+      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]);
+          properties.push(ts.factory.createPropertyAssignment(fieldNames[0], ts.factory.createObjectLiteralExpression([
+            ts.factory.createPropertyAssignment("type", ts.factory.createStringLiteral(fieldDef.type.type))
+          ])));
+        } else {
+          properties.push(ts.factory.createPropertyAssignment(fieldNames.join("_"), ts.factory.createObjectLiteralExpression(fieldNames.map((field) => {
+            const fieldDef = dm.fields.find((f) => f.name === field);
+            return ts.factory.createPropertyAssignment(field, ts.factory.createObjectLiteralExpression([
+              ts.factory.createPropertyAssignment("type", ts.factory.createStringLiteral(fieldDef.type.type))
+            ]));
+          }))));
+        }
+      }
+    }
+    return ts.factory.createObjectLiteralExpression(properties, true);
+  }
+  createEnumObject(e) {
+    return ts.factory.createObjectLiteralExpression(e.fields.map((field) => ts.factory.createPropertyAssignment(field.name, ts.factory.createStringLiteral(field.name))), true);
+  }
+  getLiteral(expr) {
+    if (!isLiteralExpr3(expr)) {
+      throw new Error("Expected a literal expression");
+    }
+    switch (expr?.$type) {
+      case "StringLiteral":
+      case "BooleanLiteral":
+        return expr.value;
+      case "NumberLiteral":
+        return parseFloat(expr.value);
+      default:
+        throw new Error("Unsupported literal type");
+    }
+  }
+  createLiteralNode(arg) {
+    return arg === null ? ts.factory.createNull() : typeof arg === "string" ? ts.factory.createStringLiteral(arg) : typeof arg === "number" ? ts.factory.createNumericLiteral(arg) : arg === true ? ts.factory.createTrue() : arg === false ? ts.factory.createFalse() : void 0;
+  }
+  createDialectConfigProvider(dsProvider) {
+    const type = dsProvider.type;
+    let urlExpr;
+    if (dsProvider.env !== void 0) {
+      urlExpr = ts.factory.createIdentifier(`process.env['${dsProvider.env}']`);
+    } else {
+      urlExpr = ts.factory.createStringLiteral(dsProvider.url);
+      if (type === "sqlite") {
+        let parsedUrl;
+        try {
+          parsedUrl = new URL(dsProvider.url);
+        } catch {
+        }
+        if (parsedUrl) {
+          if (parsedUrl.protocol !== "file:") {
+            throw new Error("Invalid SQLite URL: only file protocol is supported");
+          }
+          urlExpr = ts.factory.createStringLiteral(dsProvider.url.replace(/^file:/, ""));
+        }
+      }
+    }
+    return match2(type).with("sqlite", () => {
+      return ts.factory.createFunctionExpression(void 0, void 0, void 0, void 0, void 0, void 0, ts.factory.createBlock([
+        ts.factory.createReturnStatement(ts.factory.createCallExpression(ts.factory.createIdentifier("toDialectConfig"), void 0, [
+          urlExpr,
+          ts.factory.createIdentifier(`typeof __dirname !== 'undefined' ? __dirname : path.dirname(url.fileURLToPath(import.meta.url))`)
+        ]))
+      ], true));
+    }).with("postgresql", () => {
+      return ts.factory.createFunctionExpression(void 0, void 0, void 0, void 0, void 0, void 0, ts.factory.createBlock([
+        ts.factory.createReturnStatement(ts.factory.createCallExpression(ts.factory.createIdentifier("toDialectConfig"), void 0, [
+          urlExpr
+        ]))
+      ], true));
+    }).otherwise(() => {
+      throw new Error(`Unsupported provider: ${type}`);
+    });
+  }
+  createProceduresObject(procedures) {
+    return ts.factory.createObjectLiteralExpression(procedures.map((proc) => ts.factory.createPropertyAssignment(proc.name, this.createProcedureObject(proc))), true);
+  }
+  createProcedureObject(proc) {
+    const params = ts.factory.createArrayLiteralExpression(proc.params.map((param) => ts.factory.createObjectLiteralExpression([
+      ts.factory.createPropertyAssignment("name", ts.factory.createStringLiteral(param.name)),
+      ...param.optional ? [
+        ts.factory.createPropertyAssignment("optional", ts.factory.createTrue())
+      ] : [],
+      ts.factory.createPropertyAssignment("type", ts.factory.createStringLiteral(param.type.type ?? param.type.reference.$refText))
+    ])), true);
+    const paramsType = ts.factory.createTupleTypeNode([
+      ...proc.params.map((param) => ts.factory.createNamedTupleMember(void 0, ts.factory.createIdentifier(param.name), void 0, ts.factory.createTypeLiteralNode([
+        ts.factory.createPropertySignature(void 0, ts.factory.createStringLiteral("name"), void 0, ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral(param.name))),
+        ts.factory.createPropertySignature(void 0, ts.factory.createStringLiteral("type"), void 0, ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral(param.type.type ?? param.type.reference.$refText))),
+        ...param.optional ? [
+          ts.factory.createPropertySignature(void 0, ts.factory.createStringLiteral("optional"), void 0, ts.factory.createLiteralTypeNode(ts.factory.createTrue()))
+        ] : []
+      ])))
+    ]);
+    return ts.factory.createObjectLiteralExpression([
+      ts.factory.createPropertyAssignment("params", ts.factory.createAsExpression(params, paramsType)),
+      ts.factory.createPropertyAssignment("returnType", ts.factory.createStringLiteral(proc.returnType.type ?? proc.returnType.reference.$refText)),
+      ...proc.mutation ? [
+        ts.factory.createPropertyAssignment("mutation", ts.factory.createTrue())
+      ] : []
+    ], true);
+  }
+  generateBannerComments(statements) {
+    const banner = `////////////////////////////////////////////////////////////////////////////////////////////
+// DO NOT MODIFY THIS FILE                                                                  //
+// This file is automatically generated by ZenStack CLI and should not be manually updated. //
+//////////////////////////////////////////////////////////////////////////////////////////////
+
+`;
+    ts.addSyntheticLeadingComment(statements[0], ts.SyntaxKind.SingleLineCommentTrivia, banner);
+  }
+  createAttributeObject(attr) {
+    return ts.factory.createObjectLiteralExpression([
+      ts.factory.createPropertyAssignment("name", ts.factory.createStringLiteral(attr.decl.$refText)),
+      ...attr.args.length > 0 ? [
+        ts.factory.createPropertyAssignment("args", ts.factory.createArrayLiteralExpression(attr.args.map((arg) => this.createAttributeArg(arg))))
+      ] : []
+    ]);
+  }
+  createAttributeArg(arg) {
+    return ts.factory.createObjectLiteralExpression([
+      // name
+      ...arg.$resolvedParam?.name ? [
+        ts.factory.createPropertyAssignment("name", ts.factory.createStringLiteral(arg.$resolvedParam.name))
+      ] : [],
+      // value
+      ts.factory.createPropertyAssignment("value", this.createExpression(arg.value))
+    ]);
+  }
+  createExpression(value) {
+    return match2(value).when(isLiteralExpr3, (expr) => this.createLiteralExpression(expr.$type, expr.value)).when(isInvocationExpr2, (expr) => this.createCallExpression(expr)).when(isReferenceExpr3, (expr) => this.createRefExpression(expr)).when(isArrayExpr3, (expr) => this.createArrayExpression(expr)).when(isUnaryExpr, (expr) => this.createUnaryExpression(expr)).when(isBinaryExpr, (expr) => this.createBinaryExpression(expr)).when(isMemberAccessExpr, (expr) => this.createMemberExpression(expr)).when(isNullExpr2, () => this.createNullExpression()).when(isThisExpr, () => this.createThisExpression()).otherwise(() => {
+      throw new Error(`Unsupported attribute arg value: ${value.$type}`);
+    });
+  }
+  createThisExpression() {
+    return ts.factory.createCallExpression(ts.factory.createIdentifier("ExpressionUtils._this"), void 0, []);
+  }
+  createMemberExpression(expr) {
+    const members = [];
+    let current = expr;
+    while (isMemberAccessExpr(current)) {
+      members.unshift(current.member.$refText);
+      current = current.operand;
+    }
+    const receiver = current;
+    const args = [
+      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);
+  }
+  createNullExpression() {
+    return ts.factory.createCallExpression(ts.factory.createIdentifier("ExpressionUtils._null"), void 0, []);
+  }
+  createBinaryExpression(expr) {
+    return ts.factory.createCallExpression(ts.factory.createIdentifier("ExpressionUtils.binary"), void 0, [
+      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, [
+      this.createLiteralNode(expr.operator),
+      this.createExpression(expr.operand)
+    ]);
+  }
+  createArrayExpression(expr) {
+    return ts.factory.createCallExpression(ts.factory.createIdentifier("ExpressionUtils.array"), void 0, [
+      ts.factory.createArrayLiteralExpression(expr.items.map((item) => this.createExpression(item)))
+    ]);
+  }
+  createRefExpression(expr) {
+    if (isDataModelField(expr.target.ref)) {
+      return ts.factory.createCallExpression(ts.factory.createIdentifier("ExpressionUtils.field"), void 0, [
+        this.createLiteralNode(expr.target.$refText)
+      ]);
+    } else if (isEnumField(expr.target.ref)) {
+      return this.createLiteralExpression("StringLiteral", expr.target.$refText);
+    } else {
+      throw new Error(`Unsupported reference type: ${expr.target.$refText}`);
+    }
+  }
+  createCallExpression(expr) {
+    return ts.factory.createCallExpression(ts.factory.createIdentifier("ExpressionUtils.call"), void 0, [
+      ts.factory.createStringLiteral(expr.function.$refText),
+      ...expr.args.length > 0 ? [
+        ts.factory.createArrayLiteralExpression(expr.args.map((arg) => this.createExpression(arg.value)))
+      ] : []
+    ]);
+  }
+  createLiteralExpression(type, value) {
+    return match2(type).with("BooleanLiteral", () => ts.factory.createCallExpression(ts.factory.createIdentifier("ExpressionUtils.literal"), void 0, [
+      this.createLiteralNode(value)
+    ])).with("NumberLiteral", () => ts.factory.createCallExpression(ts.factory.createIdentifier("ExpressionUtils.literal"), void 0, [
+      ts.factory.createIdentifier(value)
+    ])).with("StringLiteral", () => ts.factory.createCallExpression(ts.factory.createIdentifier("ExpressionUtils.literal"), void 0, [
+      this.createLiteralNode(value)
+    ])).otherwise(() => {
+      throw new Error(`Unsupported literal type: ${type}`);
+    });
+  }
+};
+
+// src/zmodel-code-generator.ts
+import { ArrayExpr, Attribute, AttributeArg as AttributeArg2, AttributeParam, AttributeParamType, BinaryExpr, BinaryExprOperatorPriority, BooleanLiteral as BooleanLiteral2, ConfigArrayExpr, ConfigField, ConfigInvocationExpr, DataModel as DataModel2, DataModelAttribute, DataModelField, DataModelFieldAttribute, DataSource as DataSource3, Enum as Enum3, EnumField as EnumField2, FunctionDecl, FunctionParam, FunctionParamType, GeneratorDecl as GeneratorDecl2, InvocationExpr, LiteralExpr, MemberAccessExpr, Model as Model2, NullExpr, NumberLiteral as NumberLiteral2, ObjectExpr, Plugin, PluginField, ReferenceArg, ReferenceExpr, StringLiteral as StringLiteral2, ThisExpr, TypeDef, TypeDefField, UnaryExpr } from "@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.isAbstract ? "abstract " : ""}${ast.isView ? "view" : "model"} ${ast.name}${ast.superTypes.length > 0 ? " extends " + ast.superTypes.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) {
+    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;
+    return `${baseType}${type.array ? "[]" : ""}${type.optional ? "?" : ""}`;
+  }
+  _generateDataModelAttribute(ast) {
+    return this.attribute(ast);
+  }
+  _generateDataModelFieldAttribute(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") : ""}
+}`;
+  }
+  _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);
+  }
+  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 = BinaryExprOperatorPriority[operator];
+    if (ast.left.$type === BinaryExpr && BinaryExprOperatorPriority[ast.left["operator"]] < currentPriority) {
+      result.left = true;
+    }
+    if (!isCollectionPredicate && ast.right.$type === BinaryExpr && BinaryExprOperatorPriority[ast.right["operator"]] <= currentPriority) {
+      result.right = true;
+    }
+    return result;
+  }
+  isCollectionPredicateOperator(op) {
+    return [
+      "?",
+      "!",
+      "^"
+    ].includes(op);
+  }
+};
+_ts_decorate([
+  gen(Model2),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof Model2 === "undefined" ? Object : Model2
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateModel", null);
+_ts_decorate([
+  gen(DataSource3),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof DataSource3 === "undefined" ? Object : DataSource3
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateDataSource", null);
+_ts_decorate([
+  gen(Enum3),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof Enum3 === "undefined" ? Object : Enum3
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateEnum", null);
+_ts_decorate([
+  gen(EnumField2),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof EnumField2 === "undefined" ? Object : EnumField2
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateEnumField", null);
+_ts_decorate([
+  gen(GeneratorDecl2),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof GeneratorDecl2 === "undefined" ? Object : GeneratorDecl2
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateGenerator", null);
+_ts_decorate([
+  gen(ConfigField),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof ConfigField === "undefined" ? Object : ConfigField
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateConfigField", null);
+_ts_decorate([
+  gen(ConfigArrayExpr),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof ConfigArrayExpr === "undefined" ? Object : ConfigArrayExpr
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateConfigArrayExpr", null);
+_ts_decorate([
+  gen(ConfigInvocationExpr),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof ConfigInvocationExpr === "undefined" ? Object : ConfigInvocationExpr
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateConfigInvocationExpr", null);
+_ts_decorate([
+  gen(Plugin),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof Plugin === "undefined" ? Object : Plugin
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generatePlugin", null);
+_ts_decorate([
+  gen(PluginField),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof PluginField === "undefined" ? Object : PluginField
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generatePluginField", null);
+_ts_decorate([
+  gen(DataModel2),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof DataModel2 === "undefined" ? Object : DataModel2
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateDataModel", null);
+_ts_decorate([
+  gen(DataModelField),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof DataModelField === "undefined" ? Object : DataModelField
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateDataModelField", null);
+_ts_decorate([
+  gen(DataModelAttribute),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof DataModelAttribute === "undefined" ? Object : DataModelAttribute
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateDataModelAttribute", null);
+_ts_decorate([
+  gen(DataModelFieldAttribute),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof DataModelFieldAttribute === "undefined" ? Object : DataModelFieldAttribute
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateDataModelFieldAttribute", null);
+_ts_decorate([
+  gen(AttributeArg2),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof AttributeArg2 === "undefined" ? Object : AttributeArg2
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateAttributeArg", null);
+_ts_decorate([
+  gen(ObjectExpr),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof ObjectExpr === "undefined" ? Object : ObjectExpr
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateObjectExpr", null);
+_ts_decorate([
+  gen(ArrayExpr),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof ArrayExpr === "undefined" ? Object : ArrayExpr
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateArrayExpr", null);
+_ts_decorate([
+  gen(StringLiteral2),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof LiteralExpr === "undefined" ? Object : LiteralExpr
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateLiteralExpr", null);
+_ts_decorate([
+  gen(NumberLiteral2),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof NumberLiteral2 === "undefined" ? Object : NumberLiteral2
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateNumberLiteral", null);
+_ts_decorate([
+  gen(BooleanLiteral2),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof BooleanLiteral2 === "undefined" ? Object : BooleanLiteral2
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateBooleanLiteral", null);
+_ts_decorate([
+  gen(UnaryExpr),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof UnaryExpr === "undefined" ? Object : UnaryExpr
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateUnaryExpr", null);
+_ts_decorate([
+  gen(BinaryExpr),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof BinaryExpr === "undefined" ? Object : BinaryExpr
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateBinaryExpr", null);
+_ts_decorate([
+  gen(ReferenceExpr),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof ReferenceExpr === "undefined" ? Object : ReferenceExpr
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateReferenceExpr", null);
+_ts_decorate([
+  gen(ReferenceArg),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof ReferenceArg === "undefined" ? Object : ReferenceArg
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateReferenceArg", null);
+_ts_decorate([
+  gen(MemberAccessExpr),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof MemberAccessExpr === "undefined" ? Object : MemberAccessExpr
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateMemberExpr", null);
+_ts_decorate([
+  gen(InvocationExpr),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof InvocationExpr === "undefined" ? Object : InvocationExpr
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateInvocationExpr", null);
+_ts_decorate([
+  gen(NullExpr),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", []),
+  _ts_metadata("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateNullExpr", null);
+_ts_decorate([
+  gen(ThisExpr),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", []),
+  _ts_metadata("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateThisExpr", null);
+_ts_decorate([
+  gen(Attribute),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof Attribute === "undefined" ? Object : Attribute
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateAttribute", null);
+_ts_decorate([
+  gen(AttributeParam),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof AttributeParam === "undefined" ? Object : AttributeParam
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateAttributeParam", null);
+_ts_decorate([
+  gen(AttributeParamType),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof AttributeParamType === "undefined" ? Object : AttributeParamType
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateAttributeParamType", null);
+_ts_decorate([
+  gen(FunctionDecl),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof FunctionDecl === "undefined" ? Object : FunctionDecl
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateFunctionDecl", null);
+_ts_decorate([
+  gen(FunctionParam),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof FunctionParam === "undefined" ? Object : FunctionParam
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateFunctionParam", null);
+_ts_decorate([
+  gen(FunctionParamType),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof FunctionParamType === "undefined" ? Object : FunctionParamType
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateFunctionParamType", null);
+_ts_decorate([
+  gen(TypeDef),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof TypeDef === "undefined" ? Object : TypeDef
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateTypeDef", null);
+_ts_decorate([
+  gen(TypeDefField),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof TypeDefField === "undefined" ? Object : TypeDefField
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateTypeDefField", null);
+export {
+  model_utils_exports as ModelUtils,
+  PrismaSchemaGenerator,
+  TsSchemaGenerator,
+  ZModelCodeGenerator
+};
+//# sourceMappingURL=index.js.map