@zenstackhq/sdk 2.16.0 → 3.0.0-alpha.1

package/dist/index.cjs

@@ -0,0 +1,1906 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  ModelUtils: () => model_utils_exports,
+  PrismaSchemaGenerator: () => PrismaSchemaGenerator,
+  TsSchemaGenerator: () => TsSchemaGenerator,
+  ZModelCodeGenerator: () => ZModelCodeGenerator
+});
+module.exports = __toCommonJS(src_exports);
+
+// 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
+});
+var import_ast = require("@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 || !(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");
+}
+__name(isDelegateModel, "isDelegateModel");
+function isUniqueField(field) {
+  if (hasAttribute(field, "@unique")) {
+    return true;
+  }
+  const modelIds = getAttribute(field.$container, "@@unique");
+  if (modelIds && modelIds.args.some((arg) => (0, import_ast.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 (0, import_ast.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) => (0, import_ast.isDataModel)(d) && d.attributes.some((attr) => attr.decl.$refText === "@@auth"));
+  if (!found) {
+    found = model.declarations.find((d) => (0, import_ast.isDataModel)(d) && d.name === "User");
+  }
+  return found;
+}
+__name(getAuthDecl, "getAuthDecl");
+
+// src/prisma/prisma-schema-generator.ts
+var import_ast2 = require("@zenstackhq/language/ast");
+var import_langium = require("langium");
+var import_ts_pattern = require("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 import_ast2.DataSource:
+          this.generateDataSource(prisma, decl);
+          break;
+        case import_ast2.Enum:
+          this.generateEnum(prisma, decl);
+          break;
+        case import_ast2.DataModel:
+          this.generateModel(prisma, decl);
+          break;
+        case import_ast2.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 ((0, import_ast2.isLiteralExpr)(expr)) {
+      return this.literalToText(expr);
+    } else if ((0, import_ast2.isInvocationExpr)(expr)) {
+      const fc = this.makeFunctionCall(expr);
+      return fc.toString();
+    } else {
+      return this.configArrayToText(expr);
+    }
+  }
+  configArrayToText(expr) {
+    return "[" + expr.items.map((item) => {
+      if ((0, import_ast2.isLiteralExpr)(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 (0, import_ast2.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 ((0, import_ast2.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
+      (0, import_ast2.isTypeDef)(field.type.reference?.ref) ? false : field.type.array
+    );
+    const type = new ModelFieldType(fieldType, isArray, field.type.optional);
+    const attributes = field.attributes.filter((attr) => this.isPrismaAttribute(attr)).filter((attr) => !this.isDefaultWithPluginInvocation(attr)).filter((attr) => (
+      // 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 import_langium.AstUtils.streamAst(expr).some((node) => (0, import_ast2.isInvocationExpr)(node) && this.isFromPlugin(node.function.ref));
+  }
+  isFromPlugin(node) {
+    const model = import_langium.AstUtils.getContainerOfType(node, import_ast2.isModel);
+    return !!model && !!model.$document && model.$document.uri.path.endsWith("plugin.zmodel");
+  }
+  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);
+  }
+  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 ((0, import_ast2.isLiteralExpr)(node)) {
+      const argType = (0, import_ts_pattern.match)(node.$type).with(import_ast2.StringLiteral, () => "String").with(import_ast2.NumberLiteral, () => "Number").with(import_ast2.BooleanLiteral, () => "Boolean").exhaustive();
+      return new AttributeArgValue(argType, node.value);
+    } else if ((0, import_ast2.isArrayExpr)(node)) {
+      return new AttributeArgValue("Array", new Array(...node.items.map((item) => this.makeAttributeArgValue(item))));
+    } else if ((0, import_ast2.isReferenceExpr)(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 ((0, import_ast2.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 = (0, import_ts_pattern.match)(arg.value).when(import_ast2.isStringLiteral, (v) => `"${v.value}"`).when(import_ast2.isLiteralExpr, (v) => v.value.toString()).when(import_ast2.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
+var import_language = require("@zenstackhq/language");
+var import_ast3 = require("@zenstackhq/language/ast");
+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;
+    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);
+    import_node_fs.default.mkdirSync(import_node_path.default.dirname(outputFile), {
+      recursive: true
+    });
+    import_node_fs.default.writeFileSync(outputFile, result);
+    return {
+      model,
+      warnings
+    };
+  }
+  generateSchemaStatements(model, statements) {
+    const hasComputedFields = model.declarations.some((d) => (0, import_ast3.isDataModel)(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(import_ast3.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(import_ast3.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) => (0, import_ast3.isDataModel)(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 (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);
+  }
+  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 ((0, import_ast3.isDataModel)(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(import_ast3.isDataSource);
+    (0, import_tiny_invariant.default)(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");
+    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");
+    }
+  }
+  getMappedDefault(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 : [
+        "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)) {
+      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 (!(0, import_ast3.isMemberAccessExpr)(expr.operand)) {
+      return [
+        expr.member.$refText
+      ];
+    } else {
+      return [
+        ...this.getMemberAccessChain(expr.operand),
+        expr.member.$refText
+      ];
+    }
+  }
+  isAuthMemberAccess(expr) {
+    if ((0, import_ast3.isMemberAccessExpr)(expr)) {
+      return this.isAuthInvocation(expr.operand) || this.isAuthMemberAccess(expr.operand);
+    } else {
+      return false;
+    }
+  }
+  isAuthInvocation(expr) {
+    return (0, import_ast3.isInvocationExpr)(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 (0, import_ast3.isArrayExpr)(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" && (0, import_ast3.isArrayExpr)(arg.value) && arg.value.items.some((el) => (0, import_ast3.isReferenceExpr)(el) && el.target.ref === field)) {
+            result.push(f.name);
+          }
+        }
+      }
+    }
+    return result;
+  }
+  getOppositeRelationField(field) {
+    if (!field.type.reference?.ref || !(0, import_ast3.isDataModel)(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) {
+        (0, import_tiny_invariant.default)((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) {
+      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 (!(0, import_ast3.isLiteralExpr)(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 (0, import_ts_pattern2.match)(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 (0, import_ts_pattern2.match)(value).when(import_ast3.isLiteralExpr, (expr) => this.createLiteralExpression(expr.$type, expr.value)).when(import_ast3.isInvocationExpr, (expr) => this.createCallExpression(expr)).when(import_ast3.isReferenceExpr, (expr) => this.createRefExpression(expr)).when(import_ast3.isArrayExpr, (expr) => this.createArrayExpression(expr)).when(import_ast3.isUnaryExpr, (expr) => this.createUnaryExpression(expr)).when(import_ast3.isBinaryExpr, (expr) => this.createBinaryExpression(expr)).when(import_ast3.isMemberAccessExpr, (expr) => this.createMemberExpression(expr)).when(import_ast3.isNullExpr, () => this.createNullExpression()).when(import_ast3.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 ((0, import_ast3.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 ((0, import_ast3.isDataModelField)(expr.target.ref)) {
+      return ts.factory.createCallExpression(ts.factory.createIdentifier("ExpressionUtils.field"), void 0, [
+        this.createLiteralNode(expr.target.$refText)
+      ]);
+    } else if ((0, import_ast3.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 (0, import_ts_pattern2.match)(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
+var import_ast4 = require("@zenstackhq/language/ast");
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
+function _ts_metadata(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata, "_ts_metadata");
+var generationHandlers = /* @__PURE__ */ new Map();
+function gen(name) {
+  return function(_target, _propertyKey, descriptor) {
+    if (!generationHandlers.get(name)) {
+      generationHandlers.set(name, descriptor);
+    }
+    return descriptor;
+  };
+}
+__name(gen, "gen");
+var ZModelCodeGenerator = class {
+  static {
+    __name(this, "ZModelCodeGenerator");
+  }
+  options;
+  constructor(options) {
+    this.options = {
+      binaryExprNumberOfSpaces: options?.binaryExprNumberOfSpaces ?? 1,
+      unaryExprNumberOfSpaces: options?.unaryExprNumberOfSpaces ?? 0,
+      indent: options?.indent ?? 4,
+      quote: options?.quote ?? "single"
+    };
+  }
+  /**
+   * Generates ZModel source code from AST.
+   */
+  generate(ast) {
+    const handler = generationHandlers.get(ast.$type);
+    if (!handler) {
+      throw new Error(`No generation handler found for ${ast.$type}`);
+    }
+    return handler.value.call(this, ast);
+  }
+  _generateModel(ast) {
+    return ast.declarations.map((d) => this.generate(d)).join("\n\n");
+  }
+  _generateDataSource(ast) {
+    return `datasource ${ast.name} {
+${ast.fields.map((x) => this.indent + this.generate(x)).join("\n")}
+}`;
+  }
+  _generateEnum(ast) {
+    return `enum ${ast.name} {
+${ast.fields.map((x) => this.indent + this.generate(x)).join("\n")}
+}`;
+  }
+  _generateEnumField(ast) {
+    return `${ast.name}${ast.attributes.length > 0 ? " " + ast.attributes.map((x) => this.generate(x)).join(" ") : ""}`;
+  }
+  _generateGenerator(ast) {
+    return `generator ${ast.name} {
+${ast.fields.map((x) => this.indent + this.generate(x)).join("\n")}
+}`;
+  }
+  _generateConfigField(ast) {
+    return `${ast.name} = ${this.generate(ast.value)}`;
+  }
+  _generateConfigArrayExpr(ast) {
+    return `[${ast.items.map((x) => this.generate(x)).join(", ")}]`;
+  }
+  _generateConfigInvocationExpr(ast) {
+    if (ast.args.length === 0) {
+      return ast.name;
+    } else {
+      return `${ast.name}(${ast.args.map((x) => (x.name ? x.name + ": " : "") + this.generate(x.value)).join(", ")})`;
+    }
+  }
+  _generatePlugin(ast) {
+    return `plugin ${ast.name} {
+${ast.fields.map((x) => this.indent + this.generate(x)).join("\n")}
+}`;
+  }
+  _generatePluginField(ast) {
+    return `${ast.name} = ${this.generate(ast.value)}`;
+  }
+  _generateDataModel(ast) {
+    return `${ast.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 = import_ast4.BinaryExprOperatorPriority[operator];
+    if (ast.left.$type === import_ast4.BinaryExpr && import_ast4.BinaryExprOperatorPriority[ast.left["operator"]] < currentPriority) {
+      result.left = true;
+    }
+    if (!isCollectionPredicate && ast.right.$type === import_ast4.BinaryExpr && import_ast4.BinaryExprOperatorPriority[ast.right["operator"]] <= currentPriority) {
+      result.right = true;
+    }
+    return result;
+  }
+  isCollectionPredicateOperator(op) {
+    return [
+      "?",
+      "!",
+      "^"
+    ].includes(op);
+  }
+};
+_ts_decorate([
+  gen(import_ast4.Model),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof import_ast4.Model === "undefined" ? Object : import_ast4.Model
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateModel", null);
+_ts_decorate([
+  gen(import_ast4.DataSource),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof import_ast4.DataSource === "undefined" ? Object : import_ast4.DataSource
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateDataSource", null);
+_ts_decorate([
+  gen(import_ast4.Enum),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof import_ast4.Enum === "undefined" ? Object : import_ast4.Enum
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateEnum", null);
+_ts_decorate([
+  gen(import_ast4.EnumField),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof import_ast4.EnumField === "undefined" ? Object : import_ast4.EnumField
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateEnumField", null);
+_ts_decorate([
+  gen(import_ast4.GeneratorDecl),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof import_ast4.GeneratorDecl === "undefined" ? Object : import_ast4.GeneratorDecl
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateGenerator", null);
+_ts_decorate([
+  gen(import_ast4.ConfigField),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof import_ast4.ConfigField === "undefined" ? Object : import_ast4.ConfigField
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateConfigField", null);
+_ts_decorate([
+  gen(import_ast4.ConfigArrayExpr),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof import_ast4.ConfigArrayExpr === "undefined" ? Object : import_ast4.ConfigArrayExpr
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateConfigArrayExpr", null);
+_ts_decorate([
+  gen(import_ast4.ConfigInvocationExpr),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof import_ast4.ConfigInvocationExpr === "undefined" ? Object : import_ast4.ConfigInvocationExpr
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateConfigInvocationExpr", null);
+_ts_decorate([
+  gen(import_ast4.Plugin),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof import_ast4.Plugin === "undefined" ? Object : import_ast4.Plugin
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generatePlugin", null);
+_ts_decorate([
+  gen(import_ast4.PluginField),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof import_ast4.PluginField === "undefined" ? Object : import_ast4.PluginField
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generatePluginField", null);
+_ts_decorate([
+  gen(import_ast4.DataModel),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof import_ast4.DataModel === "undefined" ? Object : import_ast4.DataModel
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateDataModel", null);
+_ts_decorate([
+  gen(import_ast4.DataModelField),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof import_ast4.DataModelField === "undefined" ? Object : import_ast4.DataModelField
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateDataModelField", null);
+_ts_decorate([
+  gen(import_ast4.DataModelAttribute),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof import_ast4.DataModelAttribute === "undefined" ? Object : import_ast4.DataModelAttribute
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateDataModelAttribute", null);
+_ts_decorate([
+  gen(import_ast4.DataModelFieldAttribute),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof import_ast4.DataModelFieldAttribute === "undefined" ? Object : import_ast4.DataModelFieldAttribute
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateDataModelFieldAttribute", null);
+_ts_decorate([
+  gen(import_ast4.AttributeArg),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof import_ast4.AttributeArg === "undefined" ? Object : import_ast4.AttributeArg
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateAttributeArg", null);
+_ts_decorate([
+  gen(import_ast4.ObjectExpr),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof import_ast4.ObjectExpr === "undefined" ? Object : import_ast4.ObjectExpr
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateObjectExpr", null);
+_ts_decorate([
+  gen(import_ast4.ArrayExpr),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof import_ast4.ArrayExpr === "undefined" ? Object : import_ast4.ArrayExpr
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateArrayExpr", null);
+_ts_decorate([
+  gen(import_ast4.StringLiteral),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof import_ast4.LiteralExpr === "undefined" ? Object : import_ast4.LiteralExpr
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateLiteralExpr", null);
+_ts_decorate([
+  gen(import_ast4.NumberLiteral),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof import_ast4.NumberLiteral === "undefined" ? Object : import_ast4.NumberLiteral
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateNumberLiteral", null);
+_ts_decorate([
+  gen(import_ast4.BooleanLiteral),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof import_ast4.BooleanLiteral === "undefined" ? Object : import_ast4.BooleanLiteral
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateBooleanLiteral", null);
+_ts_decorate([
+  gen(import_ast4.UnaryExpr),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof import_ast4.UnaryExpr === "undefined" ? Object : import_ast4.UnaryExpr
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateUnaryExpr", null);
+_ts_decorate([
+  gen(import_ast4.BinaryExpr),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof import_ast4.BinaryExpr === "undefined" ? Object : import_ast4.BinaryExpr
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateBinaryExpr", null);
+_ts_decorate([
+  gen(import_ast4.ReferenceExpr),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof import_ast4.ReferenceExpr === "undefined" ? Object : import_ast4.ReferenceExpr
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateReferenceExpr", null);
+_ts_decorate([
+  gen(import_ast4.ReferenceArg),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof import_ast4.ReferenceArg === "undefined" ? Object : import_ast4.ReferenceArg
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateReferenceArg", null);
+_ts_decorate([
+  gen(import_ast4.MemberAccessExpr),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof import_ast4.MemberAccessExpr === "undefined" ? Object : import_ast4.MemberAccessExpr
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateMemberExpr", null);
+_ts_decorate([
+  gen(import_ast4.InvocationExpr),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof import_ast4.InvocationExpr === "undefined" ? Object : import_ast4.InvocationExpr
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateInvocationExpr", null);
+_ts_decorate([
+  gen(import_ast4.NullExpr),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", []),
+  _ts_metadata("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateNullExpr", null);
+_ts_decorate([
+  gen(import_ast4.ThisExpr),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", []),
+  _ts_metadata("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateThisExpr", null);
+_ts_decorate([
+  gen(import_ast4.Attribute),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof import_ast4.Attribute === "undefined" ? Object : import_ast4.Attribute
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateAttribute", null);
+_ts_decorate([
+  gen(import_ast4.AttributeParam),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof import_ast4.AttributeParam === "undefined" ? Object : import_ast4.AttributeParam
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateAttributeParam", null);
+_ts_decorate([
+  gen(import_ast4.AttributeParamType),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof import_ast4.AttributeParamType === "undefined" ? Object : import_ast4.AttributeParamType
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateAttributeParamType", null);
+_ts_decorate([
+  gen(import_ast4.FunctionDecl),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof import_ast4.FunctionDecl === "undefined" ? Object : import_ast4.FunctionDecl
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateFunctionDecl", null);
+_ts_decorate([
+  gen(import_ast4.FunctionParam),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof import_ast4.FunctionParam === "undefined" ? Object : import_ast4.FunctionParam
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateFunctionParam", null);
+_ts_decorate([
+  gen(import_ast4.FunctionParamType),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof import_ast4.FunctionParamType === "undefined" ? Object : import_ast4.FunctionParamType
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateFunctionParamType", null);
+_ts_decorate([
+  gen(import_ast4.TypeDef),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof import_ast4.TypeDef === "undefined" ? Object : import_ast4.TypeDef
+  ]),
+  _ts_metadata("design:returntype", void 0)
+], ZModelCodeGenerator.prototype, "_generateTypeDef", null);
+_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,
+  PrismaSchemaGenerator,
+  TsSchemaGenerator,
+  ZModelCodeGenerator
+});
+//# sourceMappingURL=index.cjs.map