orchid-orm-valibot 0.3.126 → 0.3.128

package/dist/index.mjs

@@ -1,470 +1,361 @@
-import { ArrayColumn, SmallIntColumn, IntegerColumn, RealColumn, SmallSerialColumn, SerialColumn, BigIntColumn, DecimalColumn, DoublePrecisionColumn, BigSerialColumn, MoneyColumn, VarCharColumn, TextColumn, StringColumn, CitextColumn, DateColumn, TimestampColumn, TimestampTZColumn, makeColumnNullable, EnumColumn, setColumnEncode, setColumnParseNull, setColumnParse, setDataValue, JSONColumn } from 'pqb/internal';
-import { array, minValue, object, number, optional, required, pick, partial, string, uuid, maxLength, regex, coerce, date, integer, minLength, never, unknown, instance, boolean, nullable, union, picklist, length, actionOutput, actionIssue, stringify, maxValue, finite, toUpperCase, toLowerCase, toTrimmed, ipv6, ipv4, isoDateTime, endsWith, startsWith, includes, ulid, cuid2, emoji, url, email } from 'valibot';
-
-class ValibotJSONColumn extends JSONColumn {
-  constructor(schema) {
-    super(valibotSchemaConfig, schema);
-  }
-}
+import { ArrayColumn, BigIntColumn, BigSerialColumn, CitextColumn, DateColumn, DecimalColumn, DoublePrecisionColumn, EnumColumn, IntegerColumn, JSONColumn, MoneyColumn, RealColumn, SerialColumn, SmallIntColumn, SmallSerialColumn, StringColumn, TextColumn, TimestampColumn, TimestampTZColumn, VarCharColumn, makeColumnNullable, setColumnEncode, setColumnParse, setColumnParseNull, setDataValue } from "pqb/internal";
+import { actionIssue, actionOutput, array, boolean, coerce, cuid2, date, email, emoji, endsWith, finite, includes, instance, integer, ipv4, ipv6, isoDateTime, length, maxLength, maxValue, minLength, minValue, never, nullable, number, object, optional, partial, pick, picklist, regex, required, startsWith, string, stringify, toLowerCase, toTrimmed, toUpperCase, ulid, union, unknown, url, uuid } from "valibot";
+var ValibotJSONColumn = class extends JSONColumn {
+	constructor(schema) {
+		super(valibotSchemaConfig, schema);
+	}
+};
 function applyMethod(column, key, value, validation, params) {
-  const cloned = 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 = 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 = 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 = 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, minLength, params);
-  },
-  max(value, params) {
-    return applyMethod(this, "max", value, maxLength, params);
-  },
-  length(value, params) {
-    return applyMethod(this, "length", value, length, params);
-  },
-  nonEmpty(params) {
-    return applyMethod(this, "min", 1, minLength, params);
-  }
+	min(value, params) {
+		return applyMethod(this, "min", value, minLength, params);
+	},
+	max(value, params) {
+		return applyMethod(this, "max", value, maxLength, params);
+	},
+	length(value, params) {
+		return applyMethod(this, "length", value, length, params);
+	},
+	nonEmpty(params) {
+		return applyMethod(this, "min", 1, minLength, params);
+	}
+};
+var ValibotArrayColumn = class extends ArrayColumn {
+	constructor(item) {
+		super(valibotSchemaConfig, item, array(item.inputSchema, []));
+	}
 };
-class ValibotArrayColumn extends ArrayColumn {
-  constructor(item) {
-    super(valibotSchemaConfig, item, array(item.inputSchema, []));
-  }
-}
 Object.assign(ValibotArrayColumn.prototype, arrayMethods);
 function gt(requirement, message) {
-  return {
-    type: "gt",
-    expects: `>${requirement instanceof Date ? requirement.toJSON() : stringify(requirement)}`,
-    async: false,
-    message,
-    requirement,
-    _parse(input) {
-      if (input > this.requirement) {
-        return actionOutput(input);
-      }
-      return actionIssue(
-        this,
-        gt,
-        input,
-        "value",
-        input instanceof Date ? input.toJSON() : stringify(input)
-      );
-    }
-  };
+	return {
+		type: "gt",
+		expects: `>${requirement instanceof Date ? requirement.toJSON() : stringify(requirement)}`,
+		async: false,
+		message,
+		requirement,
+		_parse(input) {
+			if (input > this.requirement) return actionOutput(input);
+			return actionIssue(this, gt, input, "value", input instanceof Date ? input.toJSON() : stringify(input));
+		}
+	};
 }
 function lt(requirement, message) {
-  return {
-    type: "lt",
-    expects: `<${requirement instanceof Date ? requirement.toJSON() : stringify(requirement)}`,
-    async: false,
-    message,
-    requirement,
-    _parse(input) {
-      if (input < this.requirement) {
-        return actionOutput(input);
-      }
-      return actionIssue(
-        this,
-        lt,
-        input,
-        "value",
-        input instanceof Date ? input.toJSON() : stringify(input)
-      );
-    }
-  };
+	return {
+		type: "lt",
+		expects: `<${requirement instanceof Date ? requirement.toJSON() : stringify(requirement)}`,
+		async: false,
+		message,
+		requirement,
+		_parse(input) {
+			if (input < this.requirement) return actionOutput(input);
+			return actionIssue(this, lt, input, "value", input instanceof Date ? input.toJSON() : stringify(input));
+		}
+	};
 }
 function step(requirement, message) {
-  return {
-    type: "step",
-    expects: `a multiple of ${stringify(requirement)}`,
-    async: false,
-    message,
-    requirement,
-    _parse(input) {
-      if (input % this.requirement === 0) {
-        return actionOutput(input);
-      }
-      return actionIssue(this, step, input, "value", stringify(input));
-    }
-  };
+	return {
+		type: "step",
+		expects: `a multiple of ${stringify(requirement)}`,
+		async: false,
+		message,
+		requirement,
+		_parse(input) {
+			if (input % this.requirement === 0) return actionOutput(input);
+			return actionIssue(this, step, input, "value", 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, maxValue, params);
-  },
-  // Require a value to be lower than or equal to a given number
-  max(value, params) {
-    return applyMethod(this, "lte", value, 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, minValue, params);
-  },
-  // Require a value to be greater than or equal to a given number
-  min(value, params) {
-    return applyMethod(this, "gte", value, 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, 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, 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", integer, params);
-  },
-  // Exclude `Infinity` from being a valid value
-  finite(params) {
-    return applySimpleMethod(this, "finite", finite, params);
-  },
-  // Require the value to be less than or equal to Number.MAX_SAFE_INTEGER
-  safe(params) {
-    return applySimpleMethod(
-      applySimpleMethod(
-        this,
-        "safe",
-        minValue,
-        params,
-        Number.MIN_SAFE_INTEGER
-      ),
-      "safe",
-      maxValue,
-      params,
-      Number.MAX_SAFE_INTEGER
-    );
-  }
+	lt(value, params) {
+		return applyMethod(this, "lt", value, lt, params);
+	},
+	lte(value, params) {
+		return applyMethod(this, "lte", value, maxValue, params);
+	},
+	max(value, params) {
+		return applyMethod(this, "lte", value, maxValue, params);
+	},
+	gt(value, params) {
+		return applyMethod(this, "gt", value, gt, params);
+	},
+	gte(value, params) {
+		return applyMethod(this, "gte", value, minValue, params);
+	},
+	min(value, params) {
+		return applyMethod(this, "gte", value, minValue, params);
+	},
+	positive(params) {
+		return applyMethod(this, "gt", 0, gt, params);
+	},
+	nonNegative(params) {
+		return applyMethod(this, "gte", 0, minValue, params);
+	},
+	negative(params) {
+		return applyMethod(this, "lt", 0, lt, params);
+	},
+	nonPositive(params) {
+		return applyMethod(this, "lte", 0, maxValue, params);
+	},
+	step(value, params) {
+		return applyMethod(this, "step", value, step, params);
+	},
+	int(params) {
+		return applySimpleMethod(this, "int", integer, params);
+	},
+	finite(params) {
+		return applySimpleMethod(this, "finite", finite, params);
+	},
+	safe(params) {
+		return applySimpleMethod(applySimpleMethod(this, "safe", minValue, params, Number.MIN_SAFE_INTEGER), "safe", maxValue, params, Number.MAX_SAFE_INTEGER);
+	}
 };
-class SmallIntColumnValibot extends SmallIntColumn {
-}
+var SmallIntColumnValibot = class extends SmallIntColumn {};
 Object.assign(SmallIntColumnValibot.prototype, numberMethods);
-class IntegerColumnValibot extends IntegerColumn {
-}
+var IntegerColumnValibot = class extends IntegerColumn {};
 Object.assign(IntegerColumnValibot.prototype, numberMethods);
-class RealColumnValibot extends RealColumn {
-}
+var RealColumnValibot = class extends RealColumn {};
 Object.assign(RealColumnValibot.prototype, numberMethods);
-class SmallSerialColumnValibot extends SmallSerialColumn {
-}
+var SmallSerialColumnValibot = class extends SmallSerialColumn {};
 Object.assign(SmallSerialColumnValibot.prototype, numberMethods);
-class SerialColumnValibot extends SerialColumn {
-}
+var SerialColumnValibot = class extends SerialColumn {};
 Object.assign(SerialColumnValibot.prototype, numberMethods);
 const stringMethods = {
-  ...arrayMethods,
-  email(params) {
-    return applySimpleMethod(this, "email", email, params);
-  },
-  url(params) {
-    return applySimpleMethod(this, "url", url, params);
-  },
-  emoji(params) {
-    return applySimpleMethod(this, "emoji", emoji, params);
-  },
-  uuid(params) {
-    return applySimpleMethod(this, "uuid", uuid, params);
-  },
-  cuid2(params) {
-    return applySimpleMethod(this, "cuid2", cuid2, params);
-  },
-  ulid(params) {
-    return applySimpleMethod(this, "ulid", ulid, params);
-  },
-  regex(value, params) {
-    return applyMethod(this, "regex", value, regex, params);
-  },
-  includes(value, params) {
-    return applyMethod(this, "includes", value, includes, params);
-  },
-  startsWith(value, params) {
-    return applyMethod(this, "startsWith", value, startsWith, params);
-  },
-  endsWith(value, params) {
-    return applyMethod(this, "endsWith", value, endsWith, params);
-  },
-  datetime(params) {
-    return applySimpleMethod(this, "datetime", isoDateTime, params);
-  },
-  ipv4(params = {}) {
-    return applySimpleMethod(this, "ipv4", ipv4, params);
-  },
-  ipv6(params = {}) {
-    return applySimpleMethod(this, "ipv6", ipv6, params);
-  },
-  trim(params) {
-    return applySimpleMethod(this, "trim", toTrimmed, params);
-  },
-  toLowerCase(params) {
-    return applySimpleMethod(this, "toLowerCase", toLowerCase, params);
-  },
-  toUpperCase(params) {
-    return applySimpleMethod(this, "toUpperCase", toUpperCase, params);
-  }
+	...arrayMethods,
+	email(params) {
+		return applySimpleMethod(this, "email", email, params);
+	},
+	url(params) {
+		return applySimpleMethod(this, "url", url, params);
+	},
+	emoji(params) {
+		return applySimpleMethod(this, "emoji", emoji, params);
+	},
+	uuid(params) {
+		return applySimpleMethod(this, "uuid", uuid, params);
+	},
+	cuid2(params) {
+		return applySimpleMethod(this, "cuid2", cuid2, params);
+	},
+	ulid(params) {
+		return applySimpleMethod(this, "ulid", ulid, params);
+	},
+	regex(value, params) {
+		return applyMethod(this, "regex", value, regex, params);
+	},
+	includes(value, params) {
+		return applyMethod(this, "includes", value, includes, params);
+	},
+	startsWith(value, params) {
+		return applyMethod(this, "startsWith", value, startsWith, params);
+	},
+	endsWith(value, params) {
+		return applyMethod(this, "endsWith", value, endsWith, params);
+	},
+	datetime(params) {
+		return applySimpleMethod(this, "datetime", isoDateTime, params);
+	},
+	ipv4(params = {}) {
+		return applySimpleMethod(this, "ipv4", ipv4, params);
+	},
+	ipv6(params = {}) {
+		return applySimpleMethod(this, "ipv6", ipv6, params);
+	},
+	trim(params) {
+		return applySimpleMethod(this, "trim", toTrimmed, params);
+	},
+	toLowerCase(params) {
+		return applySimpleMethod(this, "toLowerCase", toLowerCase, params);
+	},
+	toUpperCase(params) {
+		return applySimpleMethod(this, "toUpperCase", toUpperCase, params);
+	}
 };
-class BigIntColumnValibot extends BigIntColumn {
-}
+var BigIntColumnValibot = class extends BigIntColumn {};
 Object.assign(BigIntColumnValibot.prototype, stringMethods);
-class DecimalColumnValibot extends DecimalColumn {
-}
+var DecimalColumnValibot = class extends DecimalColumn {};
 Object.assign(DecimalColumnValibot.prototype, stringMethods);
-class DoublePrecisionColumnValibot extends DoublePrecisionColumn {
-}
+var DoublePrecisionColumnValibot = class extends DoublePrecisionColumn {};
 Object.assign(DoublePrecisionColumnValibot.prototype, stringMethods);
-class BigSerialColumnValibot extends BigSerialColumn {
-}
+var BigSerialColumnValibot = class extends BigSerialColumn {};
 Object.assign(BigSerialColumnValibot.prototype, stringMethods);
-class MoneyColumnValibot extends MoneyColumn {
-}
+var MoneyColumnValibot = class extends MoneyColumn {};
 Object.assign(MoneyColumnValibot.prototype, numberMethods);
-class VarCharColumnValibot extends VarCharColumn {
-}
+var VarCharColumnValibot = class extends VarCharColumn {};
 Object.assign(VarCharColumnValibot.prototype, stringMethods);
-class TextColumnValibot extends TextColumn {
-}
+var TextColumnValibot = class extends TextColumn {};
 Object.assign(TextColumnValibot.prototype, stringMethods);
-class StringColumnValibot extends StringColumn {
-}
+var StringColumnValibot = class extends StringColumn {};
 Object.assign(StringColumnValibot.prototype, stringMethods);
-class CitextColumnValibot extends CitextColumn {
-}
+var CitextColumnValibot = class extends CitextColumn {};
 Object.assign(CitextColumnValibot.prototype, stringMethods);
 const dateMethods = {
-  min(value, params) {
-    return applyMethod(this, "min", value, minValue, params);
-  },
-  max(value, params) {
-    return applyMethod(this, "max", value, maxValue, params);
-  }
+	min(value, params) {
+		return applyMethod(this, "min", value, minValue, params);
+	},
+	max(value, params) {
+		return applyMethod(this, "max", value, maxValue, params);
+	}
 };
-class DateColumnValibot extends DateColumn {
-}
+var DateColumnValibot = class extends DateColumn {};
 Object.assign(DateColumnValibot.prototype, dateMethods);
-class TimestampNoTzColumnValibot extends TimestampColumn {
-}
+var TimestampNoTzColumnValibot = class extends TimestampColumn {};
 Object.assign(TimestampNoTzColumnValibot.prototype, dateMethods);
-class TimestampColumnValibot extends TimestampTZColumn {
-}
+var TimestampColumnValibot = class extends TimestampTZColumn {};
 Object.assign(TimestampColumnValibot.prototype, dateMethods);
 let pointSchema;
 const parseDateToDate = (value) => new Date(value);
 const valibotSchemaConfig = {
-  type: void 0,
-  parse(schema, fn) {
-    return setColumnParse(this, fn, schema);
-  },
-  parseNull(schema, fn) {
-    return setColumnParseNull(this, fn, schema);
-  },
-  encode(schema, fn) {
-    return 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(number([]), Date.parse);
-  },
-  dateAsDate() {
-    return this.parse(date([]), parseDateToDate);
-  },
-  enum(dataType, type) {
-    return new EnumColumn(valibotSchemaConfig, dataType, type, picklist(type));
-  },
-  array(item) {
-    return new ValibotArrayColumn(item);
-  },
-  nullable() {
-    return makeColumnNullable(
-      this,
-      nullable(this.inputSchema),
-      this.nullSchema ? union([this.outputSchema, this.nullSchema]) : nullable(this.outputSchema),
-      nullable(this.querySchema)
-    );
-  },
-  json(schema) {
-    return new ValibotJSONColumn(schema ?? unknown([]));
-  },
-  boolean: () => boolean([]),
-  buffer: () => instance(Buffer, []),
-  unknown: () => unknown([]),
-  never: () => never(),
-  stringSchema: () => string([]),
-  stringMin(min) {
-    return string([minLength(min)]);
-  },
-  stringMax(max) {
-    return string([maxLength(max)]);
-  },
-  stringMinMax(min, max) {
-    return string([minLength(min), maxLength(max)]);
-  },
-  number: () => number([]),
-  int: () => number([integer()]),
-  stringNumberDate: () => coerce(date([]), (input) => new Date(input)),
-  timeInterval: () => object(
-    {
-      years: optional(number()),
-      months: optional(number()),
-      days: optional(number()),
-      hours: optional(number()),
-      minutes: optional(number()),
-      seconds: optional(number())
-    },
-    []
-  ),
-  bit: (max) => max ? string([maxLength(max), regex(/[10]/g)]) : string([regex(/[10]/g)]),
-  uuid: () => string([uuid()]),
-  inputSchema() {
-    return mapSchema(this, "inputSchema");
-  },
-  outputSchema() {
-    return mapSchema(this, "outputSchema");
-  },
-  querySchema() {
-    return 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] = optional(shape[key]);
-        }
-      }
-    }
-    return object(shape);
-  },
-  updateSchema() {
-    return 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 required(
-      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 = object({
-    srid: optional(number()),
-    lon: number(),
-    lat: number()
-  }))
+	type: void 0,
+	parse(schema, fn) {
+		return setColumnParse(this, fn, schema);
+	},
+	parseNull(schema, fn) {
+		return setColumnParseNull(this, fn, schema);
+	},
+	encode(schema, fn) {
+		return 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(number([]), Date.parse);
+	},
+	dateAsDate() {
+		return this.parse(date([]), parseDateToDate);
+	},
+	enum(dataType, type) {
+		return new EnumColumn(valibotSchemaConfig, dataType, type, picklist(type));
+	},
+	array(item) {
+		return new ValibotArrayColumn(item);
+	},
+	nullable() {
+		return makeColumnNullable(this, nullable(this.inputSchema), this.nullSchema ? union([this.outputSchema, this.nullSchema]) : nullable(this.outputSchema), nullable(this.querySchema));
+	},
+	json(schema) {
+		return new ValibotJSONColumn(schema ?? unknown([]));
+	},
+	boolean: () => boolean([]),
+	buffer: () => instance(Buffer, []),
+	unknown: () => unknown([]),
+	never: () => never(),
+	stringSchema: () => string([]),
+	stringMin(min) {
+		return string([minLength(min)]);
+	},
+	stringMax(max) {
+		return string([maxLength(max)]);
+	},
+	stringMinMax(min, max) {
+		return string([minLength(min), maxLength(max)]);
+	},
+	number: () => number([]),
+	int: () => number([integer()]),
+	stringNumberDate: () => coerce(date([]), (input) => new Date(input)),
+	timeInterval: () => object({
+		years: optional(number()),
+		months: optional(number()),
+		days: optional(number()),
+		hours: optional(number()),
+		minutes: optional(number()),
+		seconds: optional(number())
+	}, []),
+	bit: (max) => max ? string([maxLength(max), regex(/[10]/g)]) : string([regex(/[10]/g)]),
+	uuid: () => string([uuid()]),
+	inputSchema() {
+		return mapSchema(this, "inputSchema");
+	},
+	outputSchema() {
+		return mapSchema(this, "outputSchema");
+	},
+	querySchema() {
+		return 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] = optional(shape[key]);
+			}
+		}
+		return object(shape);
+	},
+	updateSchema() {
+		return 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 required(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 ??= object({
+		srid: optional(number()),
+		lon: number(),
+		lat: 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 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 object(shape);
 }
-
 export { gt, lt, step, valibotSchemaConfig };
-//# sourceMappingURL=index.mjs.map
+
+//# sourceMappingURL=index.mjs.map