postgrejs 3.12.0 → 3.12.2

package/data-type-map.d.ts

@@ -1,5 +1,20 @@
 import type { DataType } from './interfaces/data-type.js';
 import type { OID } from './types.js';
+/**
+ * Which `DataType` answers for which OID.
+ *
+ * `GlobalTypeMap` is the one every connection uses unless it was given
+ * its own, and it already holds every type this client knows. A caller
+ * registers into it to add a type - a PostGIS geometry, a composite of
+ * their own - or copies it and registers into the copy to change one
+ * type for one connection without touching anyone else's.
+ *
+ * ```ts
+ * const typeMap = new DataTypeMap(GlobalTypeMap);
+ * typeMap.register(MyGeometryType);
+ * const connection = new Connection({ ...config, typeMap });
+ * ```
+ */
 export declare class DataTypeMap {
     protected _inferScalars: DataType[];
     protected _inferArrays: DataType[];
@@ -17,7 +32,22 @@ export declare class DataTypeMap {
      * nothing reported.
      */
     constructor(other?: DataTypeMap);
+    /**
+     * The type registered for an OID.
+     *
+     * @param oid The type to look up.
+     * @returns Its `DataType`, or `undefined` when nothing is registered -
+     * in which case values of that type come back as raw `Buffer`s.
+     */
     get(oid: OID): DataType;
+    /**
+     * Registers a type, or replaces the one already holding its OID.
+     *
+     * The array counterpart is its own registration: register both to have
+     * both read and written.
+     *
+     * @param dataTypes The type, or several at once.
+     */
     register(dataTypes: DataType | DataType[]): void;
     /**
      * The two lists determine() actually walks, newest-registered first.
@@ -35,4 +65,12 @@ export declare class DataTypeMap {
     protected _rebuildInferenceLists(): void;
     determine(value: any): OID;
 }
+/**
+ * The map every connection reads unless it was given one of its own -
+ * already holding every type this client knows.
+ *
+ * Registering here changes what every connection in the process does,
+ * which is what makes it the place for a type the whole application
+ * shares, and the wrong place for one connection's exception.
+ */
 export declare const GlobalTypeMap: DataTypeMap;

package/data-type-map.js

@@ -40,6 +40,21 @@ import { ArrayUuidType, UuidType } from './data-types/uuid-type.js';
 import { ArrayVarcharType, VarcharType } from './data-types/varchar-type.js';
 import { ArrayCidType, ArrayXid8Type, ArrayXidType, CidType, Xid8Type, XidType, } from './data-types/xid-type.js';
 import { arrayLeaf } from './util/array-leaf.js';
+/**
+ * Which `DataType` answers for which OID.
+ *
+ * `GlobalTypeMap` is the one every connection uses unless it was given
+ * its own, and it already holds every type this client knows. A caller
+ * registers into it to add a type - a PostGIS geometry, a composite of
+ * their own - or copies it and registers into the copy to change one
+ * type for one connection without touching anyone else's.
+ *
+ * ```ts
+ * const typeMap = new DataTypeMap(GlobalTypeMap);
+ * typeMap.register(MyGeometryType);
+ * const connection = new Connection({ ...config, typeMap });
+ * ```
+ */
 export class DataTypeMap {
     _inferScalars = [];
     _inferArrays = [];
@@ -67,9 +82,24 @@ export class DataTypeMap {
             this._inferArrays = other._inferArrays;
         }
     }
+    /**
+     * The type registered for an OID.
+     *
+     * @param oid The type to look up.
+     * @returns Its `DataType`, or `undefined` when nothing is registered -
+     * in which case values of that type come back as raw `Buffer`s.
+     */
     get(oid) {
         return this._itemsByOID[oid];
     }
+    /**
+     * Registers a type, or replaces the one already holding its OID.
+     *
+     * The array counterpart is its own registration: register both to have
+     * both read and written.
+     *
+     * @param dataTypes The type, or several at once.
+     */
     register(dataTypes) {
         dataTypes = Array.isArray(dataTypes) ? dataTypes : [dataTypes];
         for (const t of dataTypes) {
@@ -155,6 +185,14 @@ export class DataTypeMap {
         return DataTypeOIDs.unknown;
     }
 }
+/**
+ * The map every connection reads unless it was given one of its own -
+ * already holding every type this client knows.
+ *
+ * Registering here changes what every connection in the process does,
+ * which is what makes it the place for a type the whole application
+ * shares, and the wrong place for one connection's exception.
+ */
 export const GlobalTypeMap = new DataTypeMap();
 GlobalTypeMap.register([OidType, ArrayOidType]);
 GlobalTypeMap.register([OidVectorType, ArrayOidVectorType]);

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

@@ -1,5 +1,9 @@
 import type { DataType } from '../interfaces/data-type.js';
+/** `bit(n)`, as a string of `0`s and `1`s - its own text form, and the only lossless one for a length the server chose. */
 export declare const BitType: DataType;
+/** The `_bit` array of {@link BitType}. */
 export declare const ArrayBitType: DataType;
+/** `varbit` (bit varying), as a string of `0`s and `1`s. */
 export declare const VarbitType: DataType;
+/** The `_varbit` array of {@link VarbitType}. */
 export declare const ArrayVarbitType: DataType;

package/data-types/bit-type.js

@@ -75,14 +75,18 @@ function createType(name, oid) {
         },
     };
 }
+/** `bit(n)`, as a string of `0`s and `1`s - its own text form, and the only lossless one for a length the server chose. */
 export const BitType = createType('bit', DataTypeOIDs.bit);
+/** The `_bit` array of {@link BitType}. */
 export const ArrayBitType = {
     ...BitType,
     name: '_bit',
     oid: DataTypeOIDs._bit,
     elementsOID: DataTypeOIDs.bit,
 };
+/** `varbit` (bit varying), as a string of `0`s and `1`s. */
 export const VarbitType = createType('varbit', DataTypeOIDs.varbit);
+/** The `_varbit` array of {@link VarbitType}. */
 export const ArrayVarbitType = {
     ...VarbitType,
     name: '_varbit',

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

@@ -1,3 +1,5 @@
 import type { DataType } from '../interfaces/data-type.js';
+/** `bool`, as a JavaScript boolean. Its text form is the `t`/`f` the server itself writes. */
 export declare const BoolType: DataType;
+/** The `_bool` array of {@link BoolType}. */
 export declare const ArrayBoolType: DataType;

package/data-types/bool-type.js

@@ -1,4 +1,5 @@
 import { DataTypeOIDs } from '../constants.js';
+/** `bool`, as a JavaScript boolean. Its text form is the `t`/`f` the server itself writes. */
 export const BoolType = {
     name: 'bool',
     oid: DataTypeOIDs.bool,
@@ -25,6 +26,7 @@ export const BoolType = {
         return typeof v === 'boolean';
     },
 };
+/** The `_bool` array of {@link BoolType}. */
 export const ArrayBoolType = {
     ...BoolType,
     name: '_bool',

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

@@ -1,3 +1,5 @@
 import type { DataType } from '../interfaces/data-type.js';
+/** `box`, as a {@link Box}. Its array literal separates elements with a semicolon rather than a comma, which is what `arraySeparator` is for. */
 export declare const BoxType: DataType;
+/** The `_box` array of {@link BoxType}. */
 export declare const ArrayBoxType: DataType;

package/data-types/box-type.js

@@ -3,6 +3,7 @@ import { Box, TwoPoints } from './classes/geometric.js';
 const BOX_PATTERN1 = /^\( *\( *(-?\d+\.?\d*) *, *(-?\d+\.?\d*) *\) *, *\( *(-?\d+\.?\d*) *, *(-?\d+\.?\d*) *\) *\)$/;
 const BOX_PATTERN2 = /^\( *(-?\d+\.?\d*) *, *(-?\d+\.?\d*) *\) *, *\( *(-?\d+\.?\d*) *, *(-?\d+\.?\d*) *\)$/;
 const BOX_PATTERN3 = /^(-?\d+\.?\d*) *, *(-?\d+\.?\d*) *, *(-?\d+\.?\d*) *, *(-?\d+\.?\d*)$/;
+/** `box`, as a {@link Box}. Its array literal separates elements with a semicolon rather than a comma, which is what `arraySeparator` is for. */
 export const BoxType = {
     name: 'box',
     oid: DataTypeOIDs.box,
@@ -37,6 +38,7 @@ export const BoxType = {
         return v instanceof Box || TwoPoints.isTwoPointsLike(v);
     },
 };
+/** The `_box` array of {@link BoxType}. */
 export const ArrayBoxType = {
     ...BoxType,
     name: '_box',

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

@@ -1,3 +1,5 @@
 import type { DataType } from '../interfaces/data-type.js';
+/** `bytea`, as a `Buffer`. The binary format is the bytes themselves; the text one is `\\x`-prefixed hex, at two characters a byte. */
 export declare const ByteaType: DataType;
+/** The `_bytea` array of {@link ByteaType}. */
 export declare const ArrayByteaType: DataType;

package/data-types/bytea-type.js

@@ -1,5 +1,6 @@
 import { DataTypeOIDs } from '../constants.js';
 import { parseBytea, parseByteaBuffer } from '../util/parse-bytea.js';
+/** `bytea`, as a `Buffer`. The binary format is the bytes themselves; the text one is `\\x`-prefixed hex, at two characters a byte. */
 export const ByteaType = {
     name: 'bytea',
     oid: DataTypeOIDs.bytea,
@@ -22,6 +23,7 @@ export const ByteaType = {
         return v instanceof Buffer;
     },
 };
+/** The `_bytea` array of {@link ByteaType}. */
 export const ArrayByteaType = {
     ...ByteaType,
     name: '_bytea',

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

@@ -1,3 +1,5 @@
 import type { DataType } from '../interfaces/data-type.js';
+/** `char` - the single-byte internal type, not `char(n)` - as a one-character string. */
 export declare const CharType: DataType;
+/** The `_char` array of {@link CharType}. */
 export declare const ArrayCharType: DataType;

package/data-types/char-type.js

@@ -1,4 +1,5 @@
 import { DataTypeOIDs } from '../constants.js';
+/** `char` - the single-byte internal type, not `char(n)` - as a one-character string. */
 export const CharType = {
     name: 'char',
     oid: DataTypeOIDs.char,
@@ -37,6 +38,7 @@ export const CharType = {
      */
     inferrable: false,
 };
+/** The `_char` array of {@link CharType}. */
 export const ArrayCharType = {
     ...CharType,
     name: '_char',

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

@@ -1,3 +1,5 @@
 import type { DataType } from '../interfaces/data-type.js';
+/** `circle`, as a {@link Circle} - a centre point and a radius, named as PostgreSQL names them. */
 export declare const CircleType: DataType;
+/** The `_circle` array of {@link CircleType}. */
 export declare const ArrayCircleType: DataType;

package/data-types/circle-type.js

@@ -4,6 +4,7 @@ const CIRCLE_PATTERN1 = /^< *\( *(-?\d+\.?\d*) *, *(-?\d+\.?\d*) *\) *, *(-?\d+\
 const CIRCLE_PATTERN2 = /^\( *\( *(-?\d+\.?\d*) *, *(-?\d+\.?\d*) *\) *, *(-?\d+\.?\d*) *\)$/;
 const CIRCLE_PATTERN3 = /^\( *(-?\d+\.?\d*) *, *(-?\d+\.?\d*) *\) *, *(-?\d+\.?\d*)$/;
 const CIRCLE_PATTERN4 = /^(-?\d+\.?\d*) *, *(-?\d+\.?\d*) *, *(-?\d+\.?\d*)$/;
+/** `circle`, as a {@link Circle} - a centre point and a radius, named as PostgreSQL names them. */
 export const CircleType = {
     name: 'circle',
     oid: DataTypeOIDs.circle,
@@ -40,6 +41,7 @@ export const CircleType = {
         return v instanceof Circle || Circle.isCircleLike(v);
     },
 };
+/** The `_circle` array of {@link CircleType}. */
 export const ArrayCircleType = {
     ...CircleType,
     name: '_circle',

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

@@ -1,3 +1,5 @@
 import type { DataType } from '../interfaces/data-type.js';
+/** `date`, as a `Date` at local midnight - or at UTC midnight with `utcDates`. */
 export declare const DateType: DataType;
+/** The `_date` array of {@link DateType}. */
 export declare const ArrayDateType: DataType;

package/data-types/date-type.js

@@ -3,6 +3,7 @@ import { formatDate } from '../util/format-datetime.js';
 import { utcPartsAsLocal } from '../util/local-date.js';
 import { parseDate } from '../util/parse-datetime.js';
 const timeShift = 946684800000;
+/** `date`, as a `Date` at local midnight - or at UTC midnight with `utcDates`. */
 export const DateType = {
     name: 'date',
     oid: DataTypeOIDs.date,
@@ -56,6 +57,7 @@ export const DateType = {
             v.getMilliseconds() === 0);
     },
 };
+/** The `_date` array of {@link DateType}. */
 export const ArrayDateType = {
     ...DateType,
     name: '_date',

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

@@ -1,3 +1,5 @@
 import type { DataType } from '../interfaces/data-type.js';
+/** `float4` (real), as a number - the shortest decimal that reads back as the same 32-bit float. */
 export declare const Float4Type: DataType;
+/** The `_float4` array of {@link Float4Type}. */
 export declare const ArrayFloat4Type: DataType;

package/data-types/float4-type.js

@@ -1,6 +1,7 @@
 import { DataTypeOIDs } from '../constants.js';
 import { assertCoercedNumber } from '../util/assert-integer.js';
 import { fastParseFloatBuffer } from '../util/fast-parsefloat.js';
+/** `float4` (real), as a number - the shortest decimal that reads back as the same 32-bit float. */
 export const Float4Type = {
     name: 'float4',
     oid: DataTypeOIDs.float4,
@@ -20,6 +21,7 @@ export const Float4Type = {
         return typeof v === 'number';
     },
 };
+/** The `_float4` array of {@link Float4Type}. */
 export const ArrayFloat4Type = {
     ...Float4Type,
     name: '_float4',

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

@@ -1,3 +1,5 @@
 import type { DataType } from '../interfaces/data-type.js';
+/** `float8` (double precision), as a number. */
 export declare const Float8Type: DataType;
+/** The `_float8` array of {@link Float8Type}. */
 export declare const ArrayFloat8Type: DataType;

package/data-types/float8-type.js

@@ -1,6 +1,7 @@
 import { DataTypeOIDs } from '../constants.js';
 import { assertCoercedNumber } from '../util/assert-integer.js';
 import { fastParseFloatBuffer } from '../util/fast-parsefloat.js';
+/** `float8` (double precision), as a number. */
 export const Float8Type = {
     name: 'float8',
     oid: DataTypeOIDs.float8,
@@ -21,6 +22,7 @@ export const Float8Type = {
         return typeof v === 'number';
     },
 };
+/** The `_float8` array of {@link Float8Type}. */
 export const ArrayFloat8Type = {
     ...Float8Type,
     name: '_float8',

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,
@@ -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,
@@ -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

@@ -3,6 +3,7 @@ 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,
@@ -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;