orchid-orm-valibot 0.3.126 → 0.3.128

package/dist/index.js

@@ -1,475 +1,365 @@
-'use strict';
-
-var internal = require('pqb/internal');
-var valibot = require('valibot');
-
-class ValibotJSONColumn extends internal.JSONColumn {
-  constructor(schema) {
-    super(valibotSchemaConfig, schema);
-  }
-}
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let pqb_internal = require("pqb/internal");
+let valibot = require("valibot");
+var ValibotJSONColumn = class extends pqb_internal.JSONColumn {
+	constructor(schema) {
+		super(valibotSchemaConfig, schema);
+	}
+};
 function applyMethod(column, key, value, validation, params) {
-  const cloned = internal.setDataValue(
-    column,
-    key,
-    value,
-    params
-  );
-  const v = validation(
-    value,
-    typeof params === "object" ? params.message : params
-  );
-  cloned.inputSchema.pipe.push(v);
-  cloned.outputSchema.pipe.push(v);
-  cloned.querySchema.pipe.push(v);
-  return cloned;
+	const cloned = (0, pqb_internal.setDataValue)(column, key, value, params);
+	const v = validation(value, typeof params === "object" ? params.message : params);
+	cloned.inputSchema.pipe.push(v);
+	cloned.outputSchema.pipe.push(v);
+	cloned.querySchema.pipe.push(v);
+	return cloned;
 }
 function applySimpleMethod(column, key, validation, params, ...args) {
-  const cloned = internal.setDataValue(
-    column,
-    key,
-    true,
-    params
-  );
-  const v = validation(
-    ...args,
-    typeof params === "object" ? params.message : params
-  );
-  cloned.inputSchema.pipe.push(v);
-  cloned.outputSchema.pipe.push(v);
-  cloned.querySchema.pipe.push(v);
-  return cloned;
+	const cloned = (0, pqb_internal.setDataValue)(column, key, true, params);
+	const v = validation(...args, typeof params === "object" ? params.message : params);
+	cloned.inputSchema.pipe.push(v);
+	cloned.outputSchema.pipe.push(v);
+	cloned.querySchema.pipe.push(v);
+	return cloned;
 }
 const arrayMethods = {
-  min(value, params) {
-    return applyMethod(this, "min", value, valibot.minLength, params);
-  },
-  max(value, params) {
-    return applyMethod(this, "max", value, valibot.maxLength, params);
-  },
-  length(value, params) {
-    return applyMethod(this, "length", value, valibot.length, params);
-  },
-  nonEmpty(params) {
-    return applyMethod(this, "min", 1, valibot.minLength, params);
-  }
+	min(value, params) {
+		return applyMethod(this, "min", value, valibot.minLength, params);
+	},
+	max(value, params) {
+		return applyMethod(this, "max", value, valibot.maxLength, params);
+	},
+	length(value, params) {
+		return applyMethod(this, "length", value, valibot.length, params);
+	},
+	nonEmpty(params) {
+		return applyMethod(this, "min", 1, valibot.minLength, params);
+	}
+};
+var ValibotArrayColumn = class extends pqb_internal.ArrayColumn {
+	constructor(item) {
+		super(valibotSchemaConfig, item, (0, valibot.array)(item.inputSchema, []));
+	}
 };
-class ValibotArrayColumn extends internal.ArrayColumn {
-  constructor(item) {
-    super(valibotSchemaConfig, item, valibot.array(item.inputSchema, []));
-  }
-}
 Object.assign(ValibotArrayColumn.prototype, arrayMethods);
 function gt(requirement, message) {
-  return {
-    type: "gt",
-    expects: `>${requirement instanceof Date ? requirement.toJSON() : valibot.stringify(requirement)}`,
-    async: false,
-    message,
-    requirement,
-    _parse(input) {
-      if (input > this.requirement) {
-        return valibot.actionOutput(input);
-      }
-      return valibot.actionIssue(
-        this,
-        gt,
-        input,
-        "value",
-        input instanceof Date ? input.toJSON() : valibot.stringify(input)
-      );
-    }
-  };
+	return {
+		type: "gt",
+		expects: `>${requirement instanceof Date ? requirement.toJSON() : (0, valibot.stringify)(requirement)}`,
+		async: false,
+		message,
+		requirement,
+		_parse(input) {
+			if (input > this.requirement) return (0, valibot.actionOutput)(input);
+			return (0, valibot.actionIssue)(this, gt, input, "value", input instanceof Date ? input.toJSON() : (0, valibot.stringify)(input));
+		}
+	};
 }
 function lt(requirement, message) {
-  return {
-    type: "lt",
-    expects: `<${requirement instanceof Date ? requirement.toJSON() : valibot.stringify(requirement)}`,
-    async: false,
-    message,
-    requirement,
-    _parse(input) {
-      if (input < this.requirement) {
-        return valibot.actionOutput(input);
-      }
-      return valibot.actionIssue(
-        this,
-        lt,
-        input,
-        "value",
-        input instanceof Date ? input.toJSON() : valibot.stringify(input)
-      );
-    }
-  };
+	return {
+		type: "lt",
+		expects: `<${requirement instanceof Date ? requirement.toJSON() : (0, valibot.stringify)(requirement)}`,
+		async: false,
+		message,
+		requirement,
+		_parse(input) {
+			if (input < this.requirement) return (0, valibot.actionOutput)(input);
+			return (0, valibot.actionIssue)(this, lt, input, "value", input instanceof Date ? input.toJSON() : (0, valibot.stringify)(input));
+		}
+	};
 }
 function step(requirement, message) {
-  return {
-    type: "step",
-    expects: `a multiple of ${valibot.stringify(requirement)}`,
-    async: false,
-    message,
-    requirement,
-    _parse(input) {
-      if (input % this.requirement === 0) {
-        return valibot.actionOutput(input);
-      }
-      return valibot.actionIssue(this, step, input, "value", valibot.stringify(input));
-    }
-  };
+	return {
+		type: "step",
+		expects: `a multiple of ${(0, valibot.stringify)(requirement)}`,
+		async: false,
+		message,
+		requirement,
+		_parse(input) {
+			if (input % this.requirement === 0) return (0, valibot.actionOutput)(input);
+			return (0, valibot.actionIssue)(this, step, input, "value", (0, valibot.stringify)(input));
+		}
+	};
 }
 const numberMethods = {
-  // Require a value to be lower than a given number
-  lt(value, params) {
-    return applyMethod(this, "lt", value, lt, params);
-  },
-  // Require a value to be lower than or equal to a given number (the same as `max`)
-  lte(value, params) {
-    return applyMethod(this, "lte", value, valibot.maxValue, params);
-  },
-  // Require a value to be lower than or equal to a given number
-  max(value, params) {
-    return applyMethod(this, "lte", value, valibot.maxValue, params);
-  },
-  // Require a value to be greater than a given number
-  gt(value, params) {
-    return applyMethod(this, "gt", value, gt, params);
-  },
-  // Require a value to be greater than or equal to a given number (the same as `min`)
-  gte(value, params) {
-    return applyMethod(this, "gte", value, valibot.minValue, params);
-  },
-  // Require a value to be greater than or equal to a given number
-  min(value, params) {
-    return applyMethod(this, "gte", value, valibot.minValue, params);
-  },
-  // Require a value to be greater than 0
-  positive(params) {
-    return applyMethod(this, "gt", 0, gt, params);
-  },
-  // Require a value to be greater than or equal to 0
-  nonNegative(params) {
-    return applyMethod(this, "gte", 0, valibot.minValue, params);
-  },
-  // Require a value to be lower than 0
-  negative(params) {
-    return applyMethod(this, "lt", 0, lt, params);
-  },
-  // Require a value to be lower than or equal to 0
-  nonPositive(params) {
-    return applyMethod(this, "lte", 0, valibot.maxValue, params);
-  },
-  // Require a value to be a multiple of a given number
-  step(value, params) {
-    return applyMethod(this, "step", value, step, params);
-  },
-  // Require a value to be an integer
-  int(params) {
-    return applySimpleMethod(this, "int", valibot.integer, params);
-  },
-  // Exclude `Infinity` from being a valid value
-  finite(params) {
-    return applySimpleMethod(this, "finite", valibot.finite, params);
-  },
-  // Require the value to be less than or equal to Number.MAX_SAFE_INTEGER
-  safe(params) {
-    return applySimpleMethod(
-      applySimpleMethod(
-        this,
-        "safe",
-        valibot.minValue,
-        params,
-        Number.MIN_SAFE_INTEGER
-      ),
-      "safe",
-      valibot.maxValue,
-      params,
-      Number.MAX_SAFE_INTEGER
-    );
-  }
+	lt(value, params) {
+		return applyMethod(this, "lt", value, lt, params);
+	},
+	lte(value, params) {
+		return applyMethod(this, "lte", value, valibot.maxValue, params);
+	},
+	max(value, params) {
+		return applyMethod(this, "lte", value, valibot.maxValue, params);
+	},
+	gt(value, params) {
+		return applyMethod(this, "gt", value, gt, params);
+	},
+	gte(value, params) {
+		return applyMethod(this, "gte", value, valibot.minValue, params);
+	},
+	min(value, params) {
+		return applyMethod(this, "gte", value, valibot.minValue, params);
+	},
+	positive(params) {
+		return applyMethod(this, "gt", 0, gt, params);
+	},
+	nonNegative(params) {
+		return applyMethod(this, "gte", 0, valibot.minValue, params);
+	},
+	negative(params) {
+		return applyMethod(this, "lt", 0, lt, params);
+	},
+	nonPositive(params) {
+		return applyMethod(this, "lte", 0, valibot.maxValue, params);
+	},
+	step(value, params) {
+		return applyMethod(this, "step", value, step, params);
+	},
+	int(params) {
+		return applySimpleMethod(this, "int", valibot.integer, params);
+	},
+	finite(params) {
+		return applySimpleMethod(this, "finite", valibot.finite, params);
+	},
+	safe(params) {
+		return applySimpleMethod(applySimpleMethod(this, "safe", valibot.minValue, params, Number.MIN_SAFE_INTEGER), "safe", valibot.maxValue, params, Number.MAX_SAFE_INTEGER);
+	}
 };
-class SmallIntColumnValibot extends internal.SmallIntColumn {
-}
+var SmallIntColumnValibot = class extends pqb_internal.SmallIntColumn {};
 Object.assign(SmallIntColumnValibot.prototype, numberMethods);
-class IntegerColumnValibot extends internal.IntegerColumn {
-}
+var IntegerColumnValibot = class extends pqb_internal.IntegerColumn {};
 Object.assign(IntegerColumnValibot.prototype, numberMethods);
-class RealColumnValibot extends internal.RealColumn {
-}
+var RealColumnValibot = class extends pqb_internal.RealColumn {};
 Object.assign(RealColumnValibot.prototype, numberMethods);
-class SmallSerialColumnValibot extends internal.SmallSerialColumn {
-}
+var SmallSerialColumnValibot = class extends pqb_internal.SmallSerialColumn {};
 Object.assign(SmallSerialColumnValibot.prototype, numberMethods);
-class SerialColumnValibot extends internal.SerialColumn {
-}
+var SerialColumnValibot = class extends pqb_internal.SerialColumn {};
 Object.assign(SerialColumnValibot.prototype, numberMethods);
 const stringMethods = {
-  ...arrayMethods,
-  email(params) {
-    return applySimpleMethod(this, "email", valibot.email, params);
-  },
-  url(params) {
-    return applySimpleMethod(this, "url", valibot.url, params);
-  },
-  emoji(params) {
-    return applySimpleMethod(this, "emoji", valibot.emoji, params);
-  },
-  uuid(params) {
-    return applySimpleMethod(this, "uuid", valibot.uuid, params);
-  },
-  cuid2(params) {
-    return applySimpleMethod(this, "cuid2", valibot.cuid2, params);
-  },
-  ulid(params) {
-    return applySimpleMethod(this, "ulid", valibot.ulid, params);
-  },
-  regex(value, params) {
-    return applyMethod(this, "regex", value, valibot.regex, params);
-  },
-  includes(value, params) {
-    return applyMethod(this, "includes", value, valibot.includes, params);
-  },
-  startsWith(value, params) {
-    return applyMethod(this, "startsWith", value, valibot.startsWith, params);
-  },
-  endsWith(value, params) {
-    return applyMethod(this, "endsWith", value, valibot.endsWith, params);
-  },
-  datetime(params) {
-    return applySimpleMethod(this, "datetime", valibot.isoDateTime, params);
-  },
-  ipv4(params = {}) {
-    return applySimpleMethod(this, "ipv4", valibot.ipv4, params);
-  },
-  ipv6(params = {}) {
-    return applySimpleMethod(this, "ipv6", valibot.ipv6, params);
-  },
-  trim(params) {
-    return applySimpleMethod(this, "trim", valibot.toTrimmed, params);
-  },
-  toLowerCase(params) {
-    return applySimpleMethod(this, "toLowerCase", valibot.toLowerCase, params);
-  },
-  toUpperCase(params) {
-    return applySimpleMethod(this, "toUpperCase", valibot.toUpperCase, params);
-  }
+	...arrayMethods,
+	email(params) {
+		return applySimpleMethod(this, "email", valibot.email, params);
+	},
+	url(params) {
+		return applySimpleMethod(this, "url", valibot.url, params);
+	},
+	emoji(params) {
+		return applySimpleMethod(this, "emoji", valibot.emoji, params);
+	},
+	uuid(params) {
+		return applySimpleMethod(this, "uuid", valibot.uuid, params);
+	},
+	cuid2(params) {
+		return applySimpleMethod(this, "cuid2", valibot.cuid2, params);
+	},
+	ulid(params) {
+		return applySimpleMethod(this, "ulid", valibot.ulid, params);
+	},
+	regex(value, params) {
+		return applyMethod(this, "regex", value, valibot.regex, params);
+	},
+	includes(value, params) {
+		return applyMethod(this, "includes", value, valibot.includes, params);
+	},
+	startsWith(value, params) {
+		return applyMethod(this, "startsWith", value, valibot.startsWith, params);
+	},
+	endsWith(value, params) {
+		return applyMethod(this, "endsWith", value, valibot.endsWith, params);
+	},
+	datetime(params) {
+		return applySimpleMethod(this, "datetime", valibot.isoDateTime, params);
+	},
+	ipv4(params = {}) {
+		return applySimpleMethod(this, "ipv4", valibot.ipv4, params);
+	},
+	ipv6(params = {}) {
+		return applySimpleMethod(this, "ipv6", valibot.ipv6, params);
+	},
+	trim(params) {
+		return applySimpleMethod(this, "trim", valibot.toTrimmed, params);
+	},
+	toLowerCase(params) {
+		return applySimpleMethod(this, "toLowerCase", valibot.toLowerCase, params);
+	},
+	toUpperCase(params) {
+		return applySimpleMethod(this, "toUpperCase", valibot.toUpperCase, params);
+	}
 };
-class BigIntColumnValibot extends internal.BigIntColumn {
-}
+var BigIntColumnValibot = class extends pqb_internal.BigIntColumn {};
 Object.assign(BigIntColumnValibot.prototype, stringMethods);
-class DecimalColumnValibot extends internal.DecimalColumn {
-}
+var DecimalColumnValibot = class extends pqb_internal.DecimalColumn {};
 Object.assign(DecimalColumnValibot.prototype, stringMethods);
-class DoublePrecisionColumnValibot extends internal.DoublePrecisionColumn {
-}
+var DoublePrecisionColumnValibot = class extends pqb_internal.DoublePrecisionColumn {};
 Object.assign(DoublePrecisionColumnValibot.prototype, stringMethods);
-class BigSerialColumnValibot extends internal.BigSerialColumn {
-}
+var BigSerialColumnValibot = class extends pqb_internal.BigSerialColumn {};
 Object.assign(BigSerialColumnValibot.prototype, stringMethods);
-class MoneyColumnValibot extends internal.MoneyColumn {
-}
+var MoneyColumnValibot = class extends pqb_internal.MoneyColumn {};
 Object.assign(MoneyColumnValibot.prototype, numberMethods);
-class VarCharColumnValibot extends internal.VarCharColumn {
-}
+var VarCharColumnValibot = class extends pqb_internal.VarCharColumn {};
 Object.assign(VarCharColumnValibot.prototype, stringMethods);
-class TextColumnValibot extends internal.TextColumn {
-}
+var TextColumnValibot = class extends pqb_internal.TextColumn {};
 Object.assign(TextColumnValibot.prototype, stringMethods);
-class StringColumnValibot extends internal.StringColumn {
-}
+var StringColumnValibot = class extends pqb_internal.StringColumn {};
 Object.assign(StringColumnValibot.prototype, stringMethods);
-class CitextColumnValibot extends internal.CitextColumn {
-}
+var CitextColumnValibot = class extends pqb_internal.CitextColumn {};
 Object.assign(CitextColumnValibot.prototype, stringMethods);
 const dateMethods = {
-  min(value, params) {
-    return applyMethod(this, "min", value, valibot.minValue, params);
-  },
-  max(value, params) {
-    return applyMethod(this, "max", value, valibot.maxValue, params);
-  }
+	min(value, params) {
+		return applyMethod(this, "min", value, valibot.minValue, params);
+	},
+	max(value, params) {
+		return applyMethod(this, "max", value, valibot.maxValue, params);
+	}
 };
-class DateColumnValibot extends internal.DateColumn {
-}
+var DateColumnValibot = class extends pqb_internal.DateColumn {};
 Object.assign(DateColumnValibot.prototype, dateMethods);
-class TimestampNoTzColumnValibot extends internal.TimestampColumn {
-}
+var TimestampNoTzColumnValibot = class extends pqb_internal.TimestampColumn {};
 Object.assign(TimestampNoTzColumnValibot.prototype, dateMethods);
-class TimestampColumnValibot extends internal.TimestampTZColumn {
-}
+var TimestampColumnValibot = class extends pqb_internal.TimestampTZColumn {};
 Object.assign(TimestampColumnValibot.prototype, dateMethods);
 let pointSchema;
 const parseDateToDate = (value) => new Date(value);
 const valibotSchemaConfig = {
-  type: void 0,
-  parse(schema, fn) {
-    return internal.setColumnParse(this, fn, schema);
-  },
-  parseNull(schema, fn) {
-    return internal.setColumnParseNull(this, fn, schema);
-  },
-  encode(schema, fn) {
-    return internal.setColumnEncode(this, fn, schema);
-  },
-  asType(_types) {
-    return this;
-  },
-  narrowType(type) {
-    const c = Object.create(this);
-    if (c.data.generated) {
-      c.outputSchema = c.querySchema = type;
-    } else {
-      c.inputSchema = c.outputSchema = c.querySchema = type;
-    }
-    return c;
-  },
-  narrowAllTypes(types) {
-    const c = Object.create(this);
-    if (types.input) {
-      c.inputSchema = types.input;
-    }
-    if (types.output) {
-      c.outputSchema = types.output;
-    }
-    if (types.query) {
-      c.querySchema = types.query;
-    }
-    return c;
-  },
-  dateAsNumber() {
-    return this.parse(valibot.number([]), Date.parse);
-  },
-  dateAsDate() {
-    return this.parse(valibot.date([]), parseDateToDate);
-  },
-  enum(dataType, type) {
-    return new internal.EnumColumn(valibotSchemaConfig, dataType, type, valibot.picklist(type));
-  },
-  array(item) {
-    return new ValibotArrayColumn(item);
-  },
-  nullable() {
-    return internal.makeColumnNullable(
-      this,
-      valibot.nullable(this.inputSchema),
-      this.nullSchema ? valibot.union([this.outputSchema, this.nullSchema]) : valibot.nullable(this.outputSchema),
-      valibot.nullable(this.querySchema)
-    );
-  },
-  json(schema) {
-    return new ValibotJSONColumn(schema ?? valibot.unknown([]));
-  },
-  boolean: () => valibot.boolean([]),
-  buffer: () => valibot.instance(Buffer, []),
-  unknown: () => valibot.unknown([]),
-  never: () => valibot.never(),
-  stringSchema: () => valibot.string([]),
-  stringMin(min) {
-    return valibot.string([valibot.minLength(min)]);
-  },
-  stringMax(max) {
-    return valibot.string([valibot.maxLength(max)]);
-  },
-  stringMinMax(min, max) {
-    return valibot.string([valibot.minLength(min), valibot.maxLength(max)]);
-  },
-  number: () => valibot.number([]),
-  int: () => valibot.number([valibot.integer()]),
-  stringNumberDate: () => valibot.coerce(valibot.date([]), (input) => new Date(input)),
-  timeInterval: () => valibot.object(
-    {
-      years: valibot.optional(valibot.number()),
-      months: valibot.optional(valibot.number()),
-      days: valibot.optional(valibot.number()),
-      hours: valibot.optional(valibot.number()),
-      minutes: valibot.optional(valibot.number()),
-      seconds: valibot.optional(valibot.number())
-    },
-    []
-  ),
-  bit: (max) => max ? valibot.string([valibot.maxLength(max), valibot.regex(/[10]/g)]) : valibot.string([valibot.regex(/[10]/g)]),
-  uuid: () => valibot.string([valibot.uuid()]),
-  inputSchema() {
-    return mapSchema(this, "inputSchema");
-  },
-  outputSchema() {
-    return mapSchema(this, "outputSchema");
-  },
-  querySchema() {
-    return valibot.partial(mapSchema(this, "querySchema"));
-  },
-  createSchema() {
-    const input = this.inputSchema();
-    const shape = {};
-    const { shape: columns } = this.prototype.columns;
-    for (const key in columns) {
-      const column = columns[key];
-      if (column.dataType && !column.data.primaryKey) {
-        shape[key] = input.entries[key];
-        if (column.data.isNullable || column.data.default !== void 0) {
-          shape[key] = valibot.optional(shape[key]);
-        }
-      }
-    }
-    return valibot.object(shape);
-  },
-  updateSchema() {
-    return valibot.partial(this.createSchema());
-  },
-  pkeySchema() {
-    const keys = [];
-    const {
-      columns: { shape }
-    } = this.prototype;
-    for (const key in shape) {
-      if (shape[key].data.primaryKey) {
-        keys.push(key);
-      }
-    }
-    return valibot.required(
-      valibot.pick(this.querySchema(), keys)
-    );
-  },
-  error(message) {
-    const c = this;
-    c.inputSchema.message = c.outputSchema.message = c.querySchema.message = message;
-    return c;
-  },
-  smallint: () => new SmallIntColumnValibot(valibotSchemaConfig),
-  integer: () => new IntegerColumnValibot(valibotSchemaConfig),
-  real: () => new RealColumnValibot(valibotSchemaConfig),
-  smallSerial: () => new SmallSerialColumnValibot(valibotSchemaConfig),
-  serial: () => new SerialColumnValibot(valibotSchemaConfig),
-  bigint: () => new BigIntColumnValibot(valibotSchemaConfig),
-  decimal: (precision, scale) => new DecimalColumnValibot(valibotSchemaConfig, precision, scale),
-  doublePrecision: () => new DoublePrecisionColumnValibot(valibotSchemaConfig),
-  bigSerial: () => new BigSerialColumnValibot(valibotSchemaConfig),
-  money: () => new MoneyColumnValibot(valibotSchemaConfig),
-  varchar: (limit) => new VarCharColumnValibot(valibotSchemaConfig, limit),
-  text: () => new TextColumnValibot(valibotSchemaConfig),
-  string: (limit) => new StringColumnValibot(valibotSchemaConfig, limit),
-  citext: () => new CitextColumnValibot(valibotSchemaConfig),
-  date: () => new DateColumnValibot(valibotSchemaConfig),
-  timestampNoTZ: (precision) => new TimestampNoTzColumnValibot(valibotSchemaConfig, precision),
-  timestamp: (precision) => new TimestampColumnValibot(valibotSchemaConfig, precision),
-  geographyPointSchema: () => pointSchema ?? (pointSchema = valibot.object({
-    srid: valibot.optional(valibot.number()),
-    lon: valibot.number(),
-    lat: valibot.number()
-  }))
+	type: void 0,
+	parse(schema, fn) {
+		return (0, pqb_internal.setColumnParse)(this, fn, schema);
+	},
+	parseNull(schema, fn) {
+		return (0, pqb_internal.setColumnParseNull)(this, fn, schema);
+	},
+	encode(schema, fn) {
+		return (0, pqb_internal.setColumnEncode)(this, fn, schema);
+	},
+	asType(_types) {
+		return this;
+	},
+	narrowType(type) {
+		const c = Object.create(this);
+		if (c.data.generated) c.outputSchema = c.querySchema = type;
+		else c.inputSchema = c.outputSchema = c.querySchema = type;
+		return c;
+	},
+	narrowAllTypes(types) {
+		const c = Object.create(this);
+		if (types.input) c.inputSchema = types.input;
+		if (types.output) c.outputSchema = types.output;
+		if (types.query) c.querySchema = types.query;
+		return c;
+	},
+	dateAsNumber() {
+		return this.parse((0, valibot.number)([]), Date.parse);
+	},
+	dateAsDate() {
+		return this.parse((0, valibot.date)([]), parseDateToDate);
+	},
+	enum(dataType, type) {
+		return new pqb_internal.EnumColumn(valibotSchemaConfig, dataType, type, (0, valibot.picklist)(type));
+	},
+	array(item) {
+		return new ValibotArrayColumn(item);
+	},
+	nullable() {
+		return (0, pqb_internal.makeColumnNullable)(this, (0, valibot.nullable)(this.inputSchema), this.nullSchema ? (0, valibot.union)([this.outputSchema, this.nullSchema]) : (0, valibot.nullable)(this.outputSchema), (0, valibot.nullable)(this.querySchema));
+	},
+	json(schema) {
+		return new ValibotJSONColumn(schema ?? (0, valibot.unknown)([]));
+	},
+	boolean: () => (0, valibot.boolean)([]),
+	buffer: () => (0, valibot.instance)(Buffer, []),
+	unknown: () => (0, valibot.unknown)([]),
+	never: () => (0, valibot.never)(),
+	stringSchema: () => (0, valibot.string)([]),
+	stringMin(min) {
+		return (0, valibot.string)([(0, valibot.minLength)(min)]);
+	},
+	stringMax(max) {
+		return (0, valibot.string)([(0, valibot.maxLength)(max)]);
+	},
+	stringMinMax(min, max) {
+		return (0, valibot.string)([(0, valibot.minLength)(min), (0, valibot.maxLength)(max)]);
+	},
+	number: () => (0, valibot.number)([]),
+	int: () => (0, valibot.number)([(0, valibot.integer)()]),
+	stringNumberDate: () => (0, valibot.coerce)((0, valibot.date)([]), (input) => new Date(input)),
+	timeInterval: () => (0, valibot.object)({
+		years: (0, valibot.optional)((0, valibot.number)()),
+		months: (0, valibot.optional)((0, valibot.number)()),
+		days: (0, valibot.optional)((0, valibot.number)()),
+		hours: (0, valibot.optional)((0, valibot.number)()),
+		minutes: (0, valibot.optional)((0, valibot.number)()),
+		seconds: (0, valibot.optional)((0, valibot.number)())
+	}, []),
+	bit: (max) => max ? (0, valibot.string)([(0, valibot.maxLength)(max), (0, valibot.regex)(/[10]/g)]) : (0, valibot.string)([(0, valibot.regex)(/[10]/g)]),
+	uuid: () => (0, valibot.string)([(0, valibot.uuid)()]),
+	inputSchema() {
+		return mapSchema(this, "inputSchema");
+	},
+	outputSchema() {
+		return mapSchema(this, "outputSchema");
+	},
+	querySchema() {
+		return (0, valibot.partial)(mapSchema(this, "querySchema"));
+	},
+	createSchema() {
+		const input = this.inputSchema();
+		const shape = {};
+		const { shape: columns } = this.prototype.columns;
+		for (const key in columns) {
+			const column = columns[key];
+			if (column.dataType && !column.data.primaryKey) {
+				shape[key] = input.entries[key];
+				if (column.data.isNullable || column.data.default !== void 0) shape[key] = (0, valibot.optional)(shape[key]);
+			}
+		}
+		return (0, valibot.object)(shape);
+	},
+	updateSchema() {
+		return (0, valibot.partial)(this.createSchema());
+	},
+	pkeySchema() {
+		const keys = [];
+		const { columns: { shape } } = this.prototype;
+		for (const key in shape) if (shape[key].data.primaryKey) keys.push(key);
+		return (0, valibot.required)((0, valibot.pick)(this.querySchema(), keys));
+	},
+	error(message) {
+		const c = this;
+		c.inputSchema.message = c.outputSchema.message = c.querySchema.message = message;
+		return c;
+	},
+	smallint: () => new SmallIntColumnValibot(valibotSchemaConfig),
+	integer: () => new IntegerColumnValibot(valibotSchemaConfig),
+	real: () => new RealColumnValibot(valibotSchemaConfig),
+	smallSerial: () => new SmallSerialColumnValibot(valibotSchemaConfig),
+	serial: () => new SerialColumnValibot(valibotSchemaConfig),
+	bigint: () => new BigIntColumnValibot(valibotSchemaConfig),
+	decimal: (precision, scale) => new DecimalColumnValibot(valibotSchemaConfig, precision, scale),
+	doublePrecision: () => new DoublePrecisionColumnValibot(valibotSchemaConfig),
+	bigSerial: () => new BigSerialColumnValibot(valibotSchemaConfig),
+	money: () => new MoneyColumnValibot(valibotSchemaConfig),
+	varchar: (limit) => new VarCharColumnValibot(valibotSchemaConfig, limit),
+	text: () => new TextColumnValibot(valibotSchemaConfig),
+	string: (limit) => new StringColumnValibot(valibotSchemaConfig, limit),
+	citext: () => new CitextColumnValibot(valibotSchemaConfig),
+	date: () => new DateColumnValibot(valibotSchemaConfig),
+	timestampNoTZ: (precision) => new TimestampNoTzColumnValibot(valibotSchemaConfig, precision),
+	timestamp: (precision) => new TimestampColumnValibot(valibotSchemaConfig, precision),
+	geographyPointSchema: () => pointSchema ??= (0, valibot.object)({
+		srid: (0, valibot.optional)((0, valibot.number)()),
+		lon: (0, valibot.number)(),
+		lat: (0, valibot.number)()
+	})
 };
 function mapSchema(klass, schemaKey) {
-  const shape = {};
-  const { shape: columns } = klass.prototype.columns;
-  for (const key in columns) {
-    if (columns[key].dataType) {
-      shape[key] = columns[key][schemaKey];
-    }
-  }
-  return valibot.object(shape);
+	const shape = {};
+	const { shape: columns } = klass.prototype.columns;
+	for (const key in columns) if (columns[key].dataType) shape[key] = columns[key][schemaKey];
+	return (0, valibot.object)(shape);
 }
-
 exports.gt = gt;
 exports.lt = lt;
 exports.step = step;
 exports.valibotSchemaConfig = valibotSchemaConfig;
-//# sourceMappingURL=index.js.map
+
+//# sourceMappingURL=index.js.map