postgrejs 2.12.0

package/esm/util/parse-datetime.js

@@ -0,0 +1,34 @@
+// noinspection RegExpUnnecessaryNonCapturingGroup
+import { fastParseInt } from './fast-parseint.js';
+// noinspection RegExpUnnecessaryNonCapturingGroup
+const TIMESTAMP_PATTERN = 
+// eslint-disable-next-line
+/^(\d{4})-?(0[1-9]|1[012])?-?([123]0|[012][1-9]|31)?(?:[T ]?([01][0-9]|2[0-3]):?([0-5][0-9]):?([0-5][0-9])?(?:\.(\d+))?(?:(Z)|(?:([+-])([01]?[0-9]|2[0-3]):?([0-5][0-9])?))?)?$/;
+const INFINITY_PATTERN = /^-?infinity$/;
+export function parseDateTime(str, parseTime, parseTimeZone, utc) {
+    let m = str.match(TIMESTAMP_PATTERN);
+    if (!m) {
+        m = str.match(INFINITY_PATTERN);
+        if (m)
+            return Number(str.replace('i', 'I'));
+        return new Date('invalid');
+    }
+    const args = [1970, 0, 1, 0, 0, 0, 0];
+    const l = parseTime ? 7 : 3;
+    for (let i = 0; i < l; i++) {
+        const s = m[i + 1];
+        args[i] = fastParseInt(s) || 0;
+    }
+    // Months starts from 0
+    if (args[1] > 0)
+        args[1]--;
+    if (parseTimeZone && parseTime && m[9]) {
+        const r = m[9] === '-' ? -1 : 1;
+        args[3] -= (fastParseInt(m[10]) || 0) * r;
+        args[4] -= (fastParseInt(m[11]) || 0) * r;
+        return new Date(Date.UTC(...args));
+    }
+    if (m[8] || utc)
+        return new Date(Date.UTC(...args));
+    return new Date(...args);
+}

package/esm/util/parse-row.js

@@ -0,0 +1,7 @@
+export function parseRow(parsers, row, options) {
+    const l = row.length;
+    let i;
+    for (i = 0; i < l; i++) {
+        row[i] = row[i] == null ? null : parsers[i].call(undefined, row[i], options);
+    }
+}

package/esm/util/parse-time.js

@@ -0,0 +1,25 @@
+import { fastParseInt } from './fast-parseint.js';
+// eslint-disable-next-line
+// noinspection RegExpUnnecessaryNonCapturingGroup
+export const STRICT_TIME_PATTERN = /^([01][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])(?:\.(\d+))?(?:(Z)|(?:([+-])([01]?[0-9]|2[0-3]):?([0-5][0-9])?))?$/;
+// noinspection RegExpUnnecessaryNonCapturingGroup
+export const TIME_PATTERN = /^([01][0-9]|2[0-3]):?([0-5][0-9]):?([0-5][0-9])?(?:\.(\d+))?(?:(Z)|(?:([+-])([01]?[0-9]|2[0-3]):?([0-5][0-9])?))?$/;
+export function parseTime(str, parseTimeZone, utc) {
+    const m = str.match(TIME_PATTERN);
+    if (!m)
+        return new Date('invalid');
+    const args = [1970, 0, 1, 0, 0, 0, 0];
+    for (let i = 1; i < 4; i++) {
+        const s = m[i];
+        args[i + 2] = fastParseInt(s) || 0;
+    }
+    if (parseTimeZone && m[6]) {
+        const r = m[9] === '-' ? -1 : 1;
+        args[3] -= (fastParseInt(m[7]) || 0) * r;
+        args[4] -= (fastParseInt(m[8]) || 0) * r;
+        return new Date(Date.UTC(...args));
+    }
+    if (m[5] || utc)
+        return new Date(Date.UTC(...args));
+    return new Date(...args);
+}

package/esm/util/stringify-arrayliteral.js

@@ -0,0 +1,34 @@
+import { arrayCalculateDim } from './array-calculatedim.js';
+export function stringifyArrayLiteral(value, options, encode) {
+    const dim = arrayCalculateDim(value);
+    const writeDim = (arr, level) => {
+        const elemCount = dim[level];
+        const out = [];
+        for (let i = 0; i < elemCount; i++) {
+            let x = arr && arr[i];
+            if (level < dim.length - 1) {
+                if (x != null && !Array.isArray(x))
+                    x = [x];
+                out.push(writeDim(x, level + 1));
+                continue;
+            }
+            // if value is null
+            if (x == null) {
+                out.push('NULL');
+                continue;
+            }
+            if (Array.isArray(x)) {
+                out.push(stringifyArrayLiteral(x, options, encode));
+                continue;
+            }
+            if (encode)
+                x = encode(x, options || {});
+            out.push(escapeArrayItem('' + x));
+        }
+        return '{' + out.join(',') + '}';
+    };
+    return writeDim(value, 0);
+}
+function escapeArrayItem(str) {
+    return '"' + str.replace(/\\/g, '\\\\').replace(/"/g, '\\"') + '"';
+}

package/esm/util/stringify-for-sql.js

@@ -0,0 +1,25 @@
+import { UuidType } from '../data-types/uuid-type.js';
+import { escapeLiteral } from './escape-literal.js';
+export function stringifyArrayForSQL(v, options, encode) {
+    const arr = v.map(x => stringifyValueForSQL(x, options, encode));
+    return 'ARRAY[' + arr.join(',') + ']';
+}
+export function stringifyValueForSQL(v, options, encode) {
+    if (v == null)
+        return 'null';
+    if (typeof v === 'boolean')
+        return v ? 'true' : 'false';
+    if (Array.isArray(v))
+        return stringifyArrayForSQL(v, options, encode);
+    if (encode)
+        v = encode(v, options || {});
+    if (typeof v === 'number')
+        return '' + v;
+    if (typeof v === 'bigint')
+        return v.toString();
+    if (typeof v === 'string' && UuidType.isType(v))
+        return escapeLiteral('' + v) + '::uuid';
+    if (typeof v === 'object')
+        return escapeLiteral(JSON.stringify(v)) + '::json';
+    return escapeLiteral('' + v);
+}

package/esm/util/wrap-row-description.js

@@ -0,0 +1,31 @@
+import { DataFormat, DataTypeNames } from '../constants.js';
+export function wrapRowDescription(typeMap, fields, columnFormat) {
+    return fields.map((f, idx) => {
+        const cf = Array.isArray(columnFormat) ? columnFormat[idx] : columnFormat;
+        const x = {
+            fieldName: f.fieldName,
+            tableId: f.tableId,
+            columnId: f.columnId,
+            dataTypeId: f.dataTypeId,
+            dataTypeName: DataTypeNames[f.dataTypeId] || '',
+            jsType: cf === DataFormat.binary ? 'Buffer' : 'string',
+        };
+        x.isArray = x.dataTypeName.startsWith('_');
+        if (x.isArray) {
+            x.elementDataTypeName = x.dataTypeName.substring(1);
+            for (const oid of Object.keys(DataTypeNames)) {
+                if (DataTypeNames[oid] === x.elementDataTypeName)
+                    x.elementDataTypeId = parseInt(oid, 10);
+            }
+        }
+        if (f.fixedSize && f.fixedSize > 0)
+            x.fixedSize = f.fixedSize;
+        if (f.modifier && f.modifier > 0)
+            x.modifier = f.modifier;
+        const reg = typeMap.get(x.dataTypeId);
+        if (reg) {
+            x.jsType = reg.jsType;
+        }
+        return x;
+    });
+}

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "postgrejs",
+  "description": "Enterprise level PostgreSQL client for JavaScript",
+  "version": "2.12.0",
+  "author": "Panates",
+  "contributors": [
+    "Eray Hanoglu <e.hanoglu@panates.com>"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/panates/postgresql-client.git"
+  },
+  "type": "module",
+  "main": "./cjs/index.js",
+  "module": "./esm/index.js",
+  "types": "typings/index.d.ts",
+  "dependencies": {
+    "doublylinked": "^2.5.4",
+    "lightning-pool": "^4.2.2",
+    "postgres-bytea": "^3.0.0",
+    "power-tasks": "^1.7.3",
+    "putil-merge": "^3.12.1",
+    "putil-promisify": "^1.10.1",
+    "putil-varhelpers": "^1.6.5"
+  },
+  "engines": {
+    "node": ">=16.0"
+  },
+  "files": [
+    "cjs/",
+    "esm/",
+    "typings/",
+    "LICENSE",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "keywords": [
+    "postgresql",
+    "postgres",
+    "postgre",
+    "pg",
+    "database",
+    "db",
+    "driver",
+    "client",
+    "backend",
+    "rdbms",
+    "sql",
+    "typescript",
+    "ts",
+    "esm"
+  ]
+}

package/typings/connection/bind-param.d.ts

@@ -0,0 +1,6 @@
+import { OID } from '../types.js';
+export declare class BindParam {
+    oid: OID;
+    value: any;
+    constructor(oid: OID, value: any);
+}

package/typings/connection/connection.d.ts

@@ -0,0 +1,110 @@
+/// <reference types="node" />
+import { ConnectionState } from '../constants.js';
+import { ConnectionConfiguration } from '../interfaces/database-connection-params.js';
+import { QueryOptions } from '../interfaces/query-options.js';
+import { QueryResult } from '../interfaces/query-result.js';
+import { ScriptExecuteOptions } from '../interfaces/script-execute-options.js';
+import { ScriptResult } from '../interfaces/script-result.js';
+import { StatementPrepareOptions } from '../interfaces/statement-prepare-options.js';
+import { DatabaseError } from '../protocol/database-error.js';
+import { Protocol } from '../protocol/protocol.js';
+import { SafeEventEmitter } from '../safe-event-emitter.js';
+import { Maybe } from '../types.js';
+import { IntlConnection } from './intl-connection.js';
+import type { Pool } from './pool.js';
+import { PreparedStatement } from './prepared-statement.js';
+export type NotificationMessage = Protocol.NotificationResponseMessage;
+export type NotificationCallback = (msg: NotificationMessage) => any;
+export declare class Connection extends SafeEventEmitter implements AsyncDisposable {
+    protected readonly _pool?: Pool;
+    protected readonly _intlCon: IntlConnection;
+    protected readonly _notificationListeners: SafeEventEmitter;
+    protected _closing: boolean;
+    constructor(pool: Pool, intlCon: IntlConnection);
+    constructor(config?: ConnectionConfiguration | string);
+    /**
+     * Returns configuration object
+     */
+    get config(): ConnectionConfiguration;
+    /**
+     * Returns true if connection is in a transaction
+     */
+    get inTransaction(): boolean;
+    /**
+     * Returns current state of the connection
+     */
+    get state(): ConnectionState;
+    /**
+     * Returns processId of current session
+     */
+    get processID(): Maybe<number>;
+    /**
+     * Returns information parameters for current session
+     */
+    get sessionParameters(): Record<string, string>;
+    /**
+     * Returns secret key of current session
+     */
+    get secretKey(): Maybe<number>;
+    /**
+     * Connects to the server
+     */
+    connect(): Promise<void>;
+    /**
+     * Closes connection. You can define how long time the connection will
+     * wait for active queries before terminating the connection.
+     * On the end of the given time, it forces to close the socket and than emits `terminate` event.
+     *
+     * @param terminateWait {number} - Determines how long the connection will wait for active queries before terminating.
+     */
+    close(terminateWait?: number): Promise<void>;
+    /**
+     * Executes single or multiple SQL scripts using Simple Query protocol.
+     *
+     * @param sql {string} - SQL script that will be executed
+     * @param options {ScriptExecuteOptions} - Execute options
+     */
+    execute(sql: string, options?: ScriptExecuteOptions): Promise<ScriptResult>;
+    query(sql: string, options?: QueryOptions): Promise<QueryResult>;
+    /**
+     * Creates a PreparedStatement instance
+     * @param sql {string} - SQL script that will be executed
+     * @param options {StatementPrepareOptions} - Options
+     */
+    prepare(sql: string, options?: StatementPrepareOptions): Promise<PreparedStatement>;
+    /**
+     * Starts a transaction
+     */
+    startTransaction(): Promise<void>;
+    /**
+     * Commits current transaction
+     */
+    commit(): Promise<void>;
+    /**
+     * Rolls back current transaction
+     */
+    rollback(): Promise<void>;
+    /**
+     * Starts transaction and creates a savepoint
+     * @param name {string} - Name of the savepoint
+     */
+    savepoint(name: string): Promise<void>;
+    /**
+     * Rolls back current transaction to given savepoint
+     * @param name {string} - Name of the savepoint
+     */
+    rollbackToSavepoint(name: string): Promise<void>;
+    /**
+     * Releases savepoint
+     * @param name {string} - Name of the savepoint
+     */
+    releaseSavepoint(name: string): Promise<void>;
+    listen(channel: string, callback: NotificationCallback): Promise<void>;
+    unListen(channel: string): Promise<void>;
+    unListenAll(): Promise<void>;
+    protected _handleNotification(msg: NotificationMessage): void;
+    protected _close(): Promise<void>;
+    protected _handleError(err: DatabaseError, script: string): DatabaseError;
+    protected _captureErrorStack<T>(promise: Promise<T>): Promise<T>;
+    [Symbol.asyncDispose](): Promise<void>;
+}

package/typings/connection/cursor.d.ts

@@ -0,0 +1,25 @@
+/// <reference types="node" />
+import { FieldInfo } from '../interfaces/field-info.js';
+import { QueryOptions } from '../interfaces/query-options.js';
+import { SafeEventEmitter } from '../safe-event-emitter.js';
+import { AnyParseFunction, Maybe, Row } from '../types.js';
+import { Portal } from './portal.js';
+import { PreparedStatement } from './prepared-statement.js';
+export declare class Cursor extends SafeEventEmitter implements AsyncDisposable {
+    private readonly _statement;
+    private readonly _portal;
+    private readonly _parsers;
+    private readonly _queryOptions;
+    private _taskQueue;
+    private _rows;
+    private _closed;
+    readonly fields: FieldInfo[];
+    constructor(statement: PreparedStatement, portal: Portal, fields: FieldInfo[], parsers: AnyParseFunction[], queryOptions: QueryOptions);
+    get rowType(): 'array' | 'object';
+    get isClosed(): boolean;
+    next(): Promise<Maybe<Row>>;
+    fetch(nRows: number): Promise<Row[]>;
+    close(): Promise<void>;
+    private _fetchRows;
+    [Symbol.asyncDispose](): Promise<void>;
+}

package/typings/connection/intl-connection.d.ts

@@ -0,0 +1,40 @@
+import { TaskQueue } from 'power-tasks';
+import { ConnectionState } from '../constants.js';
+import { ConnectionConfiguration } from '../interfaces/database-connection-params.js';
+import { ScriptExecuteOptions } from '../interfaces/script-execute-options.js';
+import { ScriptResult } from '../interfaces/script-result.js';
+import { PgSocket } from '../protocol/pg-socket.js';
+import { SafeEventEmitter } from '../safe-event-emitter.js';
+import { Maybe } from '../types.js';
+import { Connection } from './connection.js';
+export declare class IntlConnection extends SafeEventEmitter {
+    protected _refCount: number;
+    protected _config: ConnectionConfiguration;
+    protected _onErrorSavePoint: string;
+    transactionStatus: string;
+    socket: PgSocket;
+    statementQueue: TaskQueue;
+    constructor(config?: ConnectionConfiguration | string);
+    get config(): ConnectionConfiguration;
+    get inTransaction(): boolean;
+    get state(): ConnectionState;
+    get refCount(): number;
+    get processID(): Maybe<number>;
+    get secretKey(): Maybe<number>;
+    get sessionParameters(): Record<string, string>;
+    connect(): Promise<void>;
+    close(): Promise<void>;
+    execute(sql: string, options?: ScriptExecuteOptions, cb?: (event: string, ...args: any[]) => void): Promise<ScriptResult>;
+    startTransaction(): Promise<void>;
+    savepoint(name: string): Promise<void>;
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+    rollbackToSavepoint(name: string): Promise<void>;
+    releaseSavepoint(name: string): Promise<void>;
+    ref(): void;
+    unref(): boolean;
+    assertConnected(): void;
+    protected _execute(sql: string, options?: ScriptExecuteOptions, cb?: (event: string, ...args: any[]) => void): Promise<ScriptResult>;
+    protected _onError(err: Error): void;
+}
+export declare function getIntlConnection(connection: Connection): IntlConnection;

package/typings/connection/pool.d.ts

@@ -0,0 +1,52 @@
+import { Pool as LightningPool } from 'lightning-pool';
+import { PoolConfiguration } from '../interfaces/database-connection-params.js';
+import { QueryOptions } from '../interfaces/query-options.js';
+import { QueryResult } from '../interfaces/query-result.js';
+import { ScriptExecuteOptions } from '../interfaces/script-execute-options.js';
+import { ScriptResult } from '../interfaces/script-result.js';
+import { StatementPrepareOptions } from '../interfaces/statement-prepare-options.js';
+import { SafeEventEmitter } from '../safe-event-emitter.js';
+import { Connection, NotificationCallback } from './connection.js';
+import { IntlConnection } from './intl-connection.js';
+import { PreparedStatement } from './prepared-statement.js';
+export declare class Pool extends SafeEventEmitter {
+    protected readonly _pool: LightningPool<IntlConnection>;
+    protected readonly _notificationListeners: SafeEventEmitter;
+    protected _notificationConnection?: Connection;
+    readonly config: PoolConfiguration;
+    constructor(config?: PoolConfiguration | string);
+    /**
+     * Returns number of connections that are currently acquired
+     */
+    get acquiredConnections(): number;
+    /**
+     * Returns number of unused connections in the pool
+     */
+    get idleConnections(): number;
+    /**
+     * Returns total number of connections in the pool regardless of whether they are idle or in use
+     */
+    get totalConnections(): number;
+    /**
+     * Obtains a connection from the connection pool
+     */
+    acquire(): Promise<Connection>;
+    /**
+     * Shuts down the pool and destroys all resources.
+     */
+    close(terminateWait?: number): Promise<void>;
+    /**
+     * Executes a script
+     */
+    execute(sql: string, options?: ScriptExecuteOptions): Promise<ScriptResult>;
+    /**
+     * Executes a query
+     */
+    query(sql: string, options?: QueryOptions): Promise<QueryResult>;
+    prepare(sql: string, options?: StatementPrepareOptions): Promise<PreparedStatement>;
+    release(connection: Connection): Promise<void>;
+    listen(channel: string, callback: NotificationCallback): Promise<void>;
+    unListen(channel: string): Promise<void>;
+    unListenAll(): Promise<void>;
+    protected _initNotificationConnection(): Promise<void>;
+}

package/typings/connection/portal.d.ts

@@ -0,0 +1,23 @@
+import { QueryOptions } from '../interfaces/query-options.js';
+import { Protocol } from '../protocol/protocol.js';
+import { Maybe } from '../types.js';
+import { Connection } from './connection.js';
+import type { PreparedStatement } from './prepared-statement.js';
+export interface PortalExecuteResult {
+    code: Protocol.BackendMessageCode;
+    rows?: any[];
+    command?: string;
+    rowCount?: number;
+}
+export declare class Portal {
+    private readonly _statement;
+    private readonly _name?;
+    private _columnFormat;
+    constructor(statement: PreparedStatement, name: string);
+    get connection(): Connection;
+    get name(): Maybe<string>;
+    bind(params: Maybe<any[]>, queryOptions: QueryOptions): Promise<void>;
+    retrieveFields(): Promise<Protocol.RowDescription[]>;
+    execute(fetchCount?: number): Promise<PortalExecuteResult>;
+    close(): Promise<void>;
+}

package/typings/connection/prepared-statement.d.ts

@@ -0,0 +1,27 @@
+/// <reference types="node" />
+import { QueryOptions } from '../interfaces/query-options.js';
+import { QueryResult } from '../interfaces/query-result.js';
+import { StatementPrepareOptions } from '../interfaces/statement-prepare-options.js';
+import { SafeEventEmitter } from '../safe-event-emitter.js';
+import { Maybe, OID } from '../types.js';
+import { Connection } from './connection.js';
+export declare class PreparedStatement extends SafeEventEmitter implements AsyncDisposable {
+    private readonly _connection;
+    private readonly _sql;
+    private readonly _name;
+    private readonly _paramTypes;
+    protected _onErrorSavePoint: string;
+    private _refCount;
+    constructor(connection: Connection, sql: string, paramTypes?: OID[]);
+    static prepare(connection: Connection, sql: string, options?: StatementPrepareOptions): Promise<PreparedStatement>;
+    get connection(): Connection;
+    get name(): Maybe<string>;
+    get sql(): string;
+    get paramTypes(): Maybe<Maybe<OID>[]>;
+    execute(options?: QueryOptions): Promise<QueryResult>;
+    close(): Promise<void>;
+    cancel(): Promise<void>;
+    protected _execute(options?: QueryOptions): Promise<QueryResult>;
+    protected _close(): Promise<void>;
+    [Symbol.asyncDispose](): Promise<void>;
+}

package/typings/constants.d.ts

@@ -0,0 +1,130 @@
+import { Protocol } from './protocol/protocol.js';
+import DataFormat = Protocol.DataFormat;
+export { DataFormat };
+export declare const DEFAULT_COLUMN_FORMAT = DataFormat.binary;
+export declare enum ConnectionState {
+    CLOSED = 0,
+    CONNECTING = 1,
+    AUTHORIZING = 3,
+    READY = 2,
+    CLOSING = 10
+}
+export declare const DataTypeOIDs: {
+    bool: number;
+    bytea: number;
+    char: number;
+    name: number;
+    int8: number;
+    int2: number;
+    int2vector: number;
+    int4: number;
+    regproc: number;
+    text: number;
+    oid: number;
+    tid: number;
+    xid: number;
+    cid: number;
+    oidvector: number;
+    json: number;
+    xml: number;
+    point: number;
+    lseg: number;
+    path: number;
+    box: number;
+    polygon: number;
+    line: number;
+    cidr: number;
+    float4: number;
+    float8: number;
+    unknown: number;
+    circle: number;
+    macaddr8: number;
+    money: number;
+    macaddr: number;
+    inet: number;
+    bpchar: number;
+    varchar: number;
+    date: number;
+    time: number;
+    timestamp: number;
+    timestamptz: number;
+    interval: number;
+    timetz: number;
+    bit: number;
+    varbit: number;
+    numeric: number;
+    refcursor: number;
+    regprocedure: number;
+    regoper: number;
+    regoperator: number;
+    regclass: number;
+    regtype: number;
+    record: number;
+    cstring: number;
+    any: number;
+    anyarray: number;
+    void: number;
+    trigger: number;
+    language_handler: number;
+    internal: number;
+    anyelement: number;
+    anynonarray: number;
+    uuid: number;
+    jsonb: number;
+    anyrange: number;
+    int4range: number;
+    numrange: number;
+    tsrange: number;
+    rstzrange: number;
+    daterange: number;
+    int8range: number;
+    _xml: number;
+    _json: number;
+    _xid8: number;
+    _line: number;
+    _cidr: number;
+    _circle: number;
+    _macaddr8: number;
+    _money: number;
+    _bool: number;
+    _bytea: number;
+    _char: number;
+    _name: number;
+    _int2: number;
+    _int2vector: number;
+    _int4: number;
+    _regproc: number;
+    _text: number;
+    _tid: number;
+    _xid: number;
+    _cid: number;
+    _oidvector: number;
+    _bpchar: number;
+    _varchar: number;
+    _int8: number;
+    _point: number;
+    _lseg: number;
+    _path: number;
+    _box: number;
+    _float4: number;
+    _float8: number;
+    _polygon: number;
+    _oid: number;
+    _macaddr: number;
+    _inet: number;
+    _timestamp: number;
+    _date: number;
+    _time: number;
+    _timestamptz: number;
+    _interval: number;
+    _numeric: number;
+    _cstring: number;
+    _timetz: number;
+    _bit: number;
+    _varbit: number;
+    _uuid: number;
+    _jsonb: number;
+};
+export declare const DataTypeNames: {
+    [x: number]: string;
+};

package/typings/data-type-map.d.ts

@@ -0,0 +1,11 @@
+import { DataType } from './interfaces/data-type.js';
+import { OID } from './types.js';
+export declare class DataTypeMap {
+    private _itemsByOID;
+    private _items;
+    constructor(other?: DataTypeMap);
+    get(oid: OID): DataType;
+    register(dataTypes: DataType | DataType[]): void;
+    determine(value: any): OID;
+}
+export declare const GlobalTypeMap: DataTypeMap;

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

@@ -0,0 +1,3 @@
+import { DataType } from '../interfaces/data-type.js';
+export declare const BoolType: DataType;
+export declare const ArrayBoolType: DataType;

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

@@ -0,0 +1,3 @@
+import type { DataType } from '../interfaces/data-type.js';
+export declare const BoxType: DataType;
+export declare const ArrayBoxType: DataType;

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

@@ -0,0 +1,3 @@
+import type { DataType } from '../interfaces/data-type.js';
+export declare const ByteaType: DataType;
+export declare const ArrayByteaType: DataType;

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

@@ -0,0 +1,3 @@
+import type { DataType } from '../interfaces/data-type.js';
+export declare const CharType: DataType;
+export declare const ArrayCharType: DataType;

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

@@ -0,0 +1,3 @@
+import type { DataType } from '../interfaces/data-type.js';
+export declare const CircleType: DataType;
+export declare const ArrayCircleType: DataType;