@zenstackhq/sdk 3.5.6 → 3.6.1

package/dist/index.js

@@ -1,1731 +0,0 @@
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-// src/model-utils.ts
-var model_utils_exports = {};
-__export(model_utils_exports, {
-  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
-});
-import { isDataModel, isLiteralExpr, isModel, isTypeDef } from "@zenstackhq/language/ast";
-import { getAllFields, getModelIdFields, getModelUniqueFields } from "@zenstackhq/language/utils";
-function isIdField(field, contextModel) {
-  if (hasAttribute(field, "@id")) {
-    return true;
-  }
-  const modelLevelIds = getModelIdFields(contextModel);
-  if (modelLevelIds.map((f) => f.name).includes(field.name)) {
-    return true;
-  }
-  const allFields = 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 = getModelUniqueFields(contextModel);
-  if (modelLevelUnique.map((f) => f.name).includes(field.name)) {
-    return true;
-  }
-  return false;
-}
-__name(isIdField, "isIdField");
-function hasAttribute(decl, name) {
-  return !!getAttribute(decl, name);
-}
-__name(hasAttribute, "hasAttribute");
-function getAttribute(decl, name) {
-  return decl.attributes.find((attr) => attr.decl.$refText === name);
-}
-__name(getAttribute, "getAttribute");
-function isDelegateModel(node) {
-  return isDataModel(node) && hasAttribute(node, "@@delegate");
-}
-__name(isDelegateModel, "isDelegateModel");
-function getOwnedFields(model) {
-  const fields = [
-    ...model.fields
-  ];
-  for (const mixin of model.mixins) {
-    if (mixin.ref) {
-      fields.push(...getOwnedFields(mixin.ref));
-    }
-  }
-  return fields;
-}
-__name(getOwnedFields, "getOwnedFields");
-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;
-}
-__name(getDelegateOriginModel, "getDelegateOriginModel");
-function isUniqueField(field) {
-  if (hasAttribute(field, "@unique")) {
-    return true;
-  }
-  const modelIds = getAttribute(field.$container, "@@unique");
-  if (modelIds && modelIds.args.some((arg) => isLiteralExpr(arg.value) && arg.value.value === field.name)) {
-    return true;
-  }
-  return false;
-}
-__name(isUniqueField, "isUniqueField");
-function isFromStdlib(node) {
-  const model = getContainingModel(node);
-  return !!model && !!model.$document && model.$document.uri.path.endsWith("stdlib.zmodel");
-}
-__name(isFromStdlib, "isFromStdlib");
-function getContainingModel(node) {
-  if (!node) {
-    return null;
-  }
-  return isModel(node) ? node : getContainingModel(node.$container);
-}
-__name(getContainingModel, "getContainingModel");
-function resolved(ref) {
-  if (!ref.ref) {
-    throw new Error(`Reference not resolved: ${ref.$refText}`);
-  }
-  return ref.ref;
-}
-__name(resolved, "resolved");
-function getAuthDecl(model) {
-  let found = model.declarations.find((d) => (isDataModel(d) || isTypeDef(d)) && d.attributes.some((attr) => attr.decl.$refText === "@@auth"));
-  if (!found) {
-    found = model.declarations.find((d) => (isDataModel(d) || isTypeDef(d)) && d.name === "User");
-  }
-  return found;
-}
-__name(getAuthDecl, "getAuthDecl");
-function getIdFields(dm) {
-  return 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
-import { lowerCaseFirst } from "@zenstackhq/common-helpers";
-import { ZModelCodeGenerator } from "@zenstackhq/language";
-import { BooleanLiteral, DataModel, DataSource as DataSource2, Enum as Enum2, GeneratorDecl, isArrayExpr, isDataModel as isDataModel2, isDataSource, isGeneratorDecl, isInvocationExpr, isLiteralExpr as isLiteralExpr2, isNullExpr, isReferenceExpr, isStringLiteral, isTypeDef as isTypeDef2, NumberLiteral, StringLiteral } from "@zenstackhq/language/ast";
-import { getAllAttributes, getAllFields as getAllFields2, getStringLiteral, isAuthInvocation, isDelegateModel as isDelegateModel2 } from "@zenstackhq/language/utils";
-import { AstUtils } from "langium";
-import { match } from "ts-pattern";
-
-// src/prisma/indent-string.ts
-function indentString(string, count = 4) {
-  const indent = " ";
-  return string.replace(/^(?!\s*$)/gm, indent.repeat(count));
-}
-__name(indentString, "indentString");
-
-// src/prisma/prisma-builder.ts
-var PrismaModel = class {
-  static {
-    __name(this, "PrismaModel");
-  }
-  datasources = [];
-  generators = [];
-  models = [];
-  enums = [];
-  addDataSource(name, fields = []) {
-    const ds = new DataSource(name, fields);
-    this.datasources.push(ds);
-    return ds;
-  }
-  addGenerator(name, fields) {
-    const generator = new Generator(name, fields);
-    this.generators.push(generator);
-    return generator;
-  }
-  addModel(name) {
-    const model = new Model(name, false);
-    this.models.push(model);
-    return model;
-  }
-  addView(name) {
-    const model = new Model(name, true);
-    this.models.push(model);
-    return model;
-  }
-  addEnum(name) {
-    const e = new Enum(name);
-    this.enums.push(e);
-    return e;
-  }
-  toString() {
-    return [
-      ...this.datasources,
-      ...this.generators,
-      ...this.enums,
-      ...this.models
-    ].map((d) => d.toString()).join("\n\n");
-  }
-};
-var DataSource = class {
-  static {
-    __name(this, "DataSource");
-  }
-  name;
-  fields;
-  constructor(name, fields = []) {
-    this.name = name;
-    this.fields = fields;
-  }
-  toString() {
-    return `datasource ${this.name} {
-` + this.fields.map((f) => indentString(`${f.name} = ${f.text}`)).join("\n") + `
-}`;
-  }
-};
-var Generator = class {
-  static {
-    __name(this, "Generator");
-  }
-  name;
-  fields;
-  constructor(name, fields) {
-    this.name = name;
-    this.fields = fields;
-  }
-  toString() {
-    return `generator ${this.name} {
-` + this.fields.map((f) => indentString(`${f.name} = ${f.text}`)).join("\n") + `
-}`;
-  }
-};
-var DeclarationBase = class {
-  static {
-    __name(this, "DeclarationBase");
-  }
-  documentations;
-  constructor(documentations = []) {
-    this.documentations = documentations;
-  }
-  addComment(name) {
-    this.documentations.push(name);
-    return name;
-  }
-  toString() {
-    return this.documentations.map((x) => `${x}
-`).join("");
-  }
-};
-var ContainerDeclaration = class extends DeclarationBase {
-  static {
-    __name(this, "ContainerDeclaration");
-  }
-  attributes;
-  constructor(documentations = [], attributes = []) {
-    super(documentations), this.attributes = attributes;
-  }
-};
-var FieldDeclaration = class extends DeclarationBase {
-  static {
-    __name(this, "FieldDeclaration");
-  }
-  attributes;
-  constructor(documentations = [], attributes = []) {
-    super(documentations), this.attributes = attributes;
-  }
-};
-var Model = class extends ContainerDeclaration {
-  static {
-    __name(this, "Model");
-  }
-  name;
-  isView;
-  fields = [];
-  constructor(name, isView, documentations = []) {
-    super(documentations), this.name = name, this.isView = isView;
-  }
-  addField(name, type, attributes = [], documentations = [], addToFront = false) {
-    const field = new ModelField(name, type, attributes, documentations);
-    if (addToFront) {
-      this.fields.unshift(field);
-    } else {
-      this.fields.push(field);
-    }
-    return field;
-  }
-  addAttribute(name, args = []) {
-    const attr = new ContainerAttribute(name, args);
-    this.attributes.push(attr);
-    return attr;
-  }
-  toString() {
-    const result = [
-      ...this.fields
-    ];
-    if (this.attributes.length > 0) {
-      result.push("");
-    }
-    result.push(...this.attributes);
-    return super.toString() + `${this.isView ? "view" : "model"} ${this.name} {
-` + indentString(result.map((d) => d.toString()).join("\n")) + `
-}`;
-  }
-};
-var ModelFieldType = class {
-  static {
-    __name(this, "ModelFieldType");
-  }
-  type;
-  array;
-  optional;
-  constructor(type, array, optional) {
-    this.type = type;
-    this.array = array;
-    this.optional = optional;
-  }
-  toString() {
-    return `${this.type}${this.array ? "[]" : ""}${this.optional ? "?" : ""}`;
-  }
-};
-var ModelField = class extends FieldDeclaration {
-  static {
-    __name(this, "ModelField");
-  }
-  name;
-  type;
-  constructor(name, type, attributes = [], documentations = []) {
-    super(documentations, attributes), this.name = name, this.type = type;
-  }
-  addAttribute(name, args = []) {
-    const attr = new FieldAttribute(name, args);
-    this.attributes.push(attr);
-    return attr;
-  }
-  toString() {
-    return super.toString() + `${this.name} ${this.type}` + (this.attributes.length > 0 ? " " + this.attributes.map((a) => a.toString()).join(" ") : "");
-  }
-};
-var FieldAttribute = class {
-  static {
-    __name(this, "FieldAttribute");
-  }
-  name;
-  args;
-  constructor(name, args = []) {
-    this.name = name;
-    this.args = args;
-  }
-  toString() {
-    return `${this.name}(` + this.args.map((a) => a.toString()).join(", ") + `)`;
-  }
-};
-var ContainerAttribute = class {
-  static {
-    __name(this, "ContainerAttribute");
-  }
-  name;
-  args;
-  constructor(name, args = []) {
-    this.name = name;
-    this.args = args;
-  }
-  toString() {
-    return `${this.name}(` + this.args.map((a) => a.toString()).join(", ") + `)`;
-  }
-};
-var AttributeArg = class {
-  static {
-    __name(this, "AttributeArg");
-  }
-  name;
-  value;
-  constructor(name, value) {
-    this.name = name;
-    this.value = value;
-  }
-  toString() {
-    return this.name ? `${this.name}: ${this.value}` : this.value.toString();
-  }
-};
-var AttributeArgValue = class {
-  static {
-    __name(this, "AttributeArgValue");
-  }
-  type;
-  value;
-  constructor(type, value) {
-    this.type = type;
-    this.value = value;
-    switch (type) {
-      case "String":
-        if (typeof value !== "string") throw new Error("Value must be string");
-        break;
-      case "Number":
-        if (typeof value !== "number" && typeof value !== "string") throw new Error("Value must be number or string");
-        break;
-      case "Boolean":
-        if (typeof value !== "boolean") throw new Error("Value must be boolean");
-        break;
-      case "Array":
-        if (!Array.isArray(value)) throw new Error("Value must be array");
-        break;
-      case "FieldReference":
-        if (typeof value !== "string" && !(value instanceof FieldReference)) throw new Error("Value must be string or FieldReference");
-        break;
-      case "FunctionCall":
-        if (!(value instanceof FunctionCall)) throw new Error("Value must be FunctionCall");
-        break;
-    }
-  }
-  toString() {
-    switch (this.type) {
-      case "String":
-        return JSON.stringify(this.value);
-      case "Number":
-        return this.value.toString();
-      case "FieldReference": {
-        if (typeof this.value === "string") {
-          return this.value;
-        } else {
-          const fr = this.value;
-          let r = fr.field;
-          if (fr.args.length > 0) {
-            r += "(" + fr.args.map((a) => a.toString()).join(",") + ")";
-          }
-          return r;
-        }
-      }
-      case "FunctionCall":
-        return this.value.toString();
-      case "Boolean":
-        return this.value ? "true" : "false";
-      case "Array":
-        return "[" + this.value.map((v) => v.toString()).join(", ") + "]";
-      default:
-        throw new Error(`Unknown attribute value type ${this.type}`);
-    }
-  }
-};
-var FieldReference = class {
-  static {
-    __name(this, "FieldReference");
-  }
-  field;
-  args;
-  constructor(field, args = []) {
-    this.field = field;
-    this.args = args;
-  }
-};
-var FieldReferenceArg = class {
-  static {
-    __name(this, "FieldReferenceArg");
-  }
-  name;
-  value;
-  constructor(name, value) {
-    this.name = name;
-    this.value = value;
-  }
-  toString() {
-    return `${this.name}: ${this.value}`;
-  }
-};
-var FunctionCall = class {
-  static {
-    __name(this, "FunctionCall");
-  }
-  func;
-  args;
-  constructor(func, args = []) {
-    this.func = func;
-    this.args = args;
-  }
-  toString() {
-    return `${this.func}(` + this.args.map((a) => a.toString()).join(", ") + ")";
-  }
-};
-var FunctionCallArg = class {
-  static {
-    __name(this, "FunctionCallArg");
-  }
-  value;
-  constructor(value) {
-    this.value = value;
-  }
-  toString() {
-    return this.value;
-  }
-};
-var Enum = class extends ContainerDeclaration {
-  static {
-    __name(this, "Enum");
-  }
-  name;
-  fields = [];
-  constructor(name, documentations = []) {
-    super(documentations), this.name = name;
-  }
-  addField(name, attributes = [], documentations = []) {
-    const field = new EnumField(name, attributes, documentations);
-    this.fields.push(field);
-    return field;
-  }
-  addAttribute(name, args = []) {
-    const attr = new ContainerAttribute(name, args);
-    this.attributes.push(attr);
-    return attr;
-  }
-  addComment(name) {
-    this.documentations.push(name);
-    return name;
-  }
-  toString() {
-    return super.toString() + `enum ${this.name} {
-` + indentString([
-      ...this.fields,
-      ...this.attributes
-    ].map((d) => d.toString()).join("\n")) + "\n}";
-  }
-};
-var EnumField = class extends DeclarationBase {
-  static {
-    __name(this, "EnumField");
-  }
-  name;
-  attributes;
-  constructor(name, attributes = [], documentations = []) {
-    super(documentations), this.name = name, this.attributes = attributes;
-  }
-  addAttribute(name, args = []) {
-    const attr = new FieldAttribute(name, args);
-    this.attributes.push(attr);
-    return attr;
-  }
-  toString() {
-    return super.toString() + this.name + (this.attributes.length > 0 ? " " + this.attributes.map((a) => a.toString()).join(" ") : "");
-  }
-};
-
-// src/prisma/prisma-schema-generator.ts
-var IDENTIFIER_NAME_MAX_LENGTH = 50 - DELEGATE_AUX_RELATION_PREFIX.length;
-var NON_PRISMA_DATASOURCE_FIELDS = [
-  "defaultSchema"
-];
-var PrismaSchemaGenerator = class {
-  static {
-    __name(this, "PrismaSchemaGenerator");
-  }
-  zmodel;
-  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 DataSource2:
-          this.generateDataSource(prisma, decl);
-          break;
-        case Enum2:
-          this.generateEnum(prisma, decl);
-          break;
-        case DataModel:
-          this.generateModel(prisma, decl);
-          break;
-        case GeneratorDecl:
-          this.generateGenerator(prisma, decl);
-          break;
-      }
-    }
-    if (!this.zmodel.declarations.some(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 (isLiteralExpr2(expr)) {
-      return this.literalToText(expr);
-    } else if (isInvocationExpr(expr)) {
-      const fc = this.makeFunctionCall(expr);
-      return fc.toString();
-    } else {
-      return this.configArrayToText(expr);
-    }
-  }
-  configArrayToText(expr) {
-    return "[" + expr.items.map((item) => {
-      if (isLiteralExpr2(item)) {
-        return this.literalToText(item);
-      } else {
-        return item.name + (item.args.length > 0 ? "(" + item.args.map((arg) => this.configInvocationArgToText(arg)).join(", ") + ")" : "");
-      }
-    }).join(", ") + "]";
-  }
-  configInvocationArgToText(arg) {
-    return `${arg.name}: ${this.literalToText(arg.value)}`;
-  }
-  literalToText(expr) {
-    return JSON.stringify(expr.value);
-  }
-  generateGenerator(prisma, decl) {
-    prisma.addGenerator(decl.name, decl.fields.map((f) => ({
-      name: f.name,
-      text: this.configExprToText(f.value)
-    })));
-  }
-  generateDefaultGenerator(prisma) {
-    const gen = prisma.addGenerator("client", [
-      {
-        name: "provider",
-        text: '"prisma-client-js"'
-      }
-    ]);
-    const previewFeatures = [];
-    const dataSource = this.zmodel.declarations.find(isDataSource);
-    if (dataSource?.fields.some((f) => f.name === "extensions")) {
-      previewFeatures.push("postgresqlExtensions");
-    }
-    if (this.zmodel.declarations.some((d) => isDataModel2(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 = getAllFields2(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 = 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(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 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 = 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 (isTypeDef2(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
-      isTypeDef2(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 AstUtils.streamAst(expr).some(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 (isLiteralExpr2(node)) {
-      const argType = match(node.$type).with(StringLiteral, () => "String").with(NumberLiteral, () => "Number").with(BooleanLiteral, () => "Boolean").exhaustive();
-      return new AttributeArgValue(argType, node.value);
-    } else if (isArrayExpr(node)) {
-      return new AttributeArgValue("Array", new Array(...node.items.map((item) => this.makeAttributeArgValue(item))));
-    } else if (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 (isInvocationExpr(node)) {
-      return new AttributeArgValue("FunctionCall", this.makeFunctionCall(node));
-    } else {
-      throw Error(`Unsupported attribute argument expression type: ${node.$type}`);
-    }
-  }
-  exprToText(expr) {
-    return new ZModelCodeGenerator({
-      quote: "double"
-    }).generate(expr);
-  }
-  makeFunctionCall(node) {
-    return new FunctionCall(node.function.ref.name, node.args.map((arg) => {
-      const val = match(arg.value).when(isStringLiteral, (v) => `"${v.value}"`).when(isLiteralExpr2, (v) => v.value.toString()).when(isNullExpr, () => "null").otherwise(() => {
-        throw new Error("Function call argument must be literal or null");
-      });
-      return new FunctionCallArg(val);
-    }));
-  }
-  generateContainerAttribute(container, attr) {
-    const attrName = attr.decl.ref.name;
-    container.attributes.push(new ContainerAttribute(attrName, attr.args.map((arg) => this.makeAttributeArg(arg))));
-  }
-  generateEnum(prisma, decl) {
-    const _enum = prisma.addEnum(decl.name);
-    for (const field of decl.fields) {
-      this.generateEnumField(_enum, field);
-    }
-    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 (!isDelegateModel2(decl)) {
-      return;
-    }
-    const concreteModels = this.getConcreteModels(decl);
-    concreteModels.forEach((concrete) => {
-      const auxName = this.truncate(`${DELEGATE_AUX_RELATION_PREFIX}_${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}_${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 (!isDelegateModel2(dataModel)) {
-      return [];
-    }
-    return dataModel.$container.declarations.filter((d) => isDataModel2(d) && d !== dataModel && d.baseModel?.ref === dataModel);
-  }
-  truncate(name) {
-    if (name.length <= IDENTIFIER_NAME_MAX_LENGTH) {
-      return name;
-    }
-    const existing = this.shortNameMap.get(name);
-    if (existing) {
-      return existing;
-    }
-    const baseName = name.slice(0, IDENTIFIER_NAME_MAX_LENGTH);
-    let index = 0;
-    let shortName = `${baseName}_${index}`;
-    while (true) {
-      const conflict = Array.from(this.shortNameMap.values()).find((v) => v === shortName);
-      if (!conflict) {
-        this.shortNameMap.set(name, shortName);
-        break;
-      }
-      index++;
-      shortName = `${baseName}_${index}`;
-    }
-    return shortName;
-  }
-};
-
-// src/ts-schema-generator.ts
-import { invariant } from "@zenstackhq/common-helpers";
-import { isArrayExpr as isArrayExpr2, isBinaryExpr, isCollectionPredicateBinding, isDataField, isDataModel as isDataModel3, isDataSource as isDataSource2, isEnum, isEnumField, isInvocationExpr as isInvocationExpr2, isLiteralExpr as isLiteralExpr3, isMemberAccessExpr, isNullExpr as isNullExpr2, isProcedure, isReferenceExpr as isReferenceExpr2, isThisExpr, isTypeDef as isTypeDef3, isUnaryExpr } from "@zenstackhq/language/ast";
-import { getAllAttributes as getAllAttributes2, getAllFields as getAllFields3, getAttributeArg, isDataFieldReference } from "@zenstackhq/language/utils";
-import fs from "fs";
-import path from "path";
-import { match as match2 } from "ts-pattern";
-import * as ts from "typescript";
-var TsSchemaGenerator = class {
-  static {
-    __name(this, "TsSchemaGenerator");
-  }
-  usedExpressionUtils = false;
-  usedAttributeApplication = false;
-  usedFieldDefault = false;
-  async generate(model, options) {
-    fs.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 = path.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);
-      fs.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(isTypeDef3) ? [
-        ts.factory.createPropertyDeclaration(void 0, "typeDefs", void 0, void 0, this.createAsConst(this.createTypeDefsObject(model, lite)))
-      ] : []
-    ];
-    const enums = model.declarations.filter(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(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) => isDataModel3(d) && !hasAttribute(d, "@@ignore"));
-  }
-  getAllTypeDefs(model) {
-    return model.declarations.filter((d) => isTypeDef3(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 = getAllFields3(dm);
-    const allAttributes = lite ? [] : getAllAttributes2(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(isDataModel3).filter((d) => d.baseModel?.ref === dm).map((d) => d.name);
-  }
-  createTypeDefObject(td, lite) {
-    const allFields = getAllFields3(td);
-    const allAttributes = getAllAttributes2(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 = match2(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 (isDataModel3(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" && isDataFieldReference(arg.value) && arg.value.target.ref === field);
-  }
-  getDataSourceProvider(model) {
-    const dataSource = model.declarations.find(isDataSource2);
-    invariant(dataSource, "No data source found in the model");
-    const providerExpr = dataSource.fields.find((f) => f.name === "provider")?.value;
-    invariant(isLiteralExpr3(providerExpr) && typeof providerExpr.value === "string", "Provider must be a string literal");
-    return providerExpr.value;
-  }
-  getDataSourceDefaultSchema(model) {
-    const dataSource = model.declarations.find(isDataSource2);
-    invariant(dataSource, "No data source found in the model");
-    const defaultSchemaExpr = dataSource.fields.find((f) => f.name === "defaultSchema")?.value;
-    if (!defaultSchemaExpr) {
-      return void 0;
-    }
-    invariant(isLiteralExpr3(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;
-    invariant(defaultValue, "Expected a default value");
-    return this.getMappedValue(defaultValue, field.type);
-  }
-  getMappedValue(expr, fieldType) {
-    if (isLiteralExpr3(expr)) {
-      const lit = expr.value;
-      return fieldType.type === "Boolean" ? lit : [
-        "Int",
-        "Float",
-        "Decimal",
-        "BigInt"
-      ].includes(fieldType.type) ? Number(lit) : lit;
-    } else if (isArrayExpr2(expr)) {
-      return expr.items.map((item) => this.getMappedValue(item, fieldType));
-    } else if (isReferenceExpr2(expr) && isEnumField(expr.target.ref)) {
-      return expr.target.ref.name;
-    } else if (isInvocationExpr2(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 (isNullExpr2(expr)) {
-      return null;
-    } else {
-      throw new Error(`Unsupported expression type: ${expr.$type}`);
-    }
-  }
-  getMemberAccessChain(expr) {
-    if (!isMemberAccessExpr(expr.operand)) {
-      return [
-        expr.member.$refText
-      ];
-    } else {
-      return [
-        ...this.getMemberAccessChain(expr.operand),
-        expr.member.$refText
-      ];
-    }
-  }
-  isAuthMemberAccess(expr) {
-    if (isMemberAccessExpr(expr)) {
-      return this.isAuthInvocation(expr.operand) || this.isAuthMemberAccess(expr.operand);
-    } else {
-      return false;
-    }
-  }
-  isAuthInvocation(expr) {
-    return isInvocationExpr2(expr) && expr.function.$refText === "auth" && model_utils_exports.isFromStdlib(expr.function.ref);
-  }
-  createRelationObject(field) {
-    const relationFields = [];
-    const oppositeRelation = this.getOppositeRelationField(field);
-    if (oppositeRelation) {
-      relationFields.push(ts.factory.createPropertyAssignment("opposite", ts.factory.createStringLiteral(oppositeRelation.name)));
-    }
-    const relationName = this.getRelationName(field);
-    if (relationName) {
-      relationFields.push(ts.factory.createPropertyAssignment("name", ts.factory.createStringLiteral(relationName)));
-    }
-    const relation = getAttribute(field, "@relation");
-    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 isArrayExpr2(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" && isArrayExpr2(arg.value) && arg.value.items.some((el) => isReferenceExpr2(el) && el.target.ref === field)) {
-            result.push(f.name);
-          }
-        }
-      }
-    }
-    return result;
-  }
-  getOppositeRelationField(field) {
-    if (!field.type.reference?.ref || !isDataModel3(field.type.reference?.ref)) {
-      return void 0;
-    }
-    const sourceModel = field.$container;
-    const targetModel = field.type.reference.ref;
-    const relationName = this.getRelationName(field);
-    for (const otherField of targetModel.fields) {
-      if (otherField === field) {
-        continue;
-      }
-      if (otherField.type.reference?.ref === sourceModel) {
-        if (relationName) {
-          const otherRelationName = this.getRelationName(otherField);
-          if (otherRelationName === relationName) {
-            return otherField;
-          }
-        } else {
-          return otherField;
-        }
-      }
-    }
-    return void 0;
-  }
-  getRelationName(field) {
-    const relation = getAttribute(field, "@relation");
-    if (relation) {
-      const nameArg = relation.args.find((arg) => arg.$resolvedParam.name === "name");
-      if (nameArg) {
-        invariant(isLiteralExpr3(nameArg.value), "name must be a literal");
-        return nameArg.value.value;
-      }
-    }
-    return void 0;
-  }
-  createUniqueFieldsObject(dm) {
-    const properties = [];
-    const allFields = getAllFields3(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 = getAllAttributes2(dm);
-    const seenKeys = /* @__PURE__ */ new Set();
-    for (const attr of allAttributes) {
-      if (attr.decl.$refText === "@@id" || attr.decl.$refText === "@@unique") {
-        const fieldsArg = 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 && isLiteralExpr3(nameArg.value)) {
-      return nameArg.value.value;
-    } else {
-      return fieldNames.join("_");
-    }
-  }
-  generateFieldTypeLiteral(field) {
-    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 (!isLiteralExpr3(expr)) {
-      throw new Error("Expected a literal expression");
-    }
-    switch (expr?.$type) {
-      case "StringLiteral":
-      case "BooleanLiteral":
-        return expr.value;
-      case "NumberLiteral":
-        return parseFloat(expr.value);
-      default:
-        throw new Error("Unsupported literal type");
-    }
-  }
-  createLiteralNode(arg) {
-    return arg === null ? ts.factory.createNull() : typeof arg === "string" ? ts.factory.createStringLiteral(arg) : typeof arg === "number" ? 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 = `////////////////////////////////////////////////////////////////////////////////////////////
-// 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 match2(value).when(isLiteralExpr3, (expr) => this.createLiteralExpression(expr.$type, expr.value)).when(isInvocationExpr2, (expr) => this.createCallExpression(expr)).when(isReferenceExpr2, (expr) => this.createRefExpression(expr)).when(isArrayExpr2, (expr) => this.createArrayExpression(expr)).when(isUnaryExpr, (expr) => this.createUnaryExpression(expr)).when(isBinaryExpr, (expr) => this.createBinaryExpression(expr)).when(isMemberAccessExpr, (expr) => this.createMemberExpression(expr)).when(isNullExpr2, () => this.createNullExpression()).when(isThisExpr, () => this.createThisExpression()).otherwise(() => {
-      throw new Error(`Unsupported attribute arg value: ${value.$type}`);
-    });
-  }
-  createThisExpression() {
-    return this.createExpressionUtilsCall("_this");
-  }
-  createMemberExpression(expr) {
-    const members = [];
-    let current = expr;
-    while (isMemberAccessExpr(current)) {
-      members.unshift(current.member.$refText);
-      current = current.operand;
-    }
-    const receiver = current;
-    const args = [
-      this.createExpression(receiver),
-      ts.factory.createArrayLiteralExpression(members.map((m) => ts.factory.createStringLiteral(m)))
-    ];
-    return 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;
-    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 match2(target).when(isDataField, () => this.createExpressionUtilsCall("field", [
-      this.createLiteralNode(expr.target.$refText)
-    ])).when(isEnumField, () => this.createLiteralExpression("StringLiteral", expr.target.$refText)).when(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 match2(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(isTypeDef3) ? [
-        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(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 = path.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);
-    fs.writeFileSync(outputFile, result);
-  }
-  generateSchemaImport(model, schemaObject, schemaType, useLite, importWithFileExtension) {
-    const importSpecifiers = [];
-    if (schemaObject) {
-      if (model.declarations.some(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 = path.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);
-    fs.writeFileSync(outputFile, result);
-  }
-};
-export {
-  model_utils_exports as ModelUtils,
-  PrismaSchemaGenerator,
-  TsSchemaGenerator
-};
-//# sourceMappingURL=index.js.map