@zenstackhq/sdk 3.5.6 → 3.6.0

package/dist/index.cjs

@@ -1,1764 +1,1189 @@
-"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region \0rolldown/runtime.js
 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 __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
 };
 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;
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, 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
-});
-module.exports = __toCommonJS(src_exports);
-
-// src/model-utils.ts
-var model_utils_exports = {};
-__export(model_utils_exports, {
-  DELEGATE_AUX_RELATION_PREFIX: () => DELEGATE_AUX_RELATION_PREFIX,
-  getAttribute: () => getAttribute,
-  getAuthDecl: () => getAuthDecl,
-  getContainingModel: () => getContainingModel,
-  getDelegateOriginModel: () => getDelegateOriginModel,
-  getIdFields: () => getIdFields,
-  getOwnedFields: () => getOwnedFields,
-  hasAttribute: () => hasAttribute,
-  isDelegateModel: () => isDelegateModel,
-  isFromStdlib: () => isFromStdlib,
-  isIdField: () => isIdField,
-  isUniqueField: () => isUniqueField,
-  resolved: () => resolved
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let _zenstackhq_language_ast = require("@zenstackhq/language/ast");
+let _zenstackhq_language_utils = require("@zenstackhq/language/utils");
+let _zenstackhq_common_helpers = require("@zenstackhq/common-helpers");
+let _zenstackhq_language = require("@zenstackhq/language");
+let langium = require("langium");
+let ts_pattern = require("ts-pattern");
+let node_fs = require("node:fs");
+node_fs = __toESM(node_fs, 1);
+let node_path = require("node:path");
+node_path = __toESM(node_path, 1);
+let typescript = require("typescript");
+typescript = __toESM(typescript, 1);
+//#region src/model-utils.ts
+var model_utils_exports = /* @__PURE__ */ __exportAll({
+	DELEGATE_AUX_RELATION_PREFIX: () => DELEGATE_AUX_RELATION_PREFIX,
+	getAttribute: () => getAttribute,
+	getAuthDecl: () => getAuthDecl,
+	getContainingModel: () => getContainingModel,
+	getDelegateOriginModel: () => getDelegateOriginModel,
+	getIdFields: () => getIdFields,
+	getOwnedFields: () => getOwnedFields,
+	hasAttribute: () => hasAttribute,
+	isDelegateModel: () => isDelegateModel$1,
+	isFromStdlib: () => isFromStdlib,
+	isIdField: () => isIdField,
+	isUniqueField: () => isUniqueField,
+	resolved: () => resolved
 });
-var import_ast = require("@zenstackhq/language/ast");
-var import_utils = require("@zenstackhq/language/utils");
 function isIdField(field, contextModel) {
-  if (hasAttribute(field, "@id")) {
-    return true;
-  }
-  const modelLevelIds = (0, import_utils.getModelIdFields)(contextModel);
-  if (modelLevelIds.map((f) => f.name).includes(field.name)) {
-    return true;
-  }
-  const allFields = (0, import_utils.getAllFields)(contextModel);
-  if (allFields.some((f) => hasAttribute(f, "@id")) || modelLevelIds.length > 0) {
-    return false;
-  }
-  const firstUniqueField = allFields.find((f) => hasAttribute(f, "@unique"));
-  if (firstUniqueField) {
-    return firstUniqueField.name === field.name;
-  }
-  const modelLevelUnique = (0, import_utils.getModelUniqueFields)(contextModel);
-  if (modelLevelUnique.map((f) => f.name).includes(field.name)) {
-    return true;
-  }
-  return false;
+	if (hasAttribute(field, "@id")) return true;
+	const modelLevelIds = (0, _zenstackhq_language_utils.getModelIdFields)(contextModel);
+	if (modelLevelIds.map((f) => f.name).includes(field.name)) return true;
+	const allFields = (0, _zenstackhq_language_utils.getAllFields)(contextModel);
+	if (allFields.some((f) => hasAttribute(f, "@id")) || modelLevelIds.length > 0) return false;
+	const firstUniqueField = allFields.find((f) => hasAttribute(f, "@unique"));
+	if (firstUniqueField) return firstUniqueField.name === field.name;
+	if ((0, _zenstackhq_language_utils.getModelUniqueFields)(contextModel).map((f) => f.name).includes(field.name)) return true;
+	return false;
 }
-__name(isIdField, "isIdField");
 function hasAttribute(decl, name) {
-  return !!getAttribute(decl, name);
+	return !!getAttribute(decl, name);
 }
-__name(hasAttribute, "hasAttribute");
 function getAttribute(decl, name) {
-  return decl.attributes.find((attr) => attr.decl.$refText === name);
+	return decl.attributes.find((attr) => attr.decl.$refText === name);
 }
-__name(getAttribute, "getAttribute");
-function isDelegateModel(node) {
-  return (0, import_ast.isDataModel)(node) && hasAttribute(node, "@@delegate");
+function isDelegateModel$1(node) {
+	return (0, _zenstackhq_language_ast.isDataModel)(node) && hasAttribute(node, "@@delegate");
 }
-__name(isDelegateModel, "isDelegateModel");
+/**
+* Returns all fields that physically belong to a model's table: its directly declared
+* fields plus fields from its mixins (recursively).
+*/
 function getOwnedFields(model) {
-  const fields = [
-    ...model.fields
-  ];
-  for (const mixin of model.mixins) {
-    if (mixin.ref) {
-      fields.push(...getOwnedFields(mixin.ref));
-    }
-  }
-  return fields;
+	const fields = [...model.fields];
+	for (const mixin of model.mixins) if (mixin.ref) fields.push(...getOwnedFields(mixin.ref));
+	return fields;
 }
-__name(getOwnedFields, "getOwnedFields");
+/**
+* Returns the name of the delegate base model that "owns" the given field in the context of
+* `contextModel`. This handles both direct fields of delegate models and mixin fields that
+* belong to a mixin used by a delegate base model.
+*/
 function getDelegateOriginModel(field, contextModel) {
-  let base = contextModel.baseModel?.ref;
-  while (base) {
-    if (isDelegateModel(base) && getOwnedFields(base).some((f) => f.name === field.name)) {
-      return base.name;
-    }
-    base = base.baseModel?.ref;
-  }
-  return void 0;
+	let base = contextModel.baseModel?.ref;
+	while (base) {
+		if (isDelegateModel$1(base) && getOwnedFields(base).some((f) => f.name === field.name)) return base.name;
+		base = base.baseModel?.ref;
+	}
 }
-__name(getDelegateOriginModel, "getDelegateOriginModel");
 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;
+	if (hasAttribute(field, "@unique")) return true;
+	const modelIds = getAttribute(field.$container, "@@unique");
+	if (modelIds && modelIds.args.some((arg) => (0, _zenstackhq_language_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");
+	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);
+	if (!node) return null;
+	return (0, _zenstackhq_language_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;
+	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) || (0, import_ast.isTypeDef)(d)) && d.attributes.some((attr) => attr.decl.$refText === "@@auth"));
-  if (!found) {
-    found = model.declarations.find((d) => ((0, import_ast.isDataModel)(d) || (0, import_ast.isTypeDef)(d)) && d.name === "User");
-  }
-  return found;
+	let found = model.declarations.find((d) => ((0, _zenstackhq_language_ast.isDataModel)(d) || (0, _zenstackhq_language_ast.isTypeDef)(d)) && d.attributes.some((attr) => attr.decl.$refText === "@@auth"));
+	if (!found) found = model.declarations.find((d) => ((0, _zenstackhq_language_ast.isDataModel)(d) || (0, _zenstackhq_language_ast.isTypeDef)(d)) && d.name === "User");
+	return found;
 }
-__name(getAuthDecl, "getAuthDecl");
 function getIdFields(dm) {
-  return (0, import_utils.getAllFields)(dm).filter((f) => isIdField(f, dm)).map((f) => f.name);
+	return (0, _zenstackhq_language_utils.getAllFields)(dm).filter((f) => isIdField(f, dm)).map((f) => f.name);
 }
-__name(getIdFields, "getIdFields");
-var DELEGATE_AUX_RELATION_PREFIX = "delegate_aux";
-
-// src/prisma/prisma-schema-generator.ts
-var import_common_helpers = require("@zenstackhq/common-helpers");
-var import_language = require("@zenstackhq/language");
-var import_ast2 = require("@zenstackhq/language/ast");
-var import_utils2 = require("@zenstackhq/language/utils");
-var import_langium = require("langium");
-var import_ts_pattern = require("ts-pattern");
-
-// src/prisma/indent-string.ts
+/**
+* Prefix for auxiliary relation fields generated for delegated models
+*/
+const DELEGATE_AUX_RELATION_PREFIX = "delegate_aux";
+//#endregion
+//#region src/prisma/indent-string.ts
+/**
+* Utility for indenting strings
+*/
 function indentString(string, count = 4) {
-  const indent = " ";
-  return string.replace(/^(?!\s*$)/gm, indent.repeat(count));
+	return string.replace(/^(?!\s*$)/gm, " ".repeat(count));
 }
-__name(indentString, "indentString");
-
-// src/prisma/prisma-builder.ts
+//#endregion
+//#region src/prisma/prisma-builder.ts
+/**
+* Prisma schema builder
+*/
 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");
-  }
+	datasources = [];
+	generators = [];
+	models = [];
+	enums = [];
+	addDataSource(name, fields = []) {
+		const ds = new DataSource$1(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$1(name, false);
+		this.models.push(model);
+		return model;
+	}
+	addView(name) {
+		const model = new Model$1(name, true);
+		this.models.push(model);
+		return model;
+	}
+	addEnum(name) {
+		const e = new Enum$2(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 DataSource$1 = class {
+	constructor(name, fields = []) {
+		this.name = name;
+		this.fields = fields;
+	}
+	toString() {
+		return `datasource ${this.name} {\n` + this.fields.map((f) => indentString(`${f.name} = ${f.text}`)).join("\n") + `\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") + `
-}`;
-  }
+	constructor(name, fields) {
+		this.name = name;
+		this.fields = fields;
+	}
+	toString() {
+		return `generator ${this.name} {\n` + this.fields.map((f) => indentString(`${f.name} = ${f.text}`)).join("\n") + `\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("");
-  }
+	constructor(documentations = []) {
+		this.documentations = documentations;
+	}
+	addComment(name) {
+		this.documentations.push(name);
+		return name;
+	}
+	toString() {
+		return this.documentations.map((x) => `${x}\n`).join("");
+	}
 };
 var ContainerDeclaration = class extends DeclarationBase {
-  static {
-    __name(this, "ContainerDeclaration");
-  }
-  attributes;
-  constructor(documentations = [], attributes = []) {
-    super(documentations), this.attributes = 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;
-  }
+	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;
-  }
-  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 Model$1 = class extends ContainerDeclaration {
+	fields = [];
+	constructor(name, isView, documentations = []) {
+		super(documentations);
+		this.name = name;
+		this.isView = isView;
+	}
+	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} {\n` + indentString(result.map((d) => d.toString()).join("\n")) + `\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 ? "?" : ""}`;
-  }
+	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(" ") : "");
-  }
+	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(", ") + `)`;
-  }
+	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(", ") + `)`;
-  }
+	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 AttributeArg$2 = class {
+	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}`);
-    }
-  }
+	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;
-  }
+	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}`;
-  }
+	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(", ") + ")";
-  }
+	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;
-  }
+	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;
-  }
-  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 Enum$2 = class extends ContainerDeclaration {
+	fields = [];
+	constructor(name, documentations = []) {
+		super(documentations);
+		this.name = name;
+	}
+	addField(name, attributes = [], documentations = []) {
+		const field = new EnumField$1(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} {\n` + 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(" ") : "");
-  }
+var EnumField$1 = class extends DeclarationBase {
+	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 IDENTIFIER_NAME_MAX_LENGTH = 50 - DELEGATE_AUX_RELATION_PREFIX.length;
-var NON_PRISMA_DATASOURCE_FIELDS = [
-  "defaultSchema"
-];
+//#endregion
+//#region src/prisma/prisma-schema-generator.ts
+const IDENTIFIER_NAME_MAX_LENGTH = 38;
+const NON_PRISMA_DATASOURCE_FIELDS = ["defaultSchema"];
+/**
+* Generates Prisma schema file
+*/
 var PrismaSchemaGenerator = class {
-  static {
-    __name(this, "PrismaSchemaGenerator");
-  }
-  zmodel;
-  PRELUDE = `//////////////////////////////////////////////////////////////////////////////////////////////
+	PRELUDE = `//////////////////////////////////////////////////////////////////////////////////////////////
 // DO NOT MODIFY THIS FILE                                                                  //
 // This file is automatically generated by ZenStack CLI and should not be manually updated. //
 //////////////////////////////////////////////////////////////////////////////////////////////
 
 `;
-  // a mapping from full names to shortened names
-  shortNameMap = /* @__PURE__ */ new Map();
-  constructor(zmodel) {
-    this.zmodel = zmodel;
-  }
-  async generate() {
-    const prisma = new PrismaModel();
-    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;
-      }
-    }
-    if (!this.zmodel.declarations.some(import_ast2.isGeneratorDecl)) {
-      this.generateDefaultGenerator(prisma);
-    }
-    return this.PRELUDE + prisma.toString();
-  }
-  generateDataSource(prisma, dataSource) {
-    const fields = dataSource.fields.filter((f) => !NON_PRISMA_DATASOURCE_FIELDS.includes(f.name)).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)
-    })));
-  }
-  generateDefaultGenerator(prisma) {
-    const gen = prisma.addGenerator("client", [
-      {
-        name: "provider",
-        text: '"prisma-client-js"'
-      }
-    ]);
-    const previewFeatures = [];
-    const dataSource = this.zmodel.declarations.find(import_ast2.isDataSource);
-    if (dataSource?.fields.some((f) => f.name === "extensions")) {
-      previewFeatures.push("postgresqlExtensions");
-    }
-    if (this.zmodel.declarations.some((d) => (0, import_ast2.isDataModel)(d) && d.isView)) {
-      previewFeatures.push("views");
-    }
-    if (previewFeatures.length > 0) {
-      gen.fields.push({
-        name: "previewFeatures",
-        text: JSON.stringify(previewFeatures)
-      });
-    }
-  }
-  generateModel(prisma, decl) {
-    const model = decl.isView ? prisma.addView(decl.name) : prisma.addModel(decl.name);
-    const allFields = (0, import_utils2.getAllFields)(decl, true);
-    for (const field of allFields) {
-      if (model_utils_exports.hasAttribute(field, "@computed")) {
-        continue;
-      }
-      if (model_utils_exports.isIdField(field, decl) || !getDelegateOriginModel(field, decl)) {
-        this.generateModelField(model, field, decl);
-      }
-    }
-    const allAttributes = (0, import_utils2.getAllAttributes)(decl).filter((attr) => this.isPrismaAttribute(attr));
-    for (const attr of allAttributes) {
-      this.generateContainerAttribute(model, attr);
-    }
-    if (this.datasourceHasSchemasSetting(decl.$container) && !allAttributes.some((attr) => attr.decl.ref?.name === "@@schema")) {
-      model.addAttribute("@@schema", [
-        new AttributeArg(void 0, new AttributeArgValue("String", this.getDefaultPostgresSchemaName(decl.$container)))
-      ]);
-    }
-    decl.comments.forEach((c) => model.addComment(c));
-    this.generateDelegateRelationForBase(model, decl);
-    this.generateDelegateRelationForConcrete(model, decl);
-  }
-  getDatasourceField(zmodel, fieldName) {
-    const dataSource = zmodel.declarations.find(import_ast2.isDataSource);
-    return dataSource?.fields.find((f) => f.name === fieldName);
-  }
-  datasourceHasSchemasSetting(zmodel) {
-    return !!this.getDatasourceField(zmodel, "schemas");
-  }
-  getDefaultPostgresSchemaName(zmodel) {
-    const defaultSchemaField = this.getDatasourceField(zmodel, "defaultSchema");
-    return (0, import_utils2.getStringLiteral)(defaultSchemaField?.value) ?? "public";
-  }
-  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 = (0, import_utils2.getStringLiteral)(fieldType.unsupported.value);
-      if (value) {
-        return `Unsupported("${value}")`;
-      } else {
-        return void 0;
-      }
-    } else {
-      return void 0;
-    }
-  }
-  generateModelField(model, field, contextModel, 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.isDefaultWithAuthInvocation(attr)).filter((attr) => (
-      // when building physical schema, exclude `@default` for id fields inherited from delegate base
-      !(model_utils_exports.isIdField(field, contextModel) && getDelegateOriginModel(field, contextModel) && 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;
-  }
-  isDefaultWithAuthInvocation(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(import_utils2.isAuthInvocation);
-  }
-  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 import_language.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);
-    }
-    const allAttributes = decl.attributes.filter((attr) => this.isPrismaAttribute(attr));
-    for (const attr of allAttributes) {
-      this.generateContainerAttribute(_enum, attr);
-    }
-    if (this.datasourceHasSchemasSetting(decl.$container) && !allAttributes.some((attr) => attr.decl.ref?.name === "@@schema")) {
-      _enum.addAttribute("@@schema", [
-        new AttributeArg(void 0, new AttributeArgValue("String", this.getDefaultPostgresSchemaName(decl.$container)))
-      ]);
-    }
-    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);
-  }
-  generateDelegateRelationForBase(model, decl) {
-    if (!(0, import_utils2.isDelegateModel)(decl)) {
-      return;
-    }
-    const concreteModels = this.getConcreteModels(decl);
-    concreteModels.forEach((concrete) => {
-      const auxName = this.truncate(`${DELEGATE_AUX_RELATION_PREFIX}_${(0, import_common_helpers.lowerCaseFirst)(concrete.name)}`);
-      model.addField(auxName, new ModelFieldType(concrete.name, false, true));
-    });
-  }
-  generateDelegateRelationForConcrete(model, concreteDecl) {
-    const base = concreteDecl.baseModel?.ref;
-    if (!base) {
-      return;
-    }
-    const idFields = getIdFields(base);
-    const relationField = this.truncate(`${DELEGATE_AUX_RELATION_PREFIX}_${(0, import_common_helpers.lowerCaseFirst)(base.name)}`);
-    model.addField(relationField, base.name, [
-      new FieldAttribute("@relation", [
-        new AttributeArg("fields", new AttributeArgValue("Array", idFields.map((idField) => new AttributeArgValue("FieldReference", new FieldReference(idField))))),
-        new AttributeArg("references", new AttributeArgValue("Array", idFields.map((idField) => new AttributeArgValue("FieldReference", new FieldReference(idField))))),
-        new AttributeArg("onDelete", new AttributeArgValue("FieldReference", new FieldReference("Cascade"))),
-        new AttributeArg("onUpdate", new AttributeArgValue("FieldReference", new FieldReference("Cascade")))
-      ])
-    ]);
-  }
-  getConcreteModels(dataModel) {
-    if (!(0, import_utils2.isDelegateModel)(dataModel)) {
-      return [];
-    }
-    return dataModel.$container.declarations.filter((d) => (0, import_ast2.isDataModel)(d) && d !== dataModel && d.baseModel?.ref === dataModel);
-  }
-  truncate(name) {
-    if (name.length <= IDENTIFIER_NAME_MAX_LENGTH) {
-      return name;
-    }
-    const existing = this.shortNameMap.get(name);
-    if (existing) {
-      return existing;
-    }
-    const baseName = name.slice(0, IDENTIFIER_NAME_MAX_LENGTH);
-    let index = 0;
-    let shortName = `${baseName}_${index}`;
-    while (true) {
-      const conflict = Array.from(this.shortNameMap.values()).find((v) => v === shortName);
-      if (!conflict) {
-        this.shortNameMap.set(name, shortName);
-        break;
-      }
-      index++;
-      shortName = `${baseName}_${index}`;
-    }
-    return shortName;
-  }
+	shortNameMap = /* @__PURE__ */ new Map();
+	constructor(zmodel) {
+		this.zmodel = zmodel;
+	}
+	async generate() {
+		const prisma = new PrismaModel();
+		for (const decl of this.zmodel.declarations) switch (decl.$type) {
+			case _zenstackhq_language_ast.DataSource:
+				this.generateDataSource(prisma, decl);
+				break;
+			case _zenstackhq_language_ast.Enum:
+				this.generateEnum(prisma, decl);
+				break;
+			case _zenstackhq_language_ast.DataModel:
+				this.generateModel(prisma, decl);
+				break;
+			case _zenstackhq_language_ast.GeneratorDecl:
+				this.generateGenerator(prisma, decl);
+				break;
+		}
+		if (!this.zmodel.declarations.some(_zenstackhq_language_ast.isGeneratorDecl)) this.generateDefaultGenerator(prisma);
+		return this.PRELUDE + prisma.toString();
+	}
+	generateDataSource(prisma, dataSource) {
+		const fields = dataSource.fields.filter((f) => !NON_PRISMA_DATASOURCE_FIELDS.includes(f.name)).map((f) => ({
+			name: f.name,
+			text: this.configExprToText(f.value)
+		}));
+		prisma.addDataSource(dataSource.name, fields);
+	}
+	configExprToText(expr) {
+		if ((0, _zenstackhq_language_ast.isLiteralExpr)(expr)) return this.literalToText(expr);
+		else if ((0, _zenstackhq_language_ast.isInvocationExpr)(expr)) return this.makeFunctionCall(expr).toString();
+		else return this.configArrayToText(expr);
+	}
+	configArrayToText(expr) {
+		return "[" + expr.items.map((item) => {
+			if ((0, _zenstackhq_language_ast.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)
+		})));
+	}
+	generateDefaultGenerator(prisma) {
+		const gen = prisma.addGenerator("client", [{
+			name: "provider",
+			text: "\"prisma-client-js\""
+		}]);
+		const previewFeatures = [];
+		if (this.zmodel.declarations.find(_zenstackhq_language_ast.isDataSource)?.fields.some((f) => f.name === "extensions")) previewFeatures.push("postgresqlExtensions");
+		if (this.zmodel.declarations.some((d) => (0, _zenstackhq_language_ast.isDataModel)(d) && d.isView)) previewFeatures.push("views");
+		if (previewFeatures.length > 0) gen.fields.push({
+			name: "previewFeatures",
+			text: JSON.stringify(previewFeatures)
+		});
+	}
+	generateModel(prisma, decl) {
+		const model = decl.isView ? prisma.addView(decl.name) : prisma.addModel(decl.name);
+		const allFields = (0, _zenstackhq_language_utils.getAllFields)(decl, true);
+		for (const field of allFields) {
+			if (hasAttribute(field, "@computed")) continue;
+			if (isIdField(field, decl) || !getDelegateOriginModel(field, decl)) this.generateModelField(model, field, decl);
+		}
+		const allAttributes = (0, _zenstackhq_language_utils.getAllAttributes)(decl).filter((attr) => this.isPrismaAttribute(attr));
+		for (const attr of allAttributes) this.generateContainerAttribute(model, attr);
+		if (this.datasourceHasSchemasSetting(decl.$container) && !allAttributes.some((attr) => attr.decl.ref?.name === "@@schema")) model.addAttribute("@@schema", [new AttributeArg$2(void 0, new AttributeArgValue("String", this.getDefaultPostgresSchemaName(decl.$container)))]);
+		decl.comments.forEach((c) => model.addComment(c));
+		this.generateDelegateRelationForBase(model, decl);
+		this.generateDelegateRelationForConcrete(model, decl);
+	}
+	getDatasourceField(zmodel, fieldName) {
+		return zmodel.declarations.find(_zenstackhq_language_ast.isDataSource)?.fields.find((f) => f.name === fieldName);
+	}
+	datasourceHasSchemasSetting(zmodel) {
+		return !!this.getDatasourceField(zmodel, "schemas");
+	}
+	getDefaultPostgresSchemaName(zmodel) {
+		return (0, _zenstackhq_language_utils.getStringLiteral)(this.getDatasourceField(zmodel, "defaultSchema")?.value) ?? "public";
+	}
+	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 = (0, _zenstackhq_language_utils.getStringLiteral)(fieldType.unsupported.value);
+			if (value) return `Unsupported("${value}")`;
+			else return;
+		} else return;
+	}
+	generateModelField(model, field, contextModel, addToFront = false) {
+		let fieldType;
+		if (field.type.type) fieldType = field.type.type;
+		else if (field.type.reference?.ref) if ((0, _zenstackhq_language_ast.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 = (0, _zenstackhq_language_ast.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.isDefaultWithAuthInvocation(attr)).filter((attr) => !(isIdField(field, contextModel) && getDelegateOriginModel(field, contextModel) && attr.decl.$refText === "@default")).map((attr) => this.makeFieldAttribute(attr));
+		const docs = [...field.comments];
+		return model.addField(field.name, type, attributes, docs, addToFront);
+	}
+	isDefaultWithAuthInvocation(attr) {
+		if (attr.decl.ref?.name !== "@default") return false;
+		const expr = attr.args[0]?.value;
+		if (!expr) return false;
+		return langium.AstUtils.streamAst(expr).some(_zenstackhq_language_utils.isAuthInvocation);
+	}
+	makeFieldAttribute(attr) {
+		const attrName = attr.decl.ref.name;
+		return new FieldAttribute(attrName, attr.args.map((arg) => this.makeAttributeArg(arg)));
+	}
+	makeAttributeArg(arg) {
+		return new AttributeArg$2(arg.name, this.makeAttributeArgValue(arg.value));
+	}
+	makeAttributeArgValue(node) {
+		if ((0, _zenstackhq_language_ast.isLiteralExpr)(node)) return new AttributeArgValue((0, ts_pattern.match)(node.$type).with(_zenstackhq_language_ast.StringLiteral, () => "String").with(_zenstackhq_language_ast.NumberLiteral, () => "Number").with(_zenstackhq_language_ast.BooleanLiteral, () => "Boolean").exhaustive(), node.value);
+		else if ((0, _zenstackhq_language_ast.isArrayExpr)(node)) return new AttributeArgValue("Array", new Array(...node.items.map((item) => this.makeAttributeArgValue(item))));
+		else if ((0, _zenstackhq_language_ast.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, _zenstackhq_language_ast.isInvocationExpr)(node)) return new AttributeArgValue("FunctionCall", this.makeFunctionCall(node));
+		else throw Error(`Unsupported attribute argument expression type: ${node.$type}`);
+	}
+	exprToText(expr) {
+		return new _zenstackhq_language.ZModelCodeGenerator({ quote: "double" }).generate(expr);
+	}
+	makeFunctionCall(node) {
+		return new FunctionCall(node.function.ref.name, node.args.map((arg) => {
+			return new FunctionCallArg((0, ts_pattern.match)(arg.value).when(_zenstackhq_language_ast.isStringLiteral, (v) => `"${v.value}"`).when(_zenstackhq_language_ast.isLiteralExpr, (v) => v.value.toString()).when(_zenstackhq_language_ast.isNullExpr, () => "null").otherwise(() => {
+				throw new Error("Function call argument must be literal or null");
+			}));
+		}));
+	}
+	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);
+		const allAttributes = decl.attributes.filter((attr) => this.isPrismaAttribute(attr));
+		for (const attr of allAttributes) this.generateContainerAttribute(_enum, attr);
+		if (this.datasourceHasSchemasSetting(decl.$container) && !allAttributes.some((attr) => attr.decl.ref?.name === "@@schema")) _enum.addAttribute("@@schema", [new AttributeArg$2(void 0, new AttributeArgValue("String", this.getDefaultPostgresSchemaName(decl.$container)))]);
+		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);
+	}
+	generateDelegateRelationForBase(model, decl) {
+		if (!(0, _zenstackhq_language_utils.isDelegateModel)(decl)) return;
+		this.getConcreteModels(decl).forEach((concrete) => {
+			const auxName = this.truncate(`${DELEGATE_AUX_RELATION_PREFIX}_${(0, _zenstackhq_common_helpers.lowerCaseFirst)(concrete.name)}`);
+			model.addField(auxName, new ModelFieldType(concrete.name, false, true));
+		});
+	}
+	generateDelegateRelationForConcrete(model, concreteDecl) {
+		const base = concreteDecl.baseModel?.ref;
+		if (!base) return;
+		const idFields = getIdFields(base);
+		const relationField = this.truncate(`${DELEGATE_AUX_RELATION_PREFIX}_${(0, _zenstackhq_common_helpers.lowerCaseFirst)(base.name)}`);
+		model.addField(relationField, base.name, [new FieldAttribute("@relation", [
+			new AttributeArg$2("fields", new AttributeArgValue("Array", idFields.map((idField) => new AttributeArgValue("FieldReference", new FieldReference(idField))))),
+			new AttributeArg$2("references", new AttributeArgValue("Array", idFields.map((idField) => new AttributeArgValue("FieldReference", new FieldReference(idField))))),
+			new AttributeArg$2("onDelete", new AttributeArgValue("FieldReference", new FieldReference("Cascade"))),
+			new AttributeArg$2("onUpdate", new AttributeArgValue("FieldReference", new FieldReference("Cascade")))
+		])]);
+	}
+	getConcreteModels(dataModel) {
+		if (!(0, _zenstackhq_language_utils.isDelegateModel)(dataModel)) return [];
+		return dataModel.$container.declarations.filter((d) => (0, _zenstackhq_language_ast.isDataModel)(d) && d !== dataModel && d.baseModel?.ref === dataModel);
+	}
+	truncate(name) {
+		if (name.length <= IDENTIFIER_NAME_MAX_LENGTH) return name;
+		const existing = this.shortNameMap.get(name);
+		if (existing) return existing;
+		const baseName = name.slice(0, IDENTIFIER_NAME_MAX_LENGTH);
+		let index = 0;
+		let shortName = `${baseName}_${index}`;
+		while (true) {
+			if (!Array.from(this.shortNameMap.values()).find((v) => v === shortName)) {
+				this.shortNameMap.set(name, shortName);
+				break;
+			}
+			index++;
+			shortName = `${baseName}_${index}`;
+		}
+		return shortName;
+	}
 };
-
-// src/ts-schema-generator.ts
-var import_common_helpers2 = require("@zenstackhq/common-helpers");
-var import_ast3 = require("@zenstackhq/language/ast");
-var import_utils3 = require("@zenstackhq/language/utils");
-var import_node_fs = __toESM(require("fs"), 1);
-var import_node_path = __toESM(require("path"), 1);
-var import_ts_pattern2 = require("ts-pattern");
-var ts = __toESM(require("typescript"), 1);
+//#endregion
+//#region src/ts-schema-generator.ts
 var TsSchemaGenerator = class {
-  static {
-    __name(this, "TsSchemaGenerator");
-  }
-  usedExpressionUtils = false;
-  usedAttributeApplication = false;
-  usedFieldDefault = false;
-  async generate(model, options) {
-    import_node_fs.default.mkdirSync(options.outDir, {
-      recursive: true
-    });
-    this.generateSchema(model, options);
-    if (options.generateModelTypes !== false) {
-      this.generateModelsAndTypeDefs(model, options);
-    }
-    if (options.generateInputTypes !== false) {
-      this.generateInputTypes(model, options);
-    }
-  }
-  generateSchema(model, options) {
-    const targets = [];
-    if (!options.liteOnly) {
-      targets.push({
-        lite: false,
-        file: "schema.ts"
-      });
-    }
-    if (options.lite || options.liteOnly) {
-      targets.push({
-        lite: true,
-        file: "schema-lite.ts"
-      });
-    }
-    for (const { lite, file } of targets) {
-      this.usedExpressionUtils = false;
-      this.usedAttributeApplication = false;
-      this.usedFieldDefault = false;
-      const statements = [];
-      this.generateSchemaStatements(model, statements, lite);
-      this.generateBannerComments(statements);
-      const schemaOutputFile = import_node_path.default.join(options.outDir, file);
-      const sourceFile = ts.createSourceFile(schemaOutputFile, "", ts.ScriptTarget.ESNext, false, ts.ScriptKind.TS);
-      const printer = ts.createPrinter();
-      const result = printer.printList(ts.ListFormat.MultiLine, ts.factory.createNodeArray(statements), sourceFile);
-      import_node_fs.default.writeFileSync(schemaOutputFile, result);
-    }
-  }
-  generateSchemaStatements(model, statements, lite) {
-    const schemaClass = this.createSchemaClass(model, lite);
-    const schemaImportDecl = ts.factory.createImportDeclaration(void 0, ts.factory.createImportClause(void 0, void 0, ts.factory.createNamedImports([
-      ts.factory.createImportSpecifier(true, void 0, ts.factory.createIdentifier("SchemaDef")),
-      ...this.usedAttributeApplication ? [
-        ts.factory.createImportSpecifier(true, void 0, ts.factory.createIdentifier("AttributeApplication"))
-      ] : [],
-      ...this.usedFieldDefault ? [
-        ts.factory.createImportSpecifier(true, void 0, ts.factory.createIdentifier("FieldDefault"))
-      ] : [],
-      ...this.usedExpressionUtils ? [
-        ts.factory.createImportSpecifier(false, void 0, ts.factory.createIdentifier("ExpressionUtils"))
-      ] : []
-    ])), ts.factory.createStringLiteral("@zenstackhq/schema"));
-    statements.push(schemaImportDecl);
-    statements.push(schemaClass);
-    const schemaDecl = ts.factory.createVariableStatement([
-      ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)
-    ], ts.factory.createVariableDeclarationList([
-      ts.factory.createVariableDeclaration("schema", void 0, void 0, ts.factory.createNewExpression(ts.factory.createIdentifier("SchemaType"), void 0, []))
-    ], ts.NodeFlags.Const));
-    statements.push(schemaDecl);
-  }
-  createExpressionUtilsCall(method, args) {
-    this.usedExpressionUtils = true;
-    return ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("ExpressionUtils"), method), void 0, args || []);
-  }
-  createSchemaClass(model, lite) {
-    const members = [
-      // provider
-      ts.factory.createPropertyDeclaration(void 0, "provider", void 0, void 0, this.createAsConst(this.createProviderObject(model))),
-      // models
-      ts.factory.createPropertyDeclaration(void 0, "models", void 0, void 0, this.createAsConst(this.createModelsObject(model, lite))),
-      // typeDefs
-      ...model.declarations.some(import_ast3.isTypeDef) ? [
-        ts.factory.createPropertyDeclaration(void 0, "typeDefs", void 0, void 0, this.createAsConst(this.createTypeDefsObject(model, lite)))
-      ] : []
-    ];
-    const enums = model.declarations.filter(import_ast3.isEnum);
-    if (enums.length > 0) {
-      members.push(ts.factory.createPropertyDeclaration(void 0, "enums", void 0, void 0, this.createAsConst(ts.factory.createObjectLiteralExpression(enums.map((e) => ts.factory.createPropertyAssignment(e.name, this.createEnumObject(e))), true))));
-    }
-    const authType = getAuthDecl(model);
-    if (authType) {
-      members.push(ts.factory.createPropertyDeclaration(void 0, "authType", void 0, void 0, this.createAsConst(this.createLiteralNode(authType.name))));
-    }
-    const procedures = model.declarations.filter(import_ast3.isProcedure);
-    if (procedures.length > 0) {
-      members.push(ts.factory.createPropertyDeclaration(void 0, "procedures", void 0, void 0, this.createAsConst(this.createProceduresObject(procedures))));
-    }
-    members.push(ts.factory.createPropertyDeclaration(void 0, "plugins", void 0, void 0, ts.factory.createObjectLiteralExpression([], true)));
-    const schemaClass = ts.factory.createClassDeclaration([
-      ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)
-    ], "SchemaType", void 0, [
-      ts.factory.createHeritageClause(ts.SyntaxKind.ImplementsKeyword, [
-        ts.factory.createExpressionWithTypeArguments(ts.factory.createIdentifier("SchemaDef"), void 0)
-      ])
-    ], members);
-    return schemaClass;
-  }
-  createAsConst(expr) {
-    return ts.factory.createAsExpression(expr, ts.factory.createTypeReferenceNode("const"));
-  }
-  createAttributesTypeAssertion(expr) {
-    this.usedAttributeApplication = true;
-    return ts.factory.createAsExpression(expr, ts.factory.createTypeOperatorNode(ts.SyntaxKind.ReadonlyKeyword, ts.factory.createArrayTypeNode(ts.factory.createTypeReferenceNode("AttributeApplication"))));
-  }
-  createDefaultTypeAssertion(expr) {
-    this.usedFieldDefault = true;
-    return ts.factory.createAsExpression(expr, ts.factory.createTypeReferenceNode("FieldDefault"));
-  }
-  createProviderObject(model) {
-    const dsProvider = this.getDataSourceProvider(model);
-    const defaultSchema = this.getDataSourceDefaultSchema(model);
-    return ts.factory.createObjectLiteralExpression([
-      ts.factory.createPropertyAssignment("type", ts.factory.createStringLiteral(dsProvider)),
-      ...defaultSchema ? [
-        ts.factory.createPropertyAssignment("defaultSchema", ts.factory.createStringLiteral(defaultSchema))
-      ] : []
-    ], true);
-  }
-  createModelsObject(model, lite) {
-    return ts.factory.createObjectLiteralExpression(this.getAllDataModels(model).map((dm) => ts.factory.createPropertyAssignment(dm.name, this.createDataModelObject(dm, lite))), true);
-  }
-  getAllDataModels(model) {
-    return model.declarations.filter((d) => (0, import_ast3.isDataModel)(d) && !hasAttribute(d, "@@ignore"));
-  }
-  getAllTypeDefs(model) {
-    return model.declarations.filter((d) => (0, import_ast3.isTypeDef)(d) && !hasAttribute(d, "@@ignore"));
-  }
-  createTypeDefsObject(model, lite) {
-    return ts.factory.createObjectLiteralExpression(this.getAllTypeDefs(model).map((td) => ts.factory.createPropertyAssignment(td.name, this.createTypeDefObject(td, lite))), true);
-  }
-  createDataModelObject(dm, lite) {
-    const allFields = (0, import_utils3.getAllFields)(dm);
-    const allAttributes = lite ? [] : (0, import_utils3.getAllAttributes)(dm).filter((attr) => {
-      if (attr.decl.$refText === "@@delegate" && attr.$container !== dm) {
-        return false;
-      }
-      return true;
-    });
-    const subModels = this.getSubModels(dm);
-    const fields = [
-      // name
-      ts.factory.createPropertyAssignment("name", ts.factory.createStringLiteral(dm.name)),
-      // baseModel
-      ...dm.baseModel ? [
-        ts.factory.createPropertyAssignment("baseModel", ts.factory.createStringLiteral(dm.baseModel.$refText))
-      ] : [],
-      // fields
-      ts.factory.createPropertyAssignment("fields", ts.factory.createObjectLiteralExpression(allFields.map((field) => ts.factory.createPropertyAssignment(field.name, this.createDataFieldObject(field, dm, lite))), true)),
-      // attributes
-      ...allAttributes.length > 0 ? [
-        ts.factory.createPropertyAssignment("attributes", this.createAttributesTypeAssertion(ts.factory.createArrayLiteralExpression(allAttributes.map((attr) => this.createAttributeObject(attr)), true)))
-      ] : [],
-      // idFields
-      ts.factory.createPropertyAssignment("idFields", ts.factory.createArrayLiteralExpression(getIdFields(dm).map((idField) => ts.factory.createStringLiteral(idField)))),
-      // uniqueFields
-      ts.factory.createPropertyAssignment("uniqueFields", this.createUniqueFieldsObject(dm)),
-      // isDelegate
-      ...isDelegateModel(dm) ? [
-        ts.factory.createPropertyAssignment("isDelegate", ts.factory.createTrue())
-      ] : [],
-      // subModels
-      ...subModels.length > 0 ? [
-        ts.factory.createPropertyAssignment("subModels", ts.factory.createArrayLiteralExpression(subModels.map((subModel) => ts.factory.createStringLiteral(subModel))))
-      ] : [],
-      ...dm.isView ? [
-        ts.factory.createPropertyAssignment("isView", ts.factory.createTrue())
-      ] : []
-    ];
-    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);
-  }
-  getSubModels(dm) {
-    return dm.$container.declarations.filter(import_ast3.isDataModel).filter((d) => d.baseModel?.ref === dm).map((d) => d.name);
-  }
-  createTypeDefObject(td, lite) {
-    const allFields = (0, import_utils3.getAllFields)(td);
-    const allAttributes = (0, import_utils3.getAllAttributes)(td);
-    const fields = [
-      // name
-      ts.factory.createPropertyAssignment("name", ts.factory.createStringLiteral(td.name)),
-      // fields
-      ts.factory.createPropertyAssignment("fields", ts.factory.createObjectLiteralExpression(allFields.map((field) => ts.factory.createPropertyAssignment(field.name, this.createDataFieldObject(field, void 0, lite))), true)),
-      // attributes
-      ...allAttributes.length > 0 ? [
-        ts.factory.createPropertyAssignment("attributes", this.createAttributesTypeAssertion(ts.factory.createArrayLiteralExpression(allAttributes.map((attr) => this.createAttributeObject(attr)), true)))
-      ] : []
-    ];
-    return ts.factory.createObjectLiteralExpression(fields, true);
-  }
-  createComputedFieldsObject(fields) {
-    return ts.factory.createObjectLiteralExpression(fields.map((field) => ts.factory.createMethodDeclaration(void 0, void 0, field.name, void 0, void 0, [
-      // parameter: `context: { modelAlias: string }`
-      ts.factory.createParameterDeclaration(void 0, void 0, "_context", void 0, ts.factory.createTypeLiteralNode([
-        ts.factory.createPropertySignature(void 0, "modelAlias", void 0, ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword))
-      ]), void 0)
-    ], ts.factory.createTypeReferenceNode(this.mapFieldTypeToTSType(field.type)), ts.factory.createBlock([
-      ts.factory.createThrowStatement(ts.factory.createNewExpression(ts.factory.createIdentifier("Error"), void 0, [
-        ts.factory.createStringLiteral("This is a stub for computed field")
-      ]))
-    ], true))), true);
-  }
-  createUpdatedAtObject(ignoreArg) {
-    return ts.factory.createObjectLiteralExpression([
-      ts.factory.createPropertyAssignment("ignore", ts.factory.createArrayLiteralExpression(ignoreArg.value.items.map((item) => ts.factory.createStringLiteral(item.target.$refText))))
-    ]);
-  }
-  mapFieldTypeToTSType(type) {
-    let result = (0, import_ts_pattern2.match)(type.type).with("String", () => "string").with("Boolean", () => "boolean").with("Int", () => "number").with("Float", () => "number").with("BigInt", () => "bigint").with("Decimal", () => "number").otherwise(() => "unknown");
-    if (type.array) {
-      result = `${result}[]`;
-    }
-    if (type.optional) {
-      result = `${result} | null`;
-    }
-    return result;
-  }
-  createDataFieldObject(field, contextModel, lite) {
-    const objectFields = [
-      // name
-      ts.factory.createPropertyAssignment("name", ts.factory.createStringLiteral(field.name)),
-      // type
-      ts.factory.createPropertyAssignment("type", this.generateFieldTypeLiteral(field))
-    ];
-    if (contextModel && model_utils_exports.isIdField(field, contextModel)) {
-      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()));
-    }
-    const updatedAtAttrib = getAttribute(field, "@updatedAt");
-    if (updatedAtAttrib) {
-      const ignoreArg = updatedAtAttrib.args.find((arg) => arg.$resolvedParam?.name === "ignore");
-      objectFields.push(ts.factory.createPropertyAssignment("updatedAt", ignoreArg ? this.createUpdatedAtObject(ignoreArg) : ts.factory.createTrue()));
-    }
-    if (hasAttribute(field, "@omit")) {
-      objectFields.push(ts.factory.createPropertyAssignment("omit", ts.factory.createTrue()));
-    }
-    if (contextModel && // id fields are duplicated in inherited models
-    !isIdField(field, contextModel)) {
-      const delegateOrigin = getDelegateOriginModel(field, contextModel);
-      if (delegateOrigin) {
-        objectFields.push(ts.factory.createPropertyAssignment("originModel", ts.factory.createStringLiteral(delegateOrigin)));
-      }
-    }
-    if (this.isDiscriminatorField(field)) {
-      objectFields.push(ts.factory.createPropertyAssignment("isDiscriminator", ts.factory.createTrue()));
-    }
-    if (!lite && field.attributes.length > 0) {
-      objectFields.push(ts.factory.createPropertyAssignment("attributes", this.createAttributesTypeAssertion(ts.factory.createArrayLiteralExpression(field.attributes.map((attr) => this.createAttributeObject(attr))))));
-    }
-    const defaultValue = this.getFieldMappedDefault(field);
-    if (defaultValue !== void 0) {
-      let defaultExpr;
-      if (defaultValue === null) {
-        defaultExpr = this.createExpressionUtilsCall("_null");
-      } else if (typeof defaultValue === "object" && !Array.isArray(defaultValue)) {
-        if ("call" in defaultValue) {
-          defaultExpr = this.createExpressionUtilsCall("call", [
-            ts.factory.createStringLiteral(defaultValue.call),
-            ...defaultValue.args.length > 0 ? [
-              ts.factory.createArrayLiteralExpression(defaultValue.args.map((arg) => this.createExpressionUtilsCall("literal", [
-                this.createLiteralNode(arg)
-              ])))
-            ] : []
-          ]);
-        } else if ("authMember" in defaultValue) {
-          defaultExpr = this.createExpressionUtilsCall("member", [
-            this.createExpressionUtilsCall("call", [
-              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 if (Array.isArray(defaultValue)) {
-        defaultExpr = ts.factory.createArrayLiteralExpression(defaultValue.map((item) => this.createLiteralNode(item)));
-      } else {
-        defaultExpr = this.createLiteralNode(defaultValue);
-      }
-      objectFields.push(ts.factory.createPropertyAssignment("default", this.createDefaultTypeAssertion(defaultExpr)));
-    }
-    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.createAsExpression(ts.factory.createArrayLiteralExpression(fkFor.map((fk) => ts.factory.createStringLiteral(fk)), true), ts.factory.createTypeOperatorNode(ts.SyntaxKind.ReadonlyKeyword, ts.factory.createArrayTypeNode(ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword))))));
-    }
-    return ts.factory.createObjectLiteralExpression(objectFields, true);
-  }
-  isDiscriminatorField(field) {
-    const origin = field.$container;
-    return getAttribute(origin, "@@delegate")?.args.some((arg) => arg.$resolvedParam.name === "discriminator" && (0, import_utils3.isDataFieldReference)(arg.value) && arg.value.target.ref === field);
-  }
-  getDataSourceProvider(model) {
-    const dataSource = model.declarations.find(import_ast3.isDataSource);
-    (0, import_common_helpers2.invariant)(dataSource, "No data source found in the model");
-    const providerExpr = dataSource.fields.find((f) => f.name === "provider")?.value;
-    (0, import_common_helpers2.invariant)((0, import_ast3.isLiteralExpr)(providerExpr) && typeof providerExpr.value === "string", "Provider must be a string literal");
-    return providerExpr.value;
-  }
-  getDataSourceDefaultSchema(model) {
-    const dataSource = model.declarations.find(import_ast3.isDataSource);
-    (0, import_common_helpers2.invariant)(dataSource, "No data source found in the model");
-    const defaultSchemaExpr = dataSource.fields.find((f) => f.name === "defaultSchema")?.value;
-    if (!defaultSchemaExpr) {
-      return void 0;
-    }
-    (0, import_common_helpers2.invariant)((0, import_ast3.isLiteralExpr)(defaultSchemaExpr) && typeof defaultSchemaExpr.value === "string", "Default schema must be a string literal");
-    return defaultSchemaExpr.value;
-  }
-  getFieldMappedDefault(field) {
-    const defaultAttr = getAttribute(field, "@default");
-    if (!defaultAttr) {
-      return void 0;
-    }
-    const defaultValue = defaultAttr.args[0]?.value;
-    (0, import_common_helpers2.invariant)(defaultValue, "Expected a default value");
-    return this.getMappedValue(defaultValue, field.type);
-  }
-  getMappedValue(expr, fieldType) {
-    if ((0, import_ast3.isLiteralExpr)(expr)) {
-      const lit = expr.value;
-      return fieldType.type === "Boolean" ? lit : [
-        "Int",
-        "Float",
-        "Decimal",
-        "BigInt"
-      ].includes(fieldType.type) ? Number(lit) : lit;
-    } else if ((0, import_ast3.isArrayExpr)(expr)) {
-      return expr.items.map((item) => this.getMappedValue(item, fieldType));
-    } else if ((0, import_ast3.isReferenceExpr)(expr) && (0, import_ast3.isEnumField)(expr.target.ref)) {
-      return expr.target.ref.name;
-    } else if ((0, import_ast3.isInvocationExpr)(expr)) {
-      return {
-        call: expr.function.$refText,
-        args: expr.args.map((arg) => this.getLiteral(arg.value))
-      };
-    } else if (this.isAuthMemberAccess(expr)) {
-      return {
-        authMember: this.getMemberAccessChain(expr)
-      };
-    } else if ((0, import_ast3.isNullExpr)(expr)) {
-      return null;
-    } else {
-      throw new Error(`Unsupported expression type: ${expr.$type}`);
-    }
-  }
-  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");
-    const fkFields = [];
-    if (relation) {
-      for (const arg of relation.args) {
-        const param = arg.$resolvedParam.name;
-        if (param === "fields" || param === "references") {
-          const fieldNames = this.getReferenceNames(arg.value);
-          if (fieldNames) {
-            if (param === "fields") {
-              fkFields.push(...fieldNames);
-            }
-            relationFields.push(ts.factory.createPropertyAssignment(param, ts.factory.createArrayLiteralExpression(fieldNames.map((el) => ts.factory.createStringLiteral(el)))));
-          }
-        }
-        if (param === "onDelete" || param === "onUpdate") {
-          const action = arg.value.target.$refText;
-          relationFields.push(ts.factory.createPropertyAssignment(param, ts.factory.createStringLiteral(action)));
-        }
-      }
-    }
-    if (fkFields.length > 0) {
-      const allHaveDefault = fkFields.every((fieldName) => {
-        const fieldDef = field.$container.fields.find((f) => f.name === fieldName);
-        return fieldDef && hasAttribute(fieldDef, "@default");
-      });
-      if (allHaveDefault) {
-        relationFields.push(ts.factory.createPropertyAssignment("hasDefault", ts.factory.createTrue()));
-      }
-    }
-    return ts.factory.createObjectLiteralExpression(relationFields);
-  }
-  getReferenceNames(expr) {
-    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_common_helpers2.invariant)((0, import_ast3.isLiteralExpr)(nameArg.value), "name must be a literal");
-        return nameArg.value.value;
-      }
-    }
-    return void 0;
-  }
-  createUniqueFieldsObject(dm) {
-    const properties = [];
-    const allFields = (0, import_utils3.getAllFields)(dm);
-    for (const field of allFields) {
-      if (hasAttribute(field, "@id") || hasAttribute(field, "@unique")) {
-        properties.push(ts.factory.createPropertyAssignment(field.name, ts.factory.createObjectLiteralExpression([
-          ts.factory.createPropertyAssignment("type", this.generateFieldTypeLiteral(field))
-        ])));
-      }
-    }
-    const allAttributes = (0, import_utils3.getAllAttributes)(dm);
-    const seenKeys = /* @__PURE__ */ new Set();
-    for (const attr of allAttributes) {
-      if (attr.decl.$refText === "@@id" || attr.decl.$refText === "@@unique") {
-        const fieldsArg = (0, import_utils3.getAttributeArg)(attr, "fields");
-        if (!fieldsArg) {
-          continue;
-        }
-        const fieldNames = this.getReferenceNames(fieldsArg);
-        if (!fieldNames) {
-          continue;
-        }
-        if (fieldNames.length === 1) {
-          const fieldDef = allFields.find((f) => f.name === fieldNames[0]);
-          properties.push(ts.factory.createPropertyAssignment(fieldNames[0], ts.factory.createObjectLiteralExpression([
-            ts.factory.createPropertyAssignment("type", this.generateFieldTypeLiteral(fieldDef))
-          ])));
-        } else {
-          const key = this.getCompoundUniqueKey(attr, fieldNames);
-          if (seenKeys.has(key)) {
-            continue;
-          }
-          seenKeys.add(key);
-          properties.push(ts.factory.createPropertyAssignment(key, ts.factory.createObjectLiteralExpression(fieldNames.map((field) => {
-            const fieldDef = allFields.find((f) => f.name === field);
-            return ts.factory.createPropertyAssignment(field, ts.factory.createObjectLiteralExpression([
-              ts.factory.createPropertyAssignment("type", this.generateFieldTypeLiteral(fieldDef))
-            ]));
-          }))));
-        }
-      }
-    }
-    return ts.factory.createObjectLiteralExpression(properties, true);
-  }
-  getCompoundUniqueKey(attr, fieldNames) {
-    const nameArg = attr.args.find((arg) => arg.$resolvedParam.name === "name");
-    if (nameArg && (0, import_ast3.isLiteralExpr)(nameArg.value)) {
-      return nameArg.value.value;
-    } else {
-      return fieldNames.join("_");
-    }
-  }
-  generateFieldTypeLiteral(field) {
-    (0, import_common_helpers2.invariant)(field.type.type || field.type.reference || field.type.unsupported, "Field type must be a primitive, reference, or Unsupported");
-    return field.type.type ? ts.factory.createStringLiteral(field.type.type) : field.type.reference ? ts.factory.createStringLiteral(field.type.reference.$refText) : ts.factory.createStringLiteral("Unsupported");
-  }
-  createEnumObject(e) {
-    return ts.factory.createObjectLiteralExpression([
-      ts.factory.createPropertyAssignment("name", ts.factory.createStringLiteral(e.name)),
-      ts.factory.createPropertyAssignment("values", ts.factory.createObjectLiteralExpression(e.fields.map((f) => ts.factory.createPropertyAssignment(f.name, ts.factory.createStringLiteral(f.name))), true)),
-      // only generate `fields` if there are attributes on the fields
-      ...e.fields.some((f) => f.attributes.length > 0) ? [
-        ts.factory.createPropertyAssignment("fields", ts.factory.createObjectLiteralExpression(e.fields.map((field) => ts.factory.createPropertyAssignment(field.name, ts.factory.createObjectLiteralExpression([
-          ts.factory.createPropertyAssignment("name", ts.factory.createStringLiteral(field.name)),
-          ...field.attributes.length > 0 ? [
-            ts.factory.createPropertyAssignment("attributes", this.createAttributesTypeAssertion(ts.factory.createArrayLiteralExpression(field.attributes?.map((attr) => this.createAttributeObject(attr)) ?? [], true)))
-          ] : []
-        ], true))), true))
-      ] : [],
-      ...e.attributes.length > 0 ? [
-        ts.factory.createPropertyAssignment("attributes", this.createAttributesTypeAssertion(ts.factory.createArrayLiteralExpression(e.attributes.map((attr) => this.createAttributeObject(attr)), true)))
-      ] : []
-    ], 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" ? this.createNumberLiteral(arg) : arg === true ? ts.factory.createTrue() : arg === false ? ts.factory.createFalse() : void 0;
-  }
-  createNumberLiteral(arg) {
-    return arg < 0 ? ts.factory.createPrefixUnaryExpression(ts.SyntaxKind.MinusToken, ts.factory.createNumericLiteral(-arg)) : ts.factory.createNumericLiteral(arg);
-  }
-  createProceduresObject(procedures) {
-    return ts.factory.createObjectLiteralExpression(procedures.map((proc) => ts.factory.createPropertyAssignment(proc.name, this.createProcedureObject(proc))), true);
-  }
-  createProcedureObject(proc) {
-    const params = ts.factory.createObjectLiteralExpression(proc.params.map((param) => ts.factory.createPropertyAssignment(param.name, ts.factory.createObjectLiteralExpression([
-      ts.factory.createPropertyAssignment("name", ts.factory.createStringLiteral(param.name)),
-      ...param.optional ? [
-        ts.factory.createPropertyAssignment("optional", ts.factory.createTrue())
-      ] : [],
-      ...param.type.array ? [
-        ts.factory.createPropertyAssignment("array", ts.factory.createTrue())
-      ] : [],
-      ts.factory.createPropertyAssignment("type", ts.factory.createStringLiteral(param.type.type ?? param.type.reference.$refText))
-    ]))), true);
-    return ts.factory.createObjectLiteralExpression([
-      ts.factory.createPropertyAssignment("params", params),
-      ts.factory.createPropertyAssignment("returnType", ts.factory.createStringLiteral(proc.returnType.type ?? proc.returnType.reference.$refText)),
-      ...proc.returnType.array ? [
-        ts.factory.createPropertyAssignment("returnArray", ts.factory.createTrue())
-      ] : [],
-      ...proc.mutation ? [
-        ts.factory.createPropertyAssignment("mutation", ts.factory.createTrue())
-      ] : []
-    ], true);
-  }
-  generateBannerComments(statements) {
-    const banner = `////////////////////////////////////////////////////////////////////////////////////////////
+	usedExpressionUtils = false;
+	usedAttributeApplication = false;
+	usedFieldDefault = false;
+	async generate(model, options) {
+		node_fs.default.mkdirSync(options.outDir, { recursive: true });
+		this.generateSchema(model, options);
+		if (options.generateModelTypes !== false) this.generateModelsAndTypeDefs(model, options);
+		if (options.generateInputTypes !== false) this.generateInputTypes(model, options);
+	}
+	generateSchema(model, options) {
+		const targets = [];
+		if (!options.liteOnly) targets.push({
+			lite: false,
+			file: "schema.ts"
+		});
+		if (options.lite || options.liteOnly) targets.push({
+			lite: true,
+			file: "schema-lite.ts"
+		});
+		for (const { lite, file } of targets) {
+			this.usedExpressionUtils = false;
+			this.usedAttributeApplication = false;
+			this.usedFieldDefault = false;
+			const statements = [];
+			this.generateSchemaStatements(model, statements, lite);
+			this.generateBannerComments(statements);
+			const schemaOutputFile = node_path.default.join(options.outDir, file);
+			const sourceFile = typescript.createSourceFile(schemaOutputFile, "", typescript.ScriptTarget.ESNext, false, typescript.ScriptKind.TS);
+			const result = typescript.createPrinter().printList(typescript.ListFormat.MultiLine, typescript.factory.createNodeArray(statements), sourceFile);
+			node_fs.default.writeFileSync(schemaOutputFile, result);
+		}
+	}
+	generateSchemaStatements(model, statements, lite) {
+		const schemaClass = this.createSchemaClass(model, lite);
+		const schemaImportDecl = typescript.factory.createImportDeclaration(void 0, typescript.factory.createImportClause(void 0, void 0, typescript.factory.createNamedImports([
+			typescript.factory.createImportSpecifier(true, void 0, typescript.factory.createIdentifier("SchemaDef")),
+			...this.usedAttributeApplication ? [typescript.factory.createImportSpecifier(true, void 0, typescript.factory.createIdentifier("AttributeApplication"))] : [],
+			...this.usedFieldDefault ? [typescript.factory.createImportSpecifier(true, void 0, typescript.factory.createIdentifier("FieldDefault"))] : [],
+			...this.usedExpressionUtils ? [typescript.factory.createImportSpecifier(false, void 0, typescript.factory.createIdentifier("ExpressionUtils"))] : []
+		])), typescript.factory.createStringLiteral("@zenstackhq/schema"));
+		statements.push(schemaImportDecl);
+		statements.push(schemaClass);
+		const schemaDecl = typescript.factory.createVariableStatement([typescript.factory.createModifier(typescript.SyntaxKind.ExportKeyword)], typescript.factory.createVariableDeclarationList([typescript.factory.createVariableDeclaration("schema", void 0, void 0, typescript.factory.createNewExpression(typescript.factory.createIdentifier("SchemaType"), void 0, []))], typescript.NodeFlags.Const));
+		statements.push(schemaDecl);
+	}
+	createExpressionUtilsCall(method, args) {
+		this.usedExpressionUtils = true;
+		return typescript.factory.createCallExpression(typescript.factory.createPropertyAccessExpression(typescript.factory.createIdentifier("ExpressionUtils"), method), void 0, args || []);
+	}
+	createSchemaClass(model, lite) {
+		const members = [
+			typescript.factory.createPropertyDeclaration(void 0, "provider", void 0, void 0, this.createAsConst(this.createProviderObject(model))),
+			typescript.factory.createPropertyDeclaration(void 0, "models", void 0, void 0, this.createAsConst(this.createModelsObject(model, lite))),
+			...model.declarations.some(_zenstackhq_language_ast.isTypeDef) ? [typescript.factory.createPropertyDeclaration(void 0, "typeDefs", void 0, void 0, this.createAsConst(this.createTypeDefsObject(model, lite)))] : []
+		];
+		const enums = model.declarations.filter(_zenstackhq_language_ast.isEnum);
+		if (enums.length > 0) members.push(typescript.factory.createPropertyDeclaration(void 0, "enums", void 0, void 0, this.createAsConst(typescript.factory.createObjectLiteralExpression(enums.map((e) => typescript.factory.createPropertyAssignment(e.name, this.createEnumObject(e))), true))));
+		const authType = getAuthDecl(model);
+		if (authType) members.push(typescript.factory.createPropertyDeclaration(void 0, "authType", void 0, void 0, this.createAsConst(this.createLiteralNode(authType.name))));
+		const procedures = model.declarations.filter(_zenstackhq_language_ast.isProcedure);
+		if (procedures.length > 0) members.push(typescript.factory.createPropertyDeclaration(void 0, "procedures", void 0, void 0, this.createAsConst(this.createProceduresObject(procedures))));
+		members.push(typescript.factory.createPropertyDeclaration(void 0, "plugins", void 0, void 0, typescript.factory.createObjectLiteralExpression([], true)));
+		return typescript.factory.createClassDeclaration([typescript.factory.createModifier(typescript.SyntaxKind.ExportKeyword)], "SchemaType", void 0, [typescript.factory.createHeritageClause(typescript.SyntaxKind.ImplementsKeyword, [typescript.factory.createExpressionWithTypeArguments(typescript.factory.createIdentifier("SchemaDef"), void 0)])], members);
+	}
+	createAsConst(expr) {
+		return typescript.factory.createAsExpression(expr, typescript.factory.createTypeReferenceNode("const"));
+	}
+	createAttributesTypeAssertion(expr) {
+		this.usedAttributeApplication = true;
+		return typescript.factory.createAsExpression(expr, typescript.factory.createTypeOperatorNode(typescript.SyntaxKind.ReadonlyKeyword, typescript.factory.createArrayTypeNode(typescript.factory.createTypeReferenceNode("AttributeApplication"))));
+	}
+	createDefaultTypeAssertion(expr) {
+		this.usedFieldDefault = true;
+		return typescript.factory.createAsExpression(expr, typescript.factory.createTypeReferenceNode("FieldDefault"));
+	}
+	createProviderObject(model) {
+		const dsProvider = this.getDataSourceProvider(model);
+		const defaultSchema = this.getDataSourceDefaultSchema(model);
+		return typescript.factory.createObjectLiteralExpression([typescript.factory.createPropertyAssignment("type", typescript.factory.createStringLiteral(dsProvider)), ...defaultSchema ? [typescript.factory.createPropertyAssignment("defaultSchema", typescript.factory.createStringLiteral(defaultSchema))] : []], true);
+	}
+	createModelsObject(model, lite) {
+		return typescript.factory.createObjectLiteralExpression(this.getAllDataModels(model).map((dm) => typescript.factory.createPropertyAssignment(dm.name, this.createDataModelObject(dm, lite))), true);
+	}
+	getAllDataModels(model) {
+		return model.declarations.filter((d) => (0, _zenstackhq_language_ast.isDataModel)(d) && !hasAttribute(d, "@@ignore"));
+	}
+	getAllTypeDefs(model) {
+		return model.declarations.filter((d) => (0, _zenstackhq_language_ast.isTypeDef)(d) && !hasAttribute(d, "@@ignore"));
+	}
+	createTypeDefsObject(model, lite) {
+		return typescript.factory.createObjectLiteralExpression(this.getAllTypeDefs(model).map((td) => typescript.factory.createPropertyAssignment(td.name, this.createTypeDefObject(td, lite))), true);
+	}
+	createDataModelObject(dm, lite) {
+		const allFields = (0, _zenstackhq_language_utils.getAllFields)(dm);
+		const allAttributes = lite ? [] : (0, _zenstackhq_language_utils.getAllAttributes)(dm).filter((attr) => {
+			if (attr.decl.$refText === "@@delegate" && attr.$container !== dm) return false;
+			return true;
+		});
+		const subModels = this.getSubModels(dm);
+		const fields = [
+			typescript.factory.createPropertyAssignment("name", typescript.factory.createStringLiteral(dm.name)),
+			...dm.baseModel ? [typescript.factory.createPropertyAssignment("baseModel", typescript.factory.createStringLiteral(dm.baseModel.$refText))] : [],
+			typescript.factory.createPropertyAssignment("fields", typescript.factory.createObjectLiteralExpression(allFields.map((field) => typescript.factory.createPropertyAssignment(field.name, this.createDataFieldObject(field, dm, lite))), true)),
+			...allAttributes.length > 0 ? [typescript.factory.createPropertyAssignment("attributes", this.createAttributesTypeAssertion(typescript.factory.createArrayLiteralExpression(allAttributes.map((attr) => this.createAttributeObject(attr)), true)))] : [],
+			typescript.factory.createPropertyAssignment("idFields", typescript.factory.createArrayLiteralExpression(getIdFields(dm).map((idField) => typescript.factory.createStringLiteral(idField)))),
+			typescript.factory.createPropertyAssignment("uniqueFields", this.createUniqueFieldsObject(dm)),
+			...isDelegateModel$1(dm) ? [typescript.factory.createPropertyAssignment("isDelegate", typescript.factory.createTrue())] : [],
+			...subModels.length > 0 ? [typescript.factory.createPropertyAssignment("subModels", typescript.factory.createArrayLiteralExpression(subModels.map((subModel) => typescript.factory.createStringLiteral(subModel))))] : [],
+			...dm.isView ? [typescript.factory.createPropertyAssignment("isView", typescript.factory.createTrue())] : []
+		];
+		const computedFields = allFields.filter((f) => hasAttribute(f, "@computed") && !getDelegateOriginModel(f, dm));
+		if (computedFields.length > 0) fields.push(typescript.factory.createPropertyAssignment("computedFields", this.createComputedFieldsObject(computedFields)));
+		return typescript.factory.createObjectLiteralExpression(fields, true);
+	}
+	getSubModels(dm) {
+		return dm.$container.declarations.filter(_zenstackhq_language_ast.isDataModel).filter((d) => d.baseModel?.ref === dm).map((d) => d.name);
+	}
+	createTypeDefObject(td, lite) {
+		const allFields = (0, _zenstackhq_language_utils.getAllFields)(td);
+		const allAttributes = (0, _zenstackhq_language_utils.getAllAttributes)(td);
+		const fields = [
+			typescript.factory.createPropertyAssignment("name", typescript.factory.createStringLiteral(td.name)),
+			typescript.factory.createPropertyAssignment("fields", typescript.factory.createObjectLiteralExpression(allFields.map((field) => typescript.factory.createPropertyAssignment(field.name, this.createDataFieldObject(field, void 0, lite))), true)),
+			...allAttributes.length > 0 ? [typescript.factory.createPropertyAssignment("attributes", this.createAttributesTypeAssertion(typescript.factory.createArrayLiteralExpression(allAttributes.map((attr) => this.createAttributeObject(attr)), true)))] : []
+		];
+		return typescript.factory.createObjectLiteralExpression(fields, true);
+	}
+	createComputedFieldsObject(fields) {
+		return typescript.factory.createObjectLiteralExpression(fields.map((field) => typescript.factory.createMethodDeclaration(void 0, void 0, field.name, void 0, void 0, [typescript.factory.createParameterDeclaration(void 0, void 0, "_context", void 0, typescript.factory.createTypeLiteralNode([typescript.factory.createPropertySignature(void 0, "modelAlias", void 0, typescript.factory.createKeywordTypeNode(typescript.SyntaxKind.StringKeyword))]), void 0)], typescript.factory.createTypeReferenceNode(this.mapFieldTypeToTSType(field.type)), typescript.factory.createBlock([typescript.factory.createThrowStatement(typescript.factory.createNewExpression(typescript.factory.createIdentifier("Error"), void 0, [typescript.factory.createStringLiteral("This is a stub for computed field")]))], true))), true);
+	}
+	createUpdatedAtObject(ignoreArg) {
+		return typescript.factory.createObjectLiteralExpression([typescript.factory.createPropertyAssignment("ignore", typescript.factory.createArrayLiteralExpression(ignoreArg.value.items.map((item) => typescript.factory.createStringLiteral(item.target.$refText))))]);
+	}
+	mapFieldTypeToTSType(type) {
+		let result = (0, ts_pattern.match)(type.type).with("String", () => "string").with("Boolean", () => "boolean").with("Int", () => "number").with("Float", () => "number").with("BigInt", () => "bigint").with("Decimal", () => "number").otherwise(() => "unknown");
+		if (type.array) result = `${result}[]`;
+		if (type.optional) result = `${result} | null`;
+		return result;
+	}
+	createDataFieldObject(field, contextModel, lite) {
+		const objectFields = [typescript.factory.createPropertyAssignment("name", typescript.factory.createStringLiteral(field.name)), typescript.factory.createPropertyAssignment("type", this.generateFieldTypeLiteral(field))];
+		if (contextModel && isIdField(field, contextModel)) objectFields.push(typescript.factory.createPropertyAssignment("id", typescript.factory.createTrue()));
+		if (isUniqueField(field)) objectFields.push(typescript.factory.createPropertyAssignment("unique", typescript.factory.createTrue()));
+		if (field.type.optional) objectFields.push(typescript.factory.createPropertyAssignment("optional", typescript.factory.createTrue()));
+		if (field.type.array) objectFields.push(typescript.factory.createPropertyAssignment("array", typescript.factory.createTrue()));
+		const updatedAtAttrib = getAttribute(field, "@updatedAt");
+		if (updatedAtAttrib) {
+			const ignoreArg = updatedAtAttrib.args.find((arg) => arg.$resolvedParam?.name === "ignore");
+			objectFields.push(typescript.factory.createPropertyAssignment("updatedAt", ignoreArg ? this.createUpdatedAtObject(ignoreArg) : typescript.factory.createTrue()));
+		}
+		if (hasAttribute(field, "@omit")) objectFields.push(typescript.factory.createPropertyAssignment("omit", typescript.factory.createTrue()));
+		if (contextModel && !isIdField(field, contextModel)) {
+			const delegateOrigin = getDelegateOriginModel(field, contextModel);
+			if (delegateOrigin) objectFields.push(typescript.factory.createPropertyAssignment("originModel", typescript.factory.createStringLiteral(delegateOrigin)));
+		}
+		if (this.isDiscriminatorField(field)) objectFields.push(typescript.factory.createPropertyAssignment("isDiscriminator", typescript.factory.createTrue()));
+		if (!lite && field.attributes.length > 0) objectFields.push(typescript.factory.createPropertyAssignment("attributes", this.createAttributesTypeAssertion(typescript.factory.createArrayLiteralExpression(field.attributes.map((attr) => this.createAttributeObject(attr))))));
+		const defaultValue = this.getFieldMappedDefault(field);
+		if (defaultValue !== void 0) {
+			let defaultExpr;
+			if (defaultValue === null) defaultExpr = this.createExpressionUtilsCall("_null");
+			else if (typeof defaultValue === "object" && !Array.isArray(defaultValue)) if ("call" in defaultValue) defaultExpr = this.createExpressionUtilsCall("call", [typescript.factory.createStringLiteral(defaultValue.call), ...defaultValue.args.length > 0 ? [typescript.factory.createArrayLiteralExpression(defaultValue.args.map((arg) => this.createExpressionUtilsCall("literal", [this.createLiteralNode(arg)])))] : []]);
+			else if ("authMember" in defaultValue) defaultExpr = this.createExpressionUtilsCall("member", [this.createExpressionUtilsCall("call", [typescript.factory.createStringLiteral("auth")]), typescript.factory.createArrayLiteralExpression(defaultValue.authMember.map((m) => typescript.factory.createStringLiteral(m)))]);
+			else throw new Error(`Unsupported default value type for field ${field.name}`);
+			else if (Array.isArray(defaultValue)) defaultExpr = typescript.factory.createArrayLiteralExpression(defaultValue.map((item) => this.createLiteralNode(item)));
+			else defaultExpr = this.createLiteralNode(defaultValue);
+			objectFields.push(typescript.factory.createPropertyAssignment("default", this.createDefaultTypeAssertion(defaultExpr)));
+		}
+		if (hasAttribute(field, "@computed")) objectFields.push(typescript.factory.createPropertyAssignment("computed", typescript.factory.createTrue()));
+		if ((0, _zenstackhq_language_ast.isDataModel)(field.type.reference?.ref)) objectFields.push(typescript.factory.createPropertyAssignment("relation", this.createRelationObject(field, contextModel)));
+		const fkFor = this.getForeignKeyFor(field, contextModel);
+		if (fkFor && fkFor.length > 0) objectFields.push(typescript.factory.createPropertyAssignment("foreignKeyFor", typescript.factory.createAsExpression(typescript.factory.createArrayLiteralExpression(fkFor.map((fk) => typescript.factory.createStringLiteral(fk)), true), typescript.factory.createTypeOperatorNode(typescript.SyntaxKind.ReadonlyKeyword, typescript.factory.createArrayTypeNode(typescript.factory.createKeywordTypeNode(typescript.SyntaxKind.StringKeyword))))));
+		return typescript.factory.createObjectLiteralExpression(objectFields, true);
+	}
+	isDiscriminatorField(field) {
+		const origin = field.$container;
+		return getAttribute(origin, "@@delegate")?.args.some((arg) => arg.$resolvedParam?.name === "discriminator" && (0, _zenstackhq_language_utils.isDataFieldReference)(arg.value) && arg.value.target.ref === field);
+	}
+	getDataSourceProvider(model) {
+		const dataSource = model.declarations.find(_zenstackhq_language_ast.isDataSource);
+		(0, _zenstackhq_common_helpers.invariant)(dataSource, "No data source found in the model");
+		const providerExpr = dataSource.fields.find((f) => f.name === "provider")?.value;
+		(0, _zenstackhq_common_helpers.invariant)((0, _zenstackhq_language_ast.isLiteralExpr)(providerExpr) && typeof providerExpr.value === "string", "Provider must be a string literal");
+		return providerExpr.value;
+	}
+	getDataSourceDefaultSchema(model) {
+		const dataSource = model.declarations.find(_zenstackhq_language_ast.isDataSource);
+		(0, _zenstackhq_common_helpers.invariant)(dataSource, "No data source found in the model");
+		const defaultSchemaExpr = dataSource.fields.find((f) => f.name === "defaultSchema")?.value;
+		if (!defaultSchemaExpr) return;
+		(0, _zenstackhq_common_helpers.invariant)((0, _zenstackhq_language_ast.isLiteralExpr)(defaultSchemaExpr) && typeof defaultSchemaExpr.value === "string", "Default schema must be a string literal");
+		return defaultSchemaExpr.value;
+	}
+	getFieldMappedDefault(field) {
+		const defaultAttr = getAttribute(field, "@default");
+		if (!defaultAttr) return;
+		const defaultValue = defaultAttr.args[0]?.value;
+		(0, _zenstackhq_common_helpers.invariant)(defaultValue, "Expected a default value");
+		return this.getMappedValue(defaultValue, field.type);
+	}
+	getMappedValue(expr, fieldType) {
+		if ((0, _zenstackhq_language_ast.isLiteralExpr)(expr)) {
+			const lit = expr.value;
+			return fieldType.type === "Boolean" ? lit : [
+				"Int",
+				"Float",
+				"Decimal",
+				"BigInt"
+			].includes(fieldType.type) ? Number(lit) : lit;
+		} else if ((0, _zenstackhq_language_ast.isArrayExpr)(expr)) return expr.items.map((item) => this.getMappedValue(item, fieldType));
+		else if ((0, _zenstackhq_language_ast.isReferenceExpr)(expr) && (0, _zenstackhq_language_ast.isEnumField)(expr.target.ref)) return expr.target.ref.name;
+		else if ((0, _zenstackhq_language_ast.isInvocationExpr)(expr)) return {
+			call: expr.function.$refText,
+			args: expr.args.map((arg) => this.getLiteral(arg.value))
+		};
+		else if (this.isAuthMemberAccess(expr)) return { authMember: this.getMemberAccessChain(expr) };
+		else if ((0, _zenstackhq_language_ast.isNullExpr)(expr)) return null;
+		else throw new Error(`Unsupported expression type: ${expr.$type}`);
+	}
+	getMemberAccessChain(expr) {
+		if (!(0, _zenstackhq_language_ast.isMemberAccessExpr)(expr.operand)) return [expr.member.$refText];
+		else return [...this.getMemberAccessChain(expr.operand), expr.member.$refText];
+	}
+	isAuthMemberAccess(expr) {
+		if ((0, _zenstackhq_language_ast.isMemberAccessExpr)(expr)) return this.isAuthInvocation(expr.operand) || this.isAuthMemberAccess(expr.operand);
+		else return false;
+	}
+	isAuthInvocation(expr) {
+		return (0, _zenstackhq_language_ast.isInvocationExpr)(expr) && expr.function.$refText === "auth" && isFromStdlib(expr.function.ref);
+	}
+	createRelationObject(field, contextModel) {
+		const relationFields = [];
+		const oppositeRelation = this.getOppositeRelationField(field, contextModel);
+		if (oppositeRelation) relationFields.push(typescript.factory.createPropertyAssignment("opposite", typescript.factory.createStringLiteral(oppositeRelation.name)));
+		const relationName = this.getRelationName(field);
+		if (relationName) relationFields.push(typescript.factory.createPropertyAssignment("name", typescript.factory.createStringLiteral(relationName)));
+		const relation = getAttribute(field, "@relation");
+		const fkFields = [];
+		if (relation) for (const arg of relation.args) {
+			const param = arg.$resolvedParam?.name;
+			if (param === "fields" || param === "references") {
+				const fieldNames = this.getReferenceNames(arg.value);
+				if (fieldNames) {
+					if (param === "fields") fkFields.push(...fieldNames);
+					relationFields.push(typescript.factory.createPropertyAssignment(param, typescript.factory.createArrayLiteralExpression(fieldNames.map((el) => typescript.factory.createStringLiteral(el)))));
+				}
+			}
+			if (param === "onDelete" || param === "onUpdate") {
+				const action = arg.value.target.$refText;
+				relationFields.push(typescript.factory.createPropertyAssignment(param, typescript.factory.createStringLiteral(action)));
+			}
+		}
+		if (fkFields.length > 0) {
+			if (fkFields.every((fieldName) => {
+				const fieldDef = field.$container.fields.find((f) => f.name === fieldName);
+				return fieldDef && hasAttribute(fieldDef, "@default");
+			})) relationFields.push(typescript.factory.createPropertyAssignment("hasDefault", typescript.factory.createTrue()));
+		}
+		return typescript.factory.createObjectLiteralExpression(relationFields);
+	}
+	getReferenceNames(expr) {
+		return (0, _zenstackhq_language_ast.isArrayExpr)(expr) && expr.items.map((item) => item.target.$refText);
+	}
+	getForeignKeyFor(field, contextModel) {
+		if (!contextModel) return [];
+		const result = [];
+		for (const f of (0, _zenstackhq_language_utils.getAllFields)(contextModel)) {
+			const relation = getAttribute(f, "@relation");
+			if (relation) {
+				for (const arg of relation.args) if (arg.name === "fields" && (0, _zenstackhq_language_ast.isArrayExpr)(arg.value) && arg.value.items.some((el) => (0, _zenstackhq_language_ast.isReferenceExpr)(el) && el.target.ref === field)) result.push(f.name);
+			}
+		}
+		return result;
+	}
+	getOppositeRelationField(field, contextModel) {
+		if (!field.type.reference?.ref || !(0, _zenstackhq_language_ast.isDataModel)(field.type.reference?.ref) || !contextModel) return;
+		const sourceModel = (0, _zenstackhq_language_ast.isTypeDef)(field.$container) ? contextModel : field.$container;
+		const targetModel = field.type.reference.ref;
+		const relationName = this.getRelationName(field);
+		for (const otherField of (0, _zenstackhq_language_utils.getAllFields)(targetModel)) {
+			if (otherField === field) continue;
+			if (otherField.type.reference?.ref === sourceModel) if (relationName) {
+				if (this.getRelationName(otherField) === relationName) return otherField;
+			} else return otherField;
+		}
+	}
+	getRelationName(field) {
+		const relation = getAttribute(field, "@relation");
+		if (relation) {
+			const nameArg = relation.args.find((arg) => arg.$resolvedParam?.name === "name");
+			if (nameArg) {
+				(0, _zenstackhq_common_helpers.invariant)((0, _zenstackhq_language_ast.isLiteralExpr)(nameArg.value), "name must be a literal");
+				return nameArg.value.value;
+			}
+		}
+	}
+	createUniqueFieldsObject(dm) {
+		const properties = [];
+		const allFields = (0, _zenstackhq_language_utils.getAllFields)(dm);
+		for (const field of allFields) if (hasAttribute(field, "@id") || hasAttribute(field, "@unique")) properties.push(typescript.factory.createPropertyAssignment(field.name, typescript.factory.createObjectLiteralExpression([typescript.factory.createPropertyAssignment("type", this.generateFieldTypeLiteral(field))])));
+		const allAttributes = (0, _zenstackhq_language_utils.getAllAttributes)(dm);
+		const seenKeys = /* @__PURE__ */ new Set();
+		for (const attr of allAttributes) if (attr.decl.$refText === "@@id" || attr.decl.$refText === "@@unique") {
+			const fieldsArg = (0, _zenstackhq_language_utils.getAttributeArg)(attr, "fields");
+			if (!fieldsArg) continue;
+			const fieldNames = this.getReferenceNames(fieldsArg);
+			if (!fieldNames) continue;
+			if (fieldNames.length === 1) {
+				const fieldDef = allFields.find((f) => f.name === fieldNames[0]);
+				properties.push(typescript.factory.createPropertyAssignment(fieldNames[0], typescript.factory.createObjectLiteralExpression([typescript.factory.createPropertyAssignment("type", this.generateFieldTypeLiteral(fieldDef))])));
+			} else {
+				const key = this.getCompoundUniqueKey(attr, fieldNames);
+				if (seenKeys.has(key)) continue;
+				seenKeys.add(key);
+				properties.push(typescript.factory.createPropertyAssignment(key, typescript.factory.createObjectLiteralExpression(fieldNames.map((field) => {
+					const fieldDef = allFields.find((f) => f.name === field);
+					return typescript.factory.createPropertyAssignment(field, typescript.factory.createObjectLiteralExpression([typescript.factory.createPropertyAssignment("type", this.generateFieldTypeLiteral(fieldDef))]));
+				}))));
+			}
+		}
+		return typescript.factory.createObjectLiteralExpression(properties, true);
+	}
+	getCompoundUniqueKey(attr, fieldNames) {
+		const nameArg = attr.args.find((arg) => arg.$resolvedParam?.name === "name");
+		if (nameArg && (0, _zenstackhq_language_ast.isLiteralExpr)(nameArg.value)) return nameArg.value.value;
+		else return fieldNames.join("_");
+	}
+	generateFieldTypeLiteral(field) {
+		(0, _zenstackhq_common_helpers.invariant)(field.type.type || field.type.reference || field.type.unsupported, "Field type must be a primitive, reference, or Unsupported");
+		return field.type.type ? typescript.factory.createStringLiteral(field.type.type) : field.type.reference ? typescript.factory.createStringLiteral(field.type.reference.$refText) : typescript.factory.createStringLiteral("Unsupported");
+	}
+	createEnumObject(e) {
+		return typescript.factory.createObjectLiteralExpression([
+			typescript.factory.createPropertyAssignment("name", typescript.factory.createStringLiteral(e.name)),
+			typescript.factory.createPropertyAssignment("values", typescript.factory.createObjectLiteralExpression(e.fields.map((f) => typescript.factory.createPropertyAssignment(f.name, typescript.factory.createStringLiteral(f.name))), true)),
+			...e.fields.some((f) => f.attributes.length > 0) ? [typescript.factory.createPropertyAssignment("fields", typescript.factory.createObjectLiteralExpression(e.fields.map((field) => typescript.factory.createPropertyAssignment(field.name, typescript.factory.createObjectLiteralExpression([typescript.factory.createPropertyAssignment("name", typescript.factory.createStringLiteral(field.name)), ...field.attributes.length > 0 ? [typescript.factory.createPropertyAssignment("attributes", this.createAttributesTypeAssertion(typescript.factory.createArrayLiteralExpression(field.attributes?.map((attr) => this.createAttributeObject(attr)) ?? [], true)))] : []], true))), true))] : [],
+			...e.attributes.length > 0 ? [typescript.factory.createPropertyAssignment("attributes", this.createAttributesTypeAssertion(typescript.factory.createArrayLiteralExpression(e.attributes.map((attr) => this.createAttributeObject(attr)), true)))] : []
+		], true);
+	}
+	getLiteral(expr) {
+		if (!(0, _zenstackhq_language_ast.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 ? typescript.factory.createNull() : typeof arg === "string" ? typescript.factory.createStringLiteral(arg) : typeof arg === "number" ? this.createNumberLiteral(arg) : arg === true ? typescript.factory.createTrue() : arg === false ? typescript.factory.createFalse() : void 0;
+	}
+	createNumberLiteral(arg) {
+		return arg < 0 ? typescript.factory.createPrefixUnaryExpression(typescript.SyntaxKind.MinusToken, typescript.factory.createNumericLiteral(-arg)) : typescript.factory.createNumericLiteral(arg);
+	}
+	createProceduresObject(procedures) {
+		return typescript.factory.createObjectLiteralExpression(procedures.map((proc) => typescript.factory.createPropertyAssignment(proc.name, this.createProcedureObject(proc))), true);
+	}
+	createProcedureObject(proc) {
+		const params = typescript.factory.createObjectLiteralExpression(proc.params.map((param) => typescript.factory.createPropertyAssignment(param.name, typescript.factory.createObjectLiteralExpression([
+			typescript.factory.createPropertyAssignment("name", typescript.factory.createStringLiteral(param.name)),
+			...param.optional ? [typescript.factory.createPropertyAssignment("optional", typescript.factory.createTrue())] : [],
+			...param.type.array ? [typescript.factory.createPropertyAssignment("array", typescript.factory.createTrue())] : [],
+			typescript.factory.createPropertyAssignment("type", typescript.factory.createStringLiteral(param.type.type ?? param.type.reference.$refText))
+		]))), true);
+		return typescript.factory.createObjectLiteralExpression([
+			typescript.factory.createPropertyAssignment("params", params),
+			typescript.factory.createPropertyAssignment("returnType", typescript.factory.createStringLiteral(proc.returnType.type ?? proc.returnType.reference.$refText)),
+			...proc.returnType.array ? [typescript.factory.createPropertyAssignment("returnArray", typescript.factory.createTrue())] : [],
+			...proc.mutation ? [typescript.factory.createPropertyAssignment("mutation", typescript.factory.createTrue())] : []
+		], true);
+	}
+	generateBannerComments(statements) {
+		typescript.addSyntheticLeadingComment(statements[0], typescript.SyntaxKind.SingleLineCommentTrivia, `////////////////////////////////////////////////////////////////////////////////////////////
 // DO NOT MODIFY THIS FILE                                                                  //
 // This file is automatically generated by ZenStack CLI and should not be manually updated. //
 //////////////////////////////////////////////////////////////////////////////////////////////
 
 /* eslint-disable */
 
-`;
-    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 this.createExpressionUtilsCall("_this");
-  }
-  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 this.createExpressionUtilsCall("member", args);
-  }
-  createNullExpression() {
-    return this.createExpressionUtilsCall("_null");
-  }
-  createBinaryExpression(expr) {
-    const args = [
-      this.createExpression(expr.left),
-      this.createLiteralNode(expr.operator),
-      this.createExpression(expr.right)
-    ];
-    if (expr.binding) {
-      args.push(this.createLiteralNode(expr.binding.name));
-    }
-    return this.createExpressionUtilsCall("binary", args);
-  }
-  createUnaryExpression(expr) {
-    return this.createExpressionUtilsCall("unary", [
-      this.createLiteralNode(expr.operator),
-      this.createExpression(expr.operand)
-    ]);
-  }
-  createArrayExpression(expr) {
-    const arrayResolved = expr.$resolvedType?.decl;
-    const arrayType = typeof arrayResolved === "string" ? arrayResolved : arrayResolved?.name;
-    (0, import_common_helpers2.invariant)(arrayType, "Array type must be resolved to a string or declaration");
-    return this.createExpressionUtilsCall("array", [
-      this.createLiteralNode(arrayType),
-      ts.factory.createArrayLiteralExpression(expr.items.map((item) => this.createExpression(item)))
-    ]);
-  }
-  createRefExpression(expr) {
-    const target = expr.target.ref;
-    return (0, import_ts_pattern2.match)(target).when(import_ast3.isDataField, () => this.createExpressionUtilsCall("field", [
-      this.createLiteralNode(expr.target.$refText)
-    ])).when(import_ast3.isEnumField, () => this.createLiteralExpression("StringLiteral", expr.target.$refText)).when(import_ast3.isCollectionPredicateBinding, () => this.createExpressionUtilsCall("binding", [
-      this.createLiteralNode(expr.target.$refText)
-    ])).otherwise(() => {
-      throw Error(`Unsupported reference type: ${expr.target.$refText}`);
-    });
-  }
-  createCallExpression(expr) {
-    return this.createExpressionUtilsCall("call", [
-      ts.factory.createStringLiteral(expr.function.$refText),
-      ...expr.args.length > 0 ? [
-        ts.factory.createArrayLiteralExpression(expr.args.map((arg) => this.createExpression(arg.value)))
-      ] : []
-    ]);
-  }
-  createLiteralExpression(type, value) {
-    return (0, import_ts_pattern2.match)(type).with("BooleanLiteral", () => this.createExpressionUtilsCall("literal", [
-      this.createLiteralNode(value)
-    ])).with("NumberLiteral", () => this.createExpressionUtilsCall("literal", [
-      ts.factory.createIdentifier(value)
-    ])).with("StringLiteral", () => this.createExpressionUtilsCall("literal", [
-      this.createLiteralNode(value)
-    ])).otherwise(() => {
-      throw new Error(`Unsupported literal type: ${type}`);
-    });
-  }
-  generateModelsAndTypeDefs(model, options) {
-    const statements = [];
-    statements.push(this.generateSchemaImport(model, true, true, !!(options.lite || options.liteOnly), options.importWithFileExtension));
-    statements.push(ts.factory.createImportDeclaration(void 0, ts.factory.createImportClause(true, void 0, ts.factory.createNamedImports([
-      ts.factory.createImportSpecifier(false, void 0, ts.factory.createIdentifier(`ModelResult as $ModelResult`)),
-      ...model.declarations.some(import_ast3.isTypeDef) ? [
-        ts.factory.createImportSpecifier(false, void 0, ts.factory.createIdentifier(`TypeDefResult as $TypeDefResult`))
-      ] : []
-    ])), ts.factory.createStringLiteral("@zenstackhq/orm")));
-    const dataModels = this.getAllDataModels(model);
-    for (const dm of dataModels) {
-      let modelType = ts.factory.createTypeAliasDeclaration([
-        ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)
-      ], dm.name, void 0, ts.factory.createTypeReferenceNode("$ModelResult", [
-        ts.factory.createTypeReferenceNode("$Schema"),
-        ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral(dm.name))
-      ]));
-      if (dm.comments.length > 0) {
-        modelType = this.generateDocs(modelType, dm);
-      }
-      statements.push(modelType);
-    }
-    const typeDefs = this.getAllTypeDefs(model);
-    for (const td of typeDefs) {
-      let typeDef = ts.factory.createTypeAliasDeclaration([
-        ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)
-      ], td.name, void 0, ts.factory.createTypeReferenceNode("$TypeDefResult", [
-        ts.factory.createTypeReferenceNode("$Schema"),
-        ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral(td.name))
-      ]));
-      if (td.comments.length > 0) {
-        typeDef = this.generateDocs(typeDef, td);
-      }
-      statements.push(typeDef);
-    }
-    const enums = model.declarations.filter(import_ast3.isEnum);
-    for (const e of enums) {
-      let enumDecl = ts.factory.createVariableStatement([
-        ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)
-      ], ts.factory.createVariableDeclarationList([
-        ts.factory.createVariableDeclaration(e.name, void 0, void 0, ts.factory.createPropertyAccessExpression(ts.factory.createPropertyAccessExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("$schema"), ts.factory.createIdentifier("enums")), ts.factory.createIdentifier(e.name)), ts.factory.createIdentifier("values")))
-      ], ts.NodeFlags.Const));
-      if (e.comments.length > 0) {
-        enumDecl = this.generateDocs(enumDecl, e);
-      }
-      statements.push(enumDecl);
-      let typeAlias = ts.factory.createTypeAliasDeclaration([
-        ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)
-      ], e.name, void 0, ts.factory.createIndexedAccessTypeNode(ts.factory.createTypeQueryNode(ts.factory.createIdentifier(e.name)), ts.factory.createTypeOperatorNode(ts.SyntaxKind.KeyOfKeyword, ts.factory.createTypeQueryNode(ts.factory.createIdentifier(e.name)))));
-      if (e.comments.length > 0) {
-        typeAlias = this.generateDocs(typeAlias, e);
-      }
-      statements.push(typeAlias);
-    }
-    this.generateBannerComments(statements);
-    const outputFile = import_node_path.default.join(options.outDir, "models.ts");
-    const sourceFile = ts.createSourceFile(outputFile, "", ts.ScriptTarget.ESNext, false, ts.ScriptKind.TS);
-    const printer = ts.createPrinter();
-    const result = printer.printList(ts.ListFormat.MultiLine, ts.factory.createNodeArray(statements), sourceFile);
-    import_node_fs.default.writeFileSync(outputFile, result);
-  }
-  generateSchemaImport(model, schemaObject, schemaType, useLite, importWithFileExtension) {
-    const importSpecifiers = [];
-    if (schemaObject) {
-      if (model.declarations.some(import_ast3.isEnum)) {
-        importSpecifiers.push(ts.factory.createImportSpecifier(false, ts.factory.createIdentifier("schema"), ts.factory.createIdentifier("$schema")));
-      }
-    }
-    if (schemaType) {
-      importSpecifiers.push(ts.factory.createImportSpecifier(true, ts.factory.createIdentifier("SchemaType"), ts.factory.createIdentifier("$Schema")));
-    }
-    let importFrom = useLite ? "./schema-lite" : "./schema";
-    if (importWithFileExtension) {
-      importFrom += importWithFileExtension.startsWith(".") ? importWithFileExtension : `.${importWithFileExtension}`;
-    }
-    return ts.factory.createImportDeclaration(void 0, ts.factory.createImportClause(false, void 0, ts.factory.createNamedImports(importSpecifiers)), ts.factory.createStringLiteral(importFrom));
-  }
-  generateDocs(tsDecl, decl) {
-    return ts.addSyntheticLeadingComment(tsDecl, ts.SyntaxKind.MultiLineCommentTrivia, `*
- * ${decl.comments.map((c) => c.replace(/^\s*\/*\s*/, "")).join("\n * ")}
- `, true);
-  }
-  generateInputTypes(model, options) {
-    const dataModels = this.getAllDataModels(model);
-    const statements = [];
-    statements.push(this.generateSchemaImport(model, false, true, !!(options.lite || options.liteOnly), options.importWithFileExtension));
-    const inputTypes = [
-      "FindManyArgs",
-      "FindUniqueArgs",
-      "FindFirstArgs",
-      "ExistsArgs",
-      "CreateArgs",
-      "CreateManyArgs",
-      "CreateManyAndReturnArgs",
-      "UpdateArgs",
-      "UpdateManyArgs",
-      "UpdateManyAndReturnArgs",
-      "UpsertArgs",
-      "DeleteArgs",
-      "DeleteManyArgs",
-      "CountArgs",
-      "AggregateArgs",
-      "GroupByArgs",
-      "WhereInput",
-      "SelectInput",
-      "IncludeInput",
-      "OmitInput"
-    ];
-    const inputTypeNameFixes = {
-      SelectInput: "Select",
-      IncludeInput: "Include",
-      OmitInput: "Omit"
-    };
-    statements.push(ts.factory.createImportDeclaration(void 0, ts.factory.createImportClause(true, void 0, ts.factory.createNamedImports([
-      ...inputTypes.map((inputType) => ts.factory.createImportSpecifier(false, void 0, ts.factory.createIdentifier(`${inputType} as $${inputType}`))),
-      ts.factory.createImportSpecifier(false, void 0, ts.factory.createIdentifier("QueryOptions as $QueryOptions"))
-    ])), ts.factory.createStringLiteral("@zenstackhq/orm")));
-    statements.push(ts.factory.createImportDeclaration(void 0, ts.factory.createImportClause(true, void 0, ts.factory.createNamedImports([
-      ts.factory.createImportSpecifier(false, void 0, ts.factory.createIdentifier("SimplifiedPlainResult as $Result")),
-      ts.factory.createImportSpecifier(false, void 0, ts.factory.createIdentifier("SelectIncludeOmit as $SelectIncludeOmit"))
-    ])), ts.factory.createStringLiteral("@zenstackhq/orm")));
-    for (const dm of dataModels) {
-      for (const inputType of inputTypes) {
-        const exportName = inputTypeNameFixes[inputType] ? `${dm.name}${inputTypeNameFixes[inputType]}` : `${dm.name}${inputType}`;
-        statements.push(ts.factory.createTypeAliasDeclaration([
-          ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)
-        ], exportName, void 0, ts.factory.createTypeReferenceNode(`$${inputType}`, [
-          ts.factory.createTypeReferenceNode("$Schema"),
-          ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral(dm.name))
-        ])));
-      }
-      statements.push(ts.factory.createTypeAliasDeclaration([
-        ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)
-      ], `${dm.name}GetPayload`, [
-        ts.factory.createTypeParameterDeclaration(void 0, "Args", ts.factory.createTypeReferenceNode("$SelectIncludeOmit", [
-          ts.factory.createTypeReferenceNode("$Schema"),
-          ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral(dm.name)),
-          ts.factory.createLiteralTypeNode(ts.factory.createTrue())
-        ])),
-        ts.factory.createTypeParameterDeclaration(void 0, "Options", ts.factory.createTypeReferenceNode("$QueryOptions", [
-          ts.factory.createTypeReferenceNode("$Schema")
-        ]), ts.factory.createTypeReferenceNode("$QueryOptions", [
-          ts.factory.createTypeReferenceNode("$Schema")
-        ]))
-      ], ts.factory.createTypeReferenceNode("$Result", [
-        ts.factory.createTypeReferenceNode("$Schema"),
-        ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral(dm.name)),
-        ts.factory.createTypeReferenceNode("Args"),
-        ts.factory.createTypeReferenceNode("Options")
-      ])));
-    }
-    this.generateBannerComments(statements);
-    const outputFile = import_node_path.default.join(options.outDir, "input.ts");
-    const sourceFile = ts.createSourceFile(outputFile, "", ts.ScriptTarget.ESNext, false, ts.ScriptKind.TS);
-    const printer = ts.createPrinter();
-    const result = printer.printList(ts.ListFormat.MultiLine, ts.factory.createNodeArray(statements), sourceFile);
-    import_node_fs.default.writeFileSync(outputFile, result);
-  }
+`);
+	}
+	createAttributeObject(attr) {
+		return typescript.factory.createObjectLiteralExpression([typescript.factory.createPropertyAssignment("name", typescript.factory.createStringLiteral(attr.decl.$refText)), ...attr.args.length > 0 ? [typescript.factory.createPropertyAssignment("args", typescript.factory.createArrayLiteralExpression(attr.args.map((arg) => this.createAttributeArg(arg))))] : []]);
+	}
+	createAttributeArg(arg) {
+		return typescript.factory.createObjectLiteralExpression([...arg.$resolvedParam?.name ? [typescript.factory.createPropertyAssignment("name", typescript.factory.createStringLiteral(arg.$resolvedParam.name))] : [], typescript.factory.createPropertyAssignment("value", this.createExpression(arg.value))]);
+	}
+	createExpression(value) {
+		return (0, ts_pattern.match)(value).when(_zenstackhq_language_ast.isLiteralExpr, (expr) => this.createLiteralExpression(expr.$type, expr.value)).when(_zenstackhq_language_ast.isInvocationExpr, (expr) => this.createCallExpression(expr)).when(_zenstackhq_language_ast.isReferenceExpr, (expr) => this.createRefExpression(expr)).when(_zenstackhq_language_ast.isArrayExpr, (expr) => this.createArrayExpression(expr)).when(_zenstackhq_language_ast.isUnaryExpr, (expr) => this.createUnaryExpression(expr)).when(_zenstackhq_language_ast.isBinaryExpr, (expr) => this.createBinaryExpression(expr)).when(_zenstackhq_language_ast.isMemberAccessExpr, (expr) => this.createMemberExpression(expr)).when(_zenstackhq_language_ast.isNullExpr, () => this.createNullExpression()).when(_zenstackhq_language_ast.isThisExpr, () => this.createThisExpression()).otherwise(() => {
+			throw new Error(`Unsupported attribute arg value: ${value.$type}`);
+		});
+	}
+	createThisExpression() {
+		return this.createExpressionUtilsCall("_this");
+	}
+	createMemberExpression(expr) {
+		const members = [];
+		let current = expr;
+		while ((0, _zenstackhq_language_ast.isMemberAccessExpr)(current)) {
+			members.unshift(current.member.$refText);
+			current = current.operand;
+		}
+		const receiver = current;
+		const args = [this.createExpression(receiver), typescript.factory.createArrayLiteralExpression(members.map((m) => typescript.factory.createStringLiteral(m)))];
+		return this.createExpressionUtilsCall("member", args);
+	}
+	createNullExpression() {
+		return this.createExpressionUtilsCall("_null");
+	}
+	createBinaryExpression(expr) {
+		const args = [
+			this.createExpression(expr.left),
+			this.createLiteralNode(expr.operator),
+			this.createExpression(expr.right)
+		];
+		if (expr.binding) args.push(this.createLiteralNode(expr.binding.name));
+		return this.createExpressionUtilsCall("binary", args);
+	}
+	createUnaryExpression(expr) {
+		return this.createExpressionUtilsCall("unary", [this.createLiteralNode(expr.operator), this.createExpression(expr.operand)]);
+	}
+	createArrayExpression(expr) {
+		const arrayResolved = expr.$resolvedType?.decl;
+		const arrayType = typeof arrayResolved === "string" ? arrayResolved : arrayResolved?.name;
+		(0, _zenstackhq_common_helpers.invariant)(arrayType, "Array type must be resolved to a string or declaration");
+		return this.createExpressionUtilsCall("array", [this.createLiteralNode(arrayType), typescript.factory.createArrayLiteralExpression(expr.items.map((item) => this.createExpression(item)))]);
+	}
+	createRefExpression(expr) {
+		const target = expr.target.ref;
+		return (0, ts_pattern.match)(target).when(_zenstackhq_language_ast.isDataField, () => this.createExpressionUtilsCall("field", [this.createLiteralNode(expr.target.$refText)])).when(_zenstackhq_language_ast.isEnumField, () => this.createLiteralExpression("StringLiteral", expr.target.$refText)).when(_zenstackhq_language_ast.isCollectionPredicateBinding, () => this.createExpressionUtilsCall("binding", [this.createLiteralNode(expr.target.$refText)])).otherwise(() => {
+			throw Error(`Unsupported reference type: ${expr.target.$refText}`);
+		});
+	}
+	createCallExpression(expr) {
+		return this.createExpressionUtilsCall("call", [typescript.factory.createStringLiteral(expr.function.$refText), ...expr.args.length > 0 ? [typescript.factory.createArrayLiteralExpression(expr.args.map((arg) => this.createExpression(arg.value)))] : []]);
+	}
+	createLiteralExpression(type, value) {
+		return (0, ts_pattern.match)(type).with("BooleanLiteral", () => this.createExpressionUtilsCall("literal", [this.createLiteralNode(value)])).with("NumberLiteral", () => this.createExpressionUtilsCall("literal", [typescript.factory.createIdentifier(value)])).with("StringLiteral", () => this.createExpressionUtilsCall("literal", [this.createLiteralNode(value)])).otherwise(() => {
+			throw new Error(`Unsupported literal type: ${type}`);
+		});
+	}
+	generateModelsAndTypeDefs(model, options) {
+		const statements = [];
+		statements.push(this.generateSchemaImport(model, true, true, !!(options.lite || options.liteOnly), options.importWithFileExtension));
+		statements.push(typescript.factory.createImportDeclaration(void 0, typescript.factory.createImportClause(true, void 0, typescript.factory.createNamedImports([typescript.factory.createImportSpecifier(false, void 0, typescript.factory.createIdentifier(`ModelResult as $ModelResult`)), ...model.declarations.some(_zenstackhq_language_ast.isTypeDef) ? [typescript.factory.createImportSpecifier(false, void 0, typescript.factory.createIdentifier(`TypeDefResult as $TypeDefResult`))] : []])), typescript.factory.createStringLiteral("@zenstackhq/orm")));
+		const dataModels = this.getAllDataModels(model);
+		for (const dm of dataModels) {
+			let modelType = typescript.factory.createTypeAliasDeclaration([typescript.factory.createModifier(typescript.SyntaxKind.ExportKeyword)], dm.name, void 0, typescript.factory.createTypeReferenceNode("$ModelResult", [typescript.factory.createTypeReferenceNode("$Schema"), typescript.factory.createLiteralTypeNode(typescript.factory.createStringLiteral(dm.name))]));
+			if (dm.comments.length > 0) modelType = this.generateDocs(modelType, dm);
+			statements.push(modelType);
+		}
+		const typeDefs = this.getAllTypeDefs(model);
+		for (const td of typeDefs) {
+			let typeDef = typescript.factory.createTypeAliasDeclaration([typescript.factory.createModifier(typescript.SyntaxKind.ExportKeyword)], td.name, void 0, typescript.factory.createTypeReferenceNode("$TypeDefResult", [typescript.factory.createTypeReferenceNode("$Schema"), typescript.factory.createLiteralTypeNode(typescript.factory.createStringLiteral(td.name))]));
+			if (td.comments.length > 0) typeDef = this.generateDocs(typeDef, td);
+			statements.push(typeDef);
+		}
+		const enums = model.declarations.filter(_zenstackhq_language_ast.isEnum);
+		for (const e of enums) {
+			let enumDecl = typescript.factory.createVariableStatement([typescript.factory.createModifier(typescript.SyntaxKind.ExportKeyword)], typescript.factory.createVariableDeclarationList([typescript.factory.createVariableDeclaration(e.name, void 0, void 0, typescript.factory.createPropertyAccessExpression(typescript.factory.createPropertyAccessExpression(typescript.factory.createPropertyAccessExpression(typescript.factory.createIdentifier("$schema"), typescript.factory.createIdentifier("enums")), typescript.factory.createIdentifier(e.name)), typescript.factory.createIdentifier("values")))], typescript.NodeFlags.Const));
+			if (e.comments.length > 0) enumDecl = this.generateDocs(enumDecl, e);
+			statements.push(enumDecl);
+			let typeAlias = typescript.factory.createTypeAliasDeclaration([typescript.factory.createModifier(typescript.SyntaxKind.ExportKeyword)], e.name, void 0, typescript.factory.createIndexedAccessTypeNode(typescript.factory.createTypeQueryNode(typescript.factory.createIdentifier(e.name)), typescript.factory.createTypeOperatorNode(typescript.SyntaxKind.KeyOfKeyword, typescript.factory.createTypeQueryNode(typescript.factory.createIdentifier(e.name)))));
+			if (e.comments.length > 0) typeAlias = this.generateDocs(typeAlias, e);
+			statements.push(typeAlias);
+		}
+		this.generateBannerComments(statements);
+		const outputFile = node_path.default.join(options.outDir, "models.ts");
+		const sourceFile = typescript.createSourceFile(outputFile, "", typescript.ScriptTarget.ESNext, false, typescript.ScriptKind.TS);
+		const result = typescript.createPrinter().printList(typescript.ListFormat.MultiLine, typescript.factory.createNodeArray(statements), sourceFile);
+		node_fs.default.writeFileSync(outputFile, result);
+	}
+	generateSchemaImport(model, schemaObject, schemaType, useLite, importWithFileExtension) {
+		const importSpecifiers = [];
+		if (schemaObject) {
+			if (model.declarations.some(_zenstackhq_language_ast.isEnum)) importSpecifiers.push(typescript.factory.createImportSpecifier(false, typescript.factory.createIdentifier("schema"), typescript.factory.createIdentifier("$schema")));
+		}
+		if (schemaType) importSpecifiers.push(typescript.factory.createImportSpecifier(true, typescript.factory.createIdentifier("SchemaType"), typescript.factory.createIdentifier("$Schema")));
+		let importFrom = useLite ? "./schema-lite" : "./schema";
+		if (importWithFileExtension) importFrom += importWithFileExtension.startsWith(".") ? importWithFileExtension : `.${importWithFileExtension}`;
+		return typescript.factory.createImportDeclaration(void 0, typescript.factory.createImportClause(false, void 0, typescript.factory.createNamedImports(importSpecifiers)), typescript.factory.createStringLiteral(importFrom));
+	}
+	generateDocs(tsDecl, decl) {
+		return typescript.addSyntheticLeadingComment(tsDecl, typescript.SyntaxKind.MultiLineCommentTrivia, `*\n * ${decl.comments.map((c) => c.replace(/^\s*\/*\s*/, "")).join("\n * ")}\n `, true);
+	}
+	generateInputTypes(model, options) {
+		const dataModels = this.getAllDataModels(model);
+		const statements = [];
+		statements.push(this.generateSchemaImport(model, false, true, !!(options.lite || options.liteOnly), options.importWithFileExtension));
+		const inputTypes = [
+			"FindManyArgs",
+			"FindUniqueArgs",
+			"FindFirstArgs",
+			"ExistsArgs",
+			"CreateArgs",
+			"CreateManyArgs",
+			"CreateManyAndReturnArgs",
+			"UpdateArgs",
+			"UpdateManyArgs",
+			"UpdateManyAndReturnArgs",
+			"UpsertArgs",
+			"DeleteArgs",
+			"DeleteManyArgs",
+			"CountArgs",
+			"AggregateArgs",
+			"GroupByArgs",
+			"WhereInput",
+			"SelectInput",
+			"IncludeInput",
+			"OmitInput"
+		];
+		const inputTypeNameFixes = {
+			SelectInput: "Select",
+			IncludeInput: "Include",
+			OmitInput: "Omit"
+		};
+		statements.push(typescript.factory.createImportDeclaration(void 0, typescript.factory.createImportClause(true, void 0, typescript.factory.createNamedImports([...inputTypes.map((inputType) => typescript.factory.createImportSpecifier(false, void 0, typescript.factory.createIdentifier(`${inputType} as $${inputType}`))), typescript.factory.createImportSpecifier(false, void 0, typescript.factory.createIdentifier("QueryOptions as $QueryOptions"))])), typescript.factory.createStringLiteral("@zenstackhq/orm")));
+		statements.push(typescript.factory.createImportDeclaration(void 0, typescript.factory.createImportClause(true, void 0, typescript.factory.createNamedImports([typescript.factory.createImportSpecifier(false, void 0, typescript.factory.createIdentifier("SimplifiedPlainResult as $Result")), typescript.factory.createImportSpecifier(false, void 0, typescript.factory.createIdentifier("SelectIncludeOmit as $SelectIncludeOmit"))])), typescript.factory.createStringLiteral("@zenstackhq/orm")));
+		for (const dm of dataModels) {
+			for (const inputType of inputTypes) {
+				const exportName = inputTypeNameFixes[inputType] ? `${dm.name}${inputTypeNameFixes[inputType]}` : `${dm.name}${inputType}`;
+				statements.push(typescript.factory.createTypeAliasDeclaration([typescript.factory.createModifier(typescript.SyntaxKind.ExportKeyword)], exportName, void 0, typescript.factory.createTypeReferenceNode(`$${inputType}`, [typescript.factory.createTypeReferenceNode("$Schema"), typescript.factory.createLiteralTypeNode(typescript.factory.createStringLiteral(dm.name))])));
+			}
+			statements.push(typescript.factory.createTypeAliasDeclaration([typescript.factory.createModifier(typescript.SyntaxKind.ExportKeyword)], `${dm.name}GetPayload`, [typescript.factory.createTypeParameterDeclaration(void 0, "Args", typescript.factory.createTypeReferenceNode("$SelectIncludeOmit", [
+				typescript.factory.createTypeReferenceNode("$Schema"),
+				typescript.factory.createLiteralTypeNode(typescript.factory.createStringLiteral(dm.name)),
+				typescript.factory.createLiteralTypeNode(typescript.factory.createTrue())
+			])), typescript.factory.createTypeParameterDeclaration(void 0, "Options", typescript.factory.createTypeReferenceNode("$QueryOptions", [typescript.factory.createTypeReferenceNode("$Schema")]), typescript.factory.createTypeReferenceNode("$QueryOptions", [typescript.factory.createTypeReferenceNode("$Schema")]))], typescript.factory.createTypeReferenceNode("$Result", [
+				typescript.factory.createTypeReferenceNode("$Schema"),
+				typescript.factory.createLiteralTypeNode(typescript.factory.createStringLiteral(dm.name)),
+				typescript.factory.createTypeReferenceNode("Args"),
+				typescript.factory.createTypeReferenceNode("Options")
+			])));
+		}
+		this.generateBannerComments(statements);
+		const outputFile = node_path.default.join(options.outDir, "input.ts");
+		const sourceFile = typescript.createSourceFile(outputFile, "", typescript.ScriptTarget.ESNext, false, typescript.ScriptKind.TS);
+		const result = typescript.createPrinter().printList(typescript.ListFormat.MultiLine, typescript.factory.createNodeArray(statements), sourceFile);
+		node_fs.default.writeFileSync(outputFile, result);
+	}
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  ModelUtils,
-  PrismaSchemaGenerator,
-  TsSchemaGenerator
+//#endregion
+Object.defineProperty(exports, "ModelUtils", {
+	enumerable: true,
+	get: function() {
+		return model_utils_exports;
+	}
 });
+exports.PrismaSchemaGenerator = PrismaSchemaGenerator;
+exports.TsSchemaGenerator = TsSchemaGenerator;
+
 //# sourceMappingURL=index.cjs.map