kern-orm 0.4.0 → 0.6.0

package/dist/types-DfoL8Oi9.mjs

@@ -0,0 +1,248 @@
+import { A as hasEquality, E as defineType, T as getBooleanType, a as stringifyJson, d as orderingOperators, i as formatTypeName, k as equalityOperators, l as defineNumberType, o as decodeBytea, s as encodeBytea, u as getIntegerType } from "./text-Cti9QLK7.mjs";
+// src/type/builtins/array.ts
+/**
+* Creates a one-dimensional array type of `element` values.
+*
+* A `NULL` element decodes to `null`; a nullable `element` type, such as `array(text.nullable())`, types such elements.
+* Elements are separated by commas, as in arrays of all built-in types; a custom type with another delimiter, such as `box`, is not supported.
+* An array has `eq`, `ne`, and `in` when its element type has SQL `=`.
+*/
+function array(element) {
+	const type = defineType({
+		sqlType: `${element.sqlType}[]`,
+		castType: `${element.castType}[]`
+	}).transform({
+		decode(text) {
+			const values = parseArray(text);
+			for (let index = 0; index < values.length; index++) {
+				const value = values[index];
+				values[index] = value === null ? null : element.decode(value);
+			}
+			return values;
+		},
+		encode(values) {
+			let text = "{";
+			for (let index = 0; index < values.length; index++) {
+				const value = values[index];
+				text += `${index === 0 ? "" : ","}${formatArrayElement(value === null ? null : element.encode(value))}`;
+			}
+			return `${text}}`;
+		}
+	});
+	return hasEquality(element) ? type.withOperators(equalityOperators) : type;
+}
+/** Parses a one-dimensional array literal, such as `{a,"b c",NULL}`, into the text representations of its elements. */
+function parseArray(text) {
+	const start = text.startsWith("[") ? text.indexOf("=") + 1 : 0;
+	if (text[start] !== "{" || !text.endsWith("}")) throw new Error(`Unsupported array value "${text}"`);
+	const elements = [];
+	const end = text.length - 1;
+	if (start + 1 === end) return elements;
+	let index = start + 1;
+	while (true) {
+		if (text[index] === "{") throw new Error("Multidimensional arrays are not supported");
+		if (text[index] === "\"") {
+			let element = "";
+			index++;
+			while (index < end && text[index] !== "\"") {
+				if (text[index] === "\\") {
+					index++;
+					if (index === end) break;
+				}
+				element += text[index];
+				index++;
+			}
+			if (index === end) throw new Error(`Unterminated quoted element in array value "${text}"`);
+			elements.push(element);
+			index++;
+		} else {
+			let next = text.indexOf(",", index);
+			if (next === -1) next = end;
+			if (next === index) throw new Error(`Malformed array value "${text}"`);
+			const element = text.slice(index, next);
+			elements.push(element === "NULL" ? null : element);
+			index = next;
+		}
+		if (index === end) return elements;
+		if (text[index] !== ",") throw new Error(`Malformed array value "${text}"`);
+		index++;
+	}
+}
+/** Formats the text representation of an array element, quoting it unless it is `NULL`. */
+function formatArrayElement(element) {
+	return element === null ? "NULL" : `"${element.replaceAll("\\", "\\\\").replaceAll("\"", "\\\"")}"`;
+}
+// src/type/builtins/binary.ts
+/** Binary data; PostgreSQL represents it in hex, which requires the default `bytea_output` setting. */
+const bytea = /* @__PURE__ */ defineType({ sqlType: "bytea" }).transform({
+	decode: decodeBytea,
+	encode: encodeBytea
+}).withOperators(equalityOperators);
+// src/type/builtins/boolean.ts
+/** `boolean` values. */
+const boolean = /* @__PURE__ */ getBooleanType();
+// src/type/builtins/datetime.ts
+/** Point in time as a UTC ISO 8601 string with microseconds, such as `2026-01-15T07:00:00.123456Z`; accepts a `Date` too. */
+const timestamptz = /* @__PURE__ */ defineType({ sqlType: "timestamptz" }).transform({
+	decode: normalizeTimestamptz,
+	encode: (value) => toPostgresYear(value instanceof Date ? value.toISOString() : value)
+}).withOperators(orderingOperators).withParameters(/* @__PURE__ */ createPrecisionFormatter("timestamptz"));
+/** Date and time without a time zone as an ISO 8601 string with microseconds, such as `2026-01-15T10:00:00.000000`. */
+const timestamp = /* @__PURE__ */ defineType({ sqlType: "timestamp" }).transform({
+	decode: normalizeTimestamp,
+	encode: toPostgresYear
+}).withOperators(orderingOperators).withParameters(/* @__PURE__ */ createPrecisionFormatter("timestamp"));
+/** Calendar date as an ISO 8601 string, such as `2026-01-15`. */
+const date = /* @__PURE__ */ defineType({ sqlType: "date" }).transform({
+	decode: normalizeDate,
+	encode: toPostgresYear
+}).withOperators(orderingOperators);
+/** Time of day as a string with microseconds, such as `10:00:00.000000`. */
+const time = /* @__PURE__ */ defineType({ sqlType: "time" }).transform({ decode: normalizeTime }).withOperators(orderingOperators).withParameters(/* @__PURE__ */ createPrecisionFormatter("time"));
+/** Interval in the PostgreSQL output format, such as `1 day 02:00:00`. */
+const interval = /* @__PURE__ */ defineType({ sqlType: "interval" }).withOperators(orderingOperators);
+function createPrecisionFormatter(name) {
+	return (precision) => formatTypeName(name, precision);
+}
+const timestamptzPattern = /^(\d{4,})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})(?:\.(\d{1,6}))?([+-])(\d{2})(?::(\d{2}))?(?::(\d{2}))?( BC)?$/;
+const timestampPattern = /^(\d{4,})(-\d{2}-\d{2}) (\d{2}:\d{2}:\d{2})(?:\.(\d{1,6}))?( BC)?$/;
+const datePattern = /^(\d{4,})(-\d{2}-\d{2})( BC)?$/;
+const timePattern = /^(\d{2}:\d{2}:\d{2})(?:\.(\d{1,6}))?$/;
+/** Leading ISO 8601 year that PostgreSQL does not accept: an expanded year, such as `+010000`, or year `0000`. */
+const isoYearPattern = /^([+-]\d{6,}|0000)(-.*)$/s;
+/** Special date and time values that PostgreSQL returns as they are. */
+const infinities = /* @__PURE__ */ new Set(["infinity", "-infinity"]);
+/**
+* Normalizes a `timestamptz` value to UTC ISO 8601 with microseconds, such as `2026-01-15T07:00:00.123456Z`.
+*
+* The fixed format keeps microseconds that `Date` would lose; the arithmetic avoids `Date`, whose range is narrower than that of PostgreSQL.
+*/
+function normalizeTimestamptz(text) {
+	if (infinities.has(text)) return text;
+	const match = timestamptzPattern.exec(text);
+	if (!match) throw new Error(`Unsupported timestamptz value "${text}"; kern-orm expects DateStyle ISO`);
+	const offset = (match[8] === "-" ? -1 : 1) * (Number(match[9]) * 3600 + Number(match[10] ?? 0) * 60 + Number(match[11] ?? 0));
+	const seconds = countDays(toAstronomicalYear(match[1], match[12]), Number(match[2]), Number(match[3])) * 86400 + Number(match[4]) * 3600 + Number(match[5]) * 60 + Number(match[6]) - offset;
+	const days = Math.floor(seconds / 86400);
+	const time = seconds - days * 86400;
+	return `${formatDate(days)}T${padTwo(Math.floor(time / 3600))}:${padTwo(Math.floor(time / 60) % 60)}:${padTwo(time % 60)}.${padFraction(match[7])}Z`;
+}
+/** Normalizes a `timestamp` value to ISO 8601 without a time zone, such as `2026-01-15T10:00:00.000000`. */
+function normalizeTimestamp(text) {
+	if (infinities.has(text)) return text;
+	const match = timestampPattern.exec(text);
+	if (!match) throw new Error(`Unsupported timestamp value "${text}"; kern-orm expects DateStyle ISO`);
+	return `${formatYear(toAstronomicalYear(match[1], match[5]))}${match[2]}T${match[3]}.${padFraction(match[4])}`;
+}
+/** Normalizes a `date` value to ISO 8601, such as `2026-01-15`. */
+function normalizeDate(text) {
+	if (infinities.has(text)) return text;
+	const match = datePattern.exec(text);
+	if (!match) throw new Error(`Unsupported date value "${text}"; kern-orm expects DateStyle ISO`);
+	return `${formatYear(toAstronomicalYear(match[1], match[3]))}${match[2]}`;
+}
+/** Normalizes a `time` value to `HH:MM:SS.ffffff`. */
+function normalizeTime(text) {
+	const match = timePattern.exec(text);
+	if (!match) throw new Error(`Unsupported time value "${text}"`);
+	return `${match[1]}.${padFraction(match[2])}`;
+}
+/** Converts a leading ISO 8601 year outside 1 to 9999 into the PostgreSQL format: unsigned after 9999 and with a `BC` suffix before 1. */
+function toPostgresYear(text) {
+	const match = isoYearPattern.exec(text);
+	if (!match) return text;
+	const year = Number(match[1]);
+	return year > 0 ? `${year}${match[2]}` : `${String(1 - year).padStart(4, "0")}${match[2]} BC`;
+}
+/** Returns the astronomical year of a PostgreSQL year, where 1 BC is year 0. */
+function toAstronomicalYear(year, era) {
+	return era === void 0 ? Number(year) : 1 - Number(year);
+}
+/** Formats an astronomical year as an ISO 8601 year, expanded with a sign outside 0 to 9999. */
+function formatYear(year) {
+	if (year >= 0 && year <= 9999) return String(year).padStart(4, "0");
+	return `${year < 0 ? "-" : "+"}${String(Math.abs(year)).padStart(6, "0")}`;
+}
+/** Counts the days from 1970-01-01 to a date of an astronomical year. */
+function countDays(year, month, day) {
+	const shifted = month <= 2 ? year - 1 : year;
+	const era = Math.floor(shifted / 400);
+	const yearOfEra = shifted - era * 400;
+	const dayOfYear = Math.floor((153 * (month > 2 ? month - 3 : month + 9) + 2) / 5) + day - 1;
+	const dayOfEra = yearOfEra * 365 + Math.floor(yearOfEra / 4) - Math.floor(yearOfEra / 100) + dayOfYear;
+	return era * 146097 + dayOfEra - 719468;
+}
+/** Formats the date a number of days after 1970-01-01 as an ISO 8601 date. */
+function formatDate(days) {
+	const shifted = days + 719468;
+	const era = Math.floor(shifted / 146097);
+	const dayOfEra = shifted - era * 146097;
+	const yearOfEra = Math.floor((dayOfEra - Math.floor(dayOfEra / 1460) + Math.floor(dayOfEra / 36524) - Math.floor(dayOfEra / 146096)) / 365);
+	const dayOfYear = dayOfEra - (365 * yearOfEra + Math.floor(yearOfEra / 4) - Math.floor(yearOfEra / 100));
+	const shiftedMonth = Math.floor((5 * dayOfYear + 2) / 153);
+	const day = dayOfYear - Math.floor((153 * shiftedMonth + 2) / 5) + 1;
+	const month = shiftedMonth < 10 ? shiftedMonth + 3 : shiftedMonth - 9;
+	return `${formatYear(yearOfEra + era * 400 + (month <= 2 ? 1 : 0))}-${padTwo(month)}-${padTwo(day)}`;
+}
+function padTwo(value) {
+	return value < 10 ? `0${value}` : String(value);
+}
+function padFraction(fraction) {
+	return (fraction ?? "").padEnd(6, "0");
+}
+// src/type/builtins/enum.ts
+/** Creates a type of an existing PostgreSQL enum; values are ordered as declared in the enum. */
+function enumOf(name, _values) {
+	return defineType({
+		sqlType: name,
+		castType: name
+	}).transform({
+		decode: (value) => value,
+		encode: (value) => value
+	}).withOperators(orderingOperators);
+}
+// src/type/builtins/json.ts
+function createJsonType(sqlType) {
+	return defineType({ sqlType }).transform({
+		decode: (text) => JSON.parse(text),
+		encode: stringifyJson
+	});
+}
+function addShape(type) {
+	return Object.freeze({
+		...type,
+		of: () => type
+	});
+}
+/** `json` values; `json.of<T>()` declares their shape. PostgreSQL has no `=` for `json`, so its expressions have no `eq`, `ne`, or `in`. */
+const json = /* @__PURE__ */ addShape(/* @__PURE__ */ createJsonType("json"));
+/** `jsonb` values; `jsonb.of<T>()` declares their shape. */
+const jsonb = /* @__PURE__ */ addShape(/* @__PURE__ */ createJsonType("jsonb").withOperators(equalityOperators));
+// src/type/builtins/network.ts
+/** IP address with an optional netmask as a string, such as `192.168.0.1`. */
+const inet = /* @__PURE__ */ defineType({ sqlType: "inet" }).withOperators(orderingOperators);
+/** IP network as a string, such as `10.0.0.0/8`. */
+const cidr = /* @__PURE__ */ defineType({ sqlType: "cidr" }).withOperators(orderingOperators);
+// src/type/builtins/numeric.ts
+/** 2-byte integer as a `number`. */
+const smallint = /* @__PURE__ */ defineNumberType("smallint");
+/** 4-byte integer as a `number`. */
+const integer = /* @__PURE__ */ getIntegerType();
+/** 8-byte integer as a `bigint`, which keeps values beyond `Number.MAX_SAFE_INTEGER`; accepts a `number` too. */
+const bigint = /* @__PURE__ */ defineType({ sqlType: "bigint" }).transform({
+	decode: BigInt,
+	encode: (value) => String(value)
+}).withOperators(orderingOperators);
+/** 4-byte floating-point number as a `number`. */
+const real = /* @__PURE__ */ defineNumberType("real");
+/** 8-byte floating-point number as a `number`. */
+const doublePrecision = /* @__PURE__ */ defineNumberType("double precision");
+/** Exact number as a decimal string, so that no precision is lost; `numeric.with(precision, scale)` constrains it. */
+const numeric = /* @__PURE__ */ defineType({ sqlType: "numeric" }).transform({
+	decode: (value) => value,
+	encode: (value) => String(value)
+}).withOperators(orderingOperators).withParameters((precision, scale) => formatTypeName("numeric", precision, scale));
+// src/type/builtins/uuid.ts
+/** UUID as a string. */
+const uuid = /* @__PURE__ */ defineType({ sqlType: "uuid" }).withOperators(orderingOperators);
+export { timestamptz as _, numeric as a, array as b, cidr as c, jsonb as d, enumOf as f, timestamp as g, time as h, integer as i, inet as l, interval as m, bigint as n, real as o, date as p, doublePrecision as r, smallint as s, uuid as t, json as u, boolean as v, bytea as y };

package/dist/types.d.mts

@@ -1,4 +1,4 @@
-import { Bt as EqualityOperator, C as TextOperators, E as NumberTypeOperators, Fr as Type, Ht as HasEquality, Jr as MergeOperators, Nr as BaseType, O as AnyExpression, Ut as InSignature, Vt as EqualityOperators, Xr as OperatorDefinitions, Yr as NoOperators, Zr as GenericOperator, rr as ComparisonSignature, w as TextTypeOperators } from "./index--0tyG7sU.mjs";
+import { Bi as MergeOperators, Di as Type, Hi as OperatorDefinitions, Lr as ComparisonSignature, Mr as EqualityOperators, Nr as HasEquality, Pr as InSignature, S as AnyExpression, Ti as BaseType, Ui as GenericOperator, Vi as NoOperators, _ as TextOperators, b as NumberTypeOperators, jr as EqualityOperator, v as TextTypeOperators } from "./index-CoKpXcBp.mjs";
 /**
  * Creates a one-dimensional array type of `element` values.
  *
@@ -13,63 +13,63 @@ export declare const bytea: BaseType<Uint8Array<ArrayBufferLike>, Uint8Array<Arr
 export declare const boolean: BaseType<boolean, boolean, EqualityOperators, undefined>;
 /** Point in time as a UTC ISO 8601 string with microseconds, such as `2026-01-15T07:00:00.123456Z`; accepts a `Date` too. */
 export declare const timestamptz: Type<string, string | Date, MergeOperators<NoOperators, {
+  eq: EqualityOperator<ComparisonSignature>;
+  ne: EqualityOperator<ComparisonSignature>;
+  in: EqualityOperator<InSignature>;
   lt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   lte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   gt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   gte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
-  eq: EqualityOperator<ComparisonSignature>;
-  ne: EqualityOperator<ComparisonSignature>;
-  in: EqualityOperator<InSignature>;
 }>, [precision: number]>;
 /** Date and time without a time zone as an ISO 8601 string with microseconds, such as `2026-01-15T10:00:00.000000`. */
 export declare const timestamp: Type<string, string, MergeOperators<NoOperators, {
+  eq: EqualityOperator<ComparisonSignature>;
+  ne: EqualityOperator<ComparisonSignature>;
+  in: EqualityOperator<InSignature>;
   lt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   lte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   gt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   gte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
-  eq: EqualityOperator<ComparisonSignature>;
-  ne: EqualityOperator<ComparisonSignature>;
-  in: EqualityOperator<InSignature>;
 }>, [precision: number]>;
 /** Calendar date as an ISO 8601 string, such as `2026-01-15`. */
 export declare const date: BaseType<string, string, MergeOperators<NoOperators, {
+  eq: EqualityOperator<ComparisonSignature>;
+  ne: EqualityOperator<ComparisonSignature>;
+  in: EqualityOperator<InSignature>;
   lt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   lte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   gt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   gte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
-  eq: EqualityOperator<ComparisonSignature>;
-  ne: EqualityOperator<ComparisonSignature>;
-  in: EqualityOperator<InSignature>;
 }>, undefined>;
 /** Time of day as a string with microseconds, such as `10:00:00.000000`. */
 export declare const time: Type<string, string, MergeOperators<NoOperators, {
+  eq: EqualityOperator<ComparisonSignature>;
+  ne: EqualityOperator<ComparisonSignature>;
+  in: EqualityOperator<InSignature>;
   lt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   lte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   gt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   gte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
-  eq: EqualityOperator<ComparisonSignature>;
-  ne: EqualityOperator<ComparisonSignature>;
-  in: EqualityOperator<InSignature>;
 }>, [precision: number]>;
 /** Interval in the PostgreSQL output format, such as `1 day 02:00:00`. */
 export declare const interval: BaseType<string, string, MergeOperators<NoOperators, {
+  eq: EqualityOperator<ComparisonSignature>;
+  ne: EqualityOperator<ComparisonSignature>;
+  in: EqualityOperator<InSignature>;
   lt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   lte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   gt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   gte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
-  eq: EqualityOperator<ComparisonSignature>;
-  ne: EqualityOperator<ComparisonSignature>;
-  in: EqualityOperator<InSignature>;
 }>, undefined>;
 /** Creates a type of an existing PostgreSQL enum; values are ordered as declared in the enum. */
 declare function enumOf<const Values extends readonly string[]>(name: string, _values: Values): BaseType<Values[number], Values[number], MergeOperators<NoOperators, {
+  eq: EqualityOperator<ComparisonSignature>;
+  ne: EqualityOperator<ComparisonSignature>;
+  in: EqualityOperator<InSignature>;
   lt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   lte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   gt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   gte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
-  eq: EqualityOperator<ComparisonSignature>;
-  ne: EqualityOperator<ComparisonSignature>;
-  in: EqualityOperator<InSignature>;
 }>, undefined>;
 /** JSON type of `unknown` values with operators `O` and `of`, which declares their shape. */
 type JsonType<O extends OperatorDefinitions = NoOperators> = Type<unknown, unknown, O> & {
@@ -82,106 +82,106 @@ export declare const json: JsonType<NoOperators>;
 export declare const jsonb: JsonType<MergeOperators<NoOperators, EqualityOperators>>;
 /** IP address with an optional netmask as a string, such as `192.168.0.1`. */
 export declare const inet: BaseType<string, string, MergeOperators<NoOperators, {
+  eq: EqualityOperator<ComparisonSignature>;
+  ne: EqualityOperator<ComparisonSignature>;
+  in: EqualityOperator<InSignature>;
   lt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   lte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   gt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   gte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
-  eq: EqualityOperator<ComparisonSignature>;
-  ne: EqualityOperator<ComparisonSignature>;
-  in: EqualityOperator<InSignature>;
 }>, undefined>;
 /** IP network as a string, such as `10.0.0.0/8`. */
 export declare const cidr: BaseType<string, string, MergeOperators<NoOperators, {
+  eq: EqualityOperator<ComparisonSignature>;
+  ne: EqualityOperator<ComparisonSignature>;
+  in: EqualityOperator<InSignature>;
   lt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   lte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   gt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   gte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
-  eq: EqualityOperator<ComparisonSignature>;
-  ne: EqualityOperator<ComparisonSignature>;
-  in: EqualityOperator<InSignature>;
 }>, undefined>;
 /** 2-byte integer as a `number`. */
 export declare const smallint: BaseType<number, number, MergeOperators<NoOperators, {
+  eq: EqualityOperator<ComparisonSignature>;
+  ne: EqualityOperator<ComparisonSignature>;
+  in: EqualityOperator<InSignature>;
   lt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   lte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   gt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   gte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
-  eq: EqualityOperator<ComparisonSignature>;
-  ne: EqualityOperator<ComparisonSignature>;
-  in: EqualityOperator<InSignature>;
 }>, undefined>;
 /** 4-byte integer as a `number`. */
 export declare const integer: BaseType<number, number, NumberTypeOperators, undefined>;
 /** 8-byte integer as a `bigint`, which keeps values beyond `Number.MAX_SAFE_INTEGER`; accepts a `number` too. */
 export declare const bigint: BaseType<bigint, number | bigint, MergeOperators<NoOperators, {
+  eq: EqualityOperator<ComparisonSignature>;
+  ne: EqualityOperator<ComparisonSignature>;
+  in: EqualityOperator<InSignature>;
   lt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   lte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   gt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   gte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
-  eq: EqualityOperator<ComparisonSignature>;
-  ne: EqualityOperator<ComparisonSignature>;
-  in: EqualityOperator<InSignature>;
 }>, undefined>;
 /** 4-byte floating-point number as a `number`. */
 export declare const real: BaseType<number, number, MergeOperators<NoOperators, {
+  eq: EqualityOperator<ComparisonSignature>;
+  ne: EqualityOperator<ComparisonSignature>;
+  in: EqualityOperator<InSignature>;
   lt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   lte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   gt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   gte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
-  eq: EqualityOperator<ComparisonSignature>;
-  ne: EqualityOperator<ComparisonSignature>;
-  in: EqualityOperator<InSignature>;
 }>, undefined>;
 /** 8-byte floating-point number as a `number`. */
 export declare const doublePrecision: BaseType<number, number, MergeOperators<NoOperators, {
+  eq: EqualityOperator<ComparisonSignature>;
+  ne: EqualityOperator<ComparisonSignature>;
+  in: EqualityOperator<InSignature>;
   lt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   lte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   gt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   gte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
-  eq: EqualityOperator<ComparisonSignature>;
-  ne: EqualityOperator<ComparisonSignature>;
-  in: EqualityOperator<InSignature>;
 }>, undefined>;
 /** Exact number as a decimal string, so that no precision is lost; `numeric.with(precision, scale)` constrains it. */
 export declare const numeric: Type<string, string | number | bigint, MergeOperators<NoOperators, {
+  eq: EqualityOperator<ComparisonSignature>;
+  ne: EqualityOperator<ComparisonSignature>;
+  in: EqualityOperator<InSignature>;
   lt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   lte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   gt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   gte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
-  eq: EqualityOperator<ComparisonSignature>;
-  ne: EqualityOperator<ComparisonSignature>;
-  in: EqualityOperator<InSignature>;
 }>, [precision: number, scale?: number | undefined]>;
 /** Variable-length string without a limit. */
 export declare const text: BaseType<string, string, TextTypeOperators, undefined>;
 /** Variable-length string; `varchar.with(length)` limits its length. */
 export declare const varchar: Type<string, string, MergeOperators<MergeOperators<NoOperators, {
+  eq: EqualityOperator<ComparisonSignature>;
+  ne: EqualityOperator<ComparisonSignature>;
+  in: EqualityOperator<InSignature>;
   lt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   lte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   gt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   gte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
-  eq: EqualityOperator<ComparisonSignature>;
-  ne: EqualityOperator<ComparisonSignature>;
-  in: EqualityOperator<InSignature>;
 }>, TextOperators>, [length: number]>;
 /** Fixed-length string that PostgreSQL pads with spaces; `char` alone has length 1, and `char.with(length)` sets the length. */
 export declare const char: Type<string, string, MergeOperators<MergeOperators<NoOperators, {
+  eq: EqualityOperator<ComparisonSignature>;
+  ne: EqualityOperator<ComparisonSignature>;
+  in: EqualityOperator<InSignature>;
   lt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   lte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   gt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   gte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
-  eq: EqualityOperator<ComparisonSignature>;
-  ne: EqualityOperator<ComparisonSignature>;
-  in: EqualityOperator<InSignature>;
 }>, TextOperators>, [length: number]>;
 /** UUID as a string. */
 export declare const uuid: BaseType<string, string, MergeOperators<NoOperators, {
+  eq: EqualityOperator<ComparisonSignature>;
+  ne: EqualityOperator<ComparisonSignature>;
+  in: EqualityOperator<InSignature>;
   lt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   lte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   gt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   gte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
-  eq: EqualityOperator<ComparisonSignature>;
-  ne: EqualityOperator<ComparisonSignature>;
-  in: EqualityOperator<InSignature>;
 }>, undefined>;
 export { enumOf as enum };