@juit/pgproxy-types 1.0.0

package/dist/parsers/interval.cjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/parsers/interval.ts"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,+BAA6B;AA2B7B,IAAM,mBAA0C,yBAAAA;AAGzC,IAAM,aAAoC,MAAM,uBAC7C,iBACc;AAAA,EACtB,YAAY,OAAe;AACzB,UAAM,KAAK;AAAA,EACb;AACF;AAGO,IAAM,gBAAsC,CAAC,UAAkB,IAAI,WAAW,KAAK;",
+  "names": ["postgresInterval"]
+}

package/dist/parsers/interval.d.ts

@@ -0,0 +1,23 @@
+import type { PGParser } from '../parsers';
+import type { PGSerializable } from '../serializers';
+/** A parsed PostgreSQL `interval` */
+export interface PGInterval extends PGSerializable {
+    years: number;
+    months: number;
+    days: number;
+    hours: number;
+    minutes: number;
+    seconds: number;
+    milliseconds: number;
+    toISO(): string;
+    toISOString(): string;
+    toISOStringShort(): string;
+}
+/** Constructor for {@link PGInterval} */
+export interface PGIntervalConstructor {
+    new (value: string): PGInterval;
+}
+/** A parsed PostgreSQL `interval` */
+export declare const PGInterval: PGIntervalConstructor;
+/** Parse a PostgreSQL `interval` */
+export declare const parseInterval: PGParser<PGInterval>;

package/dist/parsers/interval.mjs

@@ -0,0 +1,14 @@
+// parsers/interval.ts
+import postgresInterval from "postgres-interval";
+var PostgresInterval = postgresInterval;
+var PGInterval = class PGIntervalImpl extends PostgresInterval {
+  constructor(value) {
+    super(value);
+  }
+};
+var parseInterval = (value) => new PGInterval(value);
+export {
+  PGInterval,
+  parseInterval
+};
+//# sourceMappingURL=interval.mjs.map

package/dist/parsers/interval.mjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/parsers/interval.ts"],
+  "mappings": ";AAAA,OAAO,sBAAsB;AA2B7B,IAAM,mBAA0C;AAGzC,IAAM,aAAoC,MAAM,uBAC7C,iBACc;AAAA,EACtB,YAAY,OAAe;AACzB,UAAM,KAAK;AAAA,EACb;AACF;AAGO,IAAM,gBAAsC,CAAC,UAAkB,IAAI,WAAW,KAAK;",
+  "names": []
+}

package/dist/parsers/range.cjs

@@ -0,0 +1,97 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// parsers/range.ts
+var range_exports = {};
+__export(range_exports, {
+  PGRange: () => PGRange,
+  parseBigintRange: () => parseBigintRange,
+  parseBigintRangeArray: () => parseBigintRangeArray,
+  parseFloatRange: () => parseFloatRange,
+  parseFloatRangeArray: () => parseFloatRangeArray,
+  parseIntRange: () => parseIntRange,
+  parseIntRangeArray: () => parseIntRangeArray,
+  parseRange: () => parseRange,
+  parseRangeArray: () => parseRangeArray,
+  parseTimestampRange: () => parseTimestampRange,
+  parseTimestampRangeArray: () => parseTimestampRangeArray,
+  parseTimestampTzRange: () => parseTimestampTzRange,
+  parseTimestampTzRangeArray: () => parseTimestampTzRangeArray
+});
+module.exports = __toCommonJS(range_exports);
+var import_postgres_range = __toESM(require("postgres-range"));
+var import_array = require("./array.cjs");
+var import_basic = require("./basic.cjs");
+var PGRange = class PGRangeImpl extends import_postgres_range.default.Range {
+  mask;
+  constructor(lower, upper, flags) {
+    super(lower, upper, flags);
+    this.mask = flags;
+  }
+  toPostgres(serialize) {
+    return import_postgres_range.default.serialize(this, serialize);
+  }
+  static RANGE_EMPTY = import_postgres_range.default.RANGE_EMPTY;
+  static RANGE_LB_INC = import_postgres_range.default.RANGE_LB_INC;
+  static RANGE_UB_INC = import_postgres_range.default.RANGE_UB_INC;
+  static RANGE_LB_INF = import_postgres_range.default.RANGE_LB_INF;
+  static RANGE_UB_INF = import_postgres_range.default.RANGE_UB_INF;
+};
+function parseRange(value, parser = import_basic.parseString) {
+  const range = import_postgres_range.default.parse(value, parser);
+  return new PGRange(range.lower, range.upper, range.mask);
+}
+var parseIntRange = (value) => parseRange(value, parseInt);
+var parseFloatRange = (value) => parseRange(value, parseFloat);
+var parseBigintRange = (value) => parseRange(value, import_basic.parseBigint);
+var parseTimestampRange = (value) => parseRange(value, import_basic.parseTimestamp);
+var parseTimestampTzRange = (value) => parseRange(value, import_basic.parseTimestampTz);
+var parseRangeArray = (value) => (0, import_array.parseArray)(value, parseRange);
+var parseIntRangeArray = (value) => (0, import_array.parseArray)(value, parseIntRange);
+var parseFloatRangeArray = (value) => (0, import_array.parseArray)(value, parseFloatRange);
+var parseBigintRangeArray = (value) => (0, import_array.parseArray)(value, parseBigintRange);
+var parseTimestampRangeArray = (value) => (0, import_array.parseArray)(value, parseTimestampRange);
+var parseTimestampTzRangeArray = (value) => (0, import_array.parseArray)(value, parseTimestampTzRange);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PGRange,
+  parseBigintRange,
+  parseBigintRangeArray,
+  parseFloatRange,
+  parseFloatRangeArray,
+  parseIntRange,
+  parseIntRangeArray,
+  parseRange,
+  parseRangeArray,
+  parseTimestampRange,
+  parseTimestampRangeArray,
+  parseTimestampTzRange,
+  parseTimestampTzRangeArray
+});
+//# sourceMappingURL=range.cjs.map

package/dist/parsers/range.cjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/parsers/range.ts"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,4BAA0B;AAE1B,mBAA2B;AAC3B,mBAA2E;AAwCpE,IAAM,UAA8B,MAAM,oBACvC,sBAAAA,QAAc,MACgB;AAAA,EAC7B;AAAA,EAET,YAAY,OAAiB,OAAiB,OAAe;AAC3D,UAAM,OAAO,OAAO,KAAK;AACzB,SAAK,OAAO;AAAA,EACd;AAAA,EAEA,WAAW,WAAgC;AACzC,WAAO,sBAAAA,QAAc,UAAU,MAAM,SAAS;AAAA,EAChD;AAAA,EAEA,OAAgB,cAAc,sBAAAA,QAAc;AAAA,EAC5C,OAAgB,eAAe,sBAAAA,QAAc;AAAA,EAC7C,OAAgB,eAAe,sBAAAA,QAAc;AAAA,EAC7C,OAAgB,eAAe,sBAAAA,QAAc;AAAA,EAC7C,OAAgB,eAAe,sBAAAA,QAAc;AAC/C;AAWO,SAAS,WACZ,OACA,SAAwB,0BACZ;AACd,QAAM,QAAQ,sBAAAA,QAAc,MAAM,OAAO,MAAM;AAC/C,SAAO,IAAI,QAAQ,MAAM,OAAO,MAAM,OAAQ,MAAc,IAAI;AAClE;AAKO,IAAM,gBACX,CAAC,UAAkB,WAAW,OAAO,QAAQ;AAGxC,IAAM,kBACX,CAAC,UAAkB,WAAW,OAAO,UAAU;AAG1C,IAAM,mBACX,CAAC,UAAkB,WAAW,OAAO,wBAAW;AAG3C,IAAM,sBACX,CAAC,UAAkB,WAAW,OAAO,2BAAc;AAG9C,IAAM,wBACX,CAAC,UAAkB,WAAW,OAAO,6BAAgB;AAKhD,IAAM,kBACX,CAAC,cAAkB,yBAA4B,OAAO,UAAU;AAG3D,IAAM,qBACX,CAAC,cAAkB,yBAAW,OAAO,aAAa;AAG7C,IAAM,uBACX,CAAC,cAAkB,yBAAW,OAAO,eAAe;AAG/C,IAAM,wBACX,CAAC,cAAkB,yBAAW,OAAO,gBAAgB;AAGhD,IAAM,2BACX,CAAC,cAAkB,yBAAW,OAAO,mBAAmB;AAGnD,IAAM,6BACX,CAAC,cAAkB,yBAAW,OAAO,qBAAqB;",
+  "names": ["postgresRange"]
+}

package/dist/parsers/range.d.ts

@@ -0,0 +1,54 @@
+import type { PGParser } from '../parsers';
+import type { PGArray } from './array';
+/** A parsed PostgreSQL `range` */
+export interface PGRange<T> {
+    readonly lower: T | null;
+    readonly upper: T | null;
+    readonly mask: number;
+    hasMask(flags: number): boolean;
+    isBounded(): boolean;
+    isEmpty(): boolean;
+    isLowerBoundClosed(): boolean;
+    isUpperBoundClosed(): boolean;
+    hasLowerBound(): boolean;
+    hasUpperBound(): boolean;
+    containsPoint(point: T): boolean;
+    containsRange(range: PGRange<T>): boolean;
+}
+/** Constructor (with static constants) for {@link PGRange} */
+export interface PGRangeConstructor {
+    new <T>(lower: T | null, upper: T | null, flags: number): PGRange<T>;
+    readonly RANGE_EMPTY: number;
+    readonly RANGE_LB_INC: number;
+    readonly RANGE_UB_INC: number;
+    readonly RANGE_LB_INF: number;
+    readonly RANGE_UB_INF: number;
+}
+/** A parsed PostgreSQL `range` */
+export declare const PGRange: PGRangeConstructor;
+/** Parse a PostgreSQL `range` */
+export declare function parseRange(value: string): PGRange<string>;
+/** Parse a PostgreSQL `range` */
+export declare function parseRange<T>(value: string, parser: PGParser<T>): PGRange<T>;
+/** Parse a PostgreSQL `range` of _integers_ */
+export declare const parseIntRange: PGParser<PGRange<number>>;
+/** Parse a PostgreSQL `range` of _floats_ */
+export declare const parseFloatRange: PGParser<PGRange<number>>;
+/** Parse a PostgreSQL `range` of _big integers_ */
+export declare const parseBigintRange: PGParser<PGRange<bigint>>;
+/** Parse a PostgreSQL `range` of _timestamps_ */
+export declare const parseTimestampRange: PGParser<PGRange<Date>>;
+/** Parse a PostgreSQL `range` of _timestamps with time zone_ */
+export declare const parseTimestampTzRange: PGParser<PGRange<Date>>;
+/** Parse an array of PostgreSQL `range` of _strings_ */
+export declare const parseRangeArray: PGParser<PGArray<PGRange<string>>>;
+/** Parse an array of PostgreSQL `range` of _integers_ */
+export declare const parseIntRangeArray: PGParser<PGArray<PGRange<number>>>;
+/** Parse an array of PostgreSQL `range` of _floats_ */
+export declare const parseFloatRangeArray: PGParser<PGArray<PGRange<number>>>;
+/** Parse an array of PostgreSQL `range` of _big integers_ */
+export declare const parseBigintRangeArray: PGParser<PGArray<PGRange<bigint>>>;
+/** Parse an array of PostgreSQL `range` of _timestamps_ */
+export declare const parseTimestampRangeArray: PGParser<PGArray<PGRange<Date>>>;
+/** Parse an array of PostgreSQL `range` of _timestamps with time zone_ */
+export declare const parseTimestampTzRangeArray: PGParser<PGArray<PGRange<Date>>>;

package/dist/parsers/range.mjs

@@ -0,0 +1,50 @@
+// parsers/range.ts
+import postgresRange from "postgres-range";
+import { parseArray } from "./array.mjs";
+import { parseBigint, parseString, parseTimestamp, parseTimestampTz } from "./basic.mjs";
+var PGRange = class PGRangeImpl extends postgresRange.Range {
+  mask;
+  constructor(lower, upper, flags) {
+    super(lower, upper, flags);
+    this.mask = flags;
+  }
+  toPostgres(serialize) {
+    return postgresRange.serialize(this, serialize);
+  }
+  static RANGE_EMPTY = postgresRange.RANGE_EMPTY;
+  static RANGE_LB_INC = postgresRange.RANGE_LB_INC;
+  static RANGE_UB_INC = postgresRange.RANGE_UB_INC;
+  static RANGE_LB_INF = postgresRange.RANGE_LB_INF;
+  static RANGE_UB_INF = postgresRange.RANGE_UB_INF;
+};
+function parseRange(value, parser = parseString) {
+  const range = postgresRange.parse(value, parser);
+  return new PGRange(range.lower, range.upper, range.mask);
+}
+var parseIntRange = (value) => parseRange(value, parseInt);
+var parseFloatRange = (value) => parseRange(value, parseFloat);
+var parseBigintRange = (value) => parseRange(value, parseBigint);
+var parseTimestampRange = (value) => parseRange(value, parseTimestamp);
+var parseTimestampTzRange = (value) => parseRange(value, parseTimestampTz);
+var parseRangeArray = (value) => parseArray(value, parseRange);
+var parseIntRangeArray = (value) => parseArray(value, parseIntRange);
+var parseFloatRangeArray = (value) => parseArray(value, parseFloatRange);
+var parseBigintRangeArray = (value) => parseArray(value, parseBigintRange);
+var parseTimestampRangeArray = (value) => parseArray(value, parseTimestampRange);
+var parseTimestampTzRangeArray = (value) => parseArray(value, parseTimestampTzRange);
+export {
+  PGRange,
+  parseBigintRange,
+  parseBigintRangeArray,
+  parseFloatRange,
+  parseFloatRangeArray,
+  parseIntRange,
+  parseIntRangeArray,
+  parseRange,
+  parseRangeArray,
+  parseTimestampRange,
+  parseTimestampRangeArray,
+  parseTimestampTzRange,
+  parseTimestampTzRangeArray
+};
+//# sourceMappingURL=range.mjs.map

package/dist/parsers/range.mjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/parsers/range.ts"],
+  "mappings": ";AAAA,OAAO,mBAAmB;AAE1B,SAAS,kBAAkB;AAC3B,SAAS,aAAa,aAAa,gBAAgB,wBAAwB;AAwCpE,IAAM,UAA8B,MAAM,oBACvC,cAAc,MACgB;AAAA,EAC7B;AAAA,EAET,YAAY,OAAiB,OAAiB,OAAe;AAC3D,UAAM,OAAO,OAAO,KAAK;AACzB,SAAK,OAAO;AAAA,EACd;AAAA,EAEA,WAAW,WAAgC;AACzC,WAAO,cAAc,UAAU,MAAM,SAAS;AAAA,EAChD;AAAA,EAEA,OAAgB,cAAc,cAAc;AAAA,EAC5C,OAAgB,eAAe,cAAc;AAAA,EAC7C,OAAgB,eAAe,cAAc;AAAA,EAC7C,OAAgB,eAAe,cAAc;AAAA,EAC7C,OAAgB,eAAe,cAAc;AAC/C;AAWO,SAAS,WACZ,OACA,SAAwB,aACZ;AACd,QAAM,QAAQ,cAAc,MAAM,OAAO,MAAM;AAC/C,SAAO,IAAI,QAAQ,MAAM,OAAO,MAAM,OAAQ,MAAc,IAAI;AAClE;AAKO,IAAM,gBACX,CAAC,UAAkB,WAAW,OAAO,QAAQ;AAGxC,IAAM,kBACX,CAAC,UAAkB,WAAW,OAAO,UAAU;AAG1C,IAAM,mBACX,CAAC,UAAkB,WAAW,OAAO,WAAW;AAG3C,IAAM,sBACX,CAAC,UAAkB,WAAW,OAAO,cAAc;AAG9C,IAAM,wBACX,CAAC,UAAkB,WAAW,OAAO,gBAAgB;AAKhD,IAAM,kBACX,CAAC,UAAkB,WAA4B,OAAO,UAAU;AAG3D,IAAM,qBACX,CAAC,UAAkB,WAAW,OAAO,aAAa;AAG7C,IAAM,uBACX,CAAC,UAAkB,WAAW,OAAO,eAAe;AAG/C,IAAM,wBACX,CAAC,UAAkB,WAAW,OAAO,gBAAgB;AAGhD,IAAM,2BACX,CAAC,UAAkB,WAAW,OAAO,mBAAmB;AAGnD,IAAM,6BACX,CAAC,UAAkB,WAAW,OAAO,qBAAqB;",
+  "names": []
+}

package/dist/parsers.cjs

@@ -0,0 +1,104 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// parsers.ts
+var parsers_exports = {};
+__export(parsers_exports, {
+  parseArray: () => import_array.parseArray,
+  parseBigint: () => import_basic.parseBigint,
+  parseBigintArray: () => import_array.parseBigintArray,
+  parseBigintRange: () => import_range.parseBigintRange,
+  parseBigintRangeArray: () => import_range.parseBigintRangeArray,
+  parseBool: () => import_basic.parseBool,
+  parseBoolArray: () => import_array.parseBoolArray,
+  parseByteA: () => import_bytea.parseByteA,
+  parseByteAArray: () => import_array.parseByteAArray,
+  parseCircle: () => import_geometric.parseCircle,
+  parseCircleArray: () => import_array.parseCircleArray,
+  parseFloatArray: () => import_array.parseFloatArray,
+  parseFloatRange: () => import_range.parseFloatRange,
+  parseFloatRangeArray: () => import_range.parseFloatRangeArray,
+  parseIntArray: () => import_array.parseIntArray,
+  parseIntRange: () => import_range.parseIntRange,
+  parseIntRangeArray: () => import_range.parseIntRangeArray,
+  parseInterval: () => import_interval.parseInterval,
+  parseIntervalArray: () => import_array.parseIntervalArray,
+  parseJson: () => import_basic.parseJson,
+  parseJsonArray: () => import_array.parseJsonArray,
+  parsePoint: () => import_geometric.parsePoint,
+  parsePointArray: () => import_array.parsePointArray,
+  parseRange: () => import_range.parseRange,
+  parseRangeArray: () => import_range.parseRangeArray,
+  parseString: () => import_basic.parseString,
+  parseTimestamp: () => import_basic.parseTimestamp,
+  parseTimestampArray: () => import_array.parseTimestampArray,
+  parseTimestampRange: () => import_range.parseTimestampRange,
+  parseTimestampRangeArray: () => import_range.parseTimestampRangeArray,
+  parseTimestampTz: () => import_basic.parseTimestampTz,
+  parseTimestampTzArray: () => import_array.parseTimestampTzArray,
+  parseTimestampTzRange: () => import_range.parseTimestampTzRange,
+  parseTimestampTzRangeArray: () => import_range.parseTimestampTzRangeArray,
+  parseVoid: () => import_basic.parseVoid
+});
+module.exports = __toCommonJS(parsers_exports);
+var import_array = require("./parsers/array.cjs");
+var import_basic = require("./parsers/basic.cjs");
+var import_bytea = require("./parsers/bytea.cjs");
+var import_geometric = require("./parsers/geometric.cjs");
+var import_interval = require("./parsers/interval.cjs");
+var import_range = require("./parsers/range.cjs");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  parseArray,
+  parseBigint,
+  parseBigintArray,
+  parseBigintRange,
+  parseBigintRangeArray,
+  parseBool,
+  parseBoolArray,
+  parseByteA,
+  parseByteAArray,
+  parseCircle,
+  parseCircleArray,
+  parseFloatArray,
+  parseFloatRange,
+  parseFloatRangeArray,
+  parseIntArray,
+  parseIntRange,
+  parseIntRangeArray,
+  parseInterval,
+  parseIntervalArray,
+  parseJson,
+  parseJsonArray,
+  parsePoint,
+  parsePointArray,
+  parseRange,
+  parseRangeArray,
+  parseString,
+  parseTimestamp,
+  parseTimestampArray,
+  parseTimestampRange,
+  parseTimestampRangeArray,
+  parseTimestampTz,
+  parseTimestampTzArray,
+  parseTimestampTzRange,
+  parseTimestampTzRangeArray,
+  parseVoid
+});
+//# sourceMappingURL=parsers.cjs.map

package/dist/parsers.cjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../src/parsers.ts"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAKA,mBAaO;AAEP,mBAQO;AAEP,mBAEO;AAEP,uBAGO;AAEP,sBAEO;AAEP,mBAaO;",
+  "names": []
+}

package/dist/parsers.d.ts

@@ -0,0 +1,8 @@
+/** A function parsing a `string` returned from PostgreSQL */
+export type PGParser<T = string> = (value: string) => T;
+export { parseArray, parseBigintArray, parseBoolArray, parseByteAArray, parseCircleArray, parseFloatArray, parseIntArray, parseIntervalArray, parseJsonArray, parsePointArray, parseTimestampArray, parseTimestampTzArray } from './parsers/array';
+export { parseBigint, parseBool, parseJson, parseString, parseTimestamp, parseTimestampTz, parseVoid } from './parsers/basic';
+export { parseByteA } from './parsers/bytea';
+export { parseCircle, parsePoint } from './parsers/geometric';
+export { parseInterval } from './parsers/interval';
+export { parseBigintRange, parseBigintRangeArray, parseFloatRange, parseFloatRangeArray, parseIntRange, parseIntRangeArray, parseRange, parseRangeArray, parseTimestampRange, parseTimestampRangeArray, parseTimestampTzRange, parseTimestampTzRangeArray } from './parsers/range';

package/dist/parsers.mjs

@@ -0,0 +1,86 @@
+// parsers.ts
+import {
+  parseArray,
+  parseBigintArray,
+  parseBoolArray,
+  parseByteAArray,
+  parseCircleArray,
+  parseFloatArray,
+  parseIntArray,
+  parseIntervalArray,
+  parseJsonArray,
+  parsePointArray,
+  parseTimestampArray,
+  parseTimestampTzArray
+} from "./parsers/array.mjs";
+import {
+  parseBigint,
+  parseBool,
+  parseJson,
+  parseString,
+  parseTimestamp,
+  parseTimestampTz,
+  parseVoid
+} from "./parsers/basic.mjs";
+import {
+  parseByteA
+} from "./parsers/bytea.mjs";
+import {
+  parseCircle,
+  parsePoint
+} from "./parsers/geometric.mjs";
+import {
+  parseInterval
+} from "./parsers/interval.mjs";
+import {
+  parseBigintRange,
+  parseBigintRangeArray,
+  parseFloatRange,
+  parseFloatRangeArray,
+  parseIntRange,
+  parseIntRangeArray,
+  parseRange,
+  parseRangeArray,
+  parseTimestampRange,
+  parseTimestampRangeArray,
+  parseTimestampTzRange,
+  parseTimestampTzRangeArray
+} from "./parsers/range.mjs";
+export {
+  parseArray,
+  parseBigint,
+  parseBigintArray,
+  parseBigintRange,
+  parseBigintRangeArray,
+  parseBool,
+  parseBoolArray,
+  parseByteA,
+  parseByteAArray,
+  parseCircle,
+  parseCircleArray,
+  parseFloatArray,
+  parseFloatRange,
+  parseFloatRangeArray,
+  parseIntArray,
+  parseIntRange,
+  parseIntRangeArray,
+  parseInterval,
+  parseIntervalArray,
+  parseJson,
+  parseJsonArray,
+  parsePoint,
+  parsePointArray,
+  parseRange,
+  parseRangeArray,
+  parseString,
+  parseTimestamp,
+  parseTimestampArray,
+  parseTimestampRange,
+  parseTimestampRangeArray,
+  parseTimestampTz,
+  parseTimestampTzArray,
+  parseTimestampTzRange,
+  parseTimestampTzRangeArray,
+  parseVoid
+};
+//# sourceMappingURL=parsers.mjs.map

package/dist/parsers.mjs.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../src/parsers.ts"],
+  "mappings": ";AAKA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAEP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAEP;AAAA,EACE;AAAA,OACK;AAEP;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAEP;AAAA,EACE;AAAA,OACK;AAEP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;",
+  "names": []
+}