kern-orm 0.0.0-stage → 0.1.0

package/dist/testing.d.mts

@@ -0,0 +1,2 @@
+import { S as createTestHelpers, _ as PendingTestFixture, b as TestHooks, g as OpenedTestFixture, v as TestFixture, x as TestTransactionOptions, y as TestHelpers } from "./expression-Bc-s_0qJ.mjs";
+export { type OpenedTestFixture, type PendingTestFixture, type TestFixture, type TestHelpers, type TestHooks, type TestTransactionOptions, createTestHelpers };

package/dist/testing.mjs

@@ -0,0 +1,34 @@
+// src/execution/testing.ts
+/** Creates the test helpers of a database created with `test: true`, registering fixtures with the hooks of a test runner. */
+function createTestHelpers(database, hooks) {
+	const { coordinator } = database;
+	if (!coordinator.test) throw new Error("createTestHelpers requires a database created with test: true");
+	return {
+		testTransaction: (callback, options) => coordinator.testTransaction(callback, options),
+		useTestFixture(seed) {
+			let pending;
+			let fixture;
+			hooks.before(async () => {
+				const current = coordinator.startTestFixture(seed);
+				pending = current;
+				try {
+					const opened = await current.fixture;
+					if (pending === current) fixture = opened;
+				} catch (error) {
+					if (pending === current) throw error;
+				}
+			});
+			hooks.after(async () => {
+				const current = pending;
+				pending = void 0;
+				fixture = void 0;
+				await current?.close();
+			});
+			return { get data() {
+				if (!fixture) throw new Error("Test fixture is not open: read its data in the tests and hooks of the describe block or test file that uses it");
+				return fixture.data;
+			} };
+		}
+	};
+}
+export { createTestHelpers };

package/dist/text-4Xs09pIf.mjs

@@ -0,0 +1,413 @@
+// src/ast/nodes.ts
+/** Freezes an expression node; nodes are shared between queries and never change. */
+function createNode(node) {
+	return Object.freeze(node);
+}
+/** Creates SQL of `items` separated by commas between `prefix` and `suffix`, such as the arguments of a function call. */
+function createList(prefix, items, suffix) {
+	if (items.length === 0) return createNode({
+		kind: "raw",
+		fragments: [prefix + suffix],
+		values: []
+	});
+	const fragments = [prefix];
+	for (let index = 1; index < items.length; index++) fragments.push(", ");
+	fragments.push(suffix);
+	return createNode({
+		kind: "raw",
+		fragments,
+		values: items
+	});
+}
+/** Filters of a query without conditions. */
+const noFilters = /* @__PURE__ */ Object.freeze({});
+/** Creates a query of all rows of `from` with `projections`. */
+function createSelectNode(from, projections = []) {
+	return Object.freeze({
+		kind: "select",
+		from,
+		joins: [],
+		projections,
+		filters: noFilters,
+		orderBy: [],
+		limit: void 0,
+		offset: void 0,
+		rows: "many",
+		value: false,
+		guaranteedBy: void 0
+	});
+}
+const trueNode = /* @__PURE__ */ createNode({
+	kind: "boolean",
+	value: true
+});
+const falseNode = /* @__PURE__ */ createNode({
+	kind: "boolean",
+	value: false
+});
+/** Number `1`, such as the limit of a query of one row. */
+const oneNode = /* @__PURE__ */ createNode({
+	kind: "raw",
+	fragments: ["1"],
+	values: []
+});
+// src/expression/operators/generic.ts
+/** Runtime mark of generic operators. */
+const genericOperatorBrand = Symbol("kern-orm.genericOperator");
+/**
+* Defines a generic operator: one definition for every type, which works with the values of the expression it is called on.
+*
+* It receives the expression with its own type, including a type derived with `transform`, and its method has signature `S` with the value types of the expression, such as `lt` of `orderingOperators`.
+* An operator defined as a plain function works with the values of the type it was added to instead.
+* `Self` restricts the types it can be added to with `withOperators`; derived types keep the operator after `transform`.
+*/
+function defineGenericOperator(implementation) {
+	return Object.assign(implementation.bind(void 0), { [genericOperatorBrand]: true });
+}
+/** Tells whether an operator is generic, created by `defineGenericOperator`. */
+function isGenericOperator(operator) {
+	return typeof operator === "function" && genericOperatorBrand in operator;
+}
+// src/expression/operators/equality.ts
+/** Runtime mark of the operators of `equalityOperators`, which tell that a type has SQL `=`. */
+const equalityBrand = Symbol("kern-orm.equality");
+/**
+* Operators of SQL equality: `eq`, `ne`, and `in`; `orderingOperators` include them.
+*
+* A type has SQL `=` only with these operators, so that an array of it has them too; another operator named `eq` does not give it `=`.
+*/
+const equalityOperators = {
+	eq: defineEqualityOperator((self, value) => compare(self, "=", value)),
+	ne: defineEqualityOperator((self, value) => compare(self, "<>", value)),
+	in: defineEqualityOperator((self, list) => {
+		if (list.length === 0) return toBooleanExpression(falseNode);
+		const type = getType(self);
+		const nodes = [];
+		for (const item of list) nodes.push(toValueNode(item, type));
+		return toBooleanExpression(createNode({
+			kind: "in",
+			operand: toNode(self),
+			list: nodes
+		}));
+	})
+};
+/** Tells whether a type has SQL `=`, given by an operator of `equalityOperators`. */
+function hasEquality(type) {
+	const operators = type.operators;
+	for (const name in operators) if (equalityBrand in operators[name]) return true;
+	return false;
+}
+/**
+* Families of different SQL types, by their cast types, whose values PostgreSQL compares with `=` of one B-tree operator family, so that an index of either column serves the comparison.
+*
+* `varchar` has no `=` of its own and compares as `text`.
+*/
+const equalityFamilies = /* @__PURE__ */ new Map([
+	["smallint", "integer"],
+	["integer", "integer"],
+	["bigint", "integer"],
+	["text", "text"],
+	["varchar", "text"]
+]);
+/**
+* Tells whether SQL `=` compares the values of two types as they are: both have SQL `=`, and they are one SQL type or of one family of `equalityFamilies`.
+*
+* Types are one SQL type when their cast types are equal, whatever their type parameters and the JavaScript representation of their values.
+* Equal TypeScript types are not enough, such as of `uuid` and `text`, which PostgreSQL does not compare.
+*/
+function isEqualityCompatible(left, right) {
+	if (!hasEquality(left) || !hasEquality(right)) return false;
+	if (left.castType === right.castType) return true;
+	const family = equalityFamilies.get(left.castType);
+	return family !== void 0 && family === equalityFamilies.get(right.castType);
+}
+function defineEqualityOperator(implementation) {
+	return Object.assign(defineGenericOperator(implementation), { [equalityBrand]: true });
+}
+// src/table/column.ts
+/**
+* Column of a table: a type with column attributes, forming a key of kind `Key` alone, or no key for `undefined`, with a value of the database when an insert omits it if `Default` is `true`.
+*
+* A column is not a type, so SQL fragments and parameters reject it; its methods add attributes and return a new column.
+*/
+var Column = class Column {
+	type;
+	attributes;
+	constructor(type, attributes) {
+		this.type = type;
+		this.attributes = attributes;
+		Object.freeze(attributes);
+		Object.freeze(this);
+	}
+	/** Uses a physical column name different from the column key. */
+	columnName(name) {
+		return new Column(this.type, {
+			...this.attributes,
+			name
+		});
+	}
+	/** Marks the column as the primary key; the type must not be nullable. */
+	primaryKey() {
+		return markKey(this, "primaryKey");
+	}
+	/** Marks the column as a unique key. */
+	unique() {
+		return markKey(this, "unique");
+	}
+	/** Marks the column as one that the database gives a value when an insert omits it, such as by `DEFAULT` or an identity, so that inserts may omit it. */
+	hasDefault() {
+		return new Column(this.type, {
+			...this.attributes,
+			hasDefault: true
+		});
+	}
+};
+/** Creates a column of `column` that forms a key of kind `keyKind` alone, rejecting a column that already forms a key. */
+function markKey(column, keyKind) {
+	if (column.attributes.keyKind !== void 0) throw new Error(`A column marked with ${column.attributes.keyKind}() cannot be marked with ${keyKind}()`);
+	return new Column(column.type, {
+		...column.attributes,
+		keyKind
+	});
+}
+// src/type/type.ts
+/** Runtime mark of types, which tells them apart from columns and other objects. */
+const typeBrand = Symbol("kern-orm.type");
+/**
+* Defines a type whose values are the PostgreSQL text representations as they are.
+*
+* `transform` converts them to other values, such as `number[]` for `vector`.
+*/
+function defineType(options) {
+	if (options.castType === void 0 && options.sqlType.includes("(")) throw new TypeError(`Define the type parameters of "${options.sqlType}" using withParameters(), or set castType`);
+	return createType({
+		sqlType: options.sqlType,
+		castType: options.castType ?? options.sqlType,
+		encode: (value) => value,
+		decode: (text) => text,
+		operators: Object.freeze({}),
+		isNullable: false,
+		formatSqlType: void 0
+	});
+}
+/** Tells whether `value` is a type, as opposed to a column or another object. */
+function isType(value) {
+	return typeof value === "object" && value !== null && typeBrand in value;
+}
+function createType(state) {
+	const derive = (changes) => createType({
+		...state,
+		...changes
+	});
+	const { formatSqlType } = state;
+	const type = Object.freeze({
+		...state,
+		[typeBrand]: true,
+		withOperators(extra) {
+			const operators = { ...state.operators };
+			for (const name of Object.keys(extra)) {
+				if (name === "then") throw new TypeError("Operator \"then\" is not allowed: it would make expressions thenable");
+				const operator = extra[name];
+				Object.defineProperty(operators, name, {
+					value: isGenericOperator(operator) ? operator : (self, ...args) => operator(getType(self) === type ? self : toExpression(toNode(self), type), ...args),
+					enumerable: true
+				});
+			}
+			return derive({ operators: Object.freeze(operators) });
+		},
+		transform: ({ decode, encode }) => derive({
+			encode: encode ? (value) => state.encode(encode(value)) : state.encode,
+			decode: (text) => decode(state.decode(text))
+		}),
+		withParameters: (format) => derive({ formatSqlType: format }),
+		...formatSqlType && { with: (...parameters) => derive({ sqlType: formatSqlType(...parameters) }) },
+		nullable: () => derive({ isNullable: true }),
+		columnName: (name) => new Column(type, {
+			name,
+			keyKind: void 0,
+			hasDefault: false
+		}),
+		primaryKey: () => new Column(type, {
+			name: void 0,
+			keyKind: "primaryKey",
+			hasDefault: false
+		}),
+		unique: () => new Column(type, {
+			name: void 0,
+			keyKind: "unique",
+			hasDefault: false
+		}),
+		hasDefault: () => new Column(type, {
+			name: void 0,
+			keyKind: void 0,
+			hasDefault: true
+		})
+	});
+	return type;
+}
+// src/type/boolean.ts
+let booleanType;
+/** Returns the shared Boolean type used by built-in expressions and columns. */
+function getBooleanType() {
+	booleanType ??= defineType({ sqlType: "boolean" }).transform({
+		decode: (text) => text === "t",
+		encode: (value) => value ? "t" : "f"
+	}).withOperators(equalityOperators);
+	return booleanType;
+}
+// src/expression/expression.ts
+const expressionNode = Symbol("kern-orm.expression.node");
+const expressionType = Symbol("kern-orm.expression.type");
+/**
+* Runtime class of every expression.
+*
+* An expression inherits the operators of its type from a prototype created once per type.
+*/
+var ExpressionObject = class {
+	isNull() {
+		return toBooleanExpression(createIsNullNode(this[expressionNode]));
+	}
+};
+let untypedPrototype;
+/** Prototypes of expressions by their types, with the operators of the type as methods. */
+const prototypes = /* @__PURE__ */ new WeakMap();
+function getPrototype(type) {
+	let prototype = prototypes.get(type);
+	if (!prototype) {
+		prototype = createPrototype(type.operators);
+		prototypes.set(type, prototype);
+	}
+	return prototype;
+}
+function createPrototype(operators) {
+	const prototype = Object.create(ExpressionObject.prototype);
+	for (const name of Object.keys(operators)) {
+		const operator = operators[name];
+		Object.defineProperty(prototype, name, { value: function(...args) {
+			return operator(this, ...args);
+		} });
+	}
+	return prototype;
+}
+/** Returns the node behind a public expression. */
+function toNode(expression) {
+	return expression[expressionNode];
+}
+function toExpression(node, type) {
+	const expression = Object.create(type ? getPrototype(type) : untypedPrototype ??= createPrototype(equalityOperators));
+	expression[expressionNode] = node;
+	expression[expressionType] = type;
+	return Object.freeze(expression);
+}
+/** Tells whether `value` is an expression. */
+function isExpression(value) {
+	return value instanceof ExpressionObject;
+}
+/** Returns the type of an expression, if it has one. */
+function getType(expression) {
+	return expression[expressionType];
+}
+/** Exposes a Boolean node with the shared codec and operators. */
+function toBooleanExpression(node) {
+	return toExpression(node, getBooleanType());
+}
+/** Converts an expression or a plain value into a node, binding the value as a parameter encoded with `type`. */
+function toValueNode(value, type) {
+	return value instanceof ExpressionObject ? value[expressionNode] : createNode({
+		kind: "param",
+		value,
+		type
+	});
+}
+/** Creates an `IS NULL` node directly, so that resolving an object condition never calls an `isNull` operator replaced by a type. */
+function createIsNullNode(operand) {
+	return createNode({
+		kind: "isNull",
+		operand
+	});
+}
+// src/expression/operators/comparison.ts
+function compare(self, operator, value) {
+	return toBooleanExpression(compareNodes(operator, toNode(self), value, getType(self)));
+}
+/** Creates a comparison node, encoding a plain `right` value with `type`. */
+function compareNodes(operator, left, right, type) {
+	return createNode({
+		kind: "comparison",
+		operator,
+		left,
+		right: toValueNode(right, type)
+	});
+}
+// src/expression/operators/ordering.ts
+/** Operators of ordered types: those of `equalityOperators`, and `lt`, `lte`, `gt`, and `gte` comparing with operands of the expression type. */
+const orderingOperators = {
+	...equalityOperators,
+	lt: createComparison("<"),
+	lte: createComparison("<="),
+	gt: createComparison(">"),
+	gte: createComparison(">=")
+};
+function createComparison(operator) {
+	return defineGenericOperator((self, value) => compare(self, operator, value));
+}
+// src/expression/operators/text.ts
+/**
+* Operators of text types: pattern matching with `LIKE` and `ILIKE`.
+*
+* A string pattern is sent as it is; `param(type, pattern)` encodes it with a type.
+*/
+const textOperators = {
+	like: /* @__PURE__ */ createPatternComparison("LIKE"),
+	ilike: /* @__PURE__ */ createPatternComparison("ILIKE")
+};
+function createPatternComparison(operator) {
+	return defineGenericOperator((self, pattern) => toBooleanExpression(compareNodes(operator, toNode(self), pattern, void 0)));
+}
+// src/type/codecs/bytea.ts
+const hexDigits = "0123456789abcdef";
+/** Encodes bytes as a hex `bytea` literal, such as `\\x00ff`. */
+function encodeBytea(bytes) {
+	let text = "\\x";
+	for (const byte of bytes) text += hexDigits[byte >> 4] + hexDigits[byte & 15];
+	return text;
+}
+/** Decodes a hex `bytea` literal into bytes. */
+function decodeBytea(text) {
+	if (!text.startsWith("\\x")) throw new Error("Unsupported bytea value; kern-orm expects bytea_output hex");
+	const bytes = new Uint8Array((text.length - 2) / 2);
+	for (let index = 0; index < bytes.length; index++) bytes[index] = readHexDigit(text, 2 + index * 2) << 4 | readHexDigit(text, 3 + index * 2);
+	return bytes;
+}
+/** Reads the hex digit at `index`, in either case. */
+function readHexDigit(text, index) {
+	const code = text.charCodeAt(index);
+	return code <= 57 ? code - 48 : (code | 32) - 87;
+}
+// src/type/codecs/json.ts
+/** Serializes a value as JSON text; values without a JSON representation, such as functions, are rejected. */
+function stringifyJson(value) {
+	const text = JSON.stringify(value);
+	if (text === void 0) throw new TypeError(`Cannot encode ${typeof value} as JSON`);
+	return text;
+}
+// src/type/type-name.ts
+/** Appends type parameters, such as the precision and scale in `numeric(10,2)`, to a type name. */
+function formatTypeName(name, ...parameters) {
+	const defined = parameters.filter((parameter) => parameter !== void 0);
+	return defined.length === 0 ? name : `${name}(${defined.join(",")})`;
+}
+// src/type/builtins/text.ts
+function defineTextType(sqlType, castType) {
+	return defineType({
+		sqlType,
+		castType
+	}).withOperators(orderingOperators).withOperators(textOperators);
+}
+/** Variable-length string without a limit. */
+const text = /* @__PURE__ */ defineTextType("text");
+/** Variable-length string; `varchar.with(length)` limits its length. */
+const varchar = /* @__PURE__ */ defineTextType("varchar").withParameters((length) => formatTypeName("varchar", length));
+/** Fixed-length string that PostgreSQL pads with spaces; `char` alone has length 1, and `char.with(length)` sets the length. */
+const char = /* @__PURE__ */ defineTextType("char", "bpchar").withParameters((length) => formatTypeName("char", length));
+export { falseNode as A, equalityOperators as C, createList as D, defineGenericOperator as E, oneNode as M, trueNode as N, createNode as O, Column as S, isEqualityCompatible as T, toNode as _, stringifyJson as a, defineType as b, textOperators as c, compareNodes as d, createIsNullNode as f, toExpression as g, toBooleanExpression as h, formatTypeName as i, noFilters as j, createSelectNode as k, orderingOperators as l, isExpression as m, text as n, decodeBytea as o, getType as p, varchar as r, encodeBytea as s, char as t, compare as u, toValueNode as v, hasEquality as w, isType as x, getBooleanType as y };

package/dist/types.d.mts

@@ -0,0 +1,213 @@
+import { Qn as BaseType, Sn as ComparisonSignature, _n as EqualityOperators, er as Type, gn as EqualityOperator, gr as GenericOperator, hr as OperatorDefinitions, mr as NoOperators, pr as MergeOperators, t as AnyExpression, vn as HasEquality, yn as InSignature } from "./expression-Bc-s_0qJ.mjs";
+import { s as PatternSignature } from "./index-Chr-UK_t.mjs";
+/**
+ * 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 `=`.
+ */
+export declare function array<Output, Input, O extends OperatorDefinitions>(element: Type<Output, Input, O, any>): Type<Output[], Input[], HasEquality<O> extends true ? EqualityOperators : NoOperators>;
+/** Binary data; PostgreSQL represents it in hex, which requires the default `bytea_output` setting. */
+export declare const bytea: BaseType<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>, MergeOperators<NoOperators, EqualityOperators>, undefined>;
+/** `boolean` values. */
+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>>;
+}>, [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>>;
+}>, [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>>;
+}>, 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>>;
+}>, [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>>;
+}>, 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>>;
+}>, 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> & {
+  /** Declares the shape of the values, which is not validated at runtime. */
+  of<T>(): Type<T, T, O>;
+};
+/** `json` values; `json.of<T>()` declares their shape. PostgreSQL has no `=` for `json`, so its expressions have no `eq`, `ne`, or `in`. */
+export declare const json: JsonType<NoOperators>;
+/** `jsonb` values; `jsonb.of<T>()` declares their shape. */
+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>>;
+}>, 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>>;
+}>, 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>>;
+}>, undefined>;
+/** 4-byte integer as a `number`. */
+export declare const integer: 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>>;
+}>, 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>>;
+}>, 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>>;
+}>, 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>>;
+}>, 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>>;
+}>, [precision: number, scale?: number | undefined]>;
+/** Variable-length string without a limit. */
+export declare const text: BaseType<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>>;
+}>, {
+  like: GenericOperator<PatternSignature, AnyExpression<string | null, unknown>>;
+  ilike: GenericOperator<PatternSignature, AnyExpression<string | null, unknown>>;
+}>, 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>>;
+}>, {
+  like: GenericOperator<PatternSignature, AnyExpression<string | null, unknown>>;
+  ilike: GenericOperator<PatternSignature, AnyExpression<string | null, unknown>>;
+}>, [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>>;
+}>, {
+  like: GenericOperator<PatternSignature, AnyExpression<string | null, unknown>>;
+  ilike: GenericOperator<PatternSignature, AnyExpression<string | null, unknown>>;
+}>, [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>>;
+}>, undefined>;
+export { enumOf as enum };