@danielhritcu/zenstack-custom 1.1.0

package/dist/codegen/index.js

@@ -0,0 +1,2668 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/codegen/config.ts
+function defineConfig(tables, config) {
+  const derived2 = config.derived ?? {};
+  const orm = {
+    ...tables
+  };
+  for (const [name, desc] of Object.entries(derived2)) {
+    if (name in tables) {
+      throw new Error(`Derived model "${name}" collides with existing table name.`);
+    }
+    orm[name] = desc;
+  }
+  const models = config.models(orm);
+  return {
+    tables,
+    schema: config.schema,
+    default: config.default,
+    derived: derived2,
+    models
+  };
+}
+__name(defineConfig, "defineConfig");
+
+// src/codegen/dsl/extend.ts
+import { getTableConfig } from "drizzle-orm/pg-core";
+function inferNarrow(where) {
+  const narrow = {};
+  let hasNarrow = false;
+  for (const [field, condition] of Object.entries(where)) {
+    if (condition && typeof condition === "object" && !Array.isArray(condition)) {
+      const cond = condition;
+      if ("in" in cond && Array.isArray(cond["in"])) {
+        narrow[field] = cond["in"];
+        hasNarrow = true;
+      }
+    }
+  }
+  return hasNarrow ? narrow : null;
+}
+__name(inferNarrow, "inferNarrow");
+function derived(base, opts) {
+  const cfg = getTableConfig(base);
+  const descriptor = {
+    __brand: "derived",
+    base,
+    where: opts.where,
+    narrow: opts.narrow ?? inferNarrow(opts.where),
+    baseName: cfg.name
+  };
+  return new Proxy(descriptor, {
+    get(target, prop, receiver) {
+      if (prop in target) return Reflect.get(target, prop, receiver);
+      return Reflect.get(base, prop);
+    },
+    has(target, prop) {
+      return prop in target || prop in base;
+    }
+  });
+}
+__name(derived, "derived");
+function extend(tables, derivedModels) {
+  for (const key of Object.keys(derivedModels)) {
+    if (key in tables) {
+      throw new Error(`Derived model "${key}" collides with existing table name. Choose a different name.`);
+    }
+  }
+  const extended = {
+    tables: {
+      ...tables
+    },
+    derived: {
+      ...derivedModels
+    }
+  };
+  const schemaProps = Object.assign({}, tables, derivedModels, {
+    __extended: extended
+  });
+  const defineModelsFn = /* @__PURE__ */ __name((globalConfig, models) => ({
+    schema: extended,
+    global: globalConfig,
+    models
+  }), "defineModelsFn");
+  return Object.assign(defineModelsFn, schemaProps);
+}
+__name(extend, "extend");
+
+// src/codegen/dsl/relations.ts
+function one(target, opts) {
+  return {
+    kind: "one",
+    target,
+    fields: opts.fields,
+    references: opts.references,
+    ...opts.where ? {
+      where: opts.where
+    } : {},
+    ...opts.relationName ? {
+      relationName: opts.relationName
+    } : {}
+  };
+}
+__name(one, "one");
+function many(target, opts) {
+  return {
+    kind: "many",
+    target,
+    ...opts?.where ? {
+      where: opts.where
+    } : {},
+    ...opts?.single ? {
+      single: true
+    } : {}
+  };
+}
+__name(many, "many");
+function through(path) {
+  return {
+    kind: "through",
+    path
+  };
+}
+__name(through, "through");
+
+// src/codegen/dsl/model.ts
+function model(table, opts) {
+  const helpers = {
+    one,
+    many,
+    through
+  };
+  return {
+    table,
+    relations: opts.relations?.(helpers),
+    computed: opts.computed,
+    search: opts.search,
+    defaultWhere: opts.defaultWhere,
+    derived: opts.derived,
+    validate: opts.validate
+  };
+}
+__name(model, "model");
+function defineModels(extendedSchema, globalConfig, models) {
+  return {
+    schema: extendedSchema.__extended,
+    global: globalConfig,
+    models
+  };
+}
+__name(defineModels, "defineModels");
+
+// src/codegen/dsl/adapter.ts
+import { getTableConfig as getTableConfig2 } from "drizzle-orm/pg-core";
+var COMPUTED_TYPE_MAP = {
+  json: {
+    type: "Json",
+    tsType: "JsonValue"
+  },
+  string: {
+    type: "String",
+    tsType: "string"
+  },
+  text: {
+    type: "String",
+    tsType: "string"
+  },
+  int: {
+    type: "Int",
+    tsType: "number"
+  },
+  float: {
+    type: "Float",
+    tsType: "number"
+  },
+  bool: {
+    type: "Boolean",
+    tsType: "boolean"
+  },
+  boolean: {
+    type: "Boolean",
+    tsType: "boolean"
+  },
+  dateTime: {
+    type: "DateTime",
+    tsType: "Date"
+  }
+};
+function resolveColumn(tables, column) {
+  for (const table of Object.values(tables)) {
+    for (const key of Object.keys(table)) {
+      if (table[key] === column) return {
+        table,
+        jsKey: key
+      };
+    }
+  }
+  const sqlName = column.name;
+  for (const table of Object.values(tables)) {
+    for (const key of Object.keys(table)) {
+      const col = table[key];
+      if (col && typeof col === "object" && "name" in col && col.name === sqlName) {
+        return {
+          table,
+          jsKey: key
+        };
+      }
+    }
+  }
+  return void 0;
+}
+__name(resolveColumn, "resolveColumn");
+function findExportNameForTable(tables, target) {
+  for (const [exportName, table] of Object.entries(tables)) {
+    if (table === target) return exportName;
+  }
+  const targetSqlName = getTableConfig2(target).name;
+  for (const [exportName, table] of Object.entries(tables)) {
+    if (getTableConfig2(table).name === targetSqlName) return exportName;
+  }
+  throw new Error(`Could not find export name for table "${targetSqlName}"`);
+}
+__name(findExportNameForTable, "findExportNameForTable");
+function sqlNameToExportName(tables, sqlName) {
+  for (const [exportName, table] of Object.entries(tables)) {
+    if (getTableConfig2(table).name === sqlName) return exportName;
+  }
+  throw new Error(`No table export found with SQL name "${sqlName}"`);
+}
+__name(sqlNameToExportName, "sqlNameToExportName");
+function findDerivedNameForDescriptor(derived2, descriptor) {
+  for (const [name, desc] of Object.entries(derived2)) {
+    if (desc === descriptor) return name;
+  }
+  throw new Error(`Could not find derived model name for descriptor with base "${descriptor.baseName}"`);
+}
+__name(findDerivedNameForDescriptor, "findDerivedNameForDescriptor");
+function convertSearchFields(tables, fields) {
+  const result = {};
+  for (const field of fields) {
+    if ("name" in field && typeof field.name === "string") {
+      const resolved = resolveColumn(tables, field);
+      if (!resolved) throw new Error(`Could not resolve column "${field.name}"`);
+      result[resolved.jsKey] = true;
+    } else {
+      for (const [relation, nested] of Object.entries(field)) {
+        result[relation] = convertSearchFields(tables, nested);
+      }
+    }
+  }
+  return result;
+}
+__name(convertSearchFields, "convertSearchFields");
+function convertSearchProfile(tables, _modelTable, profile) {
+  return {
+    fields: convertSearchFields(tables, profile.fields)
+  };
+}
+__name(convertSearchProfile, "convertSearchProfile");
+function adaptToLegacyConfig(output) {
+  const { schema, models } = output;
+  const computedFields = {};
+  const computedCallbacks = {};
+  const derivedModels = {};
+  const filteredRelations = {};
+  const searchDefaults = {};
+  const throughRelations = {};
+  const relationTargets = {};
+  const modelScopes = {};
+  const derivedFields = {};
+  const validationSchemas = {};
+  const fkRelations = {};
+  for (const [derivedName, desc] of Object.entries(schema.derived)) {
+    const baseExportName = sqlNameToExportName(schema.tables, desc.baseName);
+    if (!derivedModels[baseExportName]) {
+      derivedModels[baseExportName] = {};
+    }
+    derivedModels[baseExportName][derivedName] = {
+      where: desc.where,
+      ...desc.narrow ? {
+        narrow: desc.narrow
+      } : {}
+    };
+  }
+  for (const [modelName, config] of Object.entries(models)) {
+    if (config.computed && typeof config.computed !== "function") {
+      const resolvedComputed = {};
+      const callbacks = {};
+      for (const [fieldName, decl] of Object.entries(config.computed)) {
+        if (typeof decl === "function") {
+          resolvedComputed[fieldName] = COMPUTED_TYPE_MAP["json"];
+          callbacks[fieldName] = decl;
+        } else {
+          const declObj = decl;
+          const typeKey = declObj.type?.toLowerCase() ?? "json";
+          resolvedComputed[fieldName] = COMPUTED_TYPE_MAP[typeKey] ?? COMPUTED_TYPE_MAP["json"];
+        }
+      }
+      computedFields[modelName] = resolvedComputed;
+      if (Object.keys(callbacks).length > 0) {
+        computedCallbacks[modelName] = callbacks;
+      }
+    }
+    if (config.relations) {
+      for (const [relName, rel] of Object.entries(config.relations)) {
+        if (rel.kind === "one") {
+          const oneRel = rel;
+          const targetTable = "__brand" in oneRel.target ? oneRel.target.base : oneRel.target;
+          const targetExportName = findExportNameForTable(schema.tables, targetTable);
+          const resolvedFields = oneRel.fields.map((col) => {
+            const resolved = resolveColumn(schema.tables, col);
+            return resolved?.jsKey ?? col.name;
+          });
+          const resolvedRefs = oneRel.references.map((col) => {
+            const resolved = resolveColumn(schema.tables, col);
+            return resolved?.jsKey ?? col.name;
+          });
+          if (oneRel.where) {
+            if (!fkRelations[modelName]) {
+              fkRelations[modelName] = {};
+            }
+            fkRelations[modelName][relName] = {
+              targetExportName,
+              fields: resolvedFields,
+              references: resolvedRefs,
+              relationName: oneRel.relationName ?? null
+            };
+            if (!filteredRelations[modelName]) {
+              filteredRelations[modelName] = {};
+            }
+            filteredRelations[modelName][relName] = {
+              relation: {
+                [relName]: true
+              },
+              where: oneRel.where,
+              single: true
+            };
+          } else {
+            if (!fkRelations[modelName]) {
+              fkRelations[modelName] = {};
+            }
+            fkRelations[modelName][relName] = {
+              targetExportName,
+              fields: resolvedFields,
+              references: resolvedRefs,
+              relationName: oneRel.relationName ?? null
+            };
+          }
+          if ("__brand" in oneRel.target && oneRel.target.__brand === "derived") {
+            const descriptor = oneRel.target;
+            const derivedName = findDerivedNameForDescriptor(schema.derived, descriptor);
+            const baseExportName = sqlNameToExportName(schema.tables, descriptor.baseName);
+            if (!derivedModels[baseExportName]) {
+              derivedModels[baseExportName] = {};
+            }
+            const derivedEntry = derivedModels[baseExportName][derivedName];
+            if (derivedEntry) {
+              if (!derivedEntry.relations) {
+                derivedEntry.relations = {};
+              }
+              if (!derivedEntry.relations[modelName]) {
+                derivedEntry.relations[modelName] = {};
+              }
+              derivedEntry.relations[modelName][relName] = true;
+            }
+            if (!relationTargets[modelName]) {
+              relationTargets[modelName] = {};
+            }
+            relationTargets[modelName][relName] = derivedName;
+          }
+        } else if (rel.kind === "many") {
+          const manyRel = rel;
+          const targetExportName = findExportNameForTable(schema.tables, manyRel.target);
+          if (!filteredRelations[modelName]) {
+            filteredRelations[modelName] = {};
+          }
+          filteredRelations[modelName][relName] = {
+            relation: {
+              [targetExportName]: true
+            },
+            ...manyRel.where ? {
+              where: manyRel.where
+            } : {},
+            ...manyRel.single ? {
+              single: true
+            } : {}
+          };
+        } else if (rel.kind === "through") {
+          const throughRel = rel;
+          if (!throughRelations[modelName]) {
+            throughRelations[modelName] = {};
+          }
+          throughRelations[modelName][relName] = {
+            path: throughRel.path
+          };
+        }
+      }
+    }
+    if (config.defaultWhere) {
+      modelScopes[modelName] = config.defaultWhere;
+    } else if (output.global.defaultWhere) {
+      modelScopes[modelName] = output.global.defaultWhere;
+    }
+    if (config.derived) {
+      derivedFields[modelName] = config.derived;
+    }
+    if (config.validate) {
+      validationSchemas[modelName] = config.validate;
+    }
+    if (config.search) {
+      const modelSearchDefaults = {};
+      for (const [profileName, profile] of Object.entries(config.search)) {
+        modelSearchDefaults[profileName] = convertSearchProfile(schema.tables, config.table, profile);
+      }
+      searchDefaults[modelName] = modelSearchDefaults;
+    }
+  }
+  return {
+    computedFields,
+    computedCallbacks,
+    derivedModels,
+    filteredRelations,
+    searchDefaults,
+    throughRelations,
+    relationTargets,
+    modelScopes,
+    derivedFields,
+    validationSchemas,
+    fkRelations
+  };
+}
+__name(adaptToLegacyConfig, "adaptToLegacyConfig");
+
+// src/codegen/utils.ts
+import * as fs from "fs";
+var APP_SLUG_SQL = "app_slug";
+var APP_SLUG_JS = "appSlug";
+var GENERATED_FILE_BANNER = [
+  "//////////////////////////////////////////////////////////////////////////////////////////////",
+  "// DO NOT MODIFY THIS FILE                                                                  //",
+  "// Generated by scripts/zen from Drizzle schema.                                            //",
+  "//////////////////////////////////////////////////////////////////////////////////////////////",
+  "",
+  "/* eslint-disable */"
+];
+function emitGeneratedFileBanner() {
+  return [
+    ...GENERATED_FILE_BANNER
+  ];
+}
+__name(emitGeneratedFileBanner, "emitGeneratedFileBanner");
+function capitalize(s) {
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
+__name(capitalize, "capitalize");
+function toPascalCase(s) {
+  return s.replace(/([a-z0-9])([A-Z])/g, "$1 $2").split(/[_\-\s]+/).filter(Boolean).map(capitalize).join("");
+}
+__name(toPascalCase, "toPascalCase");
+function uncapitalize(s) {
+  return s.charAt(0).toLowerCase() + s.slice(1);
+}
+__name(uncapitalize, "uncapitalize");
+function esc(s) {
+  return JSON.stringify(s);
+}
+__name(esc, "esc");
+function getDrizzleTableName(table) {
+  return table[Symbol.for("drizzle:Name")];
+}
+__name(getDrizzleTableName, "getDrizzleTableName");
+function writeFileIfChanged(filePath, content) {
+  if (fs.existsSync(filePath) && fs.readFileSync(filePath, "utf-8") === content) {
+    return false;
+  }
+  fs.writeFileSync(filePath, content, "utf-8");
+  return true;
+}
+__name(writeFileIfChanged, "writeFileIfChanged");
+
+// src/codegen/columns.ts
+function mapColumn(jsKey, col, enumMap) {
+  const sqlName = col.name;
+  const colType = col.columnType;
+  const notNull = col.notNull;
+  const hasDefault = col.hasDefault;
+  const isPrimary = col.primary;
+  const isUnique = col.isUnique;
+  const generated = col.generated;
+  const isArray = colType === "PgArray";
+  let type = "String";
+  const dbAttrs = [];
+  let enumPgName = null;
+  let isJsonColumn = false;
+  let actualColType = colType;
+  let actualCol = col;
+  if (isArray && col.baseColumn) {
+    actualCol = col.baseColumn;
+    actualColType = actualCol.columnType;
+  }
+  switch (actualColType) {
+    case "PgUUID":
+      type = "String";
+      dbAttrs.push("@db.Uuid");
+      break;
+    case "PgText":
+      type = "String";
+      break;
+    case "PgVarchar": {
+      type = "String";
+      const len = actualCol.length;
+      if (len) dbAttrs.push(`@db.VarChar(${len})`);
+      else dbAttrs.push("@db.VarChar");
+      break;
+    }
+    case "PgBoolean":
+      type = "Boolean";
+      break;
+    case "PgInteger":
+      type = "Int";
+      break;
+    case "PgBigInt53":
+      type = "BigInt";
+      break;
+    case "PgSerial":
+      type = "Int";
+      break;
+    case "PgReal":
+      type = "Float";
+      dbAttrs.push("@db.Real");
+      break;
+    case "PgDoublePrecision":
+      type = "Float";
+      dbAttrs.push("@db.DoublePrecision");
+      break;
+    case "PgTimestamp": {
+      type = "DateTime";
+      const wtz = actualCol.withTimezone ?? actualCol.config?.withTimezone;
+      if (wtz) dbAttrs.push("@db.Timestamptz(6)");
+      else dbAttrs.push("@db.Timestamp(6)");
+      break;
+    }
+    case "PgDate":
+    case "PgDateString":
+      type = "DateTime";
+      dbAttrs.push("@db.Date");
+      break;
+    case "PgJsonb":
+      type = "Json";
+      isJsonColumn = true;
+      dbAttrs.push("@db.JsonB");
+      break;
+    case "PgJson":
+      type = "Json";
+      isJsonColumn = true;
+      dbAttrs.push("@db.Json");
+      break;
+    case "PgEnumColumn": {
+      if (isArray) {
+        type = "String";
+      } else {
+        const eName = actualCol.enum?.enumName;
+        if (eName && enumMap.has(eName)) {
+          type = enumMap.get(eName).zenstackName;
+          enumPgName = eName;
+        } else {
+          type = "String";
+        }
+      }
+      break;
+    }
+    case "PgCustomColumn": {
+      const sqlType = actualCol.sqlName || actualCol.config?.dataType;
+      if (sqlType === "json") {
+        type = "Json";
+        isJsonColumn = true;
+        dbAttrs.push("@db.Json");
+      } else if (sqlType === "jsonb") {
+        type = "Json";
+        isJsonColumn = true;
+        dbAttrs.push("@db.JsonB");
+      } else if (sqlType === "numeric") {
+        type = "Decimal";
+      } else type = "String";
+      break;
+    }
+    case "PgNumeric":
+      type = "Decimal";
+      break;
+    default:
+      console.warn(`Unknown Drizzle column type "${actualColType}" for column "${sqlName}" \u2014 falling back to String`);
+      type = "String";
+  }
+  let defaultExpr = null;
+  if (hasDefault) {
+    if (isPrimary && actualColType === "PgUUID") {
+      defaultExpr = 'ExpressionUtils.call("uuid")';
+    } else if (actualColType === "PgBigInt53" && col.generatedIdentity) {
+      defaultExpr = 'ExpressionUtils.call("autoincrement")';
+    } else if (actualColType === "PgSerial") {
+      defaultExpr = 'ExpressionUtils.call("autoincrement")';
+    } else if (col.defaultFn) {
+      if (type === "DateTime") {
+        defaultExpr = 'ExpressionUtils.call("now")';
+      } else if (type === "String" && isPrimary) {
+        defaultExpr = 'ExpressionUtils.call("uuid")';
+      } else {
+        defaultExpr = null;
+      }
+    } else if (col.default !== void 0) {
+      const d = col.default;
+      if (typeof d === "boolean" || typeof d === "number") {
+        defaultExpr = `ExpressionUtils.literal(${d})`;
+      } else if (typeof d === "string") {
+        defaultExpr = `ExpressionUtils.literal(${esc(d)})`;
+      } else if (d && typeof d === "object" && "queryChunks" in d) {
+        try {
+          const chunks = d.queryChunks || [];
+          const sqlStr = chunks.map((c) => typeof c === "string" ? c : c.value?.[0] || "").join("").trim();
+          if (sqlStr) {
+            defaultExpr = `ExpressionUtils.call("dbgenerated", [ExpressionUtils.literal(${esc(sqlStr)})])`;
+          }
+        } catch (e) {
+          console.warn(`Failed to parse SQL default for column "${sqlName}":`, e);
+        }
+      } else if (Array.isArray(d) && d.length === 0) {
+        defaultExpr = "[] as FieldDefault";
+      } else if (typeof d === "object" && d !== null && Object.keys(d).length === 0) {
+        defaultExpr = `ExpressionUtils.literal("{}")`;
+      }
+    }
+  }
+  return {
+    name: jsKey,
+    sqlName,
+    type,
+    isJsonColumn,
+    optional: !notNull && !hasDefault,
+    array: isArray,
+    id: isPrimary,
+    unique: isUnique,
+    hasDefault,
+    dbAttrs,
+    defaultExpr,
+    enumPgName,
+    isGenerated: !!generated
+  };
+}
+__name(mapColumn, "mapColumn");
+
+// src/codegen/discover.ts
+import { getTableConfig as getTableConfig3, getViewConfig } from "drizzle-orm/pg-core";
+import * as fs2 from "fs";
+import * as ts from "typescript";
+
+// src/drizzle/define.ts
+import { SQL, sql } from "drizzle-orm";
+import { pgEnum as drizzlePgEnum } from "drizzle-orm/pg-core";
+var ENUM_MAP = Symbol.for("drizzle:EnumMap");
+
+// src/codegen/discover.ts
+function discoverEnums(allEnums) {
+  const enums = /* @__PURE__ */ new Map();
+  for (const [exportName, val] of Object.entries(allEnums)) {
+    if (typeof val !== "function" || !("enumName" in val)) continue;
+    const e = val;
+    const pgName = e.enumName;
+    const values = e.enumValues;
+    const zenstackName = capitalize(exportName.replace(/Enum$/, ""));
+    const mapping = e[ENUM_MAP] ?? null;
+    enums.set(pgName, {
+      pgName,
+      zenstackName,
+      values,
+      mapping,
+      mappedName: pgName
+    });
+  }
+  return enums;
+}
+__name(discoverEnums, "discoverEnums");
+function getColumnsObject(node) {
+  if (ts.isObjectLiteralExpression(node)) return node;
+  if (ts.isArrowFunction(node) || ts.isFunctionExpression(node)) {
+    if (ts.isObjectLiteralExpression(node.body)) return node.body;
+    if (ts.isParenthesizedExpression(node.body) && ts.isObjectLiteralExpression(node.body.expression)) {
+      return node.body.expression;
+    }
+    if (ts.isBlock(node.body)) {
+      for (const statement of node.body.statements) {
+        if (!ts.isReturnStatement(statement) || !statement.expression) continue;
+        if (ts.isObjectLiteralExpression(statement.expression)) return statement.expression;
+        if (ts.isParenthesizedExpression(statement.expression) && ts.isObjectLiteralExpression(statement.expression.expression)) {
+          return statement.expression.expression;
+        }
+      }
+    }
+  }
+  return null;
+}
+__name(getColumnsObject, "getColumnsObject");
+function getColumnBuilderName(node) {
+  if (ts.isCallExpression(node)) return getColumnBuilderName(node.expression);
+  if (ts.isPropertyAccessExpression(node)) {
+    if (ts.isIdentifier(node.expression) && node.expression.text === "col") {
+      return node.name.text;
+    }
+    return getColumnBuilderName(node.expression);
+  }
+  return null;
+}
+__name(getColumnBuilderName, "getColumnBuilderName");
+function assertNoTypedColumnOverrides(tablesFilePath) {
+  const sourceFile = ts.createSourceFile(tablesFilePath, fs2.readFileSync(tablesFilePath, "utf8"), ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+  for (const statement of sourceFile.statements) {
+    if (!ts.isVariableStatement(statement)) continue;
+    for (const declaration of statement.declarationList.declarations) {
+      if (!ts.isIdentifier(declaration.name) || !declaration.initializer) continue;
+      if (!ts.isCallExpression(declaration.initializer)) continue;
+      const columnsArg = declaration.initializer.arguments[1];
+      if (!columnsArg) continue;
+      const columnsObject = getColumnsObject(columnsArg);
+      if (!columnsObject) continue;
+      for (const property of columnsObject.properties) {
+        if (!ts.isPropertyAssignment(property)) continue;
+        const nameNode = property.name;
+        const jsKey = ts.isIdentifier(nameNode) || ts.isStringLiteral(nameNode) ? nameNode.text : null;
+        if (!jsKey) continue;
+        let typedCall = null;
+        const visit = /* @__PURE__ */ __name((node) => {
+          if (typedCall) return;
+          if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && node.expression.name.text === "$type") {
+            typedCall = node;
+            return;
+          }
+          ts.forEachChild(node, visit);
+        }, "visit");
+        visit(property.initializer);
+        if (!typedCall) continue;
+        const resolvedCall = typedCall;
+        const builderName = getColumnBuilderName(resolvedCall.expression.expression);
+        if (builderName === "json" || builderName === "jsonb" || builderName === "array") continue;
+        const fullText = property.initializer.getText();
+        if (fullText.includes(".array()")) continue;
+        console.warn(`Warning: Column "${declaration.name.text}.${jsKey}" uses $type<...>() on a ${builderName ?? "scalar"} column. Consider using a real enum.`);
+      }
+    }
+  }
+}
+__name(assertNoTypedColumnOverrides, "assertNoTypedColumnOverrides");
+function discoverTables(allTables, computedFieldsConfig = {}, derivedModelsConfig = {}) {
+  const tables = [];
+  const tablesByModel = /* @__PURE__ */ new Map();
+  for (const [exportName, _val] of Object.entries(allTables)) {
+    const val = _val;
+    if (!val || typeof val !== "object") continue;
+    const syms = Object.getOwnPropertySymbols(val);
+    if (!syms.some((s) => s.toString().includes("IsDrizzleTable"))) continue;
+    const sqlName = getDrizzleTableName(val);
+    const modelName = exportName;
+    const typeName = capitalize(exportName);
+    const sqlToJsKey = /* @__PURE__ */ new Map();
+    const jsKeySet = /* @__PURE__ */ new Set();
+    for (const key of Object.keys(val)) {
+      const col = val[key];
+      if (col.name && col.columnType) {
+        sqlToJsKey.set(col.name, key);
+        jsKeySet.add(key);
+      }
+    }
+    const cfg = getTableConfig3(val);
+    const computedFields = Object.entries(computedFieldsConfig[exportName] ?? {}).map(([name, field]) => {
+      if (jsKeySet.has(name)) {
+        throw new Error(`Computed field "${exportName}.${name}" collides with an existing column.`);
+      }
+      return {
+        name,
+        type: field.type,
+        tsType: field.tsType
+      };
+    });
+    tables.push({
+      exportName,
+      sqlName,
+      modelName,
+      typeName,
+      table: val,
+      cfg,
+      sqlToJsKey,
+      jsKeySet,
+      computedFields,
+      derivedFrom: null,
+      defaultWhere: null,
+      narrow: null
+    });
+    tablesByModel.set(modelName, tables[tables.length - 1]);
+  }
+  for (const modelName of Object.keys(computedFieldsConfig)) {
+    if (!tablesByModel.has(modelName)) {
+      throw new Error(`Computed fields declared for unknown table export "${modelName}".`);
+    }
+  }
+  for (const [baseModelName, derivedModels] of Object.entries(derivedModelsConfig)) {
+    const baseTable = tablesByModel.get(baseModelName);
+    if (!baseTable) {
+      throw new Error(`Derived models declared for unknown table export "${baseModelName}".`);
+    }
+    for (const [derivedModelName, declaration] of Object.entries(derivedModels)) {
+      if (tablesByModel.has(derivedModelName)) {
+        throw new Error(`Derived model "${derivedModelName}" collides with an existing table or derived model.`);
+      }
+      const derivedTable = {
+        ...baseTable,
+        exportName: derivedModelName,
+        modelName: derivedModelName,
+        typeName: capitalize(derivedModelName),
+        computedFields: [
+          ...baseTable.computedFields
+        ],
+        derivedFrom: baseModelName,
+        defaultWhere: declaration.where,
+        narrow: declaration.narrow ?? null
+      };
+      tables.push(derivedTable);
+      tablesByModel.set(derivedModelName, derivedTable);
+    }
+  }
+  return tables;
+}
+__name(discoverTables, "discoverTables");
+function discoverViews(allViews) {
+  const views = [];
+  for (const [exportName, val] of Object.entries(allViews)) {
+    if (!val || typeof val !== "object") continue;
+    const syms = Object.getOwnPropertySymbols(val);
+    if (!syms.some((s) => s.toString().includes("IsDrizzleView"))) continue;
+    const cfg = getViewConfig(val);
+    const sqlName = cfg.name;
+    const modelName = exportName;
+    const typeName = capitalize(exportName);
+    const sqlToJsKey = /* @__PURE__ */ new Map();
+    const columns = /* @__PURE__ */ new Map();
+    for (const [jsKey, col] of Object.entries(cfg.selectedFields)) {
+      const colObj = col;
+      if (colObj.name && colObj.columnType) {
+        sqlToJsKey.set(colObj.name, jsKey);
+        columns.set(jsKey, colObj);
+      }
+    }
+    views.push({
+      exportName,
+      sqlName,
+      modelName,
+      typeName,
+      columns,
+      sqlToJsKey
+    });
+  }
+  return views;
+}
+__name(discoverViews, "discoverViews");
+function extractFKs(table) {
+  const cfg = getTableConfig3(table);
+  return cfg.foreignKeys.map((fk) => {
+    const ref = fk.reference();
+    return {
+      name: fk.getName(),
+      localColumns: ref.columns.map((c) => c.name),
+      foreignTable: getDrizzleTableName(ref.foreignTable),
+      foreignColumns: ref.foreignColumns.map((c) => c.name)
+    };
+  });
+}
+__name(extractFKs, "extractFKs");
+
+// src/codegen/relations.ts
+function makePhysicalRelationSignature(fields, references, array) {
+  return [
+    array ? "many" : "one",
+    fields?.join(",") || "",
+    references?.join(",") || ""
+  ].join("|");
+}
+__name(makePhysicalRelationSignature, "makePhysicalRelationSignature");
+function makePhysicalFKSignature(sourceTable, targetTable, fk) {
+  return makePhysicalRelationSignature(fk.localColumns.map((column) => sourceTable.sqlToJsKey.get(column) || column), fk.foreignColumns.map((column) => targetTable.sqlToJsKey.get(column) || column), false);
+}
+__name(makePhysicalFKSignature, "makePhysicalFKSignature");
+function assertNoRelationFieldCollision(table, sourceRelations, fieldName) {
+  if (table.jsKeySet.has(fieldName)) {
+    throw new Error(`Relation "${table.exportName}.${fieldName}" collides with an existing field. Rename the FK key in tables.ts or choose a different relation key in relations.ts.`);
+  }
+  if (sourceRelations.some((relation) => relation.fieldName === fieldName)) {
+    throw new Error(`Relation "${table.exportName}.${fieldName}" collides with another relation field. Use a unique key in relations.ts.`);
+  }
+}
+__name(assertNoRelationFieldCollision, "assertNoRelationFieldCollision");
+function unfoldThroughPath(path, relationNames = []) {
+  const entries = Object.entries(path);
+  if (entries.length !== 1) {
+    throw new Error("Through relation path must contain exactly one relation per level.");
+  }
+  const entry = entries[0];
+  const [relationName, next] = entry;
+  relationNames.push(relationName);
+  if (next === true) {
+    return relationNames;
+  }
+  return unfoldThroughPath(next, relationNames);
+}
+__name(unfoldThroughPath, "unfoldThroughPath");
+function unfoldRelationSelector(relation) {
+  const entries = Object.entries(relation);
+  if (entries.length !== 1) {
+    throw new Error("Filtered relation selector must contain exactly one relation.");
+  }
+  const entry = entries[0];
+  const [relationName, enabled] = entry;
+  if (enabled !== true) {
+    throw new Error("Filtered relation selector values must be true.");
+  }
+  return relationName;
+}
+__name(unfoldRelationSelector, "unfoldRelationSelector");
+function buildRelations(tables, relationTargets = {}, filteredRelations = {}, throughRelations = {}, fkRelations = {}) {
+  const baseTables = tables.filter((table) => !table.derivedFrom);
+  const sqlToBaseTable = /* @__PURE__ */ new Map();
+  const modelToTable = /* @__PURE__ */ new Map();
+  for (const table of tables) {
+    modelToTable.set(table.modelName, table);
+    if (!table.derivedFrom) {
+      sqlToBaseTable.set(table.sqlName, table);
+    }
+  }
+  const fksByTable = /* @__PURE__ */ new Map();
+  for (const table of baseTables) {
+    fksByTable.set(table.modelName, extractFKs(table.table));
+  }
+  const modelRelations = /* @__PURE__ */ new Map();
+  for (const table of tables) {
+    modelRelations.set(table.modelName, []);
+  }
+  for (const [modelName, relations] of Object.entries(fkRelations)) {
+    const sourceTable = modelToTable.get(modelName);
+    if (!sourceTable) continue;
+    const sourceRelations = modelRelations.get(modelName) || [];
+    const colByName = new Map(sourceTable.cfg.columns.map((column) => [
+      column.name,
+      column
+    ]));
+    for (const [relName, fkInfo] of Object.entries(relations)) {
+      const targetTable = modelToTable.get(fkInfo.targetExportName) ?? sqlToBaseTable.get(fkInfo.targetExportName);
+      if (!targetTable) continue;
+      const targetModelOverride = relationTargets[modelName]?.[relName];
+      const fieldName = relName;
+      assertNoRelationFieldCollision(sourceTable, sourceRelations, fieldName);
+      let hasDefaultFK = false;
+      let isOptional = false;
+      const jsToSql = new Map([
+        ...sourceTable.sqlToJsKey.entries()
+      ].map(([sql2, js]) => [
+        js,
+        sql2
+      ]));
+      for (const jsKey of fkInfo.fields) {
+        const sqlName = jsToSql.get(jsKey) ?? jsKey;
+        const localColumn = colByName.get(sqlName);
+        if (localColumn?.hasDefault) hasDefaultFK = true;
+        if (!localColumn?.notNull) isOptional = true;
+      }
+      sourceRelations.push({
+        fieldName,
+        targetModel: targetModelOverride ?? fkInfo.targetExportName,
+        optional: isOptional,
+        array: false,
+        relationName: fkInfo.relationName,
+        fields: fkInfo.fields,
+        references: fkInfo.references,
+        hasDefault: hasDefaultFK
+      });
+    }
+    modelRelations.set(modelName, sourceRelations);
+  }
+  for (const table of tables) {
+    if (!table.derivedFrom) continue;
+    const baseRelations = modelRelations.get(table.derivedFrom) || [];
+    modelRelations.set(table.modelName, baseRelations.map((relation) => ({
+      ...relation,
+      _opposite: void 0
+    })));
+  }
+  for (const table of baseTables) {
+    const sourceRelations = modelRelations.get(table.modelName) || [];
+    const relationsByTarget = /* @__PURE__ */ new Map();
+    for (const relation of sourceRelations) {
+      if (relation.kind && relation.kind !== "normal") continue;
+      const group = relationsByTarget.get(relation.targetModel) || [];
+      group.push(relation);
+      relationsByTarget.set(relation.targetModel, group);
+    }
+    for (const [targetModel, relations] of relationsByTarget) {
+      if (relations.length <= 1) continue;
+      for (const relation of relations) {
+        if (relation.relationName) continue;
+        throw new Error(`Ambiguous relations for "${table.exportName}" -> "${targetModel}". Add explicit relationName values in supabase/schema/relations.ts.`);
+      }
+    }
+    const declaredFKRelations = new Set(sourceRelations.filter((relation) => !relation.array && relation.fields && relation.references).map((relation) => makePhysicalRelationSignature(relation.fields, relation.references, relation.array)));
+    for (const fk of fksByTable.get(table.modelName) || []) {
+      const targetTable = sqlToBaseTable.get(fk.foreignTable);
+      if (!targetTable) continue;
+      const signature = makePhysicalFKSignature(table, targetTable, fk);
+      if (declaredFKRelations.has(signature)) continue;
+      throw new Error(`Missing explicit relation in supabase/schema/relations.ts for "${table.exportName}": [${fk.localColumns.join(", ")}] -> ${targetTable.exportName}([${fk.foreignColumns.join(", ")}]).`);
+    }
+  }
+  const forwardByTarget = /* @__PURE__ */ new Map();
+  for (const sourceTable of tables) {
+    for (const relation of modelRelations.get(sourceTable.modelName) || []) {
+      if (relation.kind && relation.kind !== "normal") continue;
+      const group = forwardByTarget.get(relation.targetModel) || [];
+      group.push({
+        source: sourceTable,
+        relation
+      });
+      forwardByTarget.set(relation.targetModel, group);
+    }
+  }
+  const inverseRelations = /* @__PURE__ */ new Map();
+  for (const table of tables) {
+    const inverses = [];
+    const existingNames = new Set((modelRelations.get(table.modelName) || []).map((relation) => relation.fieldName));
+    for (const { source: sourceTable, relation } of forwardByTarget.get(table.modelName) || []) {
+      const sourceExport = sourceTable.exportName || sourceTable.sqlName;
+      let fieldName = sourceExport.endsWith("s") ? sourceExport : sourceExport + "s";
+      if (existingNames.has(fieldName)) {
+        const explicitRelation = (modelRelations.get(table.modelName) || []).find((item) => item.fieldName === fieldName);
+        if (explicitRelation) {
+          relation._opposite = fieldName;
+          continue;
+        }
+        const mainField = relation.fields?.find((field) => field !== APP_SLUG_JS) || relation.fields?.[0] || relation.fieldName;
+        fieldName = sourceExport + "By" + capitalize(mainField);
+      }
+      inverses.push({
+        fieldName,
+        targetModel: sourceTable.modelName,
+        optional: false,
+        array: true,
+        relationName: relation.relationName,
+        fields: null,
+        references: null,
+        hasDefault: false,
+        _opposite: relation.fieldName
+      });
+      relation._opposite = fieldName;
+      existingNames.add(fieldName);
+    }
+    inverseRelations.set(table.modelName, inverses);
+  }
+  const getAvailableRelations = /* @__PURE__ */ __name((modelName) => [
+    ...modelRelations.get(modelName) || [],
+    ...inverseRelations.get(modelName) || []
+  ], "getAvailableRelations");
+  for (const [modelName, declarations] of Object.entries(filteredRelations)) {
+    const sourceTable = modelToTable.get(modelName);
+    if (!sourceTable) {
+      throw new Error(`Filtered relations declared for unknown model "${modelName}".`);
+    }
+    const sourceRelations = modelRelations.get(modelName) || [];
+    const availableRelations = getAvailableRelations(modelName);
+    for (const [fieldName, declaration] of Object.entries(declarations)) {
+      const sourceRelation = unfoldRelationSelector(declaration.relation);
+      const existingFk = sourceRelations.find((r) => r.fieldName === fieldName);
+      if (existingFk && sourceRelation === fieldName) {
+        existingFk.kind = "filtered";
+        existingFk.sourceRelation = sourceRelation;
+        existingFk.where = declaration.where;
+        existingFk.single = declaration.single;
+        continue;
+      }
+      assertNoRelationFieldCollision(sourceTable, [
+        ...sourceRelations,
+        ...inverseRelations.get(modelName) || []
+      ], fieldName);
+      const baseRelation = availableRelations.find((relation) => relation.fieldName === sourceRelation);
+      if (!baseRelation) {
+        throw new Error(`Filtered relation "${modelName}.${fieldName}" references unknown relation "${sourceRelation}".`);
+      }
+      sourceRelations.push({
+        fieldName,
+        targetModel: baseRelation.targetModel,
+        optional: declaration.single ? true : baseRelation.optional,
+        array: declaration.single ? false : baseRelation.array,
+        relationName: null,
+        fields: baseRelation.fields,
+        references: baseRelation.references,
+        hasDefault: false,
+        kind: "filtered",
+        sourceRelation,
+        where: declaration.where,
+        single: declaration.single
+      });
+    }
+    modelRelations.set(modelName, sourceRelations);
+  }
+  for (const [modelName, declarations] of Object.entries(throughRelations)) {
+    const sourceTable = modelToTable.get(modelName);
+    if (!sourceTable) {
+      throw new Error(`Through relations declared for unknown model "${modelName}".`);
+    }
+    const sourceRelations = modelRelations.get(modelName) || [];
+    for (const [fieldName, declaration] of Object.entries(declarations)) {
+      assertNoRelationFieldCollision(sourceTable, [
+        ...sourceRelations,
+        ...inverseRelations.get(modelName) || []
+      ], fieldName);
+      const throughPath = unfoldThroughPath(declaration.path);
+      let currentModel = modelName;
+      let targetRelation;
+      let isMany = false;
+      for (const relationName of throughPath) {
+        const relation = getAvailableRelations(currentModel).find((item) => item.fieldName === relationName);
+        if (!relation) {
+          throw new Error(`Through relation "${modelName}.${fieldName}" references unknown relation "${currentModel}.${relationName}".`);
+        }
+        targetRelation = relation;
+        currentModel = relation.targetModel;
+        if (relation.array) {
+          isMany = true;
+        }
+      }
+      if (!targetRelation) {
+        throw new Error(`Through relation "${modelName}.${fieldName}" is missing a target path.`);
+      }
+      sourceRelations.push({
+        fieldName,
+        targetModel: targetRelation.targetModel,
+        optional: !isMany,
+        array: isMany,
+        relationName: null,
+        fields: null,
+        references: null,
+        hasDefault: false,
+        kind: "through",
+        throughPath
+      });
+    }
+    modelRelations.set(modelName, sourceRelations);
+  }
+  return {
+    modelRelations,
+    inverseRelations
+  };
+}
+__name(buildRelations, "buildRelations");
+
+// src/codegen/typed-json.ts
+import { toCamelCase } from "drizzle-orm/casing";
+import { ModuleKind, ModuleResolutionKind, Project, ScriptTarget as ScriptTarget2, SyntaxKind } from "ts-morph";
+function unwrapNullableType(type) {
+  if (!type.isUnion()) return type;
+  const nonNull = type.getUnionTypes().filter((member) => !member.isNull() && !member.isUndefined());
+  if (nonNull.length !== 1) return type;
+  return unwrapNullableType(nonNull[0]);
+}
+__name(unwrapNullableType, "unwrapNullableType");
+function getResolvedArrayInfo(type) {
+  const resolvedType = unwrapNullableType(type);
+  if (!resolvedType.isArray()) {
+    return {
+      resolvedType,
+      isArray: false
+    };
+  }
+  return {
+    resolvedType: resolvedType.getArrayElementTypeOrThrow(),
+    isArray: true
+  };
+}
+__name(getResolvedArrayInfo, "getResolvedArrayInfo");
+function normalizeTypeText(typeText) {
+  let normalized = typeText.replace(/\s+/g, " ").trim();
+  normalized = normalized.replace(/\s*\|\s*(?:null|undefined)\s*$/g, "").trim();
+  let isArray = false;
+  if (normalized.endsWith("[]")) {
+    normalized = normalized.slice(0, -2).trim();
+    isArray = true;
+  }
+  if (normalized.startsWith("(") && normalized.endsWith(")")) {
+    normalized = normalized.slice(1, -1).trim();
+  }
+  return {
+    baseText: normalized,
+    isArray
+  };
+}
+__name(normalizeTypeText, "normalizeTypeText");
+function buildTypeDefs(typesPath, tables, views, enumMap) {
+  const project = createTypedJsonProject(typesPath, !!views?.length);
+  const sf = project.getSourceFileOrThrow(typesPath);
+  const typeDefs = /* @__PURE__ */ new Map();
+  const fieldToTypeDef = /* @__PURE__ */ new Map();
+  const typedJsonFieldMap = /* @__PURE__ */ new Map();
+  const exportedTypes = createExportedTypeRegistry(sf);
+  const entityBySqlName = /* @__PURE__ */ new Map();
+  for (const table of tables) entityBySqlName.set(table.sqlName, table);
+  for (const view of views || []) entityBySqlName.set(view.sqlName, view);
+  const tableByExportName = new Map(tables.map((table) => [
+    table.exportName,
+    table
+  ]));
+  const sourceFiles = [
+    "supabase/schema/tables.ts"
+  ];
+  if (views?.length) sourceFiles.push("supabase/schema/views.ts");
+  for (const filePath of sourceFiles) {
+    scanFileForTypedColumns({
+      sourceFile: project.getSourceFileOrThrow(filePath),
+      exportedTypes,
+      typeDefs,
+      fieldToTypeDef,
+      typedJsonFieldMap,
+      entityBySqlName,
+      tableByExportName,
+      enumMap: enumMap || /* @__PURE__ */ new Map()
+    });
+  }
+  return {
+    typeDefs,
+    fieldToTypeDef,
+    typedJsonFields: sortTypedJsonFields([
+      ...typedJsonFieldMap.values()
+    ])
+  };
+}
+__name(buildTypeDefs, "buildTypeDefs");
+function createExportedTypeRegistry(sourceFile) {
+  const declarations = /* @__PURE__ */ new Map();
+  const resolvedTypes = /* @__PURE__ */ new Map();
+  for (const stmt of sourceFile.getStatements()) {
+    if (stmt.getKind() === SyntaxKind.TypeAliasDeclaration) {
+      const typeAlias = stmt.asKindOrThrow(SyntaxKind.TypeAliasDeclaration);
+      if (typeAlias.isExported()) {
+        declarations.set(typeAlias.getName(), typeAlias);
+      }
+    }
+    if (stmt.getKind() === SyntaxKind.InterfaceDeclaration) {
+      const iface = stmt.asKindOrThrow(SyntaxKind.InterfaceDeclaration);
+      if (iface.isExported()) {
+        declarations.set(iface.getName(), iface);
+      }
+    }
+  }
+  return {
+    has(name) {
+      return declarations.has(name);
+    },
+    get(name) {
+      if (!declarations.has(name)) return void 0;
+      const cachedType = resolvedTypes.get(name);
+      if (cachedType) return cachedType;
+      const declaration = declarations.get(name);
+      if (!declaration) return void 0;
+      const resolvedType = declaration.getType();
+      resolvedTypes.set(name, resolvedType);
+      return resolvedType;
+    }
+  };
+}
+__name(createExportedTypeRegistry, "createExportedTypeRegistry");
+function createTypedJsonProject(typesPath, includeViews) {
+  const project = new Project({
+    skipAddingFilesFromTsConfig: true,
+    compilerOptions: {
+      module: ModuleKind.ESNext,
+      moduleResolution: ModuleResolutionKind.Bundler,
+      target: ScriptTarget2.ES2022,
+      allowJs: false,
+      baseUrl: ".",
+      paths: {
+        "@/*": [
+          "src/*"
+        ],
+        "~/*": [
+          "app/*"
+        ]
+      }
+    }
+  });
+  project.addSourceFileAtPath(typesPath);
+  project.addSourceFileAtPath("supabase/schema/tables.ts");
+  if (includeViews) {
+    project.addSourceFileAtPath("supabase/schema/views.ts");
+  }
+  return project;
+}
+__name(createTypedJsonProject, "createTypedJsonProject");
+function scanFileForTypedColumns({ sourceFile, exportedTypes, typeDefs, fieldToTypeDef, typedJsonFieldMap, entityBySqlName, tableByExportName, enumMap }) {
+  const registerTypedJsonField = /* @__PURE__ */ __name((entitySqlName, columnSqlName, typeDefName, isArray, sourceTypeName) => {
+    const entity = entityBySqlName.get(entitySqlName);
+    if (!entity) return;
+    const fieldName = entity.sqlToJsKey.get(columnSqlName) || columnSqlName;
+    const fieldKey = `${entitySqlName}.${fieldName}`;
+    fieldToTypeDef.set(fieldKey, {
+      typeDefName,
+      isArray
+    });
+    typedJsonFieldMap.set(fieldKey, {
+      entitySqlName,
+      entityTypeName: entity.typeName,
+      fieldName,
+      typeDefName,
+      isArray,
+      sourceTypeName
+    });
+  }, "registerTypedJsonField");
+  for (const access of sourceFile.getDescendantsOfKind(SyntaxKind.PropertyAccessExpression)) {
+    if (access.getName() !== "$type") continue;
+    const call = access.getParentIfKind(SyntaxKind.CallExpression);
+    if (!call || call.getExpression() !== access) continue;
+    const typeArg = call.getTypeArguments()[0];
+    if (!typeArg) continue;
+    const propertyAssignment = call.getFirstAncestorByKind(SyntaxKind.PropertyAssignment);
+    if (!propertyAssignment) continue;
+    const columnSqlName = propertyAssignment.getName();
+    const entitySqlName = getEntitySqlName(call);
+    if (!entitySqlName) continue;
+    const rawTypeText = typeArg.getText().trim();
+    const { baseText, isArray: isArrayFromText } = normalizeTypeText(rawTypeText);
+    const rowTypeDefName = resolveWholeRowTypeDefName(baseText, tableByExportName, typeDefs, enumMap);
+    if (rowTypeDefName) {
+      const isArray2 = isArrayFromText || getResolvedArrayInfo(typeArg.getType()).isArray;
+      registerTypedJsonField(entitySqlName, columnSqlName, rowTypeDefName, isArray2);
+      continue;
+    }
+    if (exportedTypes.has(baseText)) {
+      const type = exportedTypes.get(baseText);
+      if (type && tryBuildTypeDef(baseText, type, typeDefs, exportedTypes)) {
+        const isArray2 = isArrayFromText || getResolvedArrayInfo(type).isArray;
+        registerTypedJsonField(entitySqlName, columnSqlName, baseText, isArray2, baseText);
+      }
+      continue;
+    }
+    const { resolvedType, isArray: isArrayFromType } = getResolvedArrayInfo(typeArg.getType());
+    const isArray = isArrayFromType || isArrayFromText;
+    const generatedName = `${toPascalCase(entitySqlName)}${toPascalCase(columnSqlName)}`;
+    if (tryBuildTypeDef(generatedName, resolvedType, typeDefs, exportedTypes)) {
+      registerTypedJsonField(entitySqlName, columnSqlName, generatedName, isArray);
+    }
+  }
+}
+__name(scanFileForTypedColumns, "scanFileForTypedColumns");
+function getEntitySqlName(call) {
+  let node = call.getParent();
+  while (node) {
+    if (node.getKind() === SyntaxKind.CallExpression) {
+      const candidate = node.asKindOrThrow(SyntaxKind.CallExpression);
+      const callee = candidate.getExpression().getText();
+      if (callee === "pgTable" || callee === "pgView") {
+        const firstArg = candidate.getArguments()[0];
+        return firstArg ? firstArg.getText().replace(/['"]/g, "") : null;
+      }
+    }
+    node = node.getParent();
+  }
+  return null;
+}
+__name(getEntitySqlName, "getEntitySqlName");
+function resolveWholeRowTypeDefName(typeText, tableByExportName, typeDefs, enumMap) {
+  const wholeRowMatch = typeText.match(/^typeof\s+(?:t\.)?(\w+)\.\$infer(?:Select|Insert)$/);
+  if (!wholeRowMatch) return null;
+  const refTable = tableByExportName.get(wholeRowMatch[1]);
+  if (!refTable) return null;
+  const rowTypeDefName = `${refTable.typeName}Row`;
+  if (!typeDefs.has(rowTypeDefName)) {
+    buildRowTypeDef(rowTypeDefName, refTable, typeDefs, enumMap);
+  }
+  return typeDefs.has(rowTypeDefName) ? rowTypeDefName : null;
+}
+__name(resolveWholeRowTypeDefName, "resolveWholeRowTypeDefName");
+function buildRowTypeDef(name, table, typeDefs, enumMap) {
+  const fields = {};
+  for (const jsKey of [
+    ...table.sqlToJsKey.values()
+  ]) {
+    const col = table.table[jsKey];
+    if (!col?.columnType) continue;
+    const mapped = mapColumn(jsKey, col, enumMap);
+    if (mapped.isGenerated) continue;
+    if (mapped.sqlName === "$hash") continue;
+    let type;
+    switch (mapped.type) {
+      case "String":
+      case "Int":
+      case "Float":
+      case "Boolean":
+      case "DateTime":
+      case "Json":
+        type = mapped.type;
+        break;
+      case "BigInt":
+        type = "Int";
+        break;
+      case "Decimal":
+        type = "Float";
+        break;
+      default:
+        type = "String";
+        break;
+    }
+    const fieldName = toCamelCase(mapped.name);
+    fields[fieldName] = {
+      name: fieldName,
+      ...fieldName !== mapped.name && {
+        rawName: mapped.name
+      },
+      type,
+      ...mapped.optional && {
+        optional: true
+      },
+      ...mapped.array && {
+        array: true
+      }
+    };
+  }
+  if (Object.keys(fields).length > 0) {
+    typeDefs.set(name, {
+      name,
+      fields
+    });
+  }
+}
+__name(buildRowTypeDef, "buildRowTypeDef");
+function tryBuildTypeDef(name, type, typeDefs, exportedTypes) {
+  if (typeDefs.has(name)) return true;
+  if (type.isArray()) {
+    return tryBuildTypeDef(name, type.getArrayElementTypeOrThrow(), typeDefs, exportedTypes);
+  }
+  if (type.isUnion()) {
+    const nonNull = type.getUnionTypes().filter((member) => !member.isNull() && !member.isUndefined());
+    if (nonNull.length === 1) {
+      return tryBuildTypeDef(name, nonNull[0], typeDefs, exportedTypes);
+    }
+    return false;
+  }
+  if (!type.isObject() || type.getProperties().length === 0) return false;
+  if (type.getStringIndexType()) return false;
+  if (type.getCallSignatures().length > 0) return false;
+  const fields = {};
+  for (const prop of type.getProperties()) {
+    const propName = prop.getName();
+    const declaration = prop.getValueDeclaration();
+    if (!declaration) continue;
+    const propType = prop.getTypeAtLocation(declaration);
+    const fieldName = toCamelCase(propName);
+    const mappedField = mapTypeToTypeDef(propName, propType, name, typeDefs, exportedTypes);
+    fields[fieldName] = {
+      name: fieldName,
+      ...fieldName !== propName && {
+        rawName: propName
+      },
+      type: mappedField?.type || "Json",
+      ...prop.isOptional() && {
+        optional: true
+      },
+      ...mappedField?.isArray && {
+        array: true
+      }
+    };
+  }
+  if (Object.keys(fields).length === 0) return false;
+  typeDefs.set(name, {
+    name,
+    fields
+  });
+  return true;
+}
+__name(tryBuildTypeDef, "tryBuildTypeDef");
+function mapTypeToTypeDef(fieldName, type, parentName, typeDefs, exportedTypes) {
+  if (type.isUnion()) {
+    const unwrapped = unwrapNullableType(type);
+    if (unwrapped !== type) {
+      return mapTypeToTypeDef(fieldName, unwrapped, parentName, typeDefs, exportedTypes);
+    }
+    const nonNull = type.getUnionTypes().filter((member) => !member.isNull() && !member.isUndefined());
+    if (nonNull.every((member) => member.isStringLiteral() || member.isString())) {
+      return {
+        type: "String",
+        isArray: false
+      };
+    }
+    if (nonNull.every((member) => member.isNumberLiteral() || member.isNumber())) {
+      return {
+        type: "Float",
+        isArray: false
+      };
+    }
+    if (nonNull.every((member) => member.isBooleanLiteral() || member.isBoolean())) {
+      return {
+        type: "Boolean",
+        isArray: false
+      };
+    }
+    return null;
+  }
+  if (type.isString() || type.isStringLiteral()) return {
+    type: "String",
+    isArray: false
+  };
+  if (type.isNumber() || type.isNumberLiteral()) return {
+    type: "Float",
+    isArray: false
+  };
+  if (type.isBoolean() || type.isBooleanLiteral()) return {
+    type: "Boolean",
+    isArray: false
+  };
+  if (type.getSymbol()?.getName() === "Date") return {
+    type: "DateTime",
+    isArray: false
+  };
+  if (type.isArray()) {
+    const inner = mapTypeToTypeDef(fieldName, type.getArrayElementTypeOrThrow(), parentName, typeDefs, exportedTypes);
+    return inner ? {
+      type: inner.type,
+      isArray: true
+    } : null;
+  }
+  if (type.isObject() && type.getProperties().length > 0) {
+    if (type.getStringIndexType()) return {
+      type: "Json",
+      isArray: false
+    };
+    if (type.getCallSignatures().length > 0) return null;
+    const symbol = type.getAliasSymbol() || type.getSymbol();
+    const knownName = symbol?.getName();
+    if (knownName && exportedTypes.has(knownName)) {
+      if (tryBuildTypeDef(knownName, type, typeDefs, exportedTypes)) {
+        return {
+          type: knownName,
+          isArray: false
+        };
+      }
+    }
+    const subTypeDefName = `${parentName}${toPascalCase(fieldName)}`;
+    if (tryBuildTypeDef(subTypeDefName, type, typeDefs, exportedTypes)) {
+      return {
+        type: subTypeDefName,
+        isArray: false
+      };
+    }
+  }
+  return null;
+}
+__name(mapTypeToTypeDef, "mapTypeToTypeDef");
+function emitTypeDefsBlock(typeDefs) {
+  if (typeDefs.size === 0) return "";
+  const lines = [];
+  lines.push("    typeDefs = {");
+  for (const [name, typeDef] of sortTypeDefs(typeDefs)) {
+    lines.push(`        ${name}: {`);
+    lines.push(`            name: ${esc(typeDef.name)},`);
+    lines.push(`            fields: {`);
+    for (const field of Object.values(typeDef.fields)) {
+      const parts = [
+        `name: ${esc(field.name)}`,
+        `type: ${esc(field.type)}`
+      ];
+      if (field.optional) parts.push("optional: true");
+      if (field.array) parts.push("array: true");
+      if (field.rawName && field.rawName !== field.name) {
+        parts.push(`attributes: [{ name: "@map", args: [{ name: "name", value: ExpressionUtils.literal(${esc(field.rawName)}) }] }]`);
+      }
+      lines.push(`                ${field.name}: { ${parts.join(", ")} },`);
+    }
+    lines.push("            }");
+    lines.push("        },");
+  }
+  lines.push("    } as const;");
+  return lines.join("\n");
+}
+__name(emitTypeDefsBlock, "emitTypeDefsBlock");
+function mapTypeDefFieldToTs(field, typeDefs) {
+  let tsType;
+  switch (field.type) {
+    case "String":
+      tsType = "string";
+      break;
+    case "Int":
+    case "Float":
+      tsType = "number";
+      break;
+    case "Boolean":
+      tsType = "boolean";
+      break;
+    case "DateTime":
+      tsType = "Date";
+      break;
+    case "Json":
+      tsType = "unknown";
+      break;
+    default:
+      tsType = typeDefs.has(field.type) ? `${field.type}JsonShape` : "unknown";
+      break;
+  }
+  return field.array ? `${tsType}[]` : tsType;
+}
+__name(mapTypeDefFieldToTs, "mapTypeDefFieldToTs");
+function getJsonFieldAlias(info) {
+  return `${info.entityTypeName}${toPascalCase(info.fieldName)}Json`;
+}
+__name(getJsonFieldAlias, "getJsonFieldAlias");
+function getJsonRawFieldAlias(info) {
+  return `${getJsonFieldAlias(info)}Raw`;
+}
+__name(getJsonRawFieldAlias, "getJsonRawFieldAlias");
+function emitJsonNamespaceBlock(typeDefs, typedJsonFields, indent = "") {
+  const out = [];
+  for (const [name, typeDef] of sortTypeDefs(typeDefs)) {
+    out.push(`${indent}export type ${name}JsonShape = {`);
+    for (const field of Object.values(typeDef.fields)) {
+      const optional = field.optional ? "?" : "";
+      out.push(`${indent}  ${field.name}${optional}: ${mapTypeDefFieldToTs(field, typeDefs)};`);
+    }
+    out.push(`${indent}};`);
+    out.push("");
+  }
+  for (const info of typedJsonFields) {
+    out.push(`${indent}export type ${getJsonFieldAlias(info)} = ${info.typeDefName}JsonShape;`);
+    out.push("");
+  }
+  if (out.at(-1) === "") {
+    out.pop();
+  }
+  return out;
+}
+__name(emitJsonNamespaceBlock, "emitJsonNamespaceBlock");
+function emitJsonRawNamespaceBlock(typedJsonFields, indent = "") {
+  const out = [];
+  for (const info of typedJsonFields.filter((field) => field.sourceTypeName)) {
+    out.push(`${indent}export type ${getJsonRawFieldAlias(info)} = RawJson.${info.sourceTypeName};`);
+    out.push("");
+  }
+  if (out.at(-1) === "") {
+    out.pop();
+  }
+  return out;
+}
+__name(emitJsonRawNamespaceBlock, "emitJsonRawNamespaceBlock");
+function emitJsonTs(typeDefs, typedJsonFields) {
+  const out = [
+    ...emitGeneratedFileBanner(),
+    ""
+  ];
+  out.push(...emitJsonNamespaceBlock(typeDefs, typedJsonFields));
+  out.push("");
+  return out.join("\n");
+}
+__name(emitJsonTs, "emitJsonTs");
+function emitJsonRawTs(typedJsonFields) {
+  const out = [
+    ...emitGeneratedFileBanner(),
+    "",
+    'import type * as RawJson from "../../supabase/schema/types";',
+    ""
+  ];
+  out.push(...emitJsonRawNamespaceBlock(typedJsonFields));
+  out.push("");
+  return out.join("\n");
+}
+__name(emitJsonRawTs, "emitJsonRawTs");
+function sortTypeDefs(typeDefs) {
+  return [
+    ...typeDefs.entries()
+  ].sort(([left], [right]) => left.localeCompare(right));
+}
+__name(sortTypeDefs, "sortTypeDefs");
+function sortTypedJsonFields(typedJsonFields) {
+  return [
+    ...typedJsonFields
+  ].sort((left, right) => {
+    const leftKey = `${getJsonFieldAlias(left)}:${left.sourceTypeName || ""}`;
+    const rightKey = `${getJsonFieldAlias(right)}:${right.sourceTypeName || ""}`;
+    return leftKey.localeCompare(rightKey);
+  });
+}
+__name(sortTypedJsonFields, "sortTypedJsonFields");
+
+// src/codegen/emit.ts
+var DB_ATTR_RE = /@db\.(\w+)(?:\((\d+)\))?/;
+function buildDerivedEnumName(modelName, fieldName) {
+  return `${toPascalCase(modelName)}${toPascalCase(fieldName)}`;
+}
+__name(buildDerivedEnumName, "buildDerivedEnumName");
+function inferFieldIsNonNull(defaultWhere, fieldName) {
+  if (!defaultWhere) return false;
+  const condition = defaultWhere[fieldName];
+  if (condition === void 0 || condition === null) return false;
+  if (Array.isArray(condition)) return condition.length > 0;
+  if (typeof condition !== "object") return true;
+  if (Object.prototype.hasOwnProperty.call(condition, "not") && Reflect.get(condition, "not") === null) {
+    return true;
+  }
+  if (Object.prototype.hasOwnProperty.call(condition, "in")) {
+    const values = Reflect.get(condition, "in");
+    return Array.isArray(values) && values.length > 0;
+  }
+  return false;
+}
+__name(inferFieldIsNonNull, "inferFieldIsNonNull");
+function applyDerivedFieldOverrides(field, table) {
+  if (!table.derivedFrom) return field;
+  const narrowedValues = table.narrow?.[field.name];
+  return {
+    ...field,
+    // Keep base enum type — narrowing is handled at runtime by derived-models plugin
+    optional: narrowedValues && narrowedValues.length > 0 ? false : field.optional && !inferFieldIsNonNull(table.defaultWhere, field.name)
+  };
+}
+__name(applyDerivedFieldOverrides, "applyDerivedFieldOverrides");
+function collectDerivedEnums(tables, enumMap) {
+  const derivedEnums = /* @__PURE__ */ new Map();
+  const tablesByModel = new Map(tables.map((table) => [
+    table.modelName,
+    table
+  ]));
+  for (const table of tables) {
+    if (!table.derivedFrom || !table.narrow) continue;
+    const baseTable = tablesByModel.get(table.derivedFrom);
+    if (!baseTable) continue;
+    const baseFields = /* @__PURE__ */ new Map();
+    for (const jsKey of baseTable.sqlToJsKey.values()) {
+      const column = baseTable.table[jsKey];
+      const field = mapColumn(jsKey, column, enumMap);
+      baseFields.set(field.name === "$hash" ? "hash" : field.name, field);
+    }
+    for (const [fieldName, narrowedValues] of Object.entries(table.narrow)) {
+      if (!narrowedValues.length) continue;
+      const baseField = baseFields.get(fieldName);
+      if (!baseField) {
+        throw new Error(`Unknown narrowed field "${table.modelName}.${fieldName}".`);
+      }
+      const baseEnum = [
+        ...enumMap.values()
+      ].find((info) => info.zenstackName === baseField.type);
+      if (!baseEnum) {
+        continue;
+      }
+      const values = narrowedValues.map((value) => String(value));
+      for (const value of values) {
+        if (!baseEnum.values.includes(value)) {
+          throw new Error(`Invalid narrowed enum value "${value}" for "${table.modelName}.${fieldName}".`);
+        }
+      }
+      const enumName = buildDerivedEnumName(table.modelName, fieldName);
+      if (derivedEnums.has(enumName)) continue;
+      const mapping = baseEnum.mapping ? Object.fromEntries(Object.entries(baseEnum.mapping).filter(([, value]) => values.includes(value))) : Object.fromEntries(values.map((value) => [
+        toPascalCase(value).toUpperCase(),
+        value
+      ]));
+      derivedEnums.set(enumName, {
+        pgName: `$derived:${enumName}`,
+        zenstackName: enumName,
+        values,
+        mapping,
+        mappedName: null
+      });
+    }
+  }
+  return derivedEnums;
+}
+__name(collectDerivedEnums, "collectDerivedEnums");
+function emitEnumBlock(info) {
+  const lines = [];
+  lines.push(`        ${info.zenstackName}: {`);
+  lines.push(`            name: ${esc(info.zenstackName)},`);
+  const tuples = info.mapping ? (() => {
+    const invertedMap = Object.fromEntries(Object.entries(info.mapping).map(([k, v]) => [
+      v,
+      k
+    ]));
+    return info.values.map((v) => {
+      const key = invertedMap[v];
+      if (!key) throw new Error(`Enum "${info.pgName}" value "${v}" not found in mapping.`);
+      return [
+        v,
+        key
+      ];
+    });
+  })() : info.values.map((v) => [
+    v,
+    v
+  ]);
+  const valuesEntries = tuples.map(([value]) => `${esc(value)}: ${esc(value)}`);
+  lines.push(`            values: { ${valuesEntries.join(", ")} },`);
+  lines.push(`            fields: {`);
+  for (const [v] of tuples) {
+    lines.push(`                ${esc(v)}: { name: ${esc(v)} },`);
+  }
+  lines.push(`            },`);
+  const mappedName = info.mappedName === void 0 ? info.pgName : info.mappedName;
+  if (mappedName) {
+    lines.push(`            attributes: [{ name: "@@map", args: [{ name: "name", value: ExpressionUtils.literal(${esc(mappedName)}) }] }]`);
+  }
+  lines.push(`        }`);
+  return lines.join("\n");
+}
+__name(emitEnumBlock, "emitEnumBlock");
+function emitFieldBlock(field) {
+  const parts = [];
+  parts.push(`name: ${esc(field.name)}`);
+  parts.push(`type: ${esc(field.type)}`);
+  if (field.optional) parts.push("optional: true");
+  if (field.array) parts.push("array: true");
+  if (field.id) parts.push("id: true");
+  if (field.unique) parts.push("unique: true");
+  const attrs = [];
+  if (field.id) attrs.push('{ name: "@id" }');
+  if (field.unique) attrs.push('{ name: "@unique" }');
+  if (field.name !== field.sqlName) {
+    attrs.push(`{ name: "@map", args: [{ name: "name", value: ExpressionUtils.literal(${esc(field.sqlName)}) }] }`);
+  }
+  for (const da of field.dbAttrs) {
+    const match = da.match(DB_ATTR_RE);
+    if (match) {
+      const [, attrName, arg] = match;
+      if (arg) {
+        attrs.push(`{ name: "@db.${attrName}", args: [{ name: "x", value: ExpressionUtils.literal(${arg}) }] }`);
+      } else {
+        attrs.push(`{ name: "@db.${attrName}" }`);
+      }
+    }
+  }
+  if (field.defaultExpr) {
+    const attrValue = field.defaultExpr === "[] as FieldDefault" ? 'ExpressionUtils.literal("[]")' : field.defaultExpr;
+    attrs.push(`{ name: "@default", args: [{ name: "value", value: ${attrValue} }] }`);
+  }
+  if (field.isGenerated) {
+    attrs.push('{ name: "@ignore" }');
+  }
+  if (field.isJsonColumn && field.type !== "Json") {
+    attrs.push('{ name: "@json" }');
+  }
+  if (attrs.length > 0) {
+    parts.push(`attributes: [${attrs.join(", ")}]`);
+  }
+  if (field.defaultExpr) {
+    if (field.defaultExpr.startsWith("ExpressionUtils.literal(")) {
+      const inner = field.defaultExpr.slice("ExpressionUtils.literal(".length, -1);
+      parts.push(`default: ${inner}`);
+    } else {
+      parts.push(`default: ${field.defaultExpr}`);
+    }
+  }
+  return `{ ${parts.join(", ")} }`;
+}
+__name(emitFieldBlock, "emitFieldBlock");
+function emitRelationField(rel, opposite) {
+  const parts = [];
+  parts.push(`name: ${esc(rel.fieldName)}`);
+  parts.push(`type: ${esc(rel.targetModel)}`);
+  if (rel.optional) parts.push("optional: true");
+  if (rel.array) parts.push("array: true");
+  const relParts = [];
+  if (opposite) relParts.push(`opposite: ${esc(opposite)}`);
+  if (rel.relationName) relParts.push(`name: ${esc(rel.relationName)}`);
+  if (rel.fields) relParts.push(`fields: [${rel.fields.map((f) => esc(f)).join(", ")}]`);
+  if (rel.references) relParts.push(`references: [${rel.references.map((r) => esc(r)).join(", ")}]`);
+  if (rel.hasDefault) relParts.push("hasDefault: true");
+  parts.push(`relation: { ${relParts.join(", ")} }`);
+  const attrArgs = [];
+  if (rel.relationName) {
+    attrArgs.push(`{ name: "name", value: ExpressionUtils.literal(${esc(rel.relationName)}) }`);
+  }
+  if (rel.fields) {
+    attrArgs.push(`{ name: "fields", value: ExpressionUtils.array("String", [${rel.fields.map((f) => `ExpressionUtils.field(${esc(f)})`).join(", ")}]) }`);
+  }
+  if (rel.references) {
+    attrArgs.push(`{ name: "references", value: ExpressionUtils.array("String", [${rel.references.map((r) => `ExpressionUtils.field(${esc(r)})`).join(", ")}]) }`);
+  }
+  if (attrArgs.length > 0) {
+    parts.push(`attributes: [{ name: "@relation", args: [${attrArgs.join(", ")}] }]`);
+  }
+  return `{ ${parts.join(", ")} }`;
+}
+__name(emitRelationField, "emitRelationField");
+function emitUnknownLiteral(value) {
+  if (value === null) return "null";
+  if (typeof value === "string") return esc(value);
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => emitUnknownLiteral(item)).join(", ")}]`;
+  }
+  if (typeof value === "object") {
+    return `{ ${Object.entries(value).map(([key, item]) => `${JSON.stringify(key)}: ${emitUnknownLiteral(item)}`).join(", ")} }`;
+  }
+  throw new Error(`Unsupported config literal: ${String(value)}`);
+}
+__name(emitUnknownLiteral, "emitUnknownLiteral");
+function emitPluginsBlock(modelRelations, searchDefaults, modelScopes) {
+  const lines = [];
+  lines.push("    plugins = {");
+  lines.push("        virtualRelations: {");
+  for (const [model2, relations] of modelRelations) {
+    const virtualRelations = relations.filter((relation) => relation.kind && relation.kind !== "normal");
+    if (virtualRelations.length === 0) continue;
+    lines.push(`            ${model2}: {`);
+    for (const relation of virtualRelations) {
+      const parts = [
+        `kind: ${esc(relation.kind)}`,
+        `targetModel: ${esc(relation.targetModel)}`
+      ];
+      if (relation.sourceRelation) {
+        parts.push(`relation: ${esc(relation.sourceRelation)}`);
+      }
+      if (relation.throughPath) {
+        parts.push(`path: [${relation.throughPath.map((segment) => esc(segment)).join(", ")}]`);
+      }
+      if (relation.where) {
+        parts.push(`where: ${emitUnknownLiteral(relation.where)}`);
+      }
+      if (relation.single) {
+        parts.push("single: true");
+      }
+      lines.push(`                ${relation.fieldName}: { ${parts.join(", ")} },`);
+    }
+    lines.push("            },");
+  }
+  lines.push("        },");
+  lines.push("        searchDefaults: {");
+  for (const [model2, profiles] of Object.entries(searchDefaults)) {
+    if (!profiles) continue;
+    lines.push(`            ${model2}: {`);
+    for (const [profile, declaration] of Object.entries(profiles)) {
+      const parts = [
+        `fields: ${emitUnknownLiteral(declaration.fields)}`
+      ];
+      if (declaration.mode) {
+        parts.push(`mode: ${esc(declaration.mode)}`);
+      }
+      if (declaration.strategy) {
+        parts.push(`strategy: ${esc(declaration.strategy)}`);
+      }
+      lines.push(`                ${profile}: { ${parts.join(", ")} },`);
+    }
+    lines.push("            },");
+  }
+  lines.push("        },");
+  if (Object.keys(modelScopes).length > 0) {
+    lines.push("        modelScopes: {");
+    for (const [scopeModel, where] of Object.entries(modelScopes)) {
+      lines.push(`            ${scopeModel}: ${emitUnknownLiteral(where)},`);
+    }
+    lines.push("        },");
+  }
+  lines.push("    } as const;");
+  return lines.join("\n");
+}
+__name(emitPluginsBlock, "emitPluginsBlock");
+function applyTypeDefOverride(field, fieldMapping) {
+  if (!fieldMapping) return field;
+  return {
+    ...field,
+    type: fieldMapping.typeDefName,
+    array: fieldMapping.isArray || field.array,
+    dbAttrs: field.dbAttrs.filter((attr) => !attr.startsWith("@db.Json"))
+  };
+}
+__name(applyTypeDefOverride, "applyTypeDefOverride");
+function emitModelBlock(t, enumMap, modelRelations, inverseRelations, fieldToTypeDef) {
+  const out = [];
+  const { cfg } = t;
+  const fields = [];
+  const fieldByName = /* @__PURE__ */ new Map();
+  for (const jsKey of [
+    ...t.sqlToJsKey.values()
+  ]) {
+    const col = t.table[jsKey];
+    const field = mapColumn(jsKey, col, enumMap);
+    if (field.sqlName === "$hash") {
+      field.isGenerated = true;
+      field.name = "hash";
+    }
+    const typedField = applyDerivedFieldOverrides(applyTypeDefOverride(field, fieldToTypeDef?.get(`${t.sqlName}.${jsKey}`)), t);
+    fields.push(typedField);
+    fieldByName.set(typedField.name, typedField);
+  }
+  const fkRels = modelRelations.get(t.modelName) || [];
+  const fkFieldMap = /* @__PURE__ */ new Map();
+  for (const rel of fkRels) {
+    if (rel.fields) {
+      for (const f of rel.fields) {
+        if (!fkFieldMap.has(f)) fkFieldMap.set(f, []);
+        fkFieldMap.get(f).push(rel.fieldName);
+      }
+    }
+  }
+  out.push(`        ${t.modelName}: {`);
+  out.push(`            name: ${esc(t.modelName)},`);
+  out.push(`            fields: {`);
+  for (const field of fields) {
+    const fkFor = fkFieldMap.get(field.name);
+    let block = emitFieldBlock(field);
+    if (fkFor) {
+      block = block.slice(0, -2) + `, foreignKeyFor: [${fkFor.map((f) => esc(f)).join(", ")}] }`;
+    }
+    out.push(`                ${field.name}: ${block},`);
+  }
+  for (const rel of fkRels) {
+    const isVirtualOnly = rel.kind === "through" || rel.kind === "filtered" && !rel.fields;
+    const opposite = isVirtualOnly ? "" : rel._opposite || rel.fieldName;
+    const block = emitRelationField(rel, opposite);
+    out.push(`                ${rel.fieldName}: ${block},`);
+  }
+  const invRels = inverseRelations.get(t.modelName) || [];
+  for (const rel of invRels) {
+    const opposite = rel._opposite || rel.fieldName;
+    const block = emitRelationField(rel, opposite);
+    out.push(`                ${rel.fieldName}: ${block},`);
+  }
+  for (const computedField of t.computedFields) {
+    out.push(`                ${computedField.name}: { name: ${esc(computedField.name)}, type: ${esc(computedField.type)}, computed: true, attributes: [{ name: "@computed" }] },`);
+  }
+  out.push(`            },`);
+  if (t.computedFields.length > 0) {
+    out.push(`            computedFields: {`);
+    for (const computedField of t.computedFields) {
+      out.push(`                ${computedField.name}(_context: { modelAlias: ${esc(t.modelName)} }): ${computedField.tsType} { throw new Error("computed stub"); },`);
+    }
+    out.push(`            },`);
+  }
+  const modelAttrs = [];
+  modelAttrs.push(`{ name: "@@map", args: [{ name: "name", value: ExpressionUtils.literal(${esc(t.sqlName)}) }] }`);
+  for (const uc of cfg.uniqueConstraints) {
+    const ucCols = uc.columns.map((c) => c.name);
+    if (ucCols.length > 1) {
+      modelAttrs.push(`{ name: "@@unique", args: [{ name: "fields", value: ExpressionUtils.array("String", [${ucCols.map((c) => `ExpressionUtils.field(${esc(t.sqlToJsKey.get(c) || c)})`).join(", ")}]) }] }`);
+    }
+  }
+  if (cfg.primaryKeys.length > 0) {
+    for (const pk of cfg.primaryKeys) {
+      const pkCols = pk.columns.map((c) => c.name);
+      modelAttrs.push(`{ name: "@@id", args: [{ name: "fields", value: ExpressionUtils.array("String", [${pkCols.map((c) => `ExpressionUtils.field(${esc(t.sqlToJsKey.get(c) || c)})`).join(", ")}]) }] }`);
+    }
+  }
+  out.push(`            attributes: [${modelAttrs.join(", ")}],`);
+  const idCols = cfg.columns.filter((c) => c.primary).map((c) => t.sqlToJsKey.get(c.name) || c.name);
+  if (idCols.length === 0 && cfg.primaryKeys.length > 0) {
+    const pkCols = cfg.primaryKeys[0].columns.map((c) => t.sqlToJsKey.get(c.name) || c.name);
+    out.push(`            idFields: [${pkCols.map((c) => esc(c)).join(", ")}],`);
+  } else {
+    out.push(`            idFields: [${idCols.map((c) => esc(c)).join(", ")}],`);
+  }
+  const ufEntries = [];
+  const ufKeys = /* @__PURE__ */ new Set();
+  const addUnique = /* @__PURE__ */ __name((cols) => {
+    const key = cols.join("_");
+    if (ufKeys.has(key)) return;
+    ufKeys.add(key);
+    if (cols.length === 1) {
+      ufEntries.push(`${key}: { type: ${esc(fieldByName.get(key)?.type || "String")} }`);
+    } else {
+      const inner = cols.map((c) => `${c}: { type: ${esc(fieldByName.get(c)?.type || "String")} }`).join(", ");
+      ufEntries.push(`${key}: { ${inner} }`);
+    }
+  }, "addUnique");
+  if (idCols.length > 0) {
+    addUnique(idCols);
+  } else if (cfg.primaryKeys.length > 0) {
+    const pkCols = cfg.primaryKeys[0].columns.map((c) => t.sqlToJsKey.get(c.name) || c.name);
+    addUnique(pkCols);
+  }
+  for (const uc of cfg.uniqueConstraints) {
+    addUnique(uc.columns.map((c) => t.sqlToJsKey.get(c.name) || c.name));
+  }
+  for (const f of fields) {
+    if (f.unique) addUnique([
+      f.name
+    ]);
+  }
+  out.push(`            uniqueFields: { ${ufEntries.join(", ")} }`);
+  out.push(`        },`);
+  return out;
+}
+__name(emitModelBlock, "emitModelBlock");
+function emitViewModelBlock(v, enumMap, fieldToTypeDef) {
+  const out = [];
+  const fields = [];
+  const fieldByName = /* @__PURE__ */ new Map();
+  for (const [jsKey, col] of v.columns) {
+    const field = mapColumn(jsKey, col, enumMap);
+    if (field.sqlName === "$hash") {
+      field.isGenerated = true;
+      field.name = "hash";
+    }
+    const typedField = applyTypeDefOverride(field, fieldToTypeDef?.get(`${v.sqlName}.${jsKey}`));
+    fields.push(typedField);
+    fieldByName.set(typedField.name, typedField);
+  }
+  out.push(`        ${v.modelName}: {`);
+  out.push(`            name: ${esc(v.modelName)},`);
+  out.push(`            isView: true,`);
+  out.push(`            fields: {`);
+  for (const field of fields) {
+    const block = emitFieldBlock(field);
+    out.push(`                ${field.name}: ${block},`);
+  }
+  out.push(`            },`);
+  const modelAttrs = [];
+  modelAttrs.push(`{ name: "@@map", args: [{ name: "name", value: ExpressionUtils.literal(${esc(v.sqlName)}) }] }`);
+  out.push(`            attributes: [${modelAttrs.join(", ")}],`);
+  const idCols = [];
+  for (const [jsKey, col] of v.columns) {
+    if (col.primary) {
+      const name = jsKey === "$hash" ? "hash" : jsKey;
+      idCols.push(name);
+    }
+  }
+  if (idCols.length === 0 && fields.length > 0) {
+    idCols.push(fields[0].name);
+  }
+  out.push(`            idFields: [${idCols.map((c) => esc(c)).join(", ")}],`);
+  const ufEntries = [];
+  if (idCols.length > 0) {
+    const key = idCols.join("_");
+    if (idCols.length === 1) {
+      ufEntries.push(`${key}: { type: ${esc(fieldByName.get(key)?.type || "String")} }`);
+    } else {
+      const inner = idCols.map((c) => `${c}: { type: ${esc(fieldByName.get(c)?.type || "String")} }`).join(", ");
+      ufEntries.push(`${key}: { ${inner} }`);
+    }
+  }
+  for (const f of fields) {
+    if (f.unique && !idCols.includes(f.name)) {
+      const key = f.name;
+      ufEntries.push(`${key}: { type: ${esc(f.type)} }`);
+    }
+  }
+  out.push(`            uniqueFields: { ${ufEntries.join(", ")} }`);
+  out.push(`        },`);
+  return out;
+}
+__name(emitViewModelBlock, "emitViewModelBlock");
+function emitSchemaTs({ tables, enumMap, modelRelations, inverseRelations, searchDefaults, modelScopes, typeDefs, fieldToTypeDef, views }) {
+  const out = [
+    ...emitGeneratedFileBanner()
+  ];
+  const allEnums = new Map([
+    ...enumMap,
+    ...collectDerivedEnums(tables, enumMap)
+  ]);
+  const hasJsonComputedField = tables.some((table) => table.computedFields.some((field) => field.tsType === "JsonValue"));
+  out.push("");
+  out.push('import { ExpressionUtils, type FieldDefault, type SchemaDef } from "@zenstackhq/schema";');
+  if (hasJsonComputedField) {
+    out.push('import type { JsonValue } from "@zenstackhq/orm";');
+  }
+  out.push("export class SchemaType implements SchemaDef {");
+  out.push('    provider = { type: "postgresql" } as const;');
+  out.push("    models = {");
+  for (const t of tables) {
+    out.push(...emitModelBlock(t, enumMap, modelRelations, inverseRelations, fieldToTypeDef));
+  }
+  if (views) {
+    for (const v of views) {
+      out.push(...emitViewModelBlock(v, enumMap, fieldToTypeDef));
+    }
+  }
+  out.push("    } as const;");
+  if (typeDefs && typeDefs.size > 0) {
+    out.push(emitTypeDefsBlock(typeDefs));
+  }
+  out.push("    enums = {");
+  for (const [, info] of allEnums) {
+    out.push(emitEnumBlock(info) + ",");
+  }
+  out.push("    } as const;");
+  out.push(emitPluginsBlock(modelRelations, searchDefaults, modelScopes ?? {}));
+  out.push("}");
+  out.push("");
+  out.push("export const schema = new SchemaType();");
+  out.push("");
+  return out.join("\n");
+}
+__name(emitSchemaTs, "emitSchemaTs");
+function emitModelsTs(tables, typedJsonFields = []) {
+  const jsonFieldAliases = createJsonFieldAliasMap(typedJsonFields);
+  const out = [
+    ...emitGeneratedFileBanner()
+  ];
+  out.push("");
+  out.push('import type * as $ from "@zenstackhq/orm";');
+  out.push('import type * as Json from "./json";');
+  out.push('import { type SchemaType as Schema } from "./schema";');
+  out.push("");
+  for (const t of tables) {
+    out.push(`export interface ${t.typeName} extends $.ModelResult<Schema, ${esc(t.modelName)}> {}`);
+    out.push(`export namespace ${t.typeName} {`);
+    for (const fieldName of getEntityFieldNames(t)) {
+      const exportName = toPascalCase(fieldName);
+      const jsonAlias = jsonFieldAliases.get(`${t.typeName}.${fieldName}`);
+      if (jsonAlias) {
+        out.push(`  export interface ${exportName} extends Json.${jsonAlias} {}`);
+      } else {
+        out.push(`  export type ${exportName} = ${t.typeName}[${esc(fieldName)}];`);
+      }
+    }
+    out.push("}");
+    out.push("");
+  }
+  return out.join("\n");
+}
+__name(emitModelsTs, "emitModelsTs");
+function emitViewsTs(views, typedJsonFields = []) {
+  const jsonFieldAliases = createJsonFieldAliasMap(typedJsonFields);
+  const out = [
+    ...emitGeneratedFileBanner()
+  ];
+  out.push("");
+  out.push('import type * as $ from "@zenstackhq/orm";');
+  out.push('import type * as Json from "./json";');
+  out.push('import { type SchemaType as Schema } from "./schema";');
+  out.push("");
+  for (const v of views) {
+    out.push(`export interface ${v.typeName} extends $.ModelResult<Schema, ${esc(v.modelName)}> {}`);
+    out.push(`export namespace ${v.typeName} {`);
+    for (const fieldName of getEntityFieldNames(v)) {
+      const exportName = toPascalCase(fieldName);
+      const jsonAlias = jsonFieldAliases.get(`${v.typeName}.${fieldName}`);
+      if (jsonAlias) {
+        out.push(`  export interface ${exportName} extends Json.${jsonAlias} {}`);
+      } else {
+        out.push(`  export type ${exportName} = ${v.typeName}[${esc(fieldName)}];`);
+      }
+    }
+    out.push("}");
+    out.push("");
+  }
+  return out.join("\n");
+}
+__name(emitViewsTs, "emitViewsTs");
+function emitInputTs(tables) {
+  const out = [
+    ...emitGeneratedFileBanner()
+  ];
+  out.push("");
+  out.push('import type * as $ from "@zenstackhq/orm";');
+  out.push('import { type SchemaType as Schema } from "./schema";');
+  out.push("");
+  for (const t of tables) {
+    out.push(`export namespace ${t.typeName} {`);
+    out.push(`  export interface FindManyArgs extends $.FindManyArgs<Schema, ${esc(t.modelName)}> {}`);
+    out.push(`  export interface FindUniqueArgs extends $.FindUniqueArgs<Schema, ${esc(t.modelName)}> {}`);
+    out.push(`  export interface FindFirstArgs extends $.FindFirstArgs<Schema, ${esc(t.modelName)}> {}`);
+    out.push(`  export interface ExistsArgs extends $.ExistsArgs<Schema, ${esc(t.modelName)}> {}`);
+    out.push(`  export interface CreateArgs extends $.CreateArgs<Schema, ${esc(t.modelName)}> {}`);
+    out.push(`  export interface CreateManyArgs extends $.CreateManyArgs<Schema, ${esc(t.modelName)}> {}`);
+    out.push(`  export interface CreateManyAndReturnArgs extends $.CreateManyAndReturnArgs<Schema, ${esc(t.modelName)}> {}`);
+    out.push(`  export interface UpdateArgs extends $.UpdateArgs<Schema, ${esc(t.modelName)}> {}`);
+    out.push(`  export interface UpdateManyArgs extends $.UpdateManyArgs<Schema, ${esc(t.modelName)}> {}`);
+    out.push(`  export interface UpdateManyAndReturnArgs extends $.UpdateManyAndReturnArgs<Schema, ${esc(t.modelName)}> {}`);
+    out.push(`  export interface UpsertArgs extends $.UpsertArgs<Schema, ${esc(t.modelName)}> {}`);
+    out.push(`  export interface DeleteArgs extends $.DeleteArgs<Schema, ${esc(t.modelName)}> {}`);
+    out.push(`  export interface DeleteManyArgs extends $.DeleteManyArgs<Schema, ${esc(t.modelName)}> {}`);
+    out.push(`  export interface CountArgs extends $.CountArgs<Schema, ${esc(t.modelName)}> {}`);
+    out.push(`  export interface AggregateArgs extends $.AggregateArgs<Schema, ${esc(t.modelName)}> {}`);
+    out.push(`  export interface GroupByArgs extends $.GroupByArgs<Schema, ${esc(t.modelName)}> {}`);
+    out.push(`  export interface WhereInput extends $.WhereInput<Schema, ${esc(t.modelName)}> {}`);
+    out.push(`  export interface Select extends $.SelectInput<Schema, ${esc(t.modelName)}> {}`);
+    out.push(`  export interface Include extends $.IncludeInput<Schema, ${esc(t.modelName)}> {}`);
+    out.push(`  export interface Omit extends $.OmitInput<Schema, ${esc(t.modelName)}> {}`);
+    out.push(`  export type GetPayload<Args extends $.SelectIncludeOmit<Schema, ${esc(t.modelName)}, true>, Options extends $.QueryOptions<Schema> = $.QueryOptions<Schema>> = $.SimplifiedPlainResult<Schema, ${esc(t.modelName)}, Args, Options>;`);
+    out.push("}");
+    out.push("");
+  }
+  return out.join("\n");
+}
+__name(emitInputTs, "emitInputTs");
+function emitIndexTs({ tables, views, enumMap, typeDefs, typedJsonFields }) {
+  const allEnums = new Map([
+    ...enumMap,
+    ...collectDerivedEnums(tables, enumMap)
+  ]);
+  const jsonFieldAliases = createJsonFieldAliasMap(typedJsonFields);
+  const out = [
+    ...emitGeneratedFileBanner()
+  ];
+  out.push("");
+  out.push('import type * as $ from "@zenstackhq/orm";');
+  out.push('import type * as RawJson from "../../supabase/schema/types";');
+  out.push('import { type SchemaType as Schema } from "./schema";');
+  out.push("");
+  out.push("export namespace Json {");
+  out.push(...emitJsonNamespaceBlock(typeDefs, typedJsonFields, "  "));
+  out.push("}");
+  out.push("");
+  out.push("export namespace JsonRaw {");
+  const jsonRawLines = emitJsonRawNamespaceBlock(typedJsonFields, "  ");
+  if (jsonRawLines.length > 0) {
+    out.push(...jsonRawLines);
+  }
+  out.push("}");
+  out.push("");
+  out.push("export namespace Table {");
+  for (const table of tables) {
+    out.push(...emitEntityNamespaceBlock(table, table.modelName, jsonFieldAliases, "  "));
+    out.push("");
+  }
+  out.push("}");
+  out.push("");
+  out.push("export namespace View {");
+  for (const view of views) {
+    out.push(...emitEntityNamespaceBlock(view, view.modelName, jsonFieldAliases, "  "));
+    out.push("");
+  }
+  out.push("}");
+  out.push("");
+  out.push("export namespace Input {");
+  for (const table of tables) {
+    out.push(...emitInputNamespaceBlock(table, "  "));
+    out.push("");
+  }
+  out.push("}");
+  out.push("");
+  out.push("export namespace ComputedFields {");
+  out.push("  export type All = $.ComputedFieldsOptions<Schema>;");
+  for (const table of tables) {
+    if (table.computedFields.length === 0) continue;
+    out.push(`  export type ${table.typeName} = $.ComputedFieldsOptions<Schema>[${esc(table.modelName)}];`);
+  }
+  out.push("}");
+  out.push("");
+  out.push("export namespace Enum {");
+  for (const [, info] of allEnums) {
+    out.push(...emitEnumNamespaceBlock(info, "  "));
+    out.push("");
+  }
+  out.push("}");
+  out.push("");
+  return out.join("\n");
+}
+__name(emitIndexTs, "emitIndexTs");
+function emitCompatTs({ tables, views, enumMap, typedJsonFields }) {
+  const out = [
+    ...emitGeneratedFileBanner()
+  ];
+  const jsonAliases = typedJsonFields.map((field) => `${field.entityTypeName}${toPascalCase(field.fieldName)}Json`);
+  const jsonRawAliases = typedJsonFields.filter((field) => field.sourceTypeName).map((field) => `${field.entityTypeName}${toPascalCase(field.fieldName)}JsonRaw`);
+  out.push("");
+  out.push('import type * as $ from "@zenstackhq/orm";');
+  out.push('import * as Db from "./index";');
+  out.push('import type { SchemaType as Schema } from "./schema";');
+  out.push("");
+  out.push("export namespace Models {");
+  for (const table of tables) {
+    out.push(...emitCompatEntityAlias(table, "Table", "  "));
+    out.push("");
+  }
+  out.push("}");
+  out.push("");
+  out.push("export namespace Views {");
+  for (const view of views) {
+    out.push(...emitCompatEntityAlias(view, "View", "  "));
+    out.push("");
+  }
+  out.push("}");
+  out.push("");
+  out.push("export namespace Input {");
+  for (const table of tables) {
+    out.push(...emitCompatInputAliases(table, "  "));
+    out.push("");
+  }
+  out.push("}");
+  out.push("");
+  out.push("export namespace Json {");
+  for (const alias of jsonAliases) {
+    out.push(...emitDeprecatedTypeAlias(alias, `Db.Json.${alias}`, "  "));
+  }
+  out.push("}");
+  out.push("");
+  out.push("export namespace JsonRaw {");
+  for (const alias of jsonRawAliases) {
+    out.push(...emitDeprecatedTypeAlias(alias, `Db.JsonRaw.${alias}`, "  "));
+  }
+  out.push("}");
+  out.push("");
+  out.push("export namespace Enums {");
+  for (const [, info] of enumMap) {
+    if (!info.mapping) continue;
+    out.push(...emitDeprecatedEnumAliases(info.zenstackName, "  "));
+    out.push("");
+  }
+  out.push("}");
+  out.push("");
+  for (const table of tables) {
+    out.push(...emitDeprecatedTypeAlias(table.typeName, `Models.${table.typeName}`));
+  }
+  for (const view of views) {
+    out.push(...emitDeprecatedTypeAlias(view.typeName, `Views.${view.typeName}`));
+  }
+  for (const table of tables) {
+    out.push(...emitCompatInputAliases(table));
+  }
+  for (const alias of jsonAliases) {
+    out.push(...emitDeprecatedTypeAlias(alias, `Json.${alias}`));
+  }
+  for (const alias of jsonRawAliases) {
+    out.push(...emitDeprecatedTypeAlias(alias, `JsonRaw.${alias}`));
+  }
+  for (const [, info] of enumMap) {
+    if (!info.mapping) continue;
+    out.push(...emitDeprecatedEnumAliases(info.zenstackName));
+    out.push("");
+  }
+  return out.join("\n");
+}
+__name(emitCompatTs, "emitCompatTs");
+function emitOrmTypesTs(tables) {
+  const out = [
+    ...emitGeneratedFileBanner()
+  ];
+  out.push("");
+  out.push('import type * as $ from "@zenstackhq/orm";');
+  out.push('import type { SchemaType as Schema } from "./schema";');
+  out.push("");
+  out.push("export type Client = $.ClientContract<Schema>;");
+  out.push("");
+  out.push("export namespace ComputedFields {");
+  out.push("  export type All = $.ComputedFieldsOptions<Schema>;");
+  for (const table of tables) {
+    if (table.computedFields.length === 0) continue;
+    out.push(`  export type ${table.typeName} = $.ComputedFieldsOptions<Schema>[${esc(table.modelName)}];`);
+  }
+  out.push("}");
+  out.push("");
+  return out.join("\n");
+}
+__name(emitOrmTypesTs, "emitOrmTypesTs");
+function getEntityFieldNames(entity) {
+  const fieldNames = /* @__PURE__ */ new Set();
+  if ("table" in entity) {
+    for (const jsKey of entity.sqlToJsKey.values()) {
+      fieldNames.add(jsKey === "$hash" ? "hash" : jsKey);
+    }
+    for (const computedField of entity.computedFields) {
+      fieldNames.add(computedField.name);
+    }
+  } else {
+    for (const jsKey of entity.columns.keys()) {
+      fieldNames.add(jsKey === "$hash" ? "hash" : jsKey);
+    }
+  }
+  return [
+    ...fieldNames
+  ];
+}
+__name(getEntityFieldNames, "getEntityFieldNames");
+function createJsonFieldAliasMap(typedJsonFields) {
+  return new Map(typedJsonFields.map((field) => [
+    `${field.entityTypeName}.${field.fieldName}`,
+    `${field.entityTypeName}${toPascalCase(field.fieldName)}Json`
+  ]));
+}
+__name(createJsonFieldAliasMap, "createJsonFieldAliasMap");
+function emitEntityNamespaceBlock(entity, modelName, jsonFieldAliases, indent = "") {
+  const out = [];
+  out.push(`${indent}export interface ${entity.typeName} extends $.ModelResult<Schema, ${esc(modelName)}> {}`);
+  out.push(`${indent}export namespace ${entity.typeName} {`);
+  for (const fieldName of getEntityFieldNames(entity)) {
+    const exportName = toPascalCase(fieldName);
+    const jsonAlias = jsonFieldAliases.get(`${entity.typeName}.${fieldName}`);
+    if (jsonAlias) {
+      out.push(`${indent}  export interface ${exportName} extends Json.${jsonAlias} {}`);
+    } else {
+      out.push(`${indent}  export type ${exportName} = ${entity.typeName}[${esc(fieldName)}];`);
+    }
+  }
+  out.push(`${indent}}`);
+  return out;
+}
+__name(emitEntityNamespaceBlock, "emitEntityNamespaceBlock");
+function emitInputNamespaceBlock(table, indent = "") {
+  const out = [];
+  out.push(`${indent}export namespace ${table.typeName} {`);
+  out.push(`${indent}  export interface FindManyArgs extends $.FindManyArgs<Schema, ${esc(table.modelName)}> {}`);
+  out.push(`${indent}  export interface FindUniqueArgs extends $.FindUniqueArgs<Schema, ${esc(table.modelName)}> {}`);
+  out.push(`${indent}  export interface FindFirstArgs extends $.FindFirstArgs<Schema, ${esc(table.modelName)}> {}`);
+  out.push(`${indent}  export interface ExistsArgs extends $.ExistsArgs<Schema, ${esc(table.modelName)}> {}`);
+  out.push(`${indent}  export interface CreateArgs extends $.CreateArgs<Schema, ${esc(table.modelName)}> {}`);
+  out.push(`${indent}  export interface CreateManyArgs extends $.CreateManyArgs<Schema, ${esc(table.modelName)}> {}`);
+  out.push(`${indent}  export interface CreateManyAndReturnArgs extends $.CreateManyAndReturnArgs<Schema, ${esc(table.modelName)}> {}`);
+  out.push(`${indent}  export interface UpdateArgs extends $.UpdateArgs<Schema, ${esc(table.modelName)}> {}`);
+  out.push(`${indent}  export interface UpdateManyArgs extends $.UpdateManyArgs<Schema, ${esc(table.modelName)}> {}`);
+  out.push(`${indent}  export interface UpdateManyAndReturnArgs extends $.UpdateManyAndReturnArgs<Schema, ${esc(table.modelName)}> {}`);
+  out.push(`${indent}  export interface UpsertArgs extends $.UpsertArgs<Schema, ${esc(table.modelName)}> {}`);
+  out.push(`${indent}  export interface DeleteArgs extends $.DeleteArgs<Schema, ${esc(table.modelName)}> {}`);
+  out.push(`${indent}  export interface DeleteManyArgs extends $.DeleteManyArgs<Schema, ${esc(table.modelName)}> {}`);
+  out.push(`${indent}  export interface CountArgs extends $.CountArgs<Schema, ${esc(table.modelName)}> {}`);
+  out.push(`${indent}  export interface AggregateArgs extends $.AggregateArgs<Schema, ${esc(table.modelName)}> {}`);
+  out.push(`${indent}  export interface GroupByArgs extends $.GroupByArgs<Schema, ${esc(table.modelName)}> {}`);
+  out.push(`${indent}  export interface WhereInput extends $.WhereInput<Schema, ${esc(table.modelName)}> {}`);
+  out.push(`${indent}  export interface Select extends $.SelectInput<Schema, ${esc(table.modelName)}> {}`);
+  out.push(`${indent}  export interface Include extends $.IncludeInput<Schema, ${esc(table.modelName)}> {}`);
+  out.push(`${indent}  export interface Omit extends $.OmitInput<Schema, ${esc(table.modelName)}> {}`);
+  out.push(`${indent}  export type GetPayload<Args extends $.SelectIncludeOmit<Schema, ${esc(table.modelName)}, true>, Options extends $.QueryOptions<Schema> = $.QueryOptions<Schema>> = $.SimplifiedPlainResult<Schema, ${esc(table.modelName)}, Args, Options>;`);
+  out.push(`${indent}}`);
+  return out;
+}
+__name(emitInputNamespaceBlock, "emitInputNamespaceBlock");
+function emitEnumNamespaceBlock(info, indent = "") {
+  if (!info.mapping) return [];
+  const out = [];
+  const entries = Object.entries(info.mapping).map(([key, value]) => `${indent}  ${key}: ${esc(value)}`).join(",\n");
+  out.push(`${indent}export const ${info.zenstackName} = {`);
+  out.push(entries);
+  out.push(`${indent}} as const;`);
+  out.push(`${indent}export type ${info.zenstackName} = (typeof ${info.zenstackName})[keyof typeof ${info.zenstackName}];`);
+  out.push(`${indent}export type ${info.zenstackName}Key = ${Object.keys(info.mapping).map((key) => esc(key)).join(" | ")};`);
+  out.push(`${indent}export const ${info.zenstackName}Values = Object.values(${info.zenstackName});`);
+  out.push(`${indent}export const ${info.zenstackName}Keys = Object.keys(${info.zenstackName}) as ${info.zenstackName}Key[];`);
+  return out;
+}
+__name(emitEnumNamespaceBlock, "emitEnumNamespaceBlock");
+function emitDeprecatedTypeAlias(name, target, indent = "") {
+  return [
+    `${indent}/** @deprecated Use ${target} instead. */`,
+    `${indent}export type ${name} = ${target};`
+  ];
+}
+__name(emitDeprecatedTypeAlias, "emitDeprecatedTypeAlias");
+function emitDeprecatedValueAlias(name, target, indent = "") {
+  return [
+    `${indent}/** @deprecated Use ${target} instead. */`,
+    `${indent}export const ${name} = ${target};`
+  ];
+}
+__name(emitDeprecatedValueAlias, "emitDeprecatedValueAlias");
+function emitDeprecatedEnumAliases(enumName, indent = "") {
+  return [
+    ...emitDeprecatedValueAlias(enumName, `Db.Enum.${enumName}`, indent),
+    ...emitDeprecatedTypeAlias(enumName, `Db.Enum.${enumName}`, indent),
+    ...emitDeprecatedTypeAlias(`${enumName}Key`, `Db.Enum.${enumName}Key`, indent),
+    ...emitDeprecatedValueAlias(`${enumName}Values`, `Db.Enum.${enumName}Values`, indent),
+    ...emitDeprecatedValueAlias(`${enumName}Keys`, `Db.Enum.${enumName}Keys`, indent)
+  ];
+}
+__name(emitDeprecatedEnumAliases, "emitDeprecatedEnumAliases");
+function emitCompatEntityAlias(entity, namespace, indent = "") {
+  const target = `Db.${namespace}.${entity.typeName}`;
+  const out = [
+    `${indent}/** @deprecated Use ${target} instead. */`
+  ];
+  const legacyFields = [
+    ...entity.sqlToJsKey.entries()
+  ].map(([sqlName, jsName]) => ({
+    sqlName,
+    fieldName: jsName === "$hash" ? "hash" : jsName
+  })).filter(({ sqlName, fieldName }) => sqlName !== "$hash" && sqlName !== fieldName);
+  if (legacyFields.length === 0) {
+    out.push(`${indent}export type ${entity.typeName} = ${target};`);
+    return out;
+  }
+  out.push(`${indent}export type ${entity.typeName} = ${target} & {`);
+  for (const { sqlName, fieldName } of legacyFields) {
+    out.push(`${indent}  /** @deprecated Use ${fieldName} instead. */`);
+    out.push(`${indent}  ${esc(sqlName)}: ${target}[${esc(fieldName)}];`);
+  }
+  out.push(`${indent}};`);
+  return out;
+}
+__name(emitCompatEntityAlias, "emitCompatEntityAlias");
+function emitCompatInputAliases(table, indent = "") {
+  const target = `Db.Input.${table.typeName}`;
+  return [
+    ...emitDeprecatedTypeAlias(`${table.typeName}FindManyArgs`, `${target}.FindManyArgs`, indent),
+    ...emitDeprecatedTypeAlias(`${table.typeName}FindUniqueArgs`, `${target}.FindUniqueArgs`, indent),
+    ...emitDeprecatedTypeAlias(`${table.typeName}FindFirstArgs`, `${target}.FindFirstArgs`, indent),
+    ...emitDeprecatedTypeAlias(`${table.typeName}ExistsArgs`, `${target}.ExistsArgs`, indent),
+    ...emitDeprecatedTypeAlias(`${table.typeName}CreateArgs`, `${target}.CreateArgs`, indent),
+    ...emitDeprecatedTypeAlias(`${table.typeName}CreateManyArgs`, `${target}.CreateManyArgs`, indent),
+    ...emitDeprecatedTypeAlias(`${table.typeName}CreateManyAndReturnArgs`, `${target}.CreateManyAndReturnArgs`, indent),
+    ...emitDeprecatedTypeAlias(`${table.typeName}UpdateArgs`, `${target}.UpdateArgs`, indent),
+    ...emitDeprecatedTypeAlias(`${table.typeName}UpdateManyArgs`, `${target}.UpdateManyArgs`, indent),
+    ...emitDeprecatedTypeAlias(`${table.typeName}UpdateManyAndReturnArgs`, `${target}.UpdateManyAndReturnArgs`, indent),
+    ...emitDeprecatedTypeAlias(`${table.typeName}UpsertArgs`, `${target}.UpsertArgs`, indent),
+    ...emitDeprecatedTypeAlias(`${table.typeName}DeleteArgs`, `${target}.DeleteArgs`, indent),
+    ...emitDeprecatedTypeAlias(`${table.typeName}DeleteManyArgs`, `${target}.DeleteManyArgs`, indent),
+    ...emitDeprecatedTypeAlias(`${table.typeName}CountArgs`, `${target}.CountArgs`, indent),
+    ...emitDeprecatedTypeAlias(`${table.typeName}AggregateArgs`, `${target}.AggregateArgs`, indent),
+    ...emitDeprecatedTypeAlias(`${table.typeName}GroupByArgs`, `${target}.GroupByArgs`, indent),
+    ...emitDeprecatedTypeAlias(`${table.typeName}WhereInput`, `${target}.WhereInput`, indent),
+    ...emitDeprecatedTypeAlias(`${table.typeName}Select`, `${target}.Select`, indent),
+    ...emitDeprecatedTypeAlias(`${table.typeName}Include`, `${target}.Include`, indent),
+    ...emitDeprecatedTypeAlias(`${table.typeName}Omit`, `${target}.Omit`, indent),
+    `${indent}/** @deprecated Use ${target}.GetPayload instead. */`,
+    `${indent}export type ${table.typeName}GetPayload<Args extends $.SelectIncludeOmit<Schema, ${esc(table.modelName)}, true>, Options extends $.QueryOptions<Schema> = $.QueryOptions<Schema>> = ${target}.GetPayload<Args, Options>;`
+  ];
+}
+__name(emitCompatInputAliases, "emitCompatInputAliases");
+function emitEnumsTs(enumMap) {
+  const out = [
+    ...emitGeneratedFileBanner()
+  ];
+  out.push("");
+  for (const [, info] of enumMap) {
+    if (!info.mapping) continue;
+    const n = info.zenstackName;
+    const entries = Object.entries(info.mapping).map(([k, v]) => `  ${k}: ${esc(v)}`).join(",\n");
+    out.push(`export const ${n} = {
+${entries},
+} as const;`);
+    out.push(`export type ${n} = (typeof ${n})[keyof typeof ${n}];`);
+    out.push(`export type ${n}Key = ${Object.keys(info.mapping).map((k) => esc(k)).join(" | ")};`);
+    out.push(`export const ${n}Values = Object.values(${n});`);
+    out.push(`export const ${n}Keys = Object.keys(${n}) as ${n}Key[];`);
+    out.push("");
+  }
+  return out.join("\n");
+}
+__name(emitEnumsTs, "emitEnumsTs");
+export {
+  APP_SLUG_JS,
+  APP_SLUG_SQL,
+  GENERATED_FILE_BANNER,
+  adaptToLegacyConfig,
+  assertNoTypedColumnOverrides,
+  buildRelations,
+  buildTypeDefs,
+  capitalize,
+  defineConfig,
+  defineModels,
+  derived,
+  discoverEnums,
+  discoverTables,
+  discoverViews,
+  emitCompatTs,
+  emitEnumBlock,
+  emitEnumsTs,
+  emitFieldBlock,
+  emitGeneratedFileBanner,
+  emitIndexTs,
+  emitInputTs,
+  emitJsonNamespaceBlock,
+  emitJsonRawNamespaceBlock,
+  emitJsonRawTs,
+  emitJsonTs,
+  emitModelsTs,
+  emitOrmTypesTs,
+  emitRelationField,
+  emitSchemaTs,
+  emitTypeDefsBlock,
+  emitViewsTs,
+  esc,
+  extend,
+  extractFKs,
+  getDrizzleTableName,
+  many,
+  mapColumn,
+  model,
+  one,
+  through,
+  toPascalCase,
+  uncapitalize,
+  writeFileIfChanged
+};
+//# sourceMappingURL=index.js.map