pqb 0.0.1

package/dist/index.esm.js

@@ -0,0 +1,4587 @@
+import { types, Pool } from 'pg';
+
+class ColumnType {
+  constructor() {
+    this.data = {};
+    this.isPrimaryKey = false;
+    this.isHidden = false;
+    this.isNullable = false;
+  }
+  primaryKey() {
+    return Object.assign(this, { isPrimaryKey: true });
+  }
+  hidden() {
+    return Object.assign(this, { isHidden: true });
+  }
+  nullable() {
+    this.isNullable = true;
+    return this;
+  }
+  encode(fn) {
+    const self = this;
+    self.encodeFn = fn;
+    return self;
+  }
+  parse(fn) {
+    this.parseFn = fn;
+    return this;
+  }
+  toSQL() {
+    return this.dataType;
+  }
+}
+
+const raw = (sql, ...values) => ({
+  __raw: sql,
+  __values: values
+});
+const rawColumn = (column, sql, ...values) => ({
+  __column: column,
+  __raw: sql,
+  __values: values
+});
+const isRaw = (obj) => "__raw" in obj;
+const getRaw = (raw2, values) => {
+  values.push(...raw2.__values);
+  return raw2.__raw;
+};
+const EMPTY_OBJECT = {};
+const getQueryParsers = (q) => {
+  return q.query.parsers || q.columnsParsers;
+};
+
+const singleQuoteRegex = /'/g;
+const doubleQuoteRegex = /"/g;
+const quoteValue$1 = (value) => {
+  const type = typeof value;
+  if (type === "number")
+    return String(value);
+  else if (type === "string")
+    return `"${value.replace(doubleQuoteRegex, '\\"').replace(singleQuoteRegex, "''")}"`;
+  else if (type === "boolean")
+    return value ? "true" : "false";
+  else if (value instanceof Date)
+    return `"${value.toISOString()}"`;
+  else if (Array.isArray(value))
+    return quoteArray(value);
+  else if (type === null || type === void 0)
+    return "NULL";
+  else
+    return `"${JSON.stringify(value).replace(doubleQuoteRegex, '\\"').replace(singleQuoteRegex, "''")}"`;
+};
+const quoteArray = (array) => `'{${array.map(quoteValue$1).join(",")}}'`;
+const quote = (value) => {
+  const type = typeof value;
+  if (type === "number")
+    return `${value}`;
+  else if (type === "string")
+    return `'${value.replace(singleQuoteRegex, "''")}'`;
+  else if (type === "boolean")
+    return value ? "true" : "false";
+  else if (value instanceof Date)
+    return `'${value.toISOString()}'`;
+  else if (Array.isArray(value))
+    return quoteArray(value);
+  else if (value === null || value === void 0)
+    return "NULL";
+  else
+    return `'${JSON.stringify(value).replace(singleQuoteRegex, "''")}'`;
+};
+
+const q = (sql) => `"${sql}"`;
+const qc = (column, quotedAs) => quotedAs ? `${quotedAs}.${q(column)}` : column;
+const quoteFullColumn = (fullColumn, quotedAs) => {
+  const index = fullColumn.indexOf(".");
+  if (index !== -1) {
+    return `${q(fullColumn.slice(0, index))}.${q(fullColumn.slice(index + 1))}`;
+  } else if (quotedAs) {
+    return `${quotedAs}.${q(fullColumn)}`;
+  } else {
+    return q(fullColumn);
+  }
+};
+const expressionToSql = (expr, values, quotedAs) => {
+  return typeof expr === "object" && isRaw(expr) ? getRaw(expr, values) : quoteFullColumn(expr, quotedAs);
+};
+const quoteSchemaAndTable = (schema, table) => {
+  return schema ? `${q(schema)}.${q(table)}` : q(table);
+};
+const addValue = (values, value) => {
+  values.push(value);
+  return `$${values.length}`;
+};
+
+var __defProp$m = Object.defineProperty;
+var __defProps$h = Object.defineProperties;
+var __getOwnPropDescs$h = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$n = Object.getOwnPropertySymbols;
+var __hasOwnProp$n = Object.prototype.hasOwnProperty;
+var __propIsEnum$n = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$m = (obj, key, value) => key in obj ? __defProp$m(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$m = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$n.call(b, prop))
+      __defNormalProp$m(a, prop, b[prop]);
+  if (__getOwnPropSymbols$n)
+    for (var prop of __getOwnPropSymbols$n(b)) {
+      if (__propIsEnum$n.call(b, prop))
+        __defNormalProp$m(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$h = (a, b) => __defProps$h(a, __getOwnPropDescs$h(b));
+const createOperator = (fn) => {
+  return Object.assign(fn, { type: void 0 });
+};
+const quoteValue = (arg, values, jsonArray) => {
+  if (arg && typeof arg === "object") {
+    if (!jsonArray && Array.isArray(arg)) {
+      return `(${arg.map((value) => addValue(values, value)).join(", ")})`;
+    }
+    if ("toSql" in arg) {
+      const sql = arg.toSql(values);
+      return `(${sql.text})`;
+    }
+    if (isRaw(arg)) {
+      return getRaw(arg, values);
+    }
+  }
+  return addValue(values, arg);
+};
+const all = {
+  equals: () => createOperator((key, value, values) => value === null ? `${key} IS NULL` : `${key} = ${quoteValue(value, values)}`),
+  not: () => createOperator((key, value, values) => value === null ? `${key} IS NOT NULL` : `${key} <> ${quoteValue(value, values)}`),
+  in: () => createOperator((key, value, values) => `${key} IN ${quoteValue(value, values)}`),
+  notIn: () => createOperator((key, value, values) => `NOT ${key} IN ${quoteValue(value, values)}`),
+  lt: () => createOperator((key, value, values) => `${key} < ${quoteValue(value, values)}`),
+  lte: () => createOperator((key, value, values) => `${key} <= ${quoteValue(value, values)}`),
+  gt: () => createOperator((key, value, values) => `${key} > ${quoteValue(value, values)}`),
+  gte: () => createOperator((key, value, values) => `${key} >= ${quoteValue(value, values)}`),
+  contains: () => createOperator((key, value, values) => `${key} LIKE '%' || ${quoteValue(value, values)} || '%'`),
+  containsInsensitive: () => createOperator((key, value, values) => `${key} ILIKE '%' || ${quoteValue(value, values)} || '%'`),
+  startsWith: () => createOperator((key, value, values) => `${key} LIKE ${quoteValue(value, values)} || '%'`),
+  startsWithInsensitive: () => createOperator((key, value, values) => `${key} ILIKE ${quoteValue(value, values)} || '%'`),
+  endsWith: () => createOperator((key, value, values) => `${key} LIKE '%' || ${quoteValue(value, values)}`),
+  endsWithInsensitive: () => createOperator((key, value, values) => `${key} ILIKE '%' || ${quoteValue(value, values)}`),
+  between: () => createOperator((key, [from, to], values) => `${key} BETWEEN ${quoteValue(from, values)} AND ${quoteValue(to, values)}`),
+  jsonPath: () => createOperator((key, [path, op, value], values) => `jsonb_path_query_first(${key}, ${quote(path)}) #>> '{}' ${op} ${quoteValue(value, values, true)}`),
+  jsonSupersetOf: () => createOperator((key, value, values) => `${key} @> ${quoteValue(value, values, true)}`),
+  jsonSubsetOf: () => createOperator((key, value, values) => `${key} <@ ${quoteValue(value, values, true)}`)
+};
+const base = () => ({
+  equals: all.equals(),
+  not: all.not(),
+  in: all.in(),
+  notIn: all.notIn()
+});
+const numeric = () => __spreadProps$h(__spreadValues$m({}, base()), {
+  lt: all.lt(),
+  lte: all.lte(),
+  gt: all.gt(),
+  gte: all.gte(),
+  between: all.between()
+});
+const text = () => __spreadProps$h(__spreadValues$m({}, base()), {
+  contains: all.contains(),
+  containsInsensitive: all.containsInsensitive(),
+  startsWith: all.startsWith(),
+  startsWithInsensitive: all.startsWithInsensitive(),
+  endsWith: all.endsWith(),
+  endsWithInsensitive: all.endsWithInsensitive()
+});
+const json = () => __spreadProps$h(__spreadValues$m({}, base()), {
+  jsonPath: all.jsonPath(),
+  jsonSupersetOf: all.jsonSupersetOf(),
+  jsonSubsetOf: all.jsonSubsetOf()
+});
+const Operators = {
+  any: base(),
+  boolean: base(),
+  number: numeric(),
+  date: numeric(),
+  time: numeric(),
+  text: text(),
+  json: json(),
+  array: base()
+};
+
+var __defProp$l = Object.defineProperty;
+var __getOwnPropSymbols$m = Object.getOwnPropertySymbols;
+var __hasOwnProp$m = Object.prototype.hasOwnProperty;
+var __propIsEnum$m = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$l = (obj, key, value) => key in obj ? __defProp$l(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$l = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$m.call(b, prop))
+      __defNormalProp$l(a, prop, b[prop]);
+  if (__getOwnPropSymbols$m)
+    for (var prop of __getOwnPropSymbols$m(b)) {
+      if (__propIsEnum$m.call(b, prop))
+        __defNormalProp$l(a, prop, b[prop]);
+    }
+  return a;
+};
+function applyMixins(derivedCtor, constructors) {
+  constructors.forEach((baseCtor) => {
+    Object.getOwnPropertyNames(baseCtor.prototype).forEach((name) => {
+      Object.defineProperty(derivedCtor.prototype, name, Object.getOwnPropertyDescriptor(baseCtor.prototype, name) || /* @__PURE__ */ Object.create(null));
+    });
+  });
+}
+const joinTruthy = (...strings) => {
+  return strings.filter((string) => string).join("");
+};
+const getClonedQueryData = (query) => {
+  const cloned = __spreadValues$l({}, query);
+  for (const key in query) {
+    if (Array.isArray(query[key])) {
+      cloned[key] = [
+        ...query[key]
+      ];
+    }
+  }
+  return cloned;
+};
+const getQueryAs = (q) => {
+  return q.query.as || q.table;
+};
+const toArray = (item) => Array.isArray(item) ? item : [item];
+const noop = () => {
+};
+
+const cloneInstance = (instance) => {
+  return Object.assign(Object.create(Object.getPrototypeOf(instance)), instance);
+};
+const assignMethodsToClass = (klass, methods) => {
+  for (const name in methods) {
+    Object.defineProperty(klass.prototype, name, {
+      configurable: true,
+      enumerable: false,
+      writable: true,
+      value(...args) {
+        const cloned = cloneInstance(this);
+        return methods[name].call(cloned, args);
+      }
+    });
+  }
+};
+
+var utils = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  cloneInstance: cloneInstance,
+  assignMethodsToClass: assignMethodsToClass
+});
+
+var __defProp$k = Object.defineProperty;
+var __defProps$g = Object.defineProperties;
+var __getOwnPropDescs$g = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$l = Object.getOwnPropertySymbols;
+var __hasOwnProp$l = Object.prototype.hasOwnProperty;
+var __propIsEnum$l = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$k = (obj, key, value) => key in obj ? __defProp$k(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$k = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$l.call(b, prop))
+      __defNormalProp$k(a, prop, b[prop]);
+  if (__getOwnPropSymbols$l)
+    for (var prop of __getOwnPropSymbols$l(b)) {
+      if (__propIsEnum$l.call(b, prop))
+        __defNormalProp$k(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$g = (a, b) => __defProps$g(a, __getOwnPropDescs$g(b));
+const arrayMethods = {
+  min(value) {
+    this.data.min = value;
+    return this;
+  },
+  max(value) {
+    this.data.max = value;
+    return this;
+  },
+  length(value) {
+    this.data.length = value;
+    return this;
+  }
+};
+const stringTypeMethods = () => __spreadProps$g(__spreadValues$k({}, arrayMethods), {
+  email() {
+    this.data.email = true;
+    return this;
+  },
+  url() {
+    this.data.url = true;
+    return this;
+  },
+  uuid() {
+    this.data.uuid = true;
+    return this;
+  },
+  cuid() {
+    this.data.cuid = true;
+    return this;
+  },
+  regex(value) {
+    this.data.regex = value;
+    return this;
+  },
+  trim() {
+    this.data.trim = true;
+    return this;
+  }
+});
+const numberTypeMethods = () => ({
+  lt(value) {
+    this.data.lt = value;
+    return this;
+  },
+  lte(value) {
+    this.data.lte = value;
+    return this;
+  },
+  max(value) {
+    this.data.lte = value;
+    return this;
+  },
+  gt(value) {
+    this.data.gt = value;
+    return this;
+  },
+  gte(value) {
+    this.data.gte = value;
+    return this;
+  },
+  min(value) {
+    this.data.gte = value;
+    return this;
+  },
+  positive() {
+    this.data.gt = 0;
+    return this;
+  },
+  nonNegative() {
+    this.data.gte = 0;
+    return this;
+  },
+  negative() {
+    this.data.lt = 0;
+    return this;
+  },
+  nonPositive() {
+    this.data.lte = 0;
+    return this;
+  },
+  multipleOf(value) {
+    this.data.multipleOf = value;
+    return this;
+  },
+  step(value) {
+    this.data.multipleOf = value;
+    return this;
+  }
+});
+
+const numberMethods$1 = numberTypeMethods();
+class NumberBaseColumn extends ColumnType {
+  constructor() {
+    super(...arguments);
+    this.data = {};
+    this.operators = Operators.number;
+  }
+}
+assignMethodsToClass(NumberBaseColumn, numberMethods$1);
+class DecimalBaseColumn extends NumberBaseColumn {
+  constructor(precision, scale) {
+    super();
+    this.dataType = "decimal";
+    this.data = {
+      precision,
+      scale
+    };
+  }
+  toSQL() {
+    const { precision, scale } = this.data;
+    return joinTruthy(this.dataType, precision ? scale ? `(${precision}, ${scale})` : `(${precision})` : void 0);
+  }
+}
+class SmallIntColumn extends NumberBaseColumn {
+  constructor() {
+    super(...arguments);
+    this.dataType = "smallint";
+  }
+}
+class IntegerColumn extends NumberBaseColumn {
+  constructor() {
+    super(...arguments);
+    this.dataType = "integer";
+  }
+}
+class BigIntColumn extends NumberBaseColumn {
+  constructor() {
+    super(...arguments);
+    this.dataType = "bigint";
+  }
+}
+class DecimalColumn extends DecimalBaseColumn {
+}
+class DecimalBigIntColumn extends DecimalBaseColumn {
+}
+class RealColumn extends NumberBaseColumn {
+  constructor() {
+    super(...arguments);
+    this.dataType = "real";
+  }
+}
+class DoublePrecisionColumn extends NumberBaseColumn {
+  constructor() {
+    super(...arguments);
+    this.dataType = "double precision";
+  }
+}
+class SmallSerialColumn extends NumberBaseColumn {
+  constructor() {
+    super(...arguments);
+    this.dataType = "smallserial";
+  }
+}
+class SerialColumn extends NumberBaseColumn {
+  constructor() {
+    super(...arguments);
+    this.dataType = "serial";
+  }
+}
+class BigSerialColumn extends NumberBaseColumn {
+  constructor() {
+    super(...arguments);
+    this.dataType = "bigserial";
+  }
+}
+
+const textMethods = stringTypeMethods();
+class TextBaseColumn extends ColumnType {
+  constructor() {
+    super(...arguments);
+    this.data = {};
+    this.operators = Operators.text;
+  }
+}
+assignMethodsToClass(TextBaseColumn, textMethods);
+class LimitedTextBaseColumn extends TextBaseColumn {
+  constructor(limit) {
+    super();
+    this.data = { max: limit };
+  }
+  toSQL() {
+    return joinTruthy(this.dataType, this.data.max !== void 0 && `(${this.data.max})`);
+  }
+}
+class VarCharColumn extends LimitedTextBaseColumn {
+  constructor() {
+    super(...arguments);
+    this.dataType = "varchar";
+  }
+}
+class CharColumn extends LimitedTextBaseColumn {
+  constructor() {
+    super(...arguments);
+    this.dataType = "char";
+  }
+}
+class TextColumn extends ColumnType {
+  constructor() {
+    super(...arguments);
+    this.dataType = "text";
+    this.operators = Operators.text;
+  }
+}
+class ByteaColumn extends NumberBaseColumn {
+  constructor() {
+    super(...arguments);
+    this.dataType = "bytea";
+  }
+}
+class PointColumn extends ColumnType {
+  constructor() {
+    super(...arguments);
+    this.dataType = "point";
+    this.operators = Operators.text;
+  }
+}
+class LineColumn extends ColumnType {
+  constructor() {
+    super(...arguments);
+    this.dataType = "point";
+    this.operators = Operators.text;
+  }
+}
+class LsegColumn extends ColumnType {
+  constructor() {
+    super(...arguments);
+    this.dataType = "point";
+    this.operators = Operators.text;
+  }
+}
+class BoxColumn extends ColumnType {
+  constructor() {
+    super(...arguments);
+    this.dataType = "point";
+    this.operators = Operators.text;
+  }
+}
+class PathColumn extends ColumnType {
+  constructor() {
+    super(...arguments);
+    this.dataType = "point";
+    this.operators = Operators.text;
+  }
+}
+class PolygonColumn extends ColumnType {
+  constructor() {
+    super(...arguments);
+    this.dataType = "point";
+    this.operators = Operators.text;
+  }
+}
+class CircleColumn extends ColumnType {
+  constructor() {
+    super(...arguments);
+    this.dataType = "point";
+    this.operators = Operators.text;
+  }
+}
+class MoneyColumn extends NumberBaseColumn {
+  constructor() {
+    super(...arguments);
+    this.dataType = "money";
+  }
+}
+class CidrColumn extends ColumnType {
+  constructor() {
+    super(...arguments);
+    this.dataType = "cidr";
+    this.operators = Operators.text;
+  }
+}
+class InetColumn extends ColumnType {
+  constructor() {
+    super(...arguments);
+    this.dataType = "inet";
+    this.operators = Operators.text;
+  }
+}
+class MacAddrColumn extends ColumnType {
+  constructor() {
+    super(...arguments);
+    this.dataType = "macaddr";
+    this.operators = Operators.text;
+  }
+}
+class MacAddr8Column extends ColumnType {
+  constructor() {
+    super(...arguments);
+    this.dataType = "macaddr8";
+    this.operators = Operators.text;
+  }
+}
+class BitColumn extends ColumnType {
+  constructor(length) {
+    super();
+    this.dataType = "bit";
+    this.operators = Operators.text;
+    this.data = { length };
+  }
+  toSQL() {
+    return joinTruthy(this.dataType, this.data.length && `(${this.data.length})`);
+  }
+}
+class BitVaryingColumn extends ColumnType {
+  constructor(length) {
+    super();
+    this.dataType = "bit varying";
+    this.operators = Operators.text;
+    this.data = { length };
+  }
+  toSQL() {
+    return joinTruthy(this.dataType, this.data.length && `(${this.data.length})`);
+  }
+}
+class TsVectorColumn extends ColumnType {
+  constructor() {
+    super(...arguments);
+    this.dataType = "tsvector";
+    this.operators = Operators.text;
+  }
+}
+class TsQueryColumn extends ColumnType {
+  constructor() {
+    super(...arguments);
+    this.dataType = "tsquery";
+    this.operators = Operators.text;
+  }
+}
+class UUIDColumn extends ColumnType {
+  constructor() {
+    super(...arguments);
+    this.dataType = "uuid";
+    this.operators = Operators.text;
+  }
+}
+class XMLColumn extends ColumnType {
+  constructor() {
+    super(...arguments);
+    this.dataType = "uuid";
+    this.operators = Operators.text;
+  }
+}
+
+class DateColumn extends ColumnType {
+  constructor() {
+    super(...arguments);
+    this.dataType = "date";
+    this.operators = Operators.date;
+  }
+}
+class DateTimeBaseClass extends ColumnType {
+  constructor(precision) {
+    super();
+    this.operators = Operators.date;
+    this.data = { precision };
+  }
+  toSQL() {
+    return joinTruthy(this.dataType, this.data.precision !== void 0 && `(${this.data.precision})`);
+  }
+}
+class DateTimeWithTimeZoneBaseClass extends DateTimeBaseClass {
+  toSQL() {
+    return joinTruthy(this.baseDataType, this.data.precision !== void 0 && `(${this.data.precision})`, " with time zone");
+  }
+}
+class TimestampColumn extends DateTimeBaseClass {
+  constructor() {
+    super(...arguments);
+    this.dataType = "timestamp";
+  }
+}
+class TimestampWithTimeZoneColumn extends DateTimeWithTimeZoneBaseClass {
+  constructor() {
+    super(...arguments);
+    this.dataType = "timestamp with time zone";
+    this.baseDataType = "timestamp";
+  }
+}
+class TimeColumn extends DateTimeBaseClass {
+  constructor() {
+    super(...arguments);
+    this.dataType = "time";
+  }
+}
+class TimeWithTimeZoneColumn extends DateTimeWithTimeZoneBaseClass {
+  constructor() {
+    super(...arguments);
+    this.dataType = "time with time zone";
+    this.baseDataType = "time";
+  }
+}
+class IntervalColumn extends ColumnType {
+  constructor(fields, precision) {
+    super();
+    this.dataType = "interval";
+    this.operators = Operators.date;
+    this.data = { fields, precision };
+  }
+  toSQL() {
+    return joinTruthy(this.dataType, this.data.fields && ` ${this.data.fields}`, this.data.precision !== void 0 && ` (${this.data.precision})`);
+  }
+}
+
+class BooleanColumn extends ColumnType {
+  constructor() {
+    super(...arguments);
+    this.dataType = "boolean";
+    this.operators = Operators.boolean;
+  }
+}
+
+class EnumColumn extends ColumnType {
+  constructor(dataType) {
+    super();
+    this.dataType = dataType;
+    this.operators = Operators.any;
+  }
+}
+
+var __defProp$j = Object.defineProperty;
+var __defProps$f = Object.defineProperties;
+var __getOwnPropDescs$f = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$k = Object.getOwnPropertySymbols;
+var __hasOwnProp$k = Object.prototype.hasOwnProperty;
+var __propIsEnum$k = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$j = (obj, key, value) => key in obj ? __defProp$j(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$j = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$k.call(b, prop))
+      __defNormalProp$j(a, prop, b[prop]);
+  if (__getOwnPropSymbols$k)
+    for (var prop of __getOwnPropSymbols$k(b)) {
+      if (__propIsEnum$k.call(b, prop))
+        __defNormalProp$j(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$f = (a, b) => __defProps$f(a, __getOwnPropDescs$f(b));
+var __objRest$4 = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp$k.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols$k)
+    for (var prop of __getOwnPropSymbols$k(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum$k.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+const optional = (type) => {
+  return __spreadProps$f(__spreadValues$j({}, type), {
+    data: __spreadProps$f(__spreadValues$j({}, type.data), { optional: true })
+  });
+};
+const required = (type) => {
+  const _a = type.data, data = __objRest$4(_a, ["optional"]);
+  return __spreadProps$f(__spreadValues$j({}, type), {
+    data
+  });
+};
+
+var __defProp$i = Object.defineProperty;
+var __defProps$e = Object.defineProperties;
+var __getOwnPropDescs$e = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$j = Object.getOwnPropertySymbols;
+var __hasOwnProp$j = Object.prototype.hasOwnProperty;
+var __propIsEnum$j = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$i = (obj, key, value) => key in obj ? __defProp$i(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$i = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$j.call(b, prop))
+      __defNormalProp$i(a, prop, b[prop]);
+  if (__getOwnPropSymbols$j)
+    for (var prop of __getOwnPropSymbols$j(b)) {
+      if (__propIsEnum$j.call(b, prop))
+        __defNormalProp$i(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$e = (a, b) => __defProps$e(a, __getOwnPropDescs$e(b));
+var __objRest$3 = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp$j.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols$j)
+    for (var prop of __getOwnPropSymbols$j(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum$j.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+const nullable = (type) => {
+  return __spreadProps$e(__spreadValues$i({}, type), {
+    data: __spreadProps$e(__spreadValues$i({}, type.data), { nullable: true })
+  });
+};
+const notNullable = (type) => {
+  const _a = type.data, data = __objRest$3(_a, ["nullable"]);
+  return __spreadProps$e(__spreadValues$i({}, type), {
+    data
+  });
+};
+
+var __defProp$h = Object.defineProperty;
+var __defProps$d = Object.defineProperties;
+var __getOwnPropDescs$d = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$i = Object.getOwnPropertySymbols;
+var __hasOwnProp$i = Object.prototype.hasOwnProperty;
+var __propIsEnum$i = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$h = (obj, key, value) => key in obj ? __defProp$h(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$h = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$i.call(b, prop))
+      __defNormalProp$h(a, prop, b[prop]);
+  if (__getOwnPropSymbols$i)
+    for (var prop of __getOwnPropSymbols$i(b)) {
+      if (__propIsEnum$i.call(b, prop))
+        __defNormalProp$h(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$d = (a, b) => __defProps$d(a, __getOwnPropDescs$d(b));
+var __objRest$2 = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp$i.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols$i)
+    for (var prop of __getOwnPropSymbols$i(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum$i.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+const nullish = (type) => {
+  return __spreadProps$d(__spreadValues$h({}, type), {
+    data: __spreadProps$d(__spreadValues$h({}, type.data), { nullable: true, optional: true })
+  });
+};
+const notNullish = (type) => {
+  const _a = type.data, data = __objRest$2(_a, ["nullable", "optional"]);
+  return __spreadProps$d(__spreadValues$h({}, type), {
+    data
+  });
+};
+
+const intersection = (left, right) => {
+  return constructType({
+    dataType: "intersection",
+    left,
+    right
+  });
+};
+
+var __defProp$g = Object.defineProperty;
+var __defProps$c = Object.defineProperties;
+var __getOwnPropDescs$c = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$h = Object.getOwnPropertySymbols;
+var __hasOwnProp$h = Object.prototype.hasOwnProperty;
+var __propIsEnum$h = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$g = (obj, key, value) => key in obj ? __defProp$g(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$g = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$h.call(b, prop))
+      __defNormalProp$g(a, prop, b[prop]);
+  if (__getOwnPropSymbols$h)
+    for (var prop of __getOwnPropSymbols$h(b)) {
+      if (__propIsEnum$h.call(b, prop))
+        __defNormalProp$g(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$c = (a, b) => __defProps$c(a, __getOwnPropDescs$c(b));
+const array = (element) => {
+  return constructType(__spreadValues$g({
+    dataType: "array",
+    element,
+    deepPartial() {
+      return __spreadProps$c(__spreadValues$g({}, this), {
+        element: this.element.deepPartial()
+      });
+    },
+    nonEmpty() {
+      return this.min(1);
+    }
+  }, arrayMethods));
+};
+
+const union = (types) => {
+  return constructType({
+    dataType: "union",
+    types
+  });
+};
+
+var __defProp$f = Object.defineProperty;
+var __defProps$b = Object.defineProperties;
+var __getOwnPropDescs$b = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$g = Object.getOwnPropertySymbols;
+var __hasOwnProp$g = Object.prototype.hasOwnProperty;
+var __propIsEnum$g = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$f = (obj, key, value) => key in obj ? __defProp$f(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$f = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$g.call(b, prop))
+      __defNormalProp$f(a, prop, b[prop]);
+  if (__getOwnPropSymbols$g)
+    for (var prop of __getOwnPropSymbols$g(b)) {
+      if (__propIsEnum$g.call(b, prop))
+        __defNormalProp$f(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$b = (a, b) => __defProps$b(a, __getOwnPropDescs$b(b));
+const baseTypeMethods = {
+  type: void 0,
+  data: {},
+  dataType: "any",
+  chain: [],
+  optional() {
+    return optional(this);
+  },
+  required() {
+    return required(this);
+  },
+  nullable() {
+    return nullable(this);
+  },
+  notNullable() {
+    return notNullable(this);
+  },
+  nullish() {
+    return nullish(this);
+  },
+  notNullish() {
+    return notNullish(this);
+  },
+  deepPartial() {
+    return this;
+  },
+  transform(fn) {
+    return __spreadProps$b(__spreadValues$f({}, this), {
+      chain: [...this.chain, ["transform", fn]]
+    });
+  },
+  to(fn, type) {
+    return __spreadProps$b(__spreadValues$f({}, type), {
+      chain: [...this.chain, ["to", fn, type], ...type.chain]
+    });
+  },
+  refine(check) {
+    return __spreadProps$b(__spreadValues$f({}, this), {
+      chain: [...this.chain, ["refine", check]]
+    });
+  },
+  superRefine(check) {
+    return __spreadProps$b(__spreadValues$f({}, this), {
+      chain: [...this.chain, ["superRefine", check]]
+    });
+  },
+  and(type) {
+    return intersection(this, type);
+  },
+  or(...args) {
+    const [type, ...types] = args;
+    return union([this, type, ...types]);
+  },
+  default(value) {
+    const defaultFn = typeof value === "function" ? (input) => input != null ? input : value() : (input) => input != null ? input : value;
+    return notNullish(__spreadProps$b(__spreadValues$f({}, this), {
+      chain: ["transform", defaultFn]
+    }));
+  },
+  array() {
+    return array(this);
+  }
+};
+const constructType = (type) => {
+  return __spreadValues$f(__spreadValues$f({}, baseTypeMethods), type);
+};
+
+var __defProp$e = Object.defineProperty;
+var __defProps$a = Object.defineProperties;
+var __getOwnPropDescs$a = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$f = Object.getOwnPropertySymbols;
+var __hasOwnProp$f = Object.prototype.hasOwnProperty;
+var __propIsEnum$f = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$e = (obj, key, value) => key in obj ? __defProp$e(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$e = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$f.call(b, prop))
+      __defNormalProp$e(a, prop, b[prop]);
+  if (__getOwnPropSymbols$f)
+    for (var prop of __getOwnPropSymbols$f(b)) {
+      if (__propIsEnum$f.call(b, prop))
+        __defNormalProp$e(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$a = (a, b) => __defProps$a(a, __getOwnPropDescs$a(b));
+const any = () => {
+  return constructType({
+    dataType: "any"
+  });
+};
+const bigIntMethods = __spreadValues$e({
+  dataType: "bigint"
+}, numberTypeMethods());
+const bigint = () => {
+  return constructType(bigIntMethods);
+};
+const boolean = () => {
+  return constructType({
+    dataType: "boolean"
+  });
+};
+const nan = () => {
+  return constructType({
+    dataType: "nan"
+  });
+};
+const never = () => {
+  return constructType({
+    dataType: "never"
+  });
+};
+const nullType = () => {
+  return constructType({
+    dataType: "null"
+  });
+};
+const numberMethods = __spreadProps$a(__spreadValues$e({}, numberTypeMethods()), {
+  dataType: "number"
+});
+const number = () => {
+  return constructType(numberMethods);
+};
+const date = () => {
+  return constructType({
+    dataType: "date"
+  });
+};
+const stringMethods = __spreadProps$a(__spreadValues$e({}, stringTypeMethods()), {
+  dataType: "string"
+});
+const string = () => {
+  return constructType(stringMethods);
+};
+const undefinedType = () => {
+  return constructType({
+    dataType: "undefined"
+  });
+};
+const unknown = () => {
+  return constructType({
+    dataType: "unknown"
+  });
+};
+const voidType = () => {
+  return constructType({
+    dataType: "void"
+  });
+};
+const scalarTypes = {
+  any,
+  bigint,
+  boolean,
+  date,
+  nan,
+  never,
+  null: nullType,
+  number,
+  string,
+  undefined: undefinedType,
+  unknown,
+  void: voidType
+};
+
+var __defProp$d = Object.defineProperty;
+var __defProps$9 = Object.defineProperties;
+var __getOwnPropDescs$9 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$e = Object.getOwnPropertySymbols;
+var __hasOwnProp$e = Object.prototype.hasOwnProperty;
+var __propIsEnum$e = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$d = (obj, key, value) => key in obj ? __defProp$d(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$d = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$e.call(b, prop))
+      __defNormalProp$d(a, prop, b[prop]);
+  if (__getOwnPropSymbols$e)
+    for (var prop of __getOwnPropSymbols$e(b)) {
+      if (__propIsEnum$e.call(b, prop))
+        __defNormalProp$d(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$9 = (a, b) => __defProps$9(a, __getOwnPropDescs$9(b));
+const discriminatedUnion = (discriminator, options) => {
+  const optionsMap = /* @__PURE__ */ new Map();
+  options.forEach((option) => {
+    const discriminatorValue = option.shape[discriminator].value;
+    optionsMap.set(discriminatorValue, option);
+  });
+  return constructType({
+    dataType: "discriminatedUnion",
+    discriminator,
+    options: optionsMap,
+    deepPartial() {
+      const newOptionsMap = /* @__PURE__ */ new Map();
+      optionsMap.forEach((option, key) => {
+        const partial = option.deepPartial();
+        partial.shape[discriminator] = option.shape[discriminator];
+        newOptionsMap.set(key, partial);
+      });
+      return __spreadProps$9(__spreadValues$d({}, this), {
+        options: newOptionsMap
+      });
+    }
+  });
+};
+
+const arrayToEnum = (items) => {
+  const obj = {};
+  for (const item of items) {
+    obj[item] = item;
+  }
+  return obj;
+};
+const enumType = (options) => {
+  return constructType({
+    dataType: "enum",
+    enum: arrayToEnum(options),
+    options
+  });
+};
+
+const instanceOf = (cls) => {
+  return constructType({
+    dataType: "instanceOf",
+    class: cls
+  });
+};
+
+var __defProp$c = Object.defineProperty;
+var __defProps$8 = Object.defineProperties;
+var __getOwnPropDescs$8 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$d = Object.getOwnPropertySymbols;
+var __hasOwnProp$d = Object.prototype.hasOwnProperty;
+var __propIsEnum$d = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$c = (obj, key, value) => key in obj ? __defProp$c(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$c = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$d.call(b, prop))
+      __defNormalProp$c(a, prop, b[prop]);
+  if (__getOwnPropSymbols$d)
+    for (var prop of __getOwnPropSymbols$d(b)) {
+      if (__propIsEnum$d.call(b, prop))
+        __defNormalProp$c(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$8 = (a, b) => __defProps$8(a, __getOwnPropDescs$8(b));
+const lazy = (fn) => {
+  constructType({
+    dataType: "lazy",
+    getter: fn,
+    deepPartial() {
+      return __spreadProps$8(__spreadValues$c({}, this), {
+        typeCache: void 0,
+        getter: () => this.getter().deepPartial()
+      });
+    }
+  });
+};
+
+const literal = (value) => constructType({
+  dataType: "literal",
+  value
+});
+
+var __defProp$b = Object.defineProperty;
+var __defProps$7 = Object.defineProperties;
+var __getOwnPropDescs$7 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$c = Object.getOwnPropertySymbols;
+var __hasOwnProp$c = Object.prototype.hasOwnProperty;
+var __propIsEnum$c = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$b = (obj, key, value) => key in obj ? __defProp$b(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$b = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$c.call(b, prop))
+      __defNormalProp$b(a, prop, b[prop]);
+  if (__getOwnPropSymbols$c)
+    for (var prop of __getOwnPropSymbols$c(b)) {
+      if (__propIsEnum$c.call(b, prop))
+        __defNormalProp$b(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$7 = (a, b) => __defProps$7(a, __getOwnPropDescs$7(b));
+const map = (keyType, valueType) => {
+  return constructType({
+    dataType: "map",
+    keyType,
+    valueType,
+    deepPartial() {
+      return __spreadProps$7(__spreadValues$b({}, this), {
+        keyType: this.keyType.deepPartial(),
+        valueType: this.valueType.deepPartial()
+      });
+    }
+  });
+};
+
+const getValidEnumValues = (obj) => {
+  const values = [];
+  Object.keys(obj).forEach((k) => {
+    if (typeof obj[obj[k]] !== "number" && !values.includes(obj[k])) {
+      values.push(obj[k]);
+    }
+  });
+  return values;
+};
+const nativeEnum = (givenEnum) => {
+  const options = getValidEnumValues(givenEnum);
+  return constructType({
+    dataType: "nativeEnum",
+    enum: givenEnum,
+    options
+  });
+};
+
+var __defProp$a = Object.defineProperty;
+var __defProps$6 = Object.defineProperties;
+var __getOwnPropDescs$6 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$b = Object.getOwnPropertySymbols;
+var __hasOwnProp$b = Object.prototype.hasOwnProperty;
+var __propIsEnum$b = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$a = (obj, key, value) => key in obj ? __defProp$a(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$a = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$b.call(b, prop))
+      __defNormalProp$a(a, prop, b[prop]);
+  if (__getOwnPropSymbols$b)
+    for (var prop of __getOwnPropSymbols$b(b)) {
+      if (__propIsEnum$b.call(b, prop))
+        __defNormalProp$a(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$6 = (a, b) => __defProps$6(a, __getOwnPropDescs$6(b));
+const object = (shape) => {
+  return constructType({
+    dataType: "object",
+    shape,
+    unknownKeys: "strip",
+    catchAllType: void 0,
+    extend(add) {
+      return object(Object.assign(__spreadValues$a({}, this.shape), add));
+    },
+    merge(obj) {
+      return object(Object.assign(__spreadValues$a({}, this.shape), obj.shape));
+    },
+    pick(...arr) {
+      const picked = {};
+      arr.forEach((key) => picked[key] = this.shape[key]);
+      return object(picked);
+    },
+    omit(...arr) {
+      const picked = {};
+      for (const key in this.shape) {
+        if (!arr.includes(key)) {
+          picked[key] = this.shape[key];
+        }
+      }
+      return object(picked);
+    },
+    partial(...arr) {
+      const mapped = __spreadValues$a({}, this.shape);
+      if (arr.length) {
+        arr.forEach((key) => {
+          mapped[key] = mapped[key].optional();
+        });
+      } else {
+        for (const key in mapped) {
+          mapped[key] = mapped[key].optional();
+        }
+      }
+      return object(mapped);
+    },
+    deepPartial() {
+      const newShape = {};
+      for (const key in this.shape) {
+        newShape[key] = optional(this.shape[key].deepPartial());
+      }
+      return __spreadProps$6(__spreadValues$a({}, this), {
+        shape: newShape
+      });
+    },
+    passthrough() {
+      return __spreadProps$6(__spreadValues$a({}, this), {
+        unknownKeys: "passthrough"
+      });
+    },
+    strict() {
+      return __spreadProps$6(__spreadValues$a({}, this), {
+        unknownKeys: "strict"
+      });
+    },
+    strip() {
+      return __spreadProps$6(__spreadValues$a({}, this), {
+        unknownKeys: "strip"
+      });
+    },
+    catchAll(type) {
+      return __spreadProps$6(__spreadValues$a({}, this), {
+        catchAllType: type
+      });
+    }
+  });
+};
+
+var __defProp$9 = Object.defineProperty;
+var __defProps$5 = Object.defineProperties;
+var __getOwnPropDescs$5 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$a = Object.getOwnPropertySymbols;
+var __hasOwnProp$a = Object.prototype.hasOwnProperty;
+var __propIsEnum$a = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$9 = (obj, key, value) => key in obj ? __defProp$9(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$9 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$a.call(b, prop))
+      __defNormalProp$9(a, prop, b[prop]);
+  if (__getOwnPropSymbols$a)
+    for (var prop of __getOwnPropSymbols$a(b)) {
+      if (__propIsEnum$a.call(b, prop))
+        __defNormalProp$9(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$5 = (a, b) => __defProps$5(a, __getOwnPropDescs$5(b));
+function record(...args) {
+  const [keyType, valueType] = args.length === 1 ? [scalarTypes.string(), args[0]] : args;
+  return constructType({
+    dataType: "record",
+    keyType,
+    valueType,
+    deepPartial() {
+      return __spreadProps$5(__spreadValues$9({}, this), {
+        valueType: this.valueType.deepPartial()
+      });
+    }
+  });
+}
+
+var __defProp$8 = Object.defineProperty;
+var __defProps$4 = Object.defineProperties;
+var __getOwnPropDescs$4 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$9 = Object.getOwnPropertySymbols;
+var __hasOwnProp$9 = Object.prototype.hasOwnProperty;
+var __propIsEnum$9 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$8 = (obj, key, value) => key in obj ? __defProp$8(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$8 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$9.call(b, prop))
+      __defNormalProp$8(a, prop, b[prop]);
+  if (__getOwnPropSymbols$9)
+    for (var prop of __getOwnPropSymbols$9(b)) {
+      if (__propIsEnum$9.call(b, prop))
+        __defNormalProp$8(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$4 = (a, b) => __defProps$4(a, __getOwnPropDescs$4(b));
+const set = (valueType) => {
+  return constructType(__spreadValues$8({
+    dataType: "set",
+    valueType,
+    deepPartial() {
+      return __spreadProps$4(__spreadValues$8({}, this), {
+        valueType: this.valueType.deepPartial()
+      });
+    },
+    nonEmpty() {
+      return this.min(1);
+    }
+  }, arrayMethods));
+};
+
+var __defProp$7 = Object.defineProperty;
+var __defProps$3 = Object.defineProperties;
+var __getOwnPropDescs$3 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$8 = Object.getOwnPropertySymbols;
+var __hasOwnProp$8 = Object.prototype.hasOwnProperty;
+var __propIsEnum$8 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$7 = (obj, key, value) => key in obj ? __defProp$7(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$7 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$8.call(b, prop))
+      __defNormalProp$7(a, prop, b[prop]);
+  if (__getOwnPropSymbols$8)
+    for (var prop of __getOwnPropSymbols$8(b)) {
+      if (__propIsEnum$8.call(b, prop))
+        __defNormalProp$7(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$3 = (a, b) => __defProps$3(a, __getOwnPropDescs$3(b));
+const tuple = (items) => {
+  return constructType({
+    dataType: "tuple",
+    items,
+    deepPartial() {
+      return __spreadProps$3(__spreadValues$7({}, this), {
+        items: this.items.map((item) => item.deepPartial())
+      });
+    }
+  });
+};
+
+var __defProp$6 = Object.defineProperty;
+var __defProps$2 = Object.defineProperties;
+var __getOwnPropDescs$2 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$7 = Object.getOwnPropertySymbols;
+var __hasOwnProp$7 = Object.prototype.hasOwnProperty;
+var __propIsEnum$7 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$6 = (obj, key, value) => key in obj ? __defProp$6(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$6 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$7.call(b, prop))
+      __defNormalProp$6(a, prop, b[prop]);
+  if (__getOwnPropSymbols$7)
+    for (var prop of __getOwnPropSymbols$7(b)) {
+      if (__propIsEnum$7.call(b, prop))
+        __defNormalProp$6(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$2 = (a, b) => __defProps$2(a, __getOwnPropDescs$2(b));
+const jsonTypes = __spreadProps$2(__spreadValues$6({
+  array,
+  discriminatedUnion,
+  enum: enumType,
+  instanceOf,
+  intersection,
+  lazy,
+  literal,
+  map,
+  nativeEnum,
+  nullable,
+  nullish,
+  object,
+  optional,
+  record
+}, scalarTypes), {
+  set,
+  tuple,
+  union
+});
+class JSONColumn extends ColumnType {
+  constructor(schemaOrFn) {
+    super();
+    this.dataType = "jsonb";
+    this.operators = Operators.json;
+    const schema = typeof schemaOrFn === "function" ? schemaOrFn(jsonTypes) : schemaOrFn;
+    this.data = { schema };
+  }
+}
+class JSONTextColumn extends ColumnType {
+  constructor() {
+    super(...arguments);
+    this.dataType = "json";
+    this.operators = Operators.text;
+  }
+}
+
+class ArrayColumn extends ColumnType {
+  constructor(item) {
+    super();
+    this.dataType = "array";
+    this.operators = Operators.array;
+    this.data = { item };
+  }
+  toSQL() {
+    return `${this.data.item.toSQL()}[]`;
+  }
+}
+
+const columnTypes = {
+  smallint: () => new SmallIntColumn(),
+  integer: () => new IntegerColumn(),
+  bigint: () => new BigIntColumn(),
+  numeric: (precision, scale) => new DecimalColumn(precision, scale),
+  numericBigInt: (precision, scale) => new DecimalBigIntColumn(precision, scale),
+  decimal: (precision, scale) => new DecimalColumn(precision, scale),
+  decimalBigInt: (precision, scale) => new DecimalBigIntColumn(precision, scale),
+  real: () => new RealColumn(),
+  doublePrecision: () => new DoublePrecisionColumn(),
+  smallSerial: () => new SmallSerialColumn(),
+  serial: () => new SerialColumn(),
+  bigserial: () => new BigSerialColumn(),
+  money: () => new MoneyColumn(),
+  varchar: (limit) => new VarCharColumn(limit),
+  char: (limit) => new CharColumn(limit),
+  text: () => new TextColumn(),
+  bytea: () => new ByteaColumn(),
+  date: () => new DateColumn(),
+  timestamp: (precision) => new TimestampColumn(precision),
+  timestampWithTimeZone: (precision) => new TimestampWithTimeZoneColumn(precision),
+  time: (precision) => new TimeColumn(precision),
+  timeWithTimeZone: (precision) => new TimeWithTimeZoneColumn(precision),
+  interval: (fields, precision) => new IntervalColumn(fields, precision),
+  boolean: () => new BooleanColumn(),
+  enum: (dataType) => new EnumColumn(dataType),
+  point: () => new PointColumn(),
+  line: () => new LineColumn(),
+  lseg: () => new LsegColumn(),
+  box: () => new BoxColumn(),
+  path: () => new PathColumn(),
+  polygon: () => new PolygonColumn(),
+  circle: () => new CircleColumn(),
+  cidr() {
+    return new CidrColumn();
+  },
+  inet: () => new InetColumn(),
+  macaddr: () => new MacAddrColumn(),
+  macaddr8: () => new MacAddr8Column(),
+  bit: () => new BitColumn(),
+  bitVarying: () => new BitVaryingColumn(),
+  tsvector: () => new TsVectorColumn(),
+  tsquery: () => new TsQueryColumn(),
+  uuid: () => new UUIDColumn(),
+  xml: () => new XMLColumn(),
+  json: (schemaOrFn) => new JSONColumn(schemaOrFn),
+  jsonText: () => new JSONTextColumn(),
+  array: (item) => new ArrayColumn(item)
+};
+
+class ColumnsObject extends ColumnType {
+  constructor(shape) {
+    super();
+    this.shape = shape;
+    this.dataType = "object";
+    this.operators = Operators.any;
+  }
+}
+class ArrayOfColumnsObjects extends ColumnType {
+  constructor(shape) {
+    super();
+    this.shape = shape;
+    this.dataType = "array";
+    this.operators = Operators.any;
+  }
+}
+class TableSchema {
+  constructor(shape) {
+    this.shape = shape;
+    this.primaryKeys = Object.entries(this.shape).filter(([, column]) => {
+      return column.isPrimaryKey;
+    }).map(([key]) => key);
+  }
+}
+
+const pushDistinctSql = (sql, values, distinct, quotedAs) => {
+  sql.push("DISTINCT");
+  if (distinct.length) {
+    const columns = [];
+    distinct == null ? void 0 : distinct.forEach((item) => {
+      columns.push(expressionToSql(item, values, quotedAs));
+    });
+    sql.push(`ON (${columns.join(", ")})`);
+  }
+};
+
+const pushOrderBySql = (sql, values, quotedAs, order) => {
+  sql.push(`ORDER BY ${order.map((item) => orderByToSql(item, values, quotedAs)).join(", ")}`);
+};
+const orderByToSql = (order, values, quotedAs) => {
+  if (typeof order === "string") {
+    return `${qc(order, quotedAs)} ASC`;
+  }
+  if (isRaw(order)) {
+    return getRaw(order, values);
+  }
+  const sql = [];
+  for (const key in order) {
+    const value = order[key];
+    if (typeof value === "string") {
+      sql.push(`${qc(key, quotedAs)} ${value}`);
+    } else if (value) {
+      sql.push(`${qc(key, quotedAs)} ${value.dir} NULLS ${value.nulls}`);
+    }
+  }
+  return sql.join(", ");
+};
+
+const windowToSql = (window, values, quotedAs) => {
+  if (typeof window === "object") {
+    if (isRaw(window)) {
+      return `(${getRaw(window, values)})`;
+    } else {
+      const sql = [];
+      if (window.partitionBy) {
+        sql.push(`PARTITION BY ${Array.isArray(window.partitionBy) ? window.partitionBy.map((partitionBy) => expressionToSql(partitionBy, values, quotedAs)).join(", ") : expressionToSql(window.partitionBy, values, quotedAs)}`);
+      }
+      if (window.order) {
+        sql.push(`ORDER BY ${orderByToSql(window.order, values, quotedAs)}`);
+      }
+      return `(${sql.join(" ")})`;
+    }
+  } else {
+    return q(window);
+  }
+};
+
+const processJoinItem = (model, query, values, args, quotedAs) => {
+  var _a;
+  const [first] = args;
+  if (typeof first === "string") {
+    if (first in model.relations) {
+      const { key, joinQuery: joinQuery2 } = model.relations[first];
+      const table = typeof joinQuery2.query.from === "string" ? joinQuery2.query.from : joinQuery2.table;
+      let target3 = quoteSchemaAndTable(joinQuery2.query.schema, table);
+      const as = joinQuery2.query.as || key;
+      if (as !== table) {
+        target3 += ` AS ${q(as)}`;
+      }
+      const queryData = {
+        and: [],
+        or: []
+      };
+      if (joinQuery2.query.and)
+        queryData.and.push(...joinQuery2.query.and);
+      if (joinQuery2.query.or)
+        queryData.or.push(...joinQuery2.query.or);
+      const arg = (_a = args[1]) == null ? void 0 : _a.call(args, new model.onQueryBuilder({ table: model.table, query }, args[0])).query;
+      if (arg) {
+        if (arg.and)
+          queryData.and.push(...arg.and);
+        if (arg.or)
+          queryData.or.push(...arg.or);
+      }
+      const joinAs2 = q(as);
+      const onConditions = whereToSql(joinQuery2, queryData, values, quotedAs, joinAs2);
+      const conditions3 = onConditions ? onConditions : void 0;
+      return { target: target3, conditions: conditions3 };
+    }
+    const target2 = q(first);
+    let conditions2;
+    if (args.length === 2) {
+      const arg = args[1];
+      if (typeof arg === "function") {
+        const joinQuery2 = arg(new model.onQueryBuilder({ table: model.table, query }, args[0]));
+        const onConditions = whereToSql(model, joinQuery2.query, values, quotedAs, target2);
+        if (onConditions)
+          conditions2 = onConditions;
+      } else {
+        conditions2 = getObjectOrRawConditions(arg, values, quotedAs, target2);
+      }
+    } else if (args.length >= 3) {
+      conditions2 = getConditionsFor3Or4LengthItem(target2, values, quotedAs, args);
+    }
+    return { target: target2, conditions: conditions2 };
+  }
+  const joinTarget = first;
+  const joinQuery = joinTarget.query;
+  const quotedFrom = typeof (joinQuery == null ? void 0 : joinQuery.from) === "string" ? q(joinQuery.from) : void 0;
+  let target = quotedFrom || quoteSchemaAndTable(joinQuery == null ? void 0 : joinQuery.schema, joinTarget.table);
+  let joinAs = quotedFrom || q(joinTarget.table);
+  if (joinQuery == null ? void 0 : joinQuery.as) {
+    const quoted = q(joinQuery.as);
+    if (quoted !== joinAs) {
+      joinAs = quoted;
+      target += ` AS ${quoted}`;
+    }
+  }
+  let conditions;
+  if (args.length === 2) {
+    const arg = args[1];
+    if (typeof arg === "function") {
+      const joinQuery2 = arg(new model.onQueryBuilder({ table: model.table, query }, args[0]));
+      const onConditions = whereToSql(model, joinQuery2.query, values, quotedAs, joinAs);
+      if (onConditions)
+        conditions = onConditions;
+    } else {
+      conditions = getObjectOrRawConditions(arg, values, quotedAs, joinAs);
+    }
+  } else if (args.length >= 3) {
+    conditions = getConditionsFor3Or4LengthItem(joinAs, values, quotedAs, args);
+  }
+  if (joinQuery) {
+    const whereSql = whereToSql(model, joinQuery, values, joinAs, quotedAs);
+    if (whereSql) {
+      if (conditions)
+        conditions += ` AND ${whereSql}`;
+      else
+        conditions = whereSql;
+    }
+  }
+  return { target, conditions };
+};
+const getConditionsFor3Or4LengthItem = (target, values, quotedAs, args) => {
+  const [, leftColumn, opOrRightColumn, maybeRightColumn] = args;
+  const op = maybeRightColumn ? opOrRightColumn : "=";
+  const rightColumn = maybeRightColumn ? maybeRightColumn : opOrRightColumn;
+  return `${typeof leftColumn === "string" ? quoteFullColumn(leftColumn, target) : getRaw(leftColumn, values)} ${op} ${typeof rightColumn === "string" ? quoteFullColumn(rightColumn, quotedAs) : getRaw(rightColumn, values)}`;
+};
+const getObjectOrRawConditions = (data, values, quotedAs, joinAs) => {
+  if (isRaw(data)) {
+    return getRaw(data, values);
+  } else {
+    const pairs = [];
+    for (const key in data) {
+      const value = data[key];
+      pairs.push(`${quoteFullColumn(key, joinAs)} = ${typeof value === "string" ? quoteFullColumn(value, quotedAs) : getRaw(value, values)}`);
+    }
+    return pairs.join(", ");
+  }
+};
+const pushJoinSql = (sql, model, query, values, quotedAs) => {
+  query.join.forEach((item) => {
+    const { target, conditions } = processJoinItem(model, query, values, item.args, quotedAs);
+    sql.push(item.type, target);
+    if (conditions)
+      sql.push("ON", conditions);
+  });
+};
+
+const pushWhereSql = (sql, model, query, values, quotedAs, otherTableQuotedAs) => {
+  const whereConditions = whereToSql(model, query, values, quotedAs, otherTableQuotedAs);
+  if (whereConditions) {
+    sql.push("WHERE", whereConditions);
+  }
+};
+const whereToSql = (model, query, values, quotedAs, otherTableQuotedAs, not) => {
+  const or = query.and && query.or ? [query.and, ...query.or] : query.and ? [query.and] : query.or;
+  if (!(or == null ? void 0 : or.length))
+    return "";
+  const ors = [];
+  or.forEach((and) => {
+    const ands = [];
+    and.forEach((data) => {
+      const prefix = not ? "NOT " : "";
+      if (typeof data === "function") {
+        const qb = data(new model.whereQueryBuilder(model.table, query.as));
+        const sql = whereToSql(model, {
+          as: query.as,
+          and: qb.query.and,
+          or: qb.query.or
+        }, values, quotedAs, otherTableQuotedAs, not);
+        if (sql)
+          ands.push(sql);
+        return;
+      }
+      if ("prototype" in data || "__model" in data) {
+        const query2 = data;
+        const sql = whereToSql(query2, query2.query || EMPTY_OBJECT, values, query2.table && q(query2.table));
+        if (sql) {
+          ands.push(`${prefix}(${sql})`);
+        }
+        return;
+      }
+      if (isRaw(data)) {
+        ands.push(`${prefix}(${getRaw(data, values)})`);
+        return;
+      }
+      for (const key in data) {
+        const value = data[key];
+        const handler = whereHandlers[key];
+        if (handler) {
+          handler(value, ands, prefix, model, query, values, quotedAs, otherTableQuotedAs, not);
+        } else if (typeof value === "object" && value !== null && value !== void 0) {
+          if (isRaw(value)) {
+            ands.push(`${prefix}${quoteFullColumn(key, quotedAs)} = ${getRaw(value, values)}`);
+          } else {
+            const column = model.shape[key];
+            if (!column) {
+              throw new Error(`Unknown column ${key} provided to condition`);
+            }
+            for (const op in value) {
+              const operator = column.operators[op];
+              if (!operator) {
+                throw new Error(`Unknown operator ${op} provided to condition`);
+              }
+              ands.push(`${prefix}${operator(qc(key, quotedAs), value[op], values)}`);
+            }
+          }
+        } else {
+          ands.push(`${prefix}${quoteFullColumn(key, quotedAs)} ${value === null ? "IS NULL" : `= ${addValue(values, value)}`}`);
+        }
+      }
+    });
+    ors.push(ands.join(" AND "));
+  });
+  return ors.join(" OR ");
+};
+const whereHandlers = {
+  AND(value, ands, _, model, _q, values, quotedAs, otherTableQuotedAs, not) {
+    const sql = whereToSql(model, {
+      and: toArray(value)
+    }, values, quotedAs, otherTableQuotedAs, not);
+    if (sql)
+      ands.push(sql);
+  },
+  OR(value, ands, _, model, _q, values, quotedAs, otherTableQuotedAs, not) {
+    const sql = whereToSql(model, {
+      or: value.map(toArray)
+    }, values, quotedAs, otherTableQuotedAs, not);
+    if (sql)
+      ands.push(sql);
+  },
+  NOT(value, ands, _, model, _q, values, quotedAs, otherTableQuotedAs, not) {
+    const sql = whereToSql(model, {
+      and: toArray(value)
+    }, values, quotedAs, otherTableQuotedAs, !not);
+    if (sql)
+      ands.push(sql);
+  },
+  ON(value, ands, prefix, _, _q, values, quotedAs, otherTableQuotedAs) {
+    if (Array.isArray(value)) {
+      const item = value;
+      const leftColumn = quoteFullColumn(item[0], quotedAs);
+      const leftPath = item[1];
+      const rightColumn = quoteFullColumn(item[2], otherTableQuotedAs);
+      const rightPath = item[3];
+      ands.push(`${prefix}jsonb_path_query_first(${leftColumn}, ${addValue(values, leftPath)}) = jsonb_path_query_first(${rightColumn}, ${addValue(values, rightPath)})`);
+    } else {
+      const item = value;
+      const leftColumn = quoteFullColumn(item.on[0], typeof item.joinTo === "string" ? q(item.joinTo) : q(getQueryAs(item.joinTo)));
+      const joinTo = typeof item.joinFrom === "string" ? item.joinFrom : q(getQueryAs(item.joinFrom));
+      const [op, rightColumn] = item.on.length === 2 ? ["=", quoteFullColumn(item.on[1], joinTo)] : [item.on[1], quoteFullColumn(item.on[2], joinTo)];
+      ands.push(`${prefix}${leftColumn} ${op} ${rightColumn}`);
+    }
+  },
+  IN(value, ands, prefix, _, _q, values, quotedAs) {
+    toArray(value).forEach((item) => {
+      pushIn(ands, prefix, quotedAs, values, item);
+    });
+  },
+  EXISTS(value, ands, prefix, model, query, values, quotedAs) {
+    const joinItems = Array.isArray(value[0]) ? value : [value];
+    joinItems.forEach((item) => {
+      const { target, conditions } = processJoinItem(model, query, values, item, quotedAs);
+      ands.push(`${prefix}EXISTS (SELECT 1 FROM ${target} WHERE ${conditions} LIMIT 1)`);
+    });
+  }
+};
+const pushIn = (ands, prefix, quotedAs, values, arg) => {
+  let value;
+  if (Array.isArray(arg.values)) {
+    value = `${arg.values.map((arr) => `(${arr.map((value2) => addValue(values, value2)).join(", ")})`).join(", ")}`;
+    if (arg.columns.length > 1)
+      value = `(${value})`;
+  } else if (isRaw(arg.values)) {
+    value = getRaw(arg.values, values);
+  } else {
+    const sql = arg.values.toSql(values);
+    value = `(${sql.text})`;
+  }
+  const columnsSql = arg.columns.map((column) => quoteFullColumn(column, quotedAs)).join(", ");
+  ands.push(`${prefix}${arg.columns.length > 1 ? `(${columnsSql})` : columnsSql} IN ${value}`);
+};
+
+const aggregateToSql = (model, values, item, quotedAs) => {
+  var _a;
+  const sql = [`${item.function}(`];
+  const options = item.options || EMPTY_OBJECT;
+  if (options.distinct && !options.withinGroup)
+    sql.push("DISTINCT ");
+  if (typeof item.arg === "object") {
+    if (Array.isArray(item.arg)) {
+      sql.push(`${expressionToSql(item.arg[0], values, quotedAs)}, ${addValue(values, item.arg[1])}`);
+    } else if (isRaw(item.arg)) {
+      sql.push(getRaw(item.arg, values));
+    } else {
+      const args = [];
+      for (const key in item.arg) {
+        args.push(`${addValue(values, key)}::text, ${expressionToSql(item.arg[key], values, quotedAs)}`);
+      }
+      sql.push(args.join(", "));
+    }
+  } else if (item.arg) {
+    sql.push(expressionToSql(item.arg, values, quotedAs));
+  }
+  if (options.withinGroup)
+    sql.push(") WITHIN GROUP (");
+  else if (options.order)
+    sql.push(" ");
+  if (options.order)
+    pushOrderBySql(sql, values, quotedAs, options.order);
+  sql.push(")");
+  if (options.filter || options.filterOr) {
+    const whereSql = whereToSql(model, {
+      and: options.filter ? [options.filter] : void 0,
+      or: (_a = options.filterOr) == null ? void 0 : _a.map((item2) => [item2])
+    }, values, quotedAs);
+    sql.push(` FILTER (WHERE ${whereSql})`);
+  }
+  if (options.over) {
+    sql.push(` OVER ${windowToSql(options.over, values, quotedAs)}`);
+  }
+  if (options.as)
+    sql.push(` AS ${q(options.as)}`);
+  return sql.join("");
+};
+
+const relationQueryKey = Symbol("relationQuery");
+const isRequiredRelationKey = Symbol("isRequiredRelation");
+
+const jsonColumnOrMethodToSql = (column, values, quotedAs) => {
+  return typeof column === "string" ? quoteFullColumn(column, quotedAs) : jsonToSql(column, values, quotedAs);
+};
+const jsonToSql = (item, values, quotedAs) => {
+  const json = item.__json;
+  if (json[0] === "pathQuery") {
+    const [, , , column, path, options] = json;
+    return `jsonb_path_query(${jsonColumnOrMethodToSql(column, values, quotedAs)}, ${addValue(values, path)}${(options == null ? void 0 : options.vars) ? `, ${addValue(values, options.vars)}` : ""}${(options == null ? void 0 : options.silent) ? ", true" : ""})`;
+  } else if (json[0] === "set") {
+    const [, , , column, path, value, options] = json;
+    return `jsonb_set(${jsonColumnOrMethodToSql(column, values, quotedAs)}, '{${path.join(", ")}}', ${addValue(values, JSON.stringify(value))}${(options == null ? void 0 : options.createIfMissing) ? ", true" : ""})`;
+  } else if (json[0] === "insert") {
+    const [, , , column, path, value, options] = json;
+    return `jsonb_insert(${jsonColumnOrMethodToSql(column, values, quotedAs)}, '{${path.join(", ")}}', ${addValue(values, JSON.stringify(value))}${(options == null ? void 0 : options.insertAfter) ? ", true" : ""})`;
+  } else if (json[0] === "remove") {
+    const [, , , column, path] = json;
+    return `${jsonColumnOrMethodToSql(column, values, quotedAs)} #- '{${path.join(", ")}}'`;
+  }
+  return "";
+};
+const pushSelectSql = (sql, model, query, values, quotedAs) => {
+  sql.push(selectToSql(model, query, values, quotedAs));
+};
+const selectToSql = (model, query, values, quotedAs) => {
+  var _a;
+  if (query.select) {
+    const list = [];
+    query.select.forEach((item) => {
+      var _a2, _b;
+      if (typeof item === "string") {
+        list.push(item === "*" ? ((_a2 = query.join) == null ? void 0 : _a2.length) ? `${quotedAs}.*` : "*" : quoteFullColumn(item, quotedAs));
+      } else if ((_b = item.query) == null ? void 0 : _b[relationQueryKey]) {
+        let relationQuery = item.clone();
+        const as = q(getQueryAs(relationQuery));
+        relationQuery._as(relationQuery.query[relationQueryKey]);
+        const { returnType } = relationQuery.query;
+        if (returnType === "all" || returnType === "one" || returnType === "oneOrThrow") {
+          relationQuery = relationQuery._json();
+        }
+        list.push(`(${relationQuery.toSql(values).text}) AS ${as}`);
+      } else {
+        if ("selectAs" in item) {
+          const obj = item.selectAs;
+          for (const as in obj) {
+            const value = obj[as];
+            if (typeof value === "object") {
+              if (isRaw(value)) {
+                list.push(`${getRaw(value, values)} AS ${q(as)}`);
+              } else {
+                const sql = value.json().toSql(values);
+                list.push(`(${sql.text}) AS ${q(as)}`);
+              }
+            } else {
+              list.push(`${quoteFullColumn(value, quotedAs)} AS ${q(as)}`);
+            }
+          }
+        } else if ("__json" in item) {
+          list.push(`${jsonToSql(item, values, quotedAs)} AS ${q(item.__json[1])}`);
+        } else if (isRaw(item)) {
+          list.push(getRaw(item, values));
+        } else if ("arguments" in item) {
+          list.push(`${item.function}(${selectToSql(model, { select: item.arguments }, values, quotedAs)})${item.as ? ` AS ${q(item.as)}` : ""}`);
+        } else {
+          list.push(aggregateToSql(model, values, item, quotedAs));
+        }
+      }
+    });
+    return list.join(", ");
+  } else {
+    return ((_a = query.join) == null ? void 0 : _a.length) ? `${quotedAs}.*` : "*";
+  }
+};
+
+const aggregateOptionNames = [
+  "distinct",
+  "order",
+  "filter",
+  "filterOr",
+  "withinGroup"
+];
+const pushHavingSql = (sql, model, query, values, quotedAs) => {
+  const conditions = havingToSql(model, query, values, quotedAs);
+  if (conditions.length)
+    sql.push("HAVING", conditions);
+};
+const havingToSql = (model, query, values, quotedAs) => {
+  const or = query.having && query.havingOr ? [query.having, ...query.havingOr] : query.having ? [query.having] : query.havingOr;
+  if (!(or == null ? void 0 : or.length))
+    return "";
+  const ors = [];
+  or.forEach((and) => {
+    const ands = [];
+    and.forEach((item) => {
+      if ("prototype" in item || "__model" in item) {
+        const query2 = item;
+        const sql = havingToSql(query2, query2.query, values, query2.table && q(query2.table));
+        if (sql.length)
+          ands.push(`(${sql})`);
+        return;
+      }
+      if (isRaw(item)) {
+        ands.push(getRaw(item, values));
+        return;
+      }
+      for (const key in item) {
+        const columns = item[key];
+        if (typeof columns === "object") {
+          for (const column in columns) {
+            const valueOrOptions = columns[column];
+            if (typeof valueOrOptions === "object" && valueOrOptions !== null && valueOrOptions !== void 0) {
+              for (const op in valueOrOptions) {
+                if (!aggregateOptionNames.includes(op)) {
+                  const operator = model.shape[column].operators[op];
+                  if (!operator) {
+                    throw new Error(`Unknown operator ${op} provided to condition`);
+                  }
+                  const expression = aggregateToSql(model, values, {
+                    function: key,
+                    arg: column,
+                    options: valueOrOptions
+                  }, quotedAs);
+                  ands.push(operator(expression, valueOrOptions[op], values));
+                }
+              }
+            } else {
+              ands.push(`${aggregateToSql(model, values, {
+                function: key,
+                arg: column,
+                options: EMPTY_OBJECT
+              }, quotedAs)} = ${addValue(values, valueOrOptions)}`);
+            }
+          }
+        } else {
+          ands.push(`${key}(*) = ${columns}`);
+        }
+      }
+    });
+    ors.push(ands.join(" AND "));
+  });
+  return ors.join(" OR ");
+};
+
+const pushWithSql = (sql, values, withData) => {
+  withData.forEach((withItem) => {
+    const [name, options, query] = withItem;
+    let inner;
+    if (isRaw(query)) {
+      inner = getRaw(query, values);
+    } else {
+      inner = query.toSql(values).text;
+    }
+    sql.push(`WITH ${options.recursive ? "RECURSIVE " : ""}${q(name)}${options.columns ? `(${options.columns.map(q).join(", ")})` : ""} AS ${options.materialized ? "MATERIALIZED " : options.notMaterialized ? "NOT MATERIALIZED " : ""}(${inner})`);
+  });
+};
+
+const queryKeysOfNotSimpleQuery = [
+  "take",
+  "with",
+  "as",
+  "from",
+  "and",
+  "or",
+  "select",
+  "distinct",
+  "fromOnly",
+  "join",
+  "group",
+  "having",
+  "havingOr",
+  "window",
+  "union",
+  "order",
+  "limit",
+  "offset",
+  "for"
+];
+
+const pushFromAndAs = (sql, model, query, values, quotedAs) => {
+  sql.push("FROM");
+  if (query.fromOnly)
+    sql.push("ONLY");
+  const from = getFrom(model, query, values);
+  sql.push(from);
+  if (query.as && quotedAs && quotedAs !== from) {
+    sql.push("AS", quotedAs);
+  }
+};
+const getFrom = (model, query, values) => {
+  if (query.from) {
+    if (typeof query.from === "object") {
+      if (isRaw(query.from)) {
+        return getRaw(query.from, values);
+      }
+      if (!query.from.table) {
+        const sql = query.from.toSql(values);
+        return `(${sql.text})`;
+      }
+      const q = query.from.query;
+      const keys = Object.keys(q);
+      if (keys.some((key) => queryKeysOfNotSimpleQuery.includes(key))) {
+        const sql = query.from.toSql(values);
+        return `(${sql.text})`;
+      }
+      return quoteSchemaAndTable(q.schema, query.from.table);
+    }
+    return quoteSchemaAndTable(query.schema, query.from);
+  }
+  return quoteSchemaAndTable(query.schema, model.table);
+};
+
+const pushInsertSql = (sql, values, model, query, quotedAs) => {
+  const quotedColumns = query.columns.map(q);
+  sql.push(`INSERT INTO ${quotedAs}(${quotedColumns.join(", ")}) VALUES ${isRaw(query.values) ? getRaw(query.values, values) : query.values.map((row) => `(${row.map((value) => value === void 0 ? "DEFAULT" : addValue(values, value)).join(", ")})`).join(", ")}`);
+  if (query.onConflict) {
+    sql.push("ON CONFLICT");
+    const { expr, type } = query.onConflict;
+    if (expr) {
+      if (typeof expr === "string") {
+        sql.push(`(${q(expr)})`);
+      } else if (Array.isArray(expr)) {
+        sql.push(`(${expr.map(q).join(", ")})`);
+      } else {
+        sql.push(getRaw(expr, values));
+      }
+    } else {
+      sql.push(`(${quotedColumns.join(", ")})`);
+    }
+    if (type === "ignore") {
+      sql.push("DO NOTHING");
+    } else if (type === "merge") {
+      let set;
+      const { update } = query.onConflict;
+      if (update) {
+        if (typeof update === "string") {
+          set = `${q(update)} = excluded.${q(update)}`;
+        } else if (Array.isArray(update)) {
+          set = update.map((column) => `${q(column)} = excluded.${q(column)}`).join(", ");
+        } else if (isRaw(update)) {
+          set = getRaw(update, values);
+        } else {
+          const arr = [];
+          for (const key in update) {
+            arr.push(`${q(key)} = ${addValue(values, update[key])}`);
+          }
+          set = arr.join(", ");
+        }
+      } else {
+        set = quotedColumns.map((column) => `${column} = excluded.${column}`).join(", ");
+      }
+      sql.push("DO UPDATE SET", set);
+    }
+  }
+  pushWhereSql(sql, model, query, values, quotedAs);
+  pushReturningSql(sql, model, query, values, quotedAs);
+};
+const pushReturningSql = (sql, model, query, values, quotedAs) => {
+  if (query.select) {
+    sql.push(`RETURNING ${selectToSql(model, query, values, quotedAs)}`);
+  }
+};
+
+const pushUpdateSql = (sql, values, model, query, quotedAs) => {
+  const quotedTable = quoteSchemaAndTable(query.schema, model.table);
+  sql.push(`UPDATE ${quotedTable}`);
+  if (query.as && quotedTable !== quotedAs) {
+    sql.push(`AS ${quotedAs}`);
+  }
+  sql.push("SET");
+  query.data.forEach((item) => {
+    if (isRaw(item)) {
+      sql.push(getRaw(item, values));
+    } else {
+      const set = [];
+      for (const key in item) {
+        const value = item[key];
+        if (value !== void 0) {
+          set.push(`${q(key)} = ${processValue(values, key, value)}`);
+        }
+      }
+      sql.push(set.join(", "));
+    }
+  });
+  pushWhereSql(sql, model, query, values, quotedAs);
+  pushReturningSql(sql, model, query, values, quotedAs);
+};
+const processValue = (values, key, value) => {
+  if (value && typeof value === "object") {
+    if (isRaw(value)) {
+      return getRaw(value, values);
+    } else if ("op" in value && "arg" in value) {
+      return `${q(key)} ${value.op} ${addValue(values, value.arg)}`;
+    }
+  }
+  return addValue(values, value);
+};
+
+const pushDeleteSql = (sql, values, model, query, quotedAs) => {
+  var _a, _b, _c;
+  sql.push(`DELETE FROM ${quotedAs}`);
+  let conditions;
+  if ((_a = query.join) == null ? void 0 : _a.length) {
+    const items = query.join.map((item) => processJoinItem(model, query, values, item.args, quotedAs));
+    sql.push(`USING ${items.map((item) => item.target).join(", ")}`);
+    conditions = items.map((item) => item.conditions).filter(Boolean).join(" AND ");
+  }
+  pushWhereSql(sql, model, query, values, quotedAs);
+  if (conditions == null ? void 0 : conditions.length) {
+    if (((_b = query.and) == null ? void 0 : _b.length) || ((_c = query.or) == null ? void 0 : _c.length)) {
+      sql.push("AND", conditions);
+    } else {
+      sql.push("WHERE", conditions);
+    }
+  }
+  pushReturningSql(sql, model, query, values, quotedAs);
+};
+
+const pushTruncateSql = (sql, table, query) => {
+  sql.push("TRUNCATE", quoteSchemaAndTable(query.schema, table));
+  if (query.restartIdentity)
+    sql.push("RESTART IDENTITY");
+  if (query.cascade)
+    sql.push("CASCADE");
+};
+
+const pushColumnInfoSql = (sql, values, table, query) => {
+  sql.push(`SELECT * FROM information_schema.columns WHERE table_name = ${addValue(values, table)} AND table_catalog = current_database() AND table_schema = ${query.schema || "current_schema()"}`);
+  if (query.column) {
+    sql.push(`AND column_name = ${addValue(values, query.column)}`);
+  }
+};
+
+const toSql = (model, values = []) => {
+  const query = model.query;
+  const sql = [];
+  if (query.with) {
+    pushWithSql(sql, values, query.with);
+  }
+  if (query.type) {
+    if (query.type === "truncate") {
+      if (!model.table)
+        throw new Error("Table is missing for truncate");
+      pushTruncateSql(sql, model.table, query);
+      return { text: sql.join(" "), values };
+    }
+    if (query.type === "columnInfo") {
+      if (!model.table)
+        throw new Error("Table is missing for truncate");
+      pushColumnInfoSql(sql, values, model.table, query);
+      return { text: sql.join(" "), values };
+    }
+    if (!model.table)
+      throw new Error(`Table is missing for ${query.type}`);
+    const quotedAs2 = q(query.as || model.table);
+    if (query.type === "insert") {
+      pushInsertSql(sql, values, model, query, q(model.table));
+      return { text: sql.join(" "), values };
+    }
+    if (query.type === "update") {
+      pushUpdateSql(sql, values, model, query, quotedAs2);
+      return { text: sql.join(" "), values };
+    }
+    if (query.type === "delete") {
+      pushDeleteSql(sql, values, model, query, q(model.table));
+      return { text: sql.join(" "), values };
+    }
+  }
+  const quotedAs = model.table && q(query.as || model.table);
+  sql.push("SELECT");
+  if (query.distinct) {
+    pushDistinctSql(sql, values, query.distinct, quotedAs);
+  }
+  pushSelectSql(sql, model, query, values, quotedAs);
+  if (model.table || query.from) {
+    pushFromAndAs(sql, model, query, values, quotedAs);
+  }
+  if (query.join) {
+    pushJoinSql(sql, model, query, values, quotedAs);
+  }
+  if (query.and || query.or) {
+    pushWhereSql(sql, model, query, values, quotedAs);
+  }
+  if (query.group) {
+    const group = query.group.map((item) => typeof item === "object" && isRaw(item) ? getRaw(item, values) : qc(item, quotedAs));
+    sql.push(`GROUP BY ${group.join(", ")}`);
+  }
+  if (query.having || query.havingOr) {
+    pushHavingSql(sql, model, query, values, quotedAs);
+  }
+  if (query.window) {
+    const window = [];
+    query.window.forEach((item) => {
+      for (const key in item) {
+        window.push(`${q(key)} AS ${windowToSql(item[key], values, quotedAs)}`);
+      }
+    });
+    sql.push(`WINDOW ${window.join(", ")}`);
+  }
+  if (query.union) {
+    query.union.forEach((item) => {
+      let itemSql;
+      if (isRaw(item.arg)) {
+        itemSql = getRaw(item.arg, values);
+      } else {
+        const argSql = item.arg.toSql(values);
+        itemSql = argSql.text;
+      }
+      sql.push(`${item.kind} ${item.wrap ? `(${itemSql})` : itemSql}`);
+    });
+  }
+  if (query.order) {
+    pushOrderBySql(sql, values, quotedAs, query.order);
+  }
+  if (query.take || query.limit !== void 0) {
+    sql.push(`LIMIT ${addValue(values, query.take ? 1 : query.limit)}`);
+  }
+  if (query.offset) {
+    sql.push(`OFFSET ${addValue(values, query.offset)}`);
+  }
+  if (query.for) {
+    sql.push("FOR", query.for.type);
+    const { tableNames } = query.for;
+    if (tableNames) {
+      if (isRaw(tableNames)) {
+        sql.push("OF", getRaw(tableNames, values));
+      } else {
+        sql.push("OF", tableNames.map(q).join(", "));
+      }
+    }
+    if (query.for.mode)
+      sql.push(query.for.mode);
+  }
+  return { text: sql.join(" "), values };
+};
+
+var __getOwnPropSymbols$6 = Object.getOwnPropertySymbols;
+var __hasOwnProp$6 = Object.prototype.hasOwnProperty;
+var __propIsEnum$6 = Object.prototype.propertyIsEnumerable;
+var __objRest$1 = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp$6.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols$6)
+    for (var prop of __getOwnPropSymbols$6(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum$6.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+const defaultTypeParsers = {};
+for (const key in types.builtins) {
+  const id = types.builtins[key];
+  defaultTypeParsers[id] = types.getTypeParser(id);
+}
+[
+  types.builtins.DATE,
+  types.builtins.TIMESTAMP,
+  types.builtins.TIMESTAMPTZ,
+  types.builtins.TIME
+].forEach((id) => {
+  delete defaultTypeParsers[id];
+});
+const returnArg = (arg) => arg;
+class Adapter {
+  constructor(_a) {
+    var _b = _a, { types: types2 = defaultTypeParsers } = _b, config = __objRest$1(_b, ["types"]);
+    this.types = types2;
+    this.pool = new Pool(config);
+  }
+  async query(query, types2 = this.types) {
+    const client = await this.pool.connect();
+    try {
+      return await performQuery(client, query, types2);
+    } finally {
+      client.release();
+    }
+  }
+  async arrays(query, types2 = this.types) {
+    const client = await this.pool.connect();
+    try {
+      return await performQueryArrays(client, query, types2);
+    } finally {
+      client.release();
+    }
+  }
+  async transaction(cb) {
+    const client = await this.pool.connect();
+    try {
+      await performQuery(client, { text: "BEGIN" }, this.types);
+      const result = await cb(new TransactionAdapter(this.pool, client, this.types));
+      await performQuery(client, { text: "COMMIT" }, this.types);
+      return result;
+    } catch (err) {
+      await performQuery(client, { text: "ROLLBACK" }, this.types);
+      throw err;
+    } finally {
+      client.release();
+    }
+  }
+  destroy() {
+    return this.pool.end();
+  }
+}
+const performQuery = (client, query, types2) => {
+  return client.query({
+    text: typeof query === "string" ? query : query.text,
+    values: typeof query === "string" ? void 0 : query.values,
+    types: types2 && {
+      getTypeParser(id) {
+        return types2[id] || returnArg;
+      }
+    }
+  });
+};
+const performQueryArrays = (client, query, types2) => {
+  return client.query({
+    text: typeof query === "string" ? query : query.text,
+    values: typeof query === "string" ? void 0 : query.values,
+    rowMode: "array",
+    types: types2 && {
+      getTypeParser(id) {
+        return types2[id] || returnArg;
+      }
+    }
+  });
+};
+class TransactionAdapter {
+  constructor(pool, client, types2) {
+    this.pool = pool;
+    this.client = client;
+    this.types = types2;
+  }
+  async query(query, types2 = this.types) {
+    return await performQuery(this.client, query, types2);
+  }
+  async arrays(query, types2 = this.types) {
+    return await performQueryArrays(this.client, query, types2);
+  }
+  async transaction(cb) {
+    return await cb(this);
+  }
+  destroy() {
+    return this.pool.end();
+  }
+}
+
+const removeFromQuery = (q, key) => {
+  if (q.query)
+    delete q.query[key];
+  return q;
+};
+const pushQueryArray = (q, key, value) => {
+  if (!q.query[key])
+    q.query[key] = value;
+  else
+    q.query[key].push(...value);
+  return q;
+};
+const pushQueryValue = (q, key, value) => {
+  if (!q.query[key])
+    q.query[key] = [value];
+  else
+    q.query[key].push(value);
+  return q;
+};
+const setQueryObjectValue = (q, object, key, value) => {
+  if (!q.query[object])
+    q.query[object] = {
+      [key]: value
+    };
+  else
+    q.query[object][key] = value;
+  return q;
+};
+
+class NotFoundError extends Error {
+  constructor(message = "Record is not found") {
+    super(message);
+  }
+}
+class MoreThanOneRowError extends Error {
+}
+
+const queryMethodByReturnType = {
+  all: "query",
+  one: "query",
+  oneOrThrow: "query",
+  rows: "arrays",
+  pluck: "arrays",
+  value: "arrays",
+  valueOrThrow: "arrays",
+  rowCount: "arrays",
+  void: "arrays"
+};
+class Then {
+  then(resolve, reject) {
+    if (this.query.wrapInTransaction && !this.query.inTransaction) {
+      return this.transaction((q) => then(q, resolve, reject));
+    } else {
+      return then(this, resolve, reject);
+    }
+  }
+}
+const handleResult = async (q, result) => {
+  return parseResult(q, q.query.returnType, result);
+};
+const then = async (q, resolve, reject) => {
+  var _a, _b, _c, _d;
+  let sql;
+  let logData;
+  try {
+    let beforeCallbacks;
+    let afterCallbacks;
+    if (q.query.type === "insert") {
+      beforeCallbacks = q.query.beforeInsert;
+      afterCallbacks = q.query.afterInsert;
+    } else if (q.query.type === "update") {
+      beforeCallbacks = q.query.beforeUpdate;
+      afterCallbacks = q.query.afterUpdate;
+    }
+    if (beforeCallbacks) {
+      await Promise.all(beforeCallbacks.map((cb) => cb(q)));
+    }
+    if (q.query.beforeQuery) {
+      await Promise.all(q.query.beforeQuery.map((cb) => cb(q)));
+    }
+    sql = q.toSql();
+    if (q.query.log) {
+      logData = (_a = q.query.log) == null ? void 0 : _a.beforeQuery(q, sql);
+    }
+    const queryResult = await q.query.adapter[queryMethodByReturnType[q.query.returnType]](sql);
+    if (q.query.log) {
+      (_b = q.query.log) == null ? void 0 : _b.afterQuery(q, sql, logData);
+      sql = void 0;
+    }
+    const result = await q.query.handleResult(q, queryResult);
+    if ((afterCallbacks == null ? void 0 : afterCallbacks.length) || ((_c = q.query.afterQuery) == null ? void 0 : _c.length)) {
+      if ((_d = q.query.afterQuery) == null ? void 0 : _d.length) {
+        await Promise.all(q.query.afterQuery.map((query) => query(q, result)));
+      }
+      if (afterCallbacks == null ? void 0 : afterCallbacks.length) {
+        await Promise.all(afterCallbacks.map((query) => query(q, result)));
+      }
+    }
+    resolve == null ? void 0 : resolve(result);
+  } catch (error) {
+    if (q.query.log && sql && logData) {
+      q.query.log.onError(error, q, sql, logData);
+    }
+    reject == null ? void 0 : reject(error);
+  }
+};
+const parseResult = (q, returnType, result) => {
+  var _a, _b;
+  switch (returnType) {
+    case "all": {
+      if (q.query.throwOnNotFound && result.rows.length === 0)
+        throw new NotFoundError();
+      const parsers = getQueryParsers(q);
+      return parsers ? result.rows.map((row) => parseRecord(parsers, row)) : result.rows;
+    }
+    case "one": {
+      const row = result.rows[0];
+      if (!row)
+        return;
+      const parsers = getQueryParsers(q);
+      return parsers ? parseRecord(parsers, row) : row;
+    }
+    case "oneOrThrow": {
+      const row = result.rows[0];
+      if (!row)
+        throw new NotFoundError();
+      const parsers = getQueryParsers(q);
+      return parsers ? parseRecord(parsers, row) : row;
+    }
+    case "rows": {
+      const parsers = getQueryParsers(q);
+      return parsers ? parseRows(parsers, result.fields, result.rows) : result.rows;
+    }
+    case "pluck": {
+      const parsers = getQueryParsers(q);
+      if (parsers == null ? void 0 : parsers.pluck) {
+        return result.rows.map((row) => parsers.pluck(row[0]));
+      }
+      return result.rows.map((row) => row[0]);
+    }
+    case "value": {
+      const value = (_a = result.rows[0]) == null ? void 0 : _a[0];
+      return value !== void 0 ? parseValue(value, result.fields, q) : void 0;
+    }
+    case "valueOrThrow": {
+      const value = (_b = result.rows[0]) == null ? void 0 : _b[0];
+      if (value === void 0)
+        throw new NotFoundError();
+      return parseValue(value, result.fields, q);
+    }
+    case "rowCount": {
+      if (q.query.throwOnNotFound && result.rowCount === 0) {
+        throw new NotFoundError();
+      }
+      return result.rowCount;
+    }
+    case "void": {
+      return;
+    }
+  }
+};
+const parseRecord = (parsers, row) => {
+  for (const key in parsers) {
+    if (row[key] !== null && row[key] !== void 0) {
+      row[key] = parsers[key](row[key]);
+    }
+  }
+  return row;
+};
+const parseRows = (parsers, fields, rows) => {
+  fields.forEach((field, i) => {
+    const parser = parsers[field.name];
+    if (parser) {
+      rows.forEach((row) => {
+        row[i] = parser(row[i]);
+      });
+    }
+  });
+  return rows;
+};
+const parseValue = (value, fields, query) => {
+  const field = fields[0];
+  if (value !== null) {
+    const parsers = getQueryParsers(query);
+    const parser = parsers == null ? void 0 : parsers[field.name];
+    if (parser) {
+      return parser(value);
+    }
+  }
+  return value;
+};
+
+const addParserForRawExpression = (q, key, raw) => {
+  var _a;
+  const parser = (_a = raw.__column) == null ? void 0 : _a.parseFn;
+  if (parser)
+    addParserToQuery(q.query, key, parser);
+};
+const addParserForSelectItem = (q, as, key, item) => {
+  var _a, _b, _c, _d;
+  if (typeof item === "object") {
+    if (isRaw(item)) {
+      addParserForRawExpression(q, key, item);
+    } else {
+      const parsers = getQueryParsers(item);
+      if (parsers) {
+        if (item.query.take) {
+          addParserToQuery(q.query, key, (item2) => parseRecord(parsers, item2));
+        } else {
+          addParserToQuery(q.query, key, (items) => items.map((item2) => parseRecord(parsers, item2)));
+        }
+      }
+    }
+  } else {
+    const index = item.indexOf(".");
+    if (index !== -1) {
+      const table = item.slice(0, index);
+      const column = item.slice(index + 1);
+      if (table === as) {
+        const parser = (_a = q.columnsParsers) == null ? void 0 : _a[column];
+        if (parser)
+          addParserToQuery(q.query, key, parser);
+      } else {
+        const parser = (_c = (_b = q.query.joinedParsers) == null ? void 0 : _b[table]) == null ? void 0 : _c[column];
+        if (parser)
+          addParserToQuery(q.query, key, parser);
+      }
+    } else {
+      const parser = (_d = q.columnsParsers) == null ? void 0 : _d[item];
+      if (parser)
+        addParserToQuery(q.query, key, parser);
+    }
+  }
+};
+const addParserToQuery = (query, key, parser) => {
+  if (query.parsers)
+    query.parsers[key] = parser;
+  else
+    query.parsers = { [key]: parser };
+};
+const processSelectArg = (q, as, item) => {
+  var _a, _b, _c, _d, _e;
+  if (typeof item === "string") {
+    if (q.relations[item]) {
+      item = q[item];
+    } else {
+      const index = item.indexOf(".");
+      if (index !== -1) {
+        const table = item.slice(0, index);
+        const column = item.slice(index + 1);
+        if (table === as) {
+          const parser = (_a = q.columnsParsers) == null ? void 0 : _a[column];
+          if (parser)
+            addParserToQuery(q.query, column, parser);
+        } else {
+          const parser = (_c = (_b = q.query.joinedParsers) == null ? void 0 : _b[table]) == null ? void 0 : _c[column];
+          if (parser)
+            addParserToQuery(q.query, column, parser);
+        }
+      } else {
+        const parser = (_d = q.columnsParsers) == null ? void 0 : _d[item];
+        if (parser)
+          addParserToQuery(q.query, item, parser);
+      }
+      return item;
+    }
+  }
+  if ((_e = item.query) == null ? void 0 : _e[relationQueryKey]) {
+    const relation = item;
+    const parsers = relation.query.parsers || relation.columnsParsers;
+    if (parsers) {
+      addParserToQuery(q.query, getQueryAs(relation), (input) => {
+        if (Array.isArray(input)) {
+          input.forEach((record) => {
+            for (const key in parsers) {
+              const value = record[key];
+              if (value !== null) {
+                record[key] = parsers[key](value);
+              }
+            }
+          });
+        } else {
+          for (const key in parsers) {
+            const value = input[key];
+            if (value !== null) {
+              input[key] = parsers[key](value);
+            }
+          }
+        }
+        return input;
+      });
+    }
+  } else {
+    for (const key in item) {
+      addParserForSelectItem(q, as, key, item[key]);
+    }
+    return { selectAs: item };
+  }
+  return item;
+};
+class Select {
+  select(...args) {
+    return this.clone()._select(...args);
+  }
+  _select(...args) {
+    if (!args.length) {
+      return this;
+    }
+    const as = this.query.as || this.table;
+    const selectArgs = args.map((item) => processSelectArg(this, as, item));
+    return pushQueryArray(this, "select", selectArgs);
+  }
+  selectAll() {
+    return this.clone()._selectAll();
+  }
+  _selectAll() {
+    this.query.select = ["*"];
+    return this;
+  }
+}
+
+var __defProp$5 = Object.defineProperty;
+var __defProps$1 = Object.defineProperties;
+var __getOwnPropDescs$1 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$5 = Object.getOwnPropertySymbols;
+var __hasOwnProp$5 = Object.prototype.hasOwnProperty;
+var __propIsEnum$5 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$5 = (obj, key, value) => key in obj ? __defProp$5(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$5 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$5.call(b, prop))
+      __defNormalProp$5(a, prop, b[prop]);
+  if (__getOwnPropSymbols$5)
+    for (var prop of __getOwnPropSymbols$5(b)) {
+      if (__propIsEnum$5.call(b, prop))
+        __defNormalProp$5(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$1 = (a, b) => __defProps$1(a, __getOwnPropDescs$1(b));
+const allColumns = raw("*");
+const aggregate1FunctionNames = {
+  count: "count",
+  avg: "avg",
+  min: "min",
+  max: "max",
+  sum: "sum",
+  bitAnd: "bit_and",
+  bitOr: "bit_or",
+  boolAnd: "bool_and",
+  boolOr: "bool_or",
+  every: "every",
+  jsonAgg: "json_agg",
+  jsonbAgg: "jsonb_agg",
+  xmlAgg: "xmlagg"
+};
+const buildAggregateSelectItem = (functionName, arg, options) => {
+  return {
+    function: functionName,
+    arg,
+    options: __spreadProps$1(__spreadValues$5({}, options), {
+      order: (options == null ? void 0 : options.order) ? Array.isArray(options.order) ? options.order : [options.order] : void 0,
+      filter: options == null ? void 0 : options.filter,
+      filterOr: options == null ? void 0 : options.filterOr
+    })
+  };
+};
+const parseIntColumn = new IntegerColumn().parse((input) => parseInt(input));
+const parseIntOrNullColumn = new IntegerColumn().parse((input) => input === null ? null : parseInt(input));
+const get = (q) => {
+  q.query.returnType = "valueOrThrow";
+  removeFromQuery(q, "take");
+  const select = q.query.select;
+  if (select.length > 1) {
+    select[0] = select[select.length - 1];
+    select.length = 1;
+  }
+  return q;
+};
+class Aggregate {
+  selectAgg(functionName, arg, options) {
+    return this.clone()._selectAgg(functionName, arg, options);
+  }
+  _selectAgg(functionName, arg, options, columnType) {
+    pushQueryValue(this, "select", buildAggregateSelectItem(functionName, arg, options));
+    if (columnType == null ? void 0 : columnType.parseFn) {
+      addParserToQuery(this.query, (options == null ? void 0 : options.as) || functionName, columnType.parseFn);
+    }
+    return this;
+  }
+  count(arg, options) {
+    return this.clone()._count(arg, options);
+  }
+  _count(arg = "*", options) {
+    return get(this._selectCount(arg, options));
+  }
+  selectCount(arg, options) {
+    return this.clone()._selectCount(arg, options);
+  }
+  _selectCount(arg = "*", options) {
+    return this._selectAgg(aggregate1FunctionNames.count, arg === "*" ? allColumns : arg, options, parseIntColumn);
+  }
+  avg(arg, options) {
+    return this.clone()._avg(arg, options);
+  }
+  _avg(arg, options) {
+    return get(this._selectAvg(arg, options));
+  }
+  selectAvg(arg, options) {
+    return this.clone()._selectAvg(arg, options);
+  }
+  _selectAvg(arg, options) {
+    return this._selectAgg(aggregate1FunctionNames.avg, arg, options, parseIntOrNullColumn);
+  }
+  min(arg, options) {
+    return this.clone()._min(arg, options);
+  }
+  _min(arg, options) {
+    return get(this._selectMin(arg, options));
+  }
+  selectMin(arg, options) {
+    return this.clone()._selectMin(arg, options);
+  }
+  _selectMin(arg, options) {
+    return this._selectAgg(aggregate1FunctionNames.min, arg, options, parseIntOrNullColumn);
+  }
+  max(arg, options) {
+    return this.clone()._max(arg, options);
+  }
+  _max(arg, options) {
+    return get(this._selectMax(arg, options));
+  }
+  selectMax(arg, options) {
+    return this.clone()._selectMax(arg, options);
+  }
+  _selectMax(arg, options) {
+    return this._selectAgg(aggregate1FunctionNames.max, arg, options, parseIntOrNullColumn);
+  }
+  sum(arg, options) {
+    return this.clone()._sum(arg, options);
+  }
+  _sum(arg, options) {
+    return get(this._selectSum(arg, options));
+  }
+  selectSum(arg, options) {
+    return this.clone()._selectSum(arg, options);
+  }
+  _selectSum(arg, options) {
+    return this._selectAgg(aggregate1FunctionNames.sum, arg, options, parseIntOrNullColumn);
+  }
+  bitAnd(arg, options) {
+    return this.clone()._bitAnd(arg, options);
+  }
+  _bitAnd(arg, options) {
+    return get(this._selectBitAnd(arg, options));
+  }
+  selectBitAnd(arg, options) {
+    return this.clone()._selectBitAnd(arg, options);
+  }
+  _selectBitAnd(arg, options) {
+    return this._selectAgg(aggregate1FunctionNames.bitAnd, arg, options);
+  }
+  bitOr(arg, options) {
+    return this.clone()._bitOr(arg, options);
+  }
+  _bitOr(arg, options) {
+    return get(this._selectBitOr(arg, options));
+  }
+  selectBitOr(arg, options) {
+    return this.clone()._selectBitOr(arg, options);
+  }
+  _selectBitOr(arg, options) {
+    return this._selectAgg(aggregate1FunctionNames.bitOr, arg, options);
+  }
+  boolAnd(arg, options) {
+    return this.clone()._boolAnd(arg, options);
+  }
+  _boolAnd(arg, options) {
+    return get(this._selectBoolAnd(arg, options));
+  }
+  selectBoolAnd(arg, options) {
+    return this.clone()._selectBoolAnd(arg, options);
+  }
+  _selectBoolAnd(arg, options) {
+    return this._selectAgg(aggregate1FunctionNames.boolAnd, arg, options);
+  }
+  boolOr(arg, options) {
+    return this.clone()._boolOr(arg, options);
+  }
+  _boolOr(arg, options) {
+    return get(this._selectBoolOr(arg, options));
+  }
+  selectBoolOr(arg, options) {
+    return this.clone()._selectBoolOr(arg, options);
+  }
+  _selectBoolOr(arg, options) {
+    return this._selectAgg(aggregate1FunctionNames.boolOr, arg, options);
+  }
+  every(arg, options) {
+    return this.clone()._every(arg, options);
+  }
+  _every(arg, options) {
+    return get(this._selectEvery(arg, options));
+  }
+  selectEvery(arg, options) {
+    return this.clone()._selectEvery(arg, options);
+  }
+  _selectEvery(arg, options) {
+    return this._selectAgg(aggregate1FunctionNames.every, arg, options);
+  }
+  jsonAgg(arg, options) {
+    return this.clone()._jsonAgg(arg, options);
+  }
+  _jsonAgg(arg, options) {
+    return get(this._selectJsonAgg(arg, options));
+  }
+  selectJsonAgg(arg, options) {
+    return this.clone()._selectJsonAgg(arg, options);
+  }
+  _selectJsonAgg(arg, options) {
+    return this._selectAgg(aggregate1FunctionNames.jsonAgg, arg, options);
+  }
+  jsonbAgg(arg, options) {
+    return this.clone()._jsonbAgg(arg, options);
+  }
+  _jsonbAgg(arg, options) {
+    return get(this._selectJsonbAgg(arg, options));
+  }
+  selectJsonbAgg(arg, options) {
+    return this.clone()._selectJsonbAgg(arg, options);
+  }
+  _selectJsonbAgg(arg, options) {
+    return this._selectAgg(aggregate1FunctionNames.jsonbAgg, arg, options);
+  }
+  xmlAgg(arg, options) {
+    return this.clone()._xmlAgg(arg, options);
+  }
+  _xmlAgg(arg, options) {
+    return get(this._selectXmlAgg(arg, options));
+  }
+  selectXmlAgg(arg, options) {
+    return this.clone()._selectXmlAgg(arg, options);
+  }
+  _selectXmlAgg(arg, options) {
+    return this._selectAgg(aggregate1FunctionNames.xmlAgg, arg, options);
+  }
+  jsonObjectAgg(obj, options) {
+    return this.clone()._jsonObjectAgg(obj, options);
+  }
+  _jsonObjectAgg(obj, options) {
+    return get(this._selectJsonObjectAgg(obj, options));
+  }
+  selectJsonObjectAgg(obj, options) {
+    return this.clone()._selectJsonObjectAgg(obj, options);
+  }
+  _selectJsonObjectAgg(obj, options) {
+    return this._selectAgg("json_object_agg", obj, options);
+  }
+  jsonbObjectAgg(obj, options) {
+    return this.clone()._jsonbObjectAgg(obj, options);
+  }
+  _jsonbObjectAgg(obj, options) {
+    return get(this._selectJsonbObjectAgg(obj, options));
+  }
+  selectJsonbObjectAgg(obj, options) {
+    return this.clone()._selectJsonbObjectAgg(obj, options);
+  }
+  _selectJsonbObjectAgg(obj, options) {
+    return this._selectAgg("jsonb_object_agg", obj, options);
+  }
+  stringAgg(arg, delimiter, options) {
+    return this.clone()._stringAgg(arg, delimiter, options);
+  }
+  _stringAgg(arg, delimiter, options) {
+    return get(this._selectStringAgg(arg, delimiter, options));
+  }
+  selectStringAgg(arg, delimiter, options) {
+    return this.clone()._selectStringAgg(arg, delimiter, options);
+  }
+  _selectStringAgg(arg, delimiter, options) {
+    return this._selectAgg("string_agg", [arg, delimiter], options);
+  }
+}
+
+class From {
+  from(...args) {
+    return this.clone()._from(...args);
+  }
+  _from(...args) {
+    let as;
+    if (typeof args[1] === "string") {
+      as = args[1];
+    } else if (typeof args[1] === "object" && args[1].as) {
+      as = args[1].as;
+    } else if (typeof args[0] === "string") {
+      if (!this.query.as)
+        as = args[0];
+    } else if (!isRaw(args[0])) {
+      as = args[0].query.as || args[0].table;
+    }
+    if (typeof args[1] === "object" && "only" in args[1]) {
+      this.query.fromOnly = args[1].only;
+    }
+    const q = as ? this._as(as) : this;
+    q.query.from = args[0];
+    return q;
+  }
+}
+
+const addWhere = (q, args) => {
+  return pushQueryArray(q, "and", args);
+};
+const addWhereNot = (q, args) => {
+  return pushQueryValue(q, "and", {
+    NOT: args
+  });
+};
+const addOr = (q, args) => {
+  return pushQueryArray(q, "or", args.map((item) => [item]));
+};
+const addOrNot = (q, args) => {
+  return pushQueryArray(q, "or", args.map((item) => [{ NOT: item }]));
+};
+const addWhereIn = (q, and, arg, values, not) => {
+  const op = not ? "notIn" : "in";
+  let item;
+  if (values) {
+    if (Array.isArray(arg)) {
+      item = {
+        IN: {
+          columns: arg,
+          values
+        }
+      };
+      if (not)
+        item = { NOT: item };
+    } else {
+      item = { [arg]: { [op]: values } };
+    }
+  } else {
+    item = {};
+    for (const key in arg) {
+      item[key] = { [op]: arg[key] };
+    }
+  }
+  if (and) {
+    pushQueryValue(q, "and", item);
+  } else {
+    pushQueryValue(q, "or", [item]);
+  }
+  return q;
+};
+class Where {
+  constructor() {
+    this.query = {};
+  }
+  where(...args) {
+    return this.clone()._where(...args);
+  }
+  _where(...args) {
+    return addWhere(this, args);
+  }
+  whereNot(...args) {
+    return this.clone()._whereNot(...args);
+  }
+  _whereNot(...args) {
+    return addWhereNot(this, args);
+  }
+  and(...args) {
+    return this.where(...args);
+  }
+  _and(...args) {
+    return this._where(...args);
+  }
+  andNot(...args) {
+    return this.whereNot(...args);
+  }
+  _andNot(...args) {
+    return this._whereNot(...args);
+  }
+  or(...args) {
+    return this.clone()._or(...args);
+  }
+  _or(...args) {
+    return addOr(this, args);
+  }
+  orNot(...args) {
+    return this.clone()._orNot(...args);
+  }
+  _orNot(...args) {
+    return addOrNot(this, args);
+  }
+  whereIn(arg, values) {
+    return this.clone()._whereIn(arg, values);
+  }
+  _whereIn(arg, values) {
+    return addWhereIn(this, true, arg, values);
+  }
+  orWhereIn(arg, values) {
+    return this.clone()._orWhereIn(arg, values);
+  }
+  _orWhereIn(arg, values) {
+    return addWhereIn(this, false, arg, values);
+  }
+  whereNotIn(arg, values) {
+    return this.clone()._whereNotIn(arg, values);
+  }
+  _whereNotIn(arg, values) {
+    return addWhereIn(this, true, arg, values, true);
+  }
+  orWhereNotIn(arg, values) {
+    return this.clone()._orWhereNotIn(arg, values);
+  }
+  _orWhereNotIn(arg, values) {
+    return addWhereIn(this, false, arg, values, true);
+  }
+  whereExists(...args) {
+    return this.clone()._whereExists(...args);
+  }
+  _whereExists(...args) {
+    return this._where({ EXISTS: args });
+  }
+  orWhereExists(...args) {
+    return this.clone()._orWhereExists(...args);
+  }
+  _orWhereExists(...args) {
+    return this._or({ EXISTS: args });
+  }
+  whereNotExists(...args) {
+    return this.clone()._whereNotExists(...args);
+  }
+  _whereNotExists(...args) {
+    return this._whereNot({ EXISTS: args });
+  }
+  orWhereNotExists(...args) {
+    return this.clone()._orWhereNotExists(...args);
+  }
+  _orWhereNotExists(...args) {
+    return this._orNot({ EXISTS: args });
+  }
+}
+class WhereQueryBuilder extends Where {
+  constructor(table, tableAlias) {
+    super();
+    this.table = table;
+    this.tableAlias = tableAlias;
+    this.query = {};
+    this.relations = {};
+    this.withData = {};
+    this.__model = this;
+  }
+  clone() {
+    const cloned = Object.create(this.__model);
+    cloned.query = getClonedQueryData(this.query);
+    return cloned;
+  }
+}
+
+const join = (q, type, args) => {
+  return _join(q.clone(), type, args);
+};
+const _join = (q, type, args) => {
+  var _a;
+  const first = args[0];
+  let joinKey;
+  let parsers;
+  if (typeof first === "object") {
+    const as = first.tableAlias || first.table;
+    if (as) {
+      joinKey = as;
+      parsers = first.query.parsers || first.columnsParsers;
+    }
+  } else {
+    joinKey = first;
+    const relation = q.relations[joinKey];
+    if (relation) {
+      parsers = relation.model.query.parsers || relation.model.columnsParsers;
+    } else {
+      const shape = (_a = q.query.withShapes) == null ? void 0 : _a[first];
+      if (shape) {
+        parsers = {};
+        for (const key in shape) {
+          const parser = shape[key].parseFn;
+          if (parser) {
+            parsers[key] = parser;
+          }
+        }
+      }
+    }
+  }
+  if (joinKey && parsers) {
+    setQueryObjectValue(q, "joinedParsers", joinKey, parsers);
+  }
+  return pushQueryValue(q, "join", {
+    type,
+    args
+  });
+};
+class Join {
+  join(...args) {
+    return join(this, "JOIN", args);
+  }
+  _join(...args) {
+    return _join(this, "JOIN", args);
+  }
+  innerJoin(...args) {
+    return join(this, "INNER JOIN", args);
+  }
+  _innerJoin(...args) {
+    return _join(this, "INNER JOIN", args);
+  }
+  leftJoin(...args) {
+    return join(this, "LEFT JOIN", args);
+  }
+  _leftJoin(...args) {
+    return _join(this, "LEFT JOIN", args);
+  }
+  leftOuterJoin(...args) {
+    return join(this, "LEFT OUTER JOIN", args);
+  }
+  _leftOuterJoin(...args) {
+    return _join(this, "LEFT OUTER JOIN", args);
+  }
+  rightJoin(...args) {
+    return join(this, "RIGHT JOIN", args);
+  }
+  _rightJoin(...args) {
+    return _join(this, "RIGHT JOIN", args);
+  }
+  rightOuterJoin(...args) {
+    return join(this, "RIGHT OUTER JOIN", args);
+  }
+  _rightOuterJoin(...args) {
+    return _join(this, "RIGHT OUTER JOIN", args);
+  }
+  fullOuterJoin(...args) {
+    return join(this, "FULL OUTER JOIN", args);
+  }
+  _fullOuterJoin(...args) {
+    return _join(this, "FULL OUTER JOIN", args);
+  }
+}
+const makeOnItem = (joinTo, joinFrom, args) => {
+  return {
+    ON: {
+      joinTo,
+      joinFrom,
+      on: args
+    }
+  };
+};
+const pushQueryOn = (q, joinFrom, joinTo, ...on) => {
+  return pushQueryValue(q, "and", makeOnItem(joinFrom, joinTo, on));
+};
+const pushQueryOrOn = (q, joinFrom, joinTo, ...on) => {
+  return pushQueryValue(q, "or", [makeOnItem(joinFrom, joinTo, on)]);
+};
+const addQueryOn = (q, joinFrom, joinTo, ...args) => {
+  return pushQueryOn(q.clone(), joinFrom, joinTo, ...args);
+};
+const addQueryOrOn = (q, joinFrom, joinTo, ...args) => {
+  return pushQueryOrOn(q.clone(), joinFrom, joinTo, ...args);
+};
+class OnQueryBuilder extends WhereQueryBuilder {
+  constructor(q, joinTo) {
+    super(q.table, q.query.as);
+    this.joinTo = joinTo;
+  }
+  on(...args) {
+    return this.clone()._on(...args);
+  }
+  _on(...args) {
+    return pushQueryOn(this, this.joinTo, this, ...args);
+  }
+  orOn(...args) {
+    return this.clone()._orOn(...args);
+  }
+  _orOn(...args) {
+    return pushQueryOrOn(this, this.joinTo, this, ...args);
+  }
+  onJsonPathEquals(...args) {
+    return this.clone()._onJsonPathEquals(...args);
+  }
+  _onJsonPathEquals(...args) {
+    return pushQueryValue(this, "and", { ON: args });
+  }
+}
+
+var __defProp$4 = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$4 = Object.getOwnPropertySymbols;
+var __hasOwnProp$4 = Object.prototype.hasOwnProperty;
+var __propIsEnum$4 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$4 = (obj, key, value) => key in obj ? __defProp$4(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$4 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$4.call(b, prop))
+      __defNormalProp$4(a, prop, b[prop]);
+  if (__getOwnPropSymbols$4)
+    for (var prop of __getOwnPropSymbols$4(b)) {
+      if (__propIsEnum$4.call(b, prop))
+        __defNormalProp$4(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+class With {
+  with(...args) {
+    return this.clone()._with(...args);
+  }
+  _with(...args) {
+    let options = args.length === 3 && !isRaw(args[2]) || args.length === 4 ? args[1] : void 0;
+    const last = args[args.length - 1];
+    const query = typeof last === "function" ? last(this.queryBuilder) : last;
+    const shape = args.length === 4 ? args[2] : query.shape;
+    if ((options == null ? void 0 : options.columns) === true) {
+      options = __spreadProps(__spreadValues$4({}, options), {
+        columns: Object.keys(shape)
+      });
+    }
+    pushQueryValue(this, "with", [args[0], options || EMPTY_OBJECT, query]);
+    return setQueryObjectValue(this, "withShapes", args[0], shape);
+  }
+}
+
+class Union {
+  union(args, wrap) {
+    return this._union(args, wrap);
+  }
+  _union(args, wrap) {
+    return pushQueryArray(this, "union", args.map((arg) => ({ arg, kind: "UNION", wrap })));
+  }
+  unionAll(args, wrap) {
+    return this._unionAll(args, wrap);
+  }
+  _unionAll(args, wrap) {
+    return pushQueryArray(this, "union", args.map((arg) => ({ arg, kind: "UNION ALL", wrap })));
+  }
+  intersect(args, wrap) {
+    return this._intersect(args, wrap);
+  }
+  _intersect(args, wrap) {
+    return pushQueryArray(this, "union", args.map((arg) => ({ arg, kind: "INTERSECT", wrap })));
+  }
+  intersectAll(args, wrap) {
+    return this._intersectAll(args, wrap);
+  }
+  _intersectAll(args, wrap) {
+    return pushQueryArray(this, "union", args.map((arg) => ({ arg, kind: "INTERSECT ALL", wrap })));
+  }
+  except(args, wrap) {
+    return this._except(args, wrap);
+  }
+  _except(args, wrap) {
+    return pushQueryArray(this, "union", args.map((arg) => ({ arg, kind: "EXCEPT", wrap })));
+  }
+  exceptAll(args, wrap) {
+    return this._exceptAll(args, wrap);
+  }
+  _exceptAll(args, wrap) {
+    return pushQueryArray(this, "union", args.map((arg) => ({ arg, kind: "EXCEPT ALL", wrap })));
+  }
+}
+
+class Json {
+  json() {
+    return this.clone()._json();
+  }
+  _json() {
+    const q = this._wrap(this.__model.clone());
+    q._getOptional(raw(this.query.take ? `row_to_json("t".*)` : `COALESCE(json_agg(row_to_json("t".*)), '[]')`));
+    delete q.query.take;
+    return q;
+  }
+  jsonSet(column, path, value, options) {
+    const q = this.clone();
+    return q._jsonSet(column, path, value, options);
+  }
+  _jsonSet(column, path, value, options) {
+    var _a;
+    const json = {
+      __json: [
+        "set",
+        (_a = options == null ? void 0 : options.as) != null ? _a : typeof column === "string" ? column : column.__json[1],
+        typeof column === "string" ? this.shape[column] : column.__json[2],
+        column,
+        path,
+        value,
+        options
+      ]
+    };
+    return Object.assign(pushQueryValue(this, "select", json), json);
+  }
+  jsonInsert(...args) {
+    const q = this.clone();
+    return q._jsonInsert(...args);
+  }
+  _jsonInsert(column, path, value, options) {
+    var _a;
+    const json = {
+      __json: [
+        "insert",
+        (_a = options == null ? void 0 : options.as) != null ? _a : typeof column === "string" ? column : column.__json[1],
+        typeof column === "string" ? this.shape[column] : column.__json[2],
+        column,
+        path,
+        value,
+        options
+      ]
+    };
+    return Object.assign(pushQueryValue(this, "select", json), json);
+  }
+  jsonRemove(...args) {
+    const q = this.clone();
+    return q._jsonRemove(...args);
+  }
+  _jsonRemove(column, path, options) {
+    var _a;
+    const json = {
+      __json: [
+        "remove",
+        (_a = options == null ? void 0 : options.as) != null ? _a : typeof column === "string" ? column : column.__json[1],
+        typeof column === "string" ? this.shape[column] : column.__json[2],
+        column,
+        path
+      ]
+    };
+    return Object.assign(pushQueryValue(this, "select", json), json);
+  }
+  jsonPathQuery(...args) {
+    const q = this.clone();
+    return q._jsonPathQuery(...args);
+  }
+  _jsonPathQuery(type, column, path, as, options) {
+    const json = {
+      __json: ["pathQuery", as, type, column, path, options]
+    };
+    return Object.assign(pushQueryValue(this, "select", json), json);
+  }
+}
+
+var __defProp$3 = Object.defineProperty;
+var __getOwnPropSymbols$3 = Object.getOwnPropertySymbols;
+var __hasOwnProp$3 = Object.prototype.hasOwnProperty;
+var __propIsEnum$3 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$3 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$3.call(b, prop))
+      __defNormalProp$3(a, prop, b[prop]);
+  if (__getOwnPropSymbols$3)
+    for (var prop of __getOwnPropSymbols$3(b)) {
+      if (__propIsEnum$3.call(b, prop))
+        __defNormalProp$3(a, prop, b[prop]);
+    }
+  return a;
+};
+const processInsertItem = (item, rowIndex, relations, prependRelations, appendRelations, requiredReturning, columns, columnsMap) => {
+  Object.keys(item).forEach((key) => {
+    if (relations[key]) {
+      if (relations[key].type === "belongsTo") {
+        const foreignKey = relations[key].options.foreignKey;
+        let columnIndex = columnsMap[foreignKey];
+        if (columnIndex === void 0) {
+          columnsMap[foreignKey] = columnIndex = columns.length;
+          columns.push(foreignKey);
+        }
+        if (!prependRelations[key])
+          prependRelations[key] = [];
+        prependRelations[key].push([
+          rowIndex,
+          columnIndex,
+          item[key]
+        ]);
+      } else {
+        requiredReturning[relations[key].primaryKey] = true;
+        if (!appendRelations[key])
+          appendRelations[key] = [];
+        appendRelations[key].push([rowIndex, item[key]]);
+      }
+    } else if (columnsMap[key] === void 0) {
+      columnsMap[key] = columns.length;
+      columns.push(key);
+    }
+  });
+};
+class Insert {
+  insert(data) {
+    return this.clone()._insert(data);
+  }
+  _insert(data) {
+    const q = this;
+    const returning = q.query.select;
+    delete q.query.and;
+    delete q.query.or;
+    let columns;
+    const prependRelations = {};
+    const appendRelations = {};
+    const requiredReturning = {};
+    const relations = this.relations;
+    let values;
+    let returnType = q.query.returnType;
+    if (returning) {
+      if (Array.isArray(data)) {
+        if (returnType === "one" || returnType === "oneOrThrow") {
+          returnType = "all";
+        }
+      } else {
+        if (returnType === "all") {
+          returnType = "one";
+        }
+      }
+    } else {
+      returnType = "rowCount";
+    }
+    if ("values" in data && typeof data.values === "object" && data.values && isRaw(data.values)) {
+      columns = data.columns;
+      values = data.values;
+    } else {
+      columns = [];
+      const columnsMap = {};
+      const defaults = q.query.defaults;
+      if (Array.isArray(data)) {
+        if (defaults) {
+          data = data.map((item) => __spreadValues$3(__spreadValues$3({}, defaults), item));
+        }
+        data.forEach((item, i) => {
+          processInsertItem(item, i, relations, prependRelations, appendRelations, requiredReturning, columns, columnsMap);
+        });
+        values = Array(data.length);
+        data.forEach((item, i) => {
+          values[i] = columns.map((key) => item[key]);
+        });
+      } else {
+        if (defaults) {
+          data = __spreadValues$3(__spreadValues$3({}, defaults), data);
+        }
+        processInsertItem(data, 0, relations, prependRelations, appendRelations, requiredReturning, columns, columnsMap);
+        values = [columns.map((key) => data[key])];
+      }
+    }
+    const prependRelationsKeys = Object.keys(prependRelations);
+    if (prependRelationsKeys.length) {
+      pushQueryArray(q, "beforeQuery", prependRelationsKeys.map((relationName) => {
+        return async (q2) => {
+          const relationData = prependRelations[relationName];
+          const relation = relations[relationName];
+          const inserted = await relation.nestedInsert(q2, relationData.map(([, , data2]) => data2));
+          const primaryKey = relation.options.primaryKey;
+          relationData.forEach(([rowIndex, columnIndex], index) => {
+            values[rowIndex][columnIndex] = inserted[index][primaryKey];
+          });
+        };
+      }));
+    }
+    const appendRelationsKeys = Object.keys(appendRelations);
+    if (appendRelationsKeys.length) {
+      if (!(returning == null ? void 0 : returning.includes("*"))) {
+        const requiredColumns = Object.keys(requiredReturning);
+        if (!returning) {
+          q.query.select = requiredColumns;
+        } else {
+          q.query.select = [
+            .../* @__PURE__ */ new Set([...returning, ...requiredColumns])
+          ];
+        }
+      }
+      let resultOfTypeAll;
+      if (returnType !== "all") {
+        const { handleResult } = q.query;
+        q.query.handleResult = async (q2, queryResult) => {
+          resultOfTypeAll = await handleResult(q2, queryResult);
+          if (queryMethodByReturnType[returnType] === "arrays") {
+            queryResult.rows.forEach((row, i) => queryResult.rows[i] = Object.values(row));
+          }
+          return parseResult(q2, returnType, queryResult);
+        };
+      }
+      pushQueryArray(q, "afterQuery", appendRelationsKeys.map((relationName) => {
+        return (q2, result) => {
+          var _a, _b;
+          const all = resultOfTypeAll || result;
+          return (_b = (_a = relations[relationName]).nestedInsert) == null ? void 0 : _b.call(_a, q2, appendRelations[relationName].map(([rowIndex, data2]) => [
+            all[rowIndex],
+            data2
+          ]));
+        };
+      }));
+    }
+    q.query.type = "insert";
+    q.query.columns = columns;
+    q.query.values = values;
+    if (prependRelationsKeys.length || appendRelationsKeys.length) {
+      q.query.wrapInTransaction = true;
+    }
+    q.query.returnType = appendRelationsKeys.length ? "all" : returnType;
+    return q;
+  }
+  create(data) {
+    return this.clone()._create(data);
+  }
+  _create(data) {
+    if (!this.query.select) {
+      this.query.select = ["*"];
+    }
+    return this.insert(data);
+  }
+  defaults(data) {
+    return this.clone()._defaults(data);
+  }
+  _defaults(data) {
+    this.query.defaults = data;
+    return this;
+  }
+  onConflict(arg) {
+    return this.clone()._onConflict(arg);
+  }
+  _onConflict(arg) {
+    return new OnConflictQueryBuilder(this, arg);
+  }
+}
+class OnConflictQueryBuilder {
+  constructor(query, onConflict) {
+    this.query = query;
+    this.onConflict = onConflict;
+  }
+  ignore() {
+    this.query.query.onConflict = {
+      type: "ignore",
+      expr: this.onConflict
+    };
+    return this.query;
+  }
+  merge(update) {
+    this.query.query.onConflict = {
+      type: "merge",
+      expr: this.onConflict,
+      update
+    };
+    return this.query;
+  }
+}
+
+var __defProp$2 = Object.defineProperty;
+var __getOwnPropSymbols$2 = Object.getOwnPropertySymbols;
+var __hasOwnProp$2 = Object.prototype.hasOwnProperty;
+var __propIsEnum$2 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$2 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$2.call(b, prop))
+      __defNormalProp$2(a, prop, b[prop]);
+  if (__getOwnPropSymbols$2)
+    for (var prop of __getOwnPropSymbols$2(b)) {
+      if (__propIsEnum$2.call(b, prop))
+        __defNormalProp$2(a, prop, b[prop]);
+    }
+  return a;
+};
+const applyCountChange = (self, op, data) => {
+  self.query.type = "update";
+  let map;
+  if (typeof data === "object") {
+    map = {};
+    for (const key in data) {
+      map[key] = { op, arg: data[key] };
+    }
+  } else {
+    map = { [data]: { op, arg: 1 } };
+  }
+  pushQueryValue(self, "data", map);
+  return self;
+};
+class Update {
+  update(...args) {
+    const q = this.clone();
+    return q._update(...args);
+  }
+  _update(...args) {
+    var _a, _b, _c, _d;
+    const [data, forceAll] = args;
+    const { query } = this;
+    query.type = "update";
+    if (!((_a = query.and) == null ? void 0 : _a.length) && !((_b = query.or) == null ? void 0 : _b.length) && !forceAll) {
+      throw new Error("No where conditions or forceAll flag provided to update");
+    }
+    if (isRaw(data)) {
+      pushQueryValue(this, "data", data);
+    } else {
+      const relations = this.relations;
+      const prependRelations = {};
+      const appendRelations = {};
+      const originalReturnType = this.query.returnType;
+      const update = __spreadValues$2({}, data);
+      for (const key in data) {
+        if (relations[key]) {
+          delete update[key];
+          if (relations[key].type === "belongsTo") {
+            prependRelations[key] = data[key];
+          } else {
+            if (!((_c = query.select) == null ? void 0 : _c.includes("*"))) {
+              const primaryKey = relations[key].primaryKey;
+              if (!((_d = query.select) == null ? void 0 : _d.includes(primaryKey))) {
+                this._select(primaryKey);
+              }
+            }
+            appendRelations[key] = data[key];
+          }
+        }
+      }
+      const state = {};
+      const prependRelationKeys = Object.keys(prependRelations);
+      if (prependRelationKeys.length) {
+        const willSetKeys = prependRelationKeys.some((relationName) => {
+          const data2 = prependRelations[relationName];
+          return relations[relationName].nestedUpdate(this, update, data2, state);
+        });
+        if (!willSetKeys && !Object.keys(update).length) {
+          delete this.query.type;
+        }
+      } else if (!Object.keys(update).length) {
+        delete this.query.type;
+      }
+      const appendRelationKeys = Object.keys(appendRelations);
+      let resultOfTypeAll;
+      if ((state == null ? void 0 : state.updateLater) || appendRelationKeys.length && originalReturnType !== "all") {
+        this.query.returnType = "all";
+        if (state == null ? void 0 : state.updateLater) {
+          this.schema.primaryKeys.forEach((key) => {
+            var _a2, _b2;
+            if (!((_a2 = query.select) == null ? void 0 : _a2.includes("*")) && !((_b2 = query.select) == null ? void 0 : _b2.includes(key))) {
+              this._select(key);
+            }
+          });
+        }
+        const { handleResult } = this.query;
+        this.query.handleResult = async (q, queryResult) => {
+          resultOfTypeAll = await handleResult(q, queryResult);
+          if (state == null ? void 0 : state.updateLater) {
+            await Promise.all(state.updateLaterPromises);
+            const t = this.__model.clone().transacting(q);
+            const keys = this.schema.primaryKeys;
+            t._whereIn(keys, resultOfTypeAll.map((item) => keys.map((key) => item[key])));
+            await t._update(state.updateLater);
+            resultOfTypeAll.forEach((item) => Object.assign(item, state.updateLater));
+          }
+          if (queryMethodByReturnType[originalReturnType] === "arrays") {
+            queryResult.rows.forEach((row, i) => queryResult.rows[i] = Object.values(row));
+          }
+          return parseResult(q, originalReturnType, queryResult);
+        };
+      }
+      if (appendRelationKeys.length) {
+        pushQueryArray(this, "afterQuery", appendRelationKeys.map((relationName) => {
+          return (q, result) => {
+            var _a2, _b2;
+            const all = resultOfTypeAll || result;
+            return (_b2 = (_a2 = relations[relationName]).nestedUpdate) == null ? void 0 : _b2.call(_a2, q, all, appendRelations[relationName]);
+          };
+        }));
+      }
+      if (prependRelationKeys.length || appendRelationKeys.length) {
+        query.wrapInTransaction = true;
+      }
+      pushQueryValue(this, "data", update);
+    }
+    if (!query.select) {
+      this.query.returnType = "rowCount";
+    }
+    return this;
+  }
+  updateOrThrow(...args) {
+    const q = this.clone();
+    return q._updateOrThrow(...args);
+  }
+  _updateOrThrow(...args) {
+    this.query.throwOnNotFound = true;
+    return this._update(...args);
+  }
+  increment(data) {
+    return this.clone()._increment(data);
+  }
+  _increment(data) {
+    return applyCountChange(this, "+", data);
+  }
+  decrement(data) {
+    return this.clone()._decrement(data);
+  }
+  _decrement(data) {
+    return applyCountChange(this, "-", data);
+  }
+}
+
+const del = (self, ...args) => {
+  return self.clone()._del(...args);
+};
+const _del = (q, ...args) => {
+  var _a, _b;
+  if (!((_a = q.query.and) == null ? void 0 : _a.length) && !((_b = q.query.or) == null ? void 0 : _b.length) && !args[0]) {
+    throw new Error("No where conditions or forceAll flag provided to delete");
+  }
+  if (!q.query.select) {
+    q.query.returnType = "rowCount";
+  }
+  q.query.type = "delete";
+  return q;
+};
+class Delete {
+  del(...args) {
+    return del(this, ...args);
+  }
+  _del(...args) {
+    return _del(this, ...args);
+  }
+  delete(...args) {
+    return del(this, ...args);
+  }
+  _delete(...args) {
+    return _del(this, ...args);
+  }
+}
+
+const beginSql = {
+  text: "BEGIN",
+  values: []
+};
+const commitSql = {
+  text: "COMMIT",
+  values: []
+};
+const rollbackSql = {
+  text: "ROLLBACK",
+  values: []
+};
+class Transaction {
+  async transaction(cb) {
+    const log = this.query.log;
+    let logData;
+    if (log) {
+      logData = log.beforeQuery(this, beginSql);
+    }
+    const t = this.query.adapter.transaction((adapter) => {
+      if (log) {
+        log.afterQuery(this, beginSql, logData);
+      }
+      const q = this.clone();
+      q.query.adapter = adapter;
+      q.query.inTransaction = true;
+      if (log) {
+        logData = log.beforeQuery(this, commitSql);
+      }
+      return cb(q);
+    });
+    if (log) {
+      t.then(() => {
+        log.afterQuery(this, commitSql, logData);
+      }, () => {
+        log.afterQuery(this, rollbackSql, logData);
+      });
+    }
+    return t;
+  }
+  transacting(query) {
+    return this.clone()._transacting(query);
+  }
+  _transacting(query) {
+    this.query.adapter = query.query.adapter;
+    this.query.inTransaction = true;
+    return this;
+  }
+}
+
+const forQueryBuilder = (q, type, tableNames) => {
+  q.query.for = { type, tableNames };
+  q.__model = Object.create(q.__model);
+  q.__model.__model = q.__model;
+  Object.assign(q.__model, {
+    noWait() {
+      return this.clone()._noWait();
+    },
+    _noWait() {
+      const q2 = this.query;
+      if (q2 == null ? void 0 : q2.for)
+        q2.for.mode = "NO WAIT";
+      return this;
+    },
+    skipLocked() {
+      return this.clone()._skipLocked();
+    },
+    _skipLocked() {
+      const q2 = this.query;
+      if (q2 == null ? void 0 : q2.for)
+        q2.for.mode = "SKIP LOCKED";
+      return this;
+    }
+  });
+  return q.clone();
+};
+class For {
+  forUpdate(tableNames) {
+    return this.clone()._forUpdate(tableNames);
+  }
+  _forUpdate(tableNames) {
+    return forQueryBuilder(this, "UPDATE", tableNames);
+  }
+  forNoKeyUpdate(tableNames) {
+    return this.clone()._forNoKeyUpdate(tableNames);
+  }
+  _forNoKeyUpdate(tableNames) {
+    return forQueryBuilder(this, "NO KEY UPDATE", tableNames);
+  }
+  forShare(tableNames) {
+    return this.clone()._forShare(tableNames);
+  }
+  _forShare(tableNames) {
+    return forQueryBuilder(this, "SHARE", tableNames);
+  }
+  forKeyShare(tableNames) {
+    return this.clone()._forKeyShare(tableNames);
+  }
+  _forKeyShare(tableNames) {
+    return forQueryBuilder(this, "KEY SHARE", tableNames);
+  }
+}
+
+const rowToColumnInfo = (row) => {
+  const typed = row;
+  return {
+    defaultValue: typed.column_default,
+    type: typed.data_type,
+    maxLength: typed.character_maximum_length,
+    nullable: typed.is_nullable === "YES"
+  };
+};
+class ColumnInfoMethods {
+  columnInfo(column) {
+    return this.clone()._columnInfo(column);
+  }
+  _columnInfo(column) {
+    this.query.type = "columnInfo";
+    this.query.returnType = "all";
+    if (column) {
+      this.query.column = column;
+    }
+    this.then = function(resolve, reject) {
+      new Then().then.call(this, (rows) => {
+        if (column) {
+          resolve == null ? void 0 : resolve(rowToColumnInfo(rows[0]));
+        } else {
+          const info = {};
+          rows.forEach((row) => {
+            info[row.column_name] = rowToColumnInfo(row);
+          });
+          resolve == null ? void 0 : resolve(info);
+        }
+      }, reject);
+    };
+    return this;
+  }
+}
+
+class Clear {
+  clear(...clears) {
+    return this.clone()._clear(...clears);
+  }
+  _clear(...clears) {
+    clears.forEach((clear) => {
+      if (clear === "where") {
+        removeFromQuery(this, "and");
+        removeFromQuery(this, "or");
+      } else if (clear === "counters") {
+        if ("type" in this.query && this.query.type === "update") {
+          this.query.data = this.query.data.filter((item) => {
+            if (!isRaw(item)) {
+              let removed = false;
+              for (const key in item) {
+                const value = item[key];
+                if (typeof value === "object" && (value.op === "+" || value.op === "-")) {
+                  delete item[key];
+                  removed = true;
+                }
+              }
+              if (removed && !Object.keys(item).length) {
+                return false;
+              }
+            }
+            return true;
+          });
+        }
+      } else {
+        removeFromQuery(this, clear);
+      }
+    });
+    return this;
+  }
+}
+
+var __defProp$1 = Object.defineProperty;
+var __getOwnPropSymbols$1 = Object.getOwnPropertySymbols;
+var __hasOwnProp$1 = Object.prototype.hasOwnProperty;
+var __propIsEnum$1 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$1 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$1.call(b, prop))
+      __defNormalProp$1(a, prop, b[prop]);
+  if (__getOwnPropSymbols$1)
+    for (var prop of __getOwnPropSymbols$1(b)) {
+      if (__propIsEnum$1.call(b, prop))
+        __defNormalProp$1(a, prop, b[prop]);
+    }
+  return a;
+};
+const processHavingArg = (arg) => {
+  if ("__model" in arg || isRaw(arg)) {
+    return arg;
+  } else {
+    const processed = __spreadValues$1({}, arg);
+    for (const fn in arg) {
+      const data = arg[fn];
+      if (typeof data === "object") {
+        processed[fn] = __spreadValues$1({}, data);
+        for (const column in data) {
+          const value = data[column];
+          if (typeof value === "object") {
+            processed[fn][column] = __spreadValues$1({}, value);
+            const options = value;
+            if ("order" in options && options.order && !Array.isArray(options.order)) {
+              processed[fn][column].order = [options.order];
+            }
+            if ("filter" in options && options.filter) {
+              processed[fn][column].filter = options.filter;
+            }
+            if ("filterOr" in options && options.filterOr) {
+              processed[fn][column].filterOr = options.filterOr;
+            }
+          }
+        }
+      }
+    }
+    return processed;
+  }
+};
+class Having {
+  having(...args) {
+    return this.clone()._having(...args);
+  }
+  _having(...args) {
+    return pushQueryArray(this, "having", args.map((arg) => processHavingArg(arg)));
+  }
+  havingOr(...args) {
+    return this.clone()._havingOr(...args);
+  }
+  _havingOr(...args) {
+    return pushQueryArray(this, "havingOr", args.map((arg) => [processHavingArg(arg)]));
+  }
+}
+
+const selectWindowFunction = (self, functionName, options, parse) => {
+  pushQueryValue(self, "select", {
+    function: functionName,
+    options: {
+      as: options.as,
+      over: options
+    }
+  });
+  if (parse) {
+    addParserToQuery(self.query, options.as || functionName, parse);
+  }
+  return self;
+};
+const toInt = (input) => parseInt(input);
+class Window {
+  selectRowNumber(options) {
+    return this.clone()._selectRowNumber(options);
+  }
+  _selectRowNumber(options) {
+    return selectWindowFunction(this, "row_number", options, toInt);
+  }
+  selectRank(options) {
+    return this.clone()._selectRank(options);
+  }
+  _selectRank(options) {
+    return selectWindowFunction(this, "rank", options, toInt);
+  }
+  selectDenseRank(options) {
+    return this.clone()._selectDenseRank(options);
+  }
+  _selectDenseRank(options) {
+    return selectWindowFunction(this, "dense_rank", options, toInt);
+  }
+  selectPercentRank(options) {
+    return this.clone()._selectPercentRank(options);
+  }
+  _selectPercentRank(options) {
+    return selectWindowFunction(this, "percent_rank", options, toInt);
+  }
+  selectCumeDist(options) {
+    return this.clone()._selectCumeDist(options);
+  }
+  _selectCumeDist(options) {
+    return selectWindowFunction(this, "cume_dist", options, toInt);
+  }
+}
+
+const logColors = {
+  boldCyanBright: (message) => `\x1B[1m\x1B[96m${message}\x1B[39m\x1B[22m`,
+  boldBlue: (message) => `\x1B[1m\x1B[34m${message}\x1B[39m\x1B[22m`,
+  boldYellow: (message) => `\x1B[1m\x1B[33m${message}\x1B[39m\x1B[22m`,
+  boldMagenta: (message) => `\x1B[1m\x1B[33m${message}\x1B[39m\x1B[22m`,
+  boldRed: (message) => `\x1B[1m\x1B[31m${message}\x1B[39m\x1B[22m`
+};
+const makeMessage = (colors, timeColor, time, sqlColor, sql, valuesColor, values) => {
+  const elapsed = process.hrtime(time);
+  const formattedTime = `(${elapsed[0] ? `${elapsed[0]}s ` : ""}${(elapsed[1] / 1e6).toFixed(1)}ms)`;
+  const result = `${colors ? timeColor(formattedTime) : formattedTime} ${colors ? sqlColor(sql) : sql}`;
+  if (!values.length) {
+    return result;
+  }
+  const formattedValues = `[${values.map(quote).join(", ")}]`;
+  return `${result} ${colors ? valuesColor(formattedValues) : formattedValues}`;
+};
+const logParamToLogObject = (logger, log) => {
+  if (!log)
+    return;
+  const logObject = Object.assign({
+    colors: true,
+    beforeQuery() {
+      return process.hrtime();
+    },
+    afterQuery(_, sql, time) {
+      logger.log(makeMessage(colors, logColors.boldCyanBright, time, logColors.boldBlue, sql.text, logColors.boldYellow, sql.values));
+    },
+    onError(error, _, sql, time) {
+      const message = `Error: ${error.message}`;
+      logger.error(`${makeMessage(colors, logColors.boldMagenta, time, logColors.boldRed, sql.text, logColors.boldYellow, sql.values)} ${colors ? logColors.boldRed(message) : message}`);
+    }
+  }, log === true ? {} : log);
+  const colors = logObject.colors;
+  return logObject;
+};
+class QueryLog {
+  log(log = true) {
+    return this.clone()._log(log);
+  }
+  _log(log = true) {
+    this.query.log = logParamToLogObject(this.query.logger, log);
+    return this;
+  }
+}
+
+class QueryCallbacks {
+  beforeQuery(cb) {
+    return this.clone()._beforeQuery(cb);
+  }
+  _beforeQuery(cb) {
+    return pushQueryValue(this, "beforeQuery", cb);
+  }
+  afterQuery(cb) {
+    return this.clone()._afterQuery(cb);
+  }
+  _afterQuery(cb) {
+    return pushQueryValue(this, "afterQuery", cb);
+  }
+  beforeInsert(cb) {
+    return this.clone()._beforeInsert(cb);
+  }
+  _beforeInsert(cb) {
+    return pushQueryValue(this, "beforeInsert", cb);
+  }
+  afterInsert(cb) {
+    return this.clone()._afterInsert(cb);
+  }
+  _afterInsert(cb) {
+    return pushQueryValue(this, "afterInsert", cb);
+  }
+  beforeUpdate(cb) {
+    return this.clone()._beforeUpdate(cb);
+  }
+  _beforeUpdate(cb) {
+    return pushQueryValue(this, "beforeUpdate", cb);
+  }
+  afterUpdate(cb) {
+    return this.clone()._afterUpdate(cb);
+  }
+  _afterUpdate(cb) {
+    return pushQueryValue(this, "afterUpdate", cb);
+  }
+}
+
+class QueryUpsert {
+  upsert(data) {
+    return this.clone()._upsert(data);
+  }
+  _upsert(data) {
+    this._update(data.update);
+    this.query.returnType = "one";
+    this.query.wrapInTransaction = true;
+    const { handleResult } = this.query;
+    this.query.handleResult = async (q, queryResult) => {
+      if (queryResult.rowCount === 0) {
+        return q.insert(data.create);
+      } else if (queryResult.rowCount > 1) {
+        throw new MoreThanOneRowError(`Only one row was expected to find for upsert, found ${queryResult.rowCount} rows.`);
+      }
+      return handleResult(q, queryResult);
+    };
+    return this;
+  }
+}
+
+const _get = (q, returnType, arg) => {
+  q.query.returnType = returnType;
+  q.query.take = true;
+  if (typeof arg === "object" && isRaw(arg)) {
+    addParserForRawExpression(q, "value", arg);
+    q.query.select = [arg];
+  } else {
+    q.query.select = [
+      processSelectArg(q, getQueryAs(q), arg)
+    ];
+  }
+  return q;
+};
+class QueryGet {
+  get(arg) {
+    return this.clone()._get(arg);
+  }
+  _get(arg) {
+    return _get(this, "valueOrThrow", arg);
+  }
+  getOptional(arg) {
+    return this.clone()._getOptional(arg);
+  }
+  _getOptional(arg) {
+    return _get(this, "value", arg);
+  }
+}
+
+class QueryMethods {
+  all() {
+    return this.query.returnType === "all" ? this : this.clone()._all();
+  }
+  _all() {
+    this.query.returnType = "all";
+    removeFromQuery(this, "take");
+    return this;
+  }
+  take() {
+    return this.query.returnType === "oneOrThrow" ? this : this.clone()._take();
+  }
+  _take() {
+    this.query.returnType = "oneOrThrow";
+    this.query.take = true;
+    return this;
+  }
+  takeOptional() {
+    return this.query.returnType === "one" ? this : this.clone()._takeOptional();
+  }
+  _takeOptional() {
+    this.query.returnType = "one";
+    this.query.take = true;
+    return this;
+  }
+  rows() {
+    return this.query.returnType === "rows" ? this : this.clone()._rows();
+  }
+  _rows() {
+    this.query.returnType = "rows";
+    removeFromQuery(this, "take");
+    return this;
+  }
+  pluck(select) {
+    return this.query.returnType === "pluck" ? this : this.clone()._pluck(select);
+  }
+  _pluck(select) {
+    this.query.returnType = "pluck";
+    removeFromQuery(this, "take");
+    this.query.select = [select];
+    addParserForSelectItem(this, this.query.as || this.table, "pluck", select);
+    return this;
+  }
+  exec() {
+    return this.query.returnType === "void" ? this : this.clone()._exec();
+  }
+  _exec() {
+    this.query.returnType = "void";
+    removeFromQuery(this, "take");
+    return this;
+  }
+  clone() {
+    const cloned = Object.create(this.__model);
+    cloned.query = getClonedQueryData(this.query);
+    return cloned;
+  }
+  toSql(values) {
+    return toSql(this, values);
+  }
+  distinct(...columns) {
+    return this.clone()._distinct(...columns);
+  }
+  _distinct(...columns) {
+    return pushQueryArray(this, "distinct", columns);
+  }
+  find(...args) {
+    return this.clone()._find(...args);
+  }
+  _find(...args) {
+    const conditions = {};
+    this.schema.primaryKeys.forEach((key, i) => {
+      conditions[key] = args[i];
+    });
+    return this._where(conditions)._take();
+  }
+  findOptional(...args) {
+    return this.clone()._findOptional(...args);
+  }
+  _findOptional(...args) {
+    return this._find(...args).takeOptional();
+  }
+  findBy(...args) {
+    return this.clone()._findBy(...args);
+  }
+  _findBy(...args) {
+    return addWhere(this, args).take();
+  }
+  findByOptional(...args) {
+    return this.clone()._findByOptional(...args);
+  }
+  _findByOptional(...args) {
+    return addWhere(this, args).takeOptional();
+  }
+  as(tableAlias) {
+    return this.clone()._as(tableAlias);
+  }
+  _as(tableAlias) {
+    this.query.as = tableAlias;
+    return this;
+  }
+  withSchema(schema) {
+    return this.clone()._withSchema(schema);
+  }
+  _withSchema(schema) {
+    this.query.schema = schema;
+    return this;
+  }
+  group(...columns) {
+    return this.clone()._group(...columns);
+  }
+  _group(...columns) {
+    return pushQueryArray(this, "group", columns);
+  }
+  window(arg) {
+    return this.clone()._window(arg);
+  }
+  _window(arg) {
+    return pushQueryValue(this, "window", arg);
+  }
+  wrap(query, as) {
+    return this.clone()._wrap(query, as);
+  }
+  _wrap(query, as) {
+    const sql = this.toSql();
+    return query.as(as != null ? as : "t")._from(raw(`(${sql.text})`, ...sql.values));
+  }
+  order(...args) {
+    return this.clone()._order(...args);
+  }
+  _order(...args) {
+    return pushQueryArray(this, "order", args);
+  }
+  limit(arg) {
+    return this.clone()._limit(arg);
+  }
+  _limit(arg) {
+    this.query.limit = arg;
+    return this;
+  }
+  offset(arg) {
+    return this.clone()._offset(arg);
+  }
+  _offset(arg) {
+    this.query.offset = arg;
+    return this;
+  }
+  exists() {
+    return this.clone()._exists();
+  }
+  _exists() {
+    const q = this._getOptional(raw("1"));
+    delete q.query.take;
+    return q;
+  }
+  truncate(options) {
+    return this.clone()._truncate(options);
+  }
+  _truncate(options) {
+    const q = this.query;
+    q.type = "truncate";
+    if (options == null ? void 0 : options.restartIdentity) {
+      q.restartIdentity = true;
+    }
+    if (options == null ? void 0 : options.cascade) {
+      q.cascade = true;
+    }
+    return this._exec();
+  }
+}
+applyMixins(QueryMethods, [
+  Aggregate,
+  Select,
+  From,
+  Join,
+  With,
+  Union,
+  Json,
+  Insert,
+  Update,
+  Delete,
+  Transaction,
+  For,
+  ColumnInfoMethods,
+  Where,
+  Clear,
+  Having,
+  Window,
+  Then,
+  QueryLog,
+  QueryCallbacks,
+  QueryUpsert,
+  QueryGet
+]);
+
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+class Db {
+  constructor(adapter, queryBuilder, table = void 0, shape = {}, options) {
+    this.adapter = adapter;
+    this.queryBuilder = queryBuilder;
+    this.table = table;
+    this.shape = shape;
+    this.whereQueryBuilder = WhereQueryBuilder;
+    this.onQueryBuilder = OnQueryBuilder;
+    this.__model = this;
+    const logger = options.logger || console;
+    this.query = {
+      adapter,
+      handleResult,
+      returnType: "all",
+      logger,
+      log: logParamToLogObject(logger, options.log)
+    };
+    if (options == null ? void 0 : options.schema) {
+      this.query.schema = options.schema;
+    }
+    this.schema = new TableSchema(shape);
+    const columns = Object.keys(shape);
+    const { toSql } = this;
+    this.columns = columns;
+    this.defaultSelectColumns = columns.filter((column) => !shape[column].isHidden);
+    const defaultSelect = this.defaultSelectColumns.length === columns.length ? void 0 : this.defaultSelectColumns;
+    const columnsParsers = {};
+    let hasParsers = false;
+    for (const key in shape) {
+      const column = shape[key];
+      if (column.parseFn) {
+        hasParsers = true;
+        columnsParsers[key] = column.parseFn;
+      }
+    }
+    this.columnsParsers = hasParsers ? columnsParsers : void 0;
+    this.toSql = defaultSelect ? function(values) {
+      const q = this.clone();
+      if (!q.query.select) {
+        q.query.select = defaultSelect;
+      }
+      return toSql.call(q, values);
+    } : toSql;
+    this.relations = {};
+  }
+}
+applyMixins(Db, [QueryMethods]);
+Db.prototype.constructor = Db;
+const createDb = (_a) => {
+  var _b = _a, {
+    log,
+    logger,
+    columnTypes: ct = columnTypes
+  } = _b, options = __objRest(_b, [
+    "log",
+    "logger",
+    "columnTypes"
+  ]);
+  const adapter = "adapter" in options ? options.adapter : new Adapter(options);
+  const commonOptions = { log, logger };
+  const qb = new Db(adapter, void 0, void 0, {}, commonOptions);
+  qb.queryBuilder = qb;
+  const db = Object.assign((table, shape, options2) => {
+    return new Db(adapter, qb, table, typeof shape === "function" ? shape(ct) : shape, __spreadValues(__spreadValues({}, commonOptions), options2));
+  }, qb, { adapter, destroy: () => adapter.destroy() });
+  Object.getOwnPropertyNames(Db.prototype).forEach((name) => {
+    db[name] = Db.prototype[name];
+  });
+  return db;
+};
+
+const defaultsKey = Symbol("defaults");
+
+export { Adapter, ArrayColumn, ArrayOfColumnsObjects, BigIntColumn, BigSerialColumn, BitColumn, BitVaryingColumn, BooleanColumn, BoxColumn, ByteaColumn, CharColumn, CidrColumn, CircleColumn, ColumnInfoMethods, ColumnType, ColumnsObject, DateColumn, DateTimeBaseClass, DateTimeWithTimeZoneBaseClass, Db, DecimalBaseColumn, DecimalBigIntColumn, DecimalColumn, DoublePrecisionColumn, EMPTY_OBJECT, EnumColumn, InetColumn, Insert, IntegerColumn, IntervalColumn, JSONColumn, JSONTextColumn, Join, LimitedTextBaseColumn, LineColumn, LsegColumn, MacAddr8Column, MacAddrColumn, MoneyColumn, MoreThanOneRowError, NotFoundError, NumberBaseColumn, OnConflictQueryBuilder, OnQueryBuilder, Operators, PathColumn, PointColumn, PolygonColumn, QueryMethods, RealColumn, SerialColumn, SmallIntColumn, SmallSerialColumn, TableSchema, TextBaseColumn, TextColumn, Then, TimeColumn, TimeWithTimeZoneColumn, TimestampColumn, TimestampWithTimeZoneColumn, Transaction, TransactionAdapter, TsQueryColumn, TsVectorColumn, UUIDColumn, VarCharColumn, XMLColumn, addQueryOn, addQueryOrOn, applyMixins, columnTypes, utils as columnUtils, createDb, createOperator, defaultsKey, getClonedQueryData, getQueryAs, getQueryParsers, getRaw, handleResult, isRaw, isRequiredRelationKey, joinTruthy, noop, parseRecord, parseResult, pushQueryArray, pushQueryOn, pushQueryOrOn, pushQueryValue, queryKeysOfNotSimpleQuery, queryMethodByReturnType, quote, raw, rawColumn, relationQueryKey, removeFromQuery, setQueryObjectValue, toArray, toSql };
+//# sourceMappingURL=index.esm.js.map