postgrejs 3.11.1 → 3.12.1

package/data-types/inet-type.d.ts

@@ -1,5 +1,9 @@
 import type { DataType } from '../interfaces/data-type.js';
+/** `inet`, as a string - an address, with the netmask only when it is not the full width. */
 export declare const InetType: DataType;
+/** The `_inet` array of {@link InetType}. */
 export declare const ArrayInetType: DataType;
+/** `cidr`, as a string. The same wire format as {@link InetType}; a network always prints its netmask. */
 export declare const CidrType: DataType;
+/** The `_cidr` array of {@link CidrType}. */
 export declare const ArrayCidrType: DataType;

package/data-types/inet-type.js

@@ -230,6 +230,7 @@ function decode(v, offset) {
             v[offset + 7];
     return isCidr || bits !== size * 8 ? text + '/' + bits : text;
 }
+/** `inet`, as a string - an address, with the netmask only when it is not the full width. */
 export const InetType = {
     name: 'inet',
     oid: DataTypeOIDs.inet,
@@ -264,12 +265,14 @@ export const InetType = {
         return !!parseAddress(v);
     },
 };
+/** The `_inet` array of {@link InetType}. */
 export const ArrayInetType = {
     ...InetType,
     name: '_inet',
     oid: DataTypeOIDs._inet,
     elementsOID: DataTypeOIDs.inet,
 };
+/** `cidr`, as a string. The same wire format as {@link InetType}; a network always prints its netmask. */
 export const CidrType = {
     ...InetType,
     name: 'cidr',
@@ -278,6 +281,7 @@ export const CidrType = {
         encode(buf, v, true);
     },
 };
+/** The `_cidr` array of {@link CidrType}. */
 export const ArrayCidrType = {
     ...CidrType,
     name: '_cidr',

package/data-types/int2-type.d.ts

@@ -1,3 +1,5 @@
 import type { DataType } from '../interfaces/data-type.js';
+/** `int2` (smallint), as a number. */
 export declare const Int2Type: DataType;
+/** The `_int2` array of {@link Int2Type}. */
 export declare const ArrayInt2Type: DataType;

package/data-types/int2-type.js

@@ -1,6 +1,7 @@
 import { DataTypeOIDs } from '../constants.js';
 import { assertInteger } from '../util/assert-integer.js';
 import { fastParseInt, fastParseIntBuffer } from '../util/fast-parseint.js';
+/** `int2` (smallint), as a number. */
 export const Int2Type = {
     name: 'int2',
     oid: DataTypeOIDs.int2,
@@ -9,7 +10,7 @@ export const Int2Type = {
         return '' + v;
     },
     encodeBinary(buf, v) {
-        buf.writeInt16BE(assertInteger(fastParseInt(v), 'int2'));
+        buf.writeInt16BE(assertInteger(v, 'int2', -32768, 32767));
     },
     decodeBinary(v, offset = 0) {
         return v.readInt16BE(offset);
@@ -20,6 +21,7 @@ export const Int2Type = {
         return (typeof v === 'number' && Number.isInteger(v) && v >= -32768 && v <= 32767);
     },
 };
+/** The `_int2` array of {@link Int2Type}. */
 export const ArrayInt2Type = {
     ...Int2Type,
     name: '_int2',

package/data-types/int2-vector-type.d.ts

@@ -1,3 +1,5 @@
 import type { DataType } from '../interfaces/data-type.js';
+/** `int2vector`, the catalog's own list of column numbers, as an array of numbers. Subscripted from 0, unlike every ordinary array. */
 export declare const Int2VectorType: DataType;
+/** The `_int2vector` array of {@link Int2VectorType}. */
 export declare const ArrayInt2VectorType: DataType;

package/data-types/int2-vector-type.js

@@ -3,6 +3,7 @@ import { SmartBuffer } from '../protocol/smart-buffer.js';
 import { decodeBinaryArray } from '../util/decode-binaryarray.js';
 import { encodeBinaryArray } from '../util/encode-binaryarray.js';
 import { fastParseInt } from '../util/fast-parseint.js';
+/** `int2vector`, the catalog's own list of column numbers, as an array of numbers. Subscripted from 0, unlike every ordinary array. */
 export const Int2VectorType = {
     name: 'int2vector',
     oid: DataTypeOIDs.int2vector,
@@ -41,6 +42,7 @@ export const Int2VectorType = {
                 x <= 32767)));
     },
 };
+/** The `_int2vector` array of {@link Int2VectorType}. */
 export const ArrayInt2VectorType = {
     ...Int2VectorType,
     name: '_int2vector',

package/data-types/int4-type.d.ts

@@ -1,3 +1,5 @@
 import type { DataType } from '../interfaces/data-type.js';
+/** `int4` (integer), as a number. */
 export declare const Int4Type: DataType;
+/** The `_int4` array of {@link Int4Type}. */
 export declare const ArrayInt4Type: DataType;

package/data-types/int4-type.js

@@ -1,6 +1,7 @@
 import { DataTypeOIDs } from '../constants.js';
 import { assertInteger } from '../util/assert-integer.js';
 import { fastParseInt, fastParseIntBuffer } from '../util/fast-parseint.js';
+/** `int4` (integer), as a number. */
 export const Int4Type = {
     name: 'int4',
     oid: DataTypeOIDs.int4,
@@ -9,7 +10,7 @@ export const Int4Type = {
         return '' + v;
     },
     encodeBinary(buf, v) {
-        buf.writeInt32BE(assertInteger(fastParseInt(v), 'int4'));
+        buf.writeInt32BE(assertInteger(v, 'int4', -2147483648, 2147483647));
     },
     decodeBinary(v, offset = 0) {
         return v.readInt32BE(offset);
@@ -23,6 +24,7 @@ export const Int4Type = {
             v <= 2147483647);
     },
 };
+/** The `_int4` array of {@link Int4Type}. */
 export const ArrayInt4Type = {
     ...Int4Type,
     name: '_int4',

package/data-types/int8-type.d.ts

@@ -1,3 +1,5 @@
 import type { DataType } from '../interfaces/data-type.js';
+/** `int8` (bigint), as a number while one is exact and a `BigInt` beyond that. */
 export declare const Int8Type: DataType;
+/** The `_int8` array of {@link Int8Type}. */
 export declare const ArrayInt8Type: DataType;

package/data-types/int8-type.js

@@ -1,8 +1,9 @@
 import { DataTypeOIDs } from '../constants.js';
-import { assertBigIntSource } from '../util/assert-integer.js';
+import { assertBigInt } from '../util/assert-integer.js';
 import { readBigInt64BE } from '../util/bigint-methods.js';
 import { fastParseIntBuffer } from '../util/fast-parseint.js';
 const maxSafeInteger = BigInt(Number.MAX_SAFE_INTEGER);
+/** `int8` (bigint), as a number while one is exact and a `BigInt` beyond that. */
 export const Int8Type = {
     name: 'int8',
     oid: DataTypeOIDs.int8,
@@ -11,7 +12,7 @@ export const Int8Type = {
         return '' + v;
     },
     encodeBinary(buf, v) {
-        buf.writeBigInt64BE(assertBigIntSource(v, 'int8'));
+        buf.writeBigInt64BE(assertBigInt(v, 'int8'));
     },
     decodeBinary(buf, offset = 0) {
         const v = typeof buf.readBigInt64BE === 'function'
@@ -40,6 +41,7 @@ export const Int8Type = {
                 (v > 2147483647 || v < -2147483648)));
     },
 };
+/** The `_int8` array of {@link Int8Type}. */
 export const ArrayInt8Type = {
     ...Int8Type,
     name: '_int8',

package/data-types/interval-type.d.ts

@@ -1,5 +1,14 @@
 import type { DataType } from '../interfaces/data-type.js';
 import { Interval } from './classes/interval.js';
+/**
+ * Reads an interval as the server writes one, in any of the output
+ * styles `IntervalStyle` selects.
+ *
+ * @param v The value's text.
+ * @returns The interval, with months, days and microseconds kept apart.
+ */
 export declare function parseIntervalText(v: string): Interval;
+/** `interval`, as an {@link Interval}: months, days and microseconds kept apart, because the server keeps them apart and a month is not a fixed number of days. */
 export declare const IntervalType: DataType;
+/** The `_interval` array of {@link IntervalType}. */
 export declare const ArrayIntervalType: DataType;

package/data-types/interval-type.js

@@ -18,6 +18,13 @@ function toInterval(v) {
     throw new TypeError(`"${typeof v}" cannot be encoded as an interval - pass an Interval, ` +
         'a plain object of its fields, or a string PostgreSQL would accept');
 }
+/**
+ * Reads an interval as the server writes one, in any of the output
+ * styles `IntervalStyle` selects.
+ *
+ * @param v The value's text.
+ * @returns The interval, with months, days and microseconds kept apart.
+ */
 export function parseIntervalText(v) {
     const m = INTERVAL_PATTERN.exec(v);
     if (!m) {
@@ -41,6 +48,7 @@ export function parseIntervalText(v) {
         milliseconds: m[8] ? (sign * parseInt(m[8].padEnd(6, '0'), 10)) / 1000 : 0,
     });
 }
+/** `interval`, as an {@link Interval}: months, days and microseconds kept apart, because the server keeps them apart and a month is not a fixed number of days. */
 export const IntervalType = {
     name: 'interval',
     oid: DataTypeOIDs.interval,
@@ -71,6 +79,7 @@ export const IntervalType = {
         return v instanceof Interval;
     },
 };
+/** The `_interval` array of {@link IntervalType}. */
 export const ArrayIntervalType = {
     ...IntervalType,
     name: '_interval',

package/data-types/json-type.d.ts

@@ -1,3 +1,5 @@
 import type { DataType } from '../interfaces/data-type.js';
+/** `json`, as the text the server stored - parsing it is the caller's to do, and their choice of parser. */
 export declare const JsonType: DataType;
+/** The `_json` array of {@link JsonType}. */
 export declare const ArrayJsonType: DataType;

package/data-types/json-type.js

@@ -1,4 +1,5 @@
 import { DataTypeOIDs } from '../constants.js';
+/** `json`, as the text the server stored - parsing it is the caller's to do, and their choice of parser. */
 export const JsonType = {
     name: 'json',
     oid: DataTypeOIDs.json,
@@ -33,6 +34,7 @@ export const JsonType = {
 function decodeJsonText(v) {
     return v ? JSON.parse(v) : null;
 }
+/** The `_json` array of {@link JsonType}. */
 export const ArrayJsonType = {
     ...JsonType,
     name: '_json',

package/data-types/jsonb-type.d.ts

@@ -1,3 +1,5 @@
 import type { DataType } from '../interfaces/data-type.js';
+/** `jsonb`, as text. The binary form carries a version byte the value itself does not. */
 export declare const JsonbType: DataType;
+/** The `_jsonb` array of {@link JsonbType}. */
 export declare const ArrayJsonbType: DataType;

package/data-types/jsonb-type.js

@@ -1,4 +1,5 @@
 import { DataTypeOIDs } from '../constants.js';
+/** `jsonb`, as text. The binary form carries a version byte the value itself does not. */
 export const JsonbType = {
     name: 'jsonb',
     oid: DataTypeOIDs.jsonb,
@@ -35,6 +36,7 @@ export const JsonbType = {
 function decodeJsonbText(v) {
     return v ? JSON.parse(v) : null;
 }
+/** The `_jsonb` array of {@link JsonbType}. */
 export const ArrayJsonbType = {
     ...JsonbType,
     name: '_jsonb',

package/data-types/jsonpath-type.d.ts

@@ -1,3 +1,5 @@
 import type { DataType } from '../interfaces/data-type.js';
+/** `jsonpath`, as text. */
 export declare const JsonPathType: DataType;
+/** The `_jsonpath` array of {@link JsonPathType}. */
 export declare const ArrayJsonPathType: DataType;

package/data-types/jsonpath-type.js

@@ -11,6 +11,7 @@ import { DataTypeOIDs } from '../constants.js';
  */
 /** The only format the server has ever written, and the one it reads. */
 const JSONPATH_VERSION = 1;
+/** `jsonpath`, as text. */
 export const JsonPathType = {
     name: 'jsonpath',
     oid: DataTypeOIDs.jsonpath,
@@ -45,6 +46,7 @@ export const JsonPathType = {
         return typeof v === 'string' && /^\s*(?:(?:strict|lax)\s+)?[$@]/.test(v);
     },
 };
+/** The `_jsonpath` array of {@link JsonPathType}. */
 export const ArrayJsonPathType = {
     ...JsonPathType,
     name: '_jsonpath',

package/data-types/line-type.d.ts

@@ -1,3 +1,5 @@
 import type { DataType } from '../interfaces/data-type.js';
+/** `line`, as a {@link Line} - the `A`, `B` and `C` of `Ax + By + C = 0`, which is how the server stores it. */
 export declare const LineType: DataType;
+/** The `_line` array of {@link LineType}. */
 export declare const ArrayLineType: DataType;

package/data-types/line-type.js

@@ -1,6 +1,7 @@
 import { DataTypeOIDs } from '../constants.js';
 import { Line } from './classes/geometric.js';
 const LINE_PATTERN = /^\{ *(-?[\d.]+(?:e[-+]?\d+)?) *, *(-?[\d.]+(?:e[-+]?\d+)?) *, *(-?[\d.]+(?:e[-+]?\d+)?) *\}$/i;
+/** `line`, as a {@link Line} - the `A`, `B` and `C` of `Ax + By + C = 0`, which is how the server stores it. */
 export const LineType = {
     name: 'line',
     oid: DataTypeOIDs.line,
@@ -33,6 +34,7 @@ export const LineType = {
         return v instanceof Line || Line.isLineLike(v);
     },
 };
+/** The `_line` array of {@link LineType}. */
 export const ArrayLineType = {
     ...LineType,
     name: '_line',

package/data-types/lseg-type.d.ts

@@ -1,3 +1,5 @@
 import type { DataType } from '../interfaces/data-type.js';
+/** `lseg`, as a {@link LineSegment}. */
 export declare const LsegType: DataType;
+/** The `_lseg` array of {@link LsegType}. */
 export declare const ArrayLsegType: DataType;

package/data-types/lseg-type.js

@@ -4,6 +4,7 @@ const LSEG_PATTERN1 = /^\[ *\( *(-?\d+\.?\d*) *, *(-?\d+\.?\d*) *\) *, *\( *(-?\
 const LSEG_PATTERN2 = /^\( *\( *(-?\d+\.?\d*) *, *(-?\d+\.?\d*) *\) *, *\( *(-?\d+\.?\d*) *, *(-?\d+\.?\d*) *\) *\)$/;
 const LSEG_PATTERN3 = /^\( *(-?\d+\.?\d*) *, *(-?\d+\.?\d*) *\) *, *\( *(-?\d+\.?\d*) *, *(-?\d+\.?\d*) *\)$/;
 const LSEG_PATTERN4 = /^(-?\d+\.?\d*) *, *(-?\d+\.?\d*) *, *(-?\d+\.?\d*) *, *(-?\d+\.?\d*)$/;
+/** `lseg`, as a {@link LineSegment}. */
 export const LsegType = {
     name: 'lseg',
     oid: DataTypeOIDs.lseg,
@@ -41,6 +42,7 @@ export const LsegType = {
         return v instanceof LineSegment || TwoPoints.isTwoPointsLike(v);
     },
 };
+/** The `_lseg` array of {@link LsegType}. */
 export const ArrayLsegType = {
     ...LsegType,
     name: '_lseg',

package/data-types/macaddr-type.d.ts

@@ -1,5 +1,9 @@
 import type { DataType } from '../interfaces/data-type.js';
+/** `macaddr`, as its six-group colon-separated text. */
 export declare const MacaddrType: DataType;
+/** The `_macaddr` array of {@link MacaddrType}. */
 export declare const ArrayMacaddrType: DataType;
+/** `macaddr8`, as its eight-group colon-separated text. */
 export declare const Macaddr8Type: DataType;
+/** The `_macaddr8` array of {@link Macaddr8Type}. */
 export declare const ArrayMacaddr8Type: DataType;

package/data-types/macaddr-type.js

@@ -79,14 +79,18 @@ function createType(name, oid, size) {
         },
     };
 }
+/** `macaddr`, as its six-group colon-separated text. */
 export const MacaddrType = createType('macaddr', DataTypeOIDs.macaddr, 6);
+/** The `_macaddr` array of {@link MacaddrType}. */
 export const ArrayMacaddrType = {
     ...MacaddrType,
     name: '_macaddr',
     oid: DataTypeOIDs._macaddr,
     elementsOID: DataTypeOIDs.macaddr,
 };
+/** `macaddr8`, as its eight-group colon-separated text. */
 export const Macaddr8Type = createType('macaddr8', DataTypeOIDs.macaddr8, 8);
+/** The `_macaddr8` array of {@link Macaddr8Type}. */
 export const ArrayMacaddr8Type = {
     ...Macaddr8Type,
     name: '_macaddr8',

package/data-types/money-type.d.ts

@@ -35,4 +35,5 @@ export declare function moneyToString(minorUnits: bigint, scale: number): string
  * knows the server or is reading a value some other server rendered.
  */
 export declare const MoneyType: DataType;
+/** The `_money` array of {@link MoneyType}. */
 export declare const ArrayMoneyType: DataType;

package/data-types/money-type.js

@@ -61,18 +61,24 @@ export function moneyToString(minorUnits, scale) {
 }
 /**
  * Below this many minor units the decimal has at most fifteen
- * significant digits, which a double both holds and prints back exactly
- * - so the round trip below can only agree, and asking it is the most
- * expensive thing in the decode: measured over values that vary,
- * `parseFloat` plus the comparison is 241 ns against 113 ns without it,
- * on a decode whose string-building is 109 ns of that.
- *
- * The scale bound is the other half: the test is about *printed* digits,
- * and JavaScript switches to exponential notation below 1e-6, which
- * PostgreSQL never writes. At scale 6 the smallest non-zero value is
- * exactly 1e-6, and no currency has more.
+ * significant digits, which a double both holds and prints back exactly.
  */
+/* So the round trip below can only agree, and asking it is the most
+   expensive thing in the decode: measured over values that vary,
+   parseFloat plus the comparison is 241 ns against 113 ns without it, on
+   a decode whose string-building is 109 ns of that.
+
+   The scale bound is the other half: the test is about *printed* digits,
+   and JavaScript switches to exponential notation below 1e-6, which
+   PostgreSQL never writes. At scale 6 the smallest non-zero value is
+   exactly 1e-6, and no currency has more. */
 const FAITHFUL_LIMIT = 1000000000000000n; // 10^15
+/**
+ * Whether this value is small enough that a double is exact for it.
+ *
+ * @param minorUnits The amount, in the currency's smallest unit.
+ * @param scale How many decimal places that currency has.
+ */
 function isFaithful(minorUnits, scale) {
     return (scale <= 6 && minorUnits < FAITHFUL_LIMIT && minorUnits > -FAITHFUL_LIMIT);
 }
@@ -225,6 +231,7 @@ function toExactMinor(v, scale) {
     const out = BigInt(digits || '0');
     return neg ? -out : out;
 }
+/** The `_money` array of {@link MoneyType}. */
 export const ArrayMoneyType = {
     ...MoneyType,
     name: '_money',

package/data-types/numeric-type.d.ts

@@ -1,7 +1,9 @@
 import type { DataType } from '../interfaces/data-type.js';
 /** The decimal without the zeroes a declared scale pads it out to. */
 export declare function trimTrailingZeros(s: string): string;
+/** `numeric`, as a number while one is exact, a {@link Numeric} when it is not, and a string with `decimalAsString`. */
 export declare const NumericType: DataType;
+/** The `_numeric` array of {@link NumericType}. */
 export declare const ArrayNumericType: DataType;
 /**
  * Turns a JS exponential-notation number string (e.g. "1e+21", "-1.5e-7")

package/data-types/numeric-type.js

@@ -45,6 +45,7 @@ function toNumberOrNumeric(s) {
     const n = parseFloat(s);
     return String(n) === trimTrailingZeros(s) ? n : new Numeric(s);
 }
+/** `numeric`, as a number while one is exact, a {@link Numeric} when it is not, and a string with `decimalAsString`. */
 export const NumericType = {
     name: 'numeric',
     oid: DataTypeOIDs.numeric,
@@ -200,6 +201,7 @@ export const NumericType = {
         return typeof v === 'number' || v instanceof Numeric;
     },
 };
+/** The `_numeric` array of {@link NumericType}. */
 export const ArrayNumericType = {
     ...NumericType,
     name: '_numeric',

package/data-types/oid-type.d.ts

@@ -1,3 +1,5 @@
 import type { DataType } from '../interfaces/data-type.js';
+/** `oid`, as a number. */
 export declare const OidType: DataType;
+/** The `_oid` array of {@link OidType}. */
 export declare const ArrayOidType: DataType;

package/data-types/oid-type.js

@@ -1,6 +1,7 @@
 import { DataTypeNames, DataTypeOIDs } from '../constants.js';
 import { assertInteger } from '../util/assert-integer.js';
 import { fastParseInt, fastParseIntBuffer } from '../util/fast-parseint.js';
+/** `oid`, as a number. */
 export const OidType = {
     name: 'oid',
     oid: DataTypeOIDs.oid,
@@ -9,7 +10,7 @@ export const OidType = {
         return '' + v;
     },
     encodeBinary(buf, v) {
-        buf.writeUInt32BE(assertInteger(fastParseInt(v), 'oid'));
+        buf.writeUInt32BE(assertInteger(v, 'oid', 0, 4294967295));
     },
     decodeBinary(v, offset = 0) {
         return v.readUInt32BE(offset);
@@ -20,6 +21,7 @@ export const OidType = {
         return typeof v === 'number' && Number.isInteger(v) && !!DataTypeNames[v];
     },
 };
+/** The `_oid` array of {@link OidType}. */
 export const ArrayOidType = {
     ...OidType,
     name: '_oid',

package/data-types/oid-vector-type.d.ts

@@ -6,4 +6,5 @@ import type { DataType } from '../interfaces/data-type.js';
  * space-separated rather than braced.
  */
 export declare const OidVectorType: DataType;
+/** The `_oidvector` array of {@link OidVectorType}. */
 export declare const ArrayOidVectorType: DataType;

package/data-types/oid-vector-type.js

@@ -47,6 +47,7 @@ export const OidVectorType = {
                 x <= 4294967295)));
     },
 };
+/** The `_oidvector` array of {@link OidVectorType}. */
 export const ArrayOidVectorType = {
     ...OidVectorType,
     name: '_oidvector',

package/data-types/path-type.d.ts

@@ -1,5 +1,9 @@
 import type { DataType } from '../interfaces/data-type.js';
+/** `path`, as a {@link Path}: the points, and whether the path is closed. */
 export declare const PathType: DataType;
+/** The `_path` array of {@link PathType}. */
 export declare const ArrayPathType: DataType;
+/** `polygon`, as a {@link Polygon}. */
 export declare const PolygonType: DataType;
+/** The `_polygon` array of {@link PolygonType}. */
 export declare const ArrayPolygonType: DataType;

package/data-types/path-type.js

@@ -62,6 +62,7 @@ function toPoints(v, name) {
         return v.points;
     throw new TypeError(`"${typeof v}" cannot be encoded as a ${name} - pass a ${name === 'path' ? 'Path' : 'Polygon'} or an array of points`);
 }
+/** `path`, as a {@link Path}: the points, and whether the path is closed. */
 export const PathType = {
     name: 'path',
     oid: DataTypeOIDs.path,
@@ -97,12 +98,14 @@ export const PathType = {
         return v instanceof Path;
     },
 };
+/** The `_path` array of {@link PathType}. */
 export const ArrayPathType = {
     ...PathType,
     name: '_path',
     oid: DataTypeOIDs._path,
     elementsOID: DataTypeOIDs.path,
 };
+/** `polygon`, as a {@link Polygon}. */
 export const PolygonType = {
     name: 'polygon',
     oid: DataTypeOIDs.polygon,
@@ -131,6 +134,7 @@ export const PolygonType = {
         return v instanceof Polygon;
     },
 };
+/** The `_polygon` array of {@link PolygonType}. */
 export const ArrayPolygonType = {
     ...PolygonType,
     name: '_polygon',

package/data-types/pg-lsn-type.d.ts

@@ -1,3 +1,5 @@
 import type { DataType } from '../interfaces/data-type.js';
+/** `pg_lsn`, as the `16/B374D848` text the server prints - the spelling every tool and every catalog column uses. */
 export declare const PgLsnType: DataType;
+/** The `_pg_lsn` array of {@link PgLsnType}. */
 export declare const ArrayPgLsnType: DataType;

package/data-types/pg-lsn-type.js

@@ -37,6 +37,7 @@ function writeHalf(value, p) {
         TEXT[p++] = HEX_UPPER[(value >>> shift) & 15];
     return p;
 }
+/** `pg_lsn`, as the `16/B374D848` text the server prints - the spelling every tool and every catalog column uses. */
 export const PgLsnType = {
     name: 'pg_lsn',
     oid: DataTypeOIDs.pg_lsn,
@@ -71,6 +72,7 @@ export const PgLsnType = {
         return typeof v === 'string' && LSN_PATTERN.test(v);
     },
 };
+/** The `_pg_lsn` array of {@link PgLsnType}. */
 export const ArrayPgLsnType = {
     ...PgLsnType,
     name: '_pg_lsn',

package/data-types/point-type.d.ts

@@ -1,3 +1,5 @@
 import type { DataType } from '../interfaces/data-type.js';
+/** `point`, as a {@link Point}. */
 export declare const PointType: DataType;
+/** The `_point` array of {@link PointType}. */
 export declare const ArrayPointType: DataType;

package/data-types/point-type.js

@@ -2,6 +2,7 @@ import { DataTypeOIDs } from '../constants.js';
 import { Point } from './classes/geometric.js';
 const POINT_PATTERN1 = /^\( *(-?\d+\.?\d*) *, *(-?\d+\.?\d*) *\)$/;
 const POINT_PATTERN2 = /^(-?\d+\.?\d*) *, *(-?\d+\.?\d*)$/;
+/** `point`, as a {@link Point}. */
 export const PointType = {
     name: 'point',
     oid: DataTypeOIDs.point,
@@ -33,6 +34,7 @@ export const PointType = {
         return v instanceof Point || Point.isPointLike(v);
     },
 };
+/** The `_point` array of {@link PointType}. */
 export const ArrayPointType = {
     ...PointType,
     name: '_point',

package/data-types/range-type.d.ts

@@ -20,4 +20,8 @@ export declare function createRangeType(name: string, oid: OID, element: DataTyp
  * repeating it.
  */
 export declare function createMultiRangeType(name: string, oid: OID, range: DataType): DataType;
+/**
+ * Every range and multirange type, built from the types they are ranges
+ * of, and registered together.
+ */
 export declare const RangeTypes: DataType[];

package/data-types/range-type.js

@@ -328,6 +328,10 @@ const BUILT_IN = [
         TimestamptzType,
     ],
 ];
+/**
+ * Every range and multirange type, built from the types they are ranges
+ * of, and registered together.
+ */
 export const RangeTypes = [];
 for (const [name, oid, arrayOid, multiOid, multiArrayOid, , element,] of BUILT_IN) {
     const rangeType = createRangeType(name, oid, element);

package/data-types/snapshot-type.d.ts

@@ -1,5 +1,9 @@
 import type { DataType } from '../interfaces/data-type.js';
+/** `pg_snapshot`, as the `xmin:xmax:xip_list` text it is written as. */
 export declare const PgSnapshotType: DataType;
+/** The `_pg_snapshot` array of {@link PgSnapshotType}. */
 export declare const ArrayPgSnapshotType: DataType;
+/** `txid_snapshot`, the older spelling of {@link PgSnapshotType}, as the same text. */
 export declare const TxidSnapshotType: DataType;
+/** The `_txid_snapshot` array of {@link TxidSnapshotType}. */
 export declare const ArrayTxidSnapshotType: DataType;

package/data-types/snapshot-type.js

@@ -80,14 +80,18 @@ function createType(name, oid) {
         },
     };
 }
+/** `pg_snapshot`, as the `xmin:xmax:xip_list` text it is written as. */
 export const PgSnapshotType = createType('pg_snapshot', DataTypeOIDs.pg_snapshot);
+/** The `_pg_snapshot` array of {@link PgSnapshotType}. */
 export const ArrayPgSnapshotType = {
     ...PgSnapshotType,
     name: '_pg_snapshot',
     oid: DataTypeOIDs._pg_snapshot,
     elementsOID: DataTypeOIDs.pg_snapshot,
 };
+/** `txid_snapshot`, the older spelling of {@link PgSnapshotType}, as the same text. */
 export const TxidSnapshotType = createType('txid_snapshot', DataTypeOIDs.txid_snapshot);
+/** The `_txid_snapshot` array of {@link TxidSnapshotType}. */
 export const ArrayTxidSnapshotType = {
     ...TxidSnapshotType,
     name: '_txid_snapshot',

package/data-types/tid-type.d.ts

@@ -1,3 +1,5 @@
 import type { DataType } from '../interfaces/data-type.js';
+/** `tid`, a physical row address, as the `(block,offset)` text the server prints. */
 export declare const TidType: DataType;
+/** The `_tid` array of {@link TidType}. */
 export declare const ArrayTidType: DataType;