okmodel 0.0.0 → 0.1.0

package/dist/contracts/error.d.ts

@@ -0,0 +1,298 @@
+/**
+ * `OkmError`: categories, HTTP mapping, and `safe` / `match` (spec §14).
+ *
+ * Doctor text for every OKM code lives in the tooling registry and is not
+ * imported here. A caller who never explains a code does not load it.
+ */
+import type { Row, TableName } from "./rows.js";
+/**
+ * Catalog failures that have a code in spec section 21 or D128.
+ *
+ * OKM1020 stays the code for an unknown table and for catalog failures that
+ * still have no narrower code. A dependency cycle is OKM1026. A document this
+ * version cannot read is OKM1027.
+ */
+export declare const CATALOG_CODES: readonly ["OKM1020", "OKM1021", "OKM1022", "OKM1023", "OKM1026", "OKM1027", "OKM1122"];
+/** A catalog error code. */
+export type CatalogCode = (typeof CATALOG_CODES)[number];
+/**
+ * Column definition, reserved options, and codec failures (D130, D132).
+ *
+ * OKM1060 is an invalid column definition. OKM1061 is a table or schema option
+ * the types accept but this version does not implement. OKM1210 is a value a
+ * codec rejects.
+ */
+export declare const COLUMN_CODES: readonly ["OKM1060", "OKM1061", "OKM1210"];
+/** A column or codec error code. */
+export type ColumnCode = (typeof COLUMN_CODES)[number];
+/**
+ * Query, capability, and connect codes the read path throws.
+ *
+ * These are spec §21 codes. They are a type only, so the runtime entry does
+ * not gain a second registry.
+ */
+export type QueryCode = "OKM1101" | "OKM1102" | "OKM1104" | "OKM1105" | "OKM1111" | "OKM1120" | "OKM1121" | "OKM1190" | "OKM1801" | "OKM1802" | "OKM1843";
+/** Kinds from spec §14, in category order. */
+export declare const ERROR_KINDS: readonly ["invalid", "not_null", "check", "foreign_key", "unique", "exclusion", "conflict", "not_found", "not_unique", "forbidden", "serialization", "deadlock", "lock_timeout", "timeout", "cancelled", "unavailable", "schema_drift", "driver", "read_only", "outcome_unknown"];
+/** One spec §14 kind. */
+export type ErrorKind = (typeof ERROR_KINDS)[number];
+/** Categories from spec §14. Statuses are overridable per category. */
+export declare const ERROR_CATEGORIES: readonly ["input", "conflict", "not_found", "forbidden", "transient", "internal"];
+/** One spec §14 category. */
+export type ErrorCategory = (typeof ERROR_CATEGORIES)[number];
+/**
+ * A structured suggestion for a person or a coding agent.
+ *
+ * `suggestion` is the nearest accepted name when the input was a typo.
+ */
+export type ErrorFix = {
+    /** What to do, in one sentence. */
+    readonly summary: string;
+    /** Accepted name to use instead, when one is close. */
+    readonly suggestion?: string;
+};
+/** Column name to constraint reason. Row values are not included. */
+export type ErrorFields = Readonly<Record<string, string>>;
+/** Body of {@link OkmError.toHttp}. */
+export type HttpErrorBody = {
+    /** OKM code, or the kind when spec §21 does not number that kind. */
+    readonly code: string;
+    /** Same text as {@link OkmError.summary}. */
+    readonly reason: string;
+    /** Field reasons. Empty when the error has no columns. */
+    readonly fields: ErrorFields;
+};
+/** HTTP mapping of one error. */
+export type HttpError = {
+    readonly status: number;
+    readonly body: HttpErrorBody;
+};
+/** Replacement statuses. Omitted categories keep the spec default. */
+export type ErrorStatuses = Partial<Record<ErrorCategory, number>>;
+/** Structured log record. Row values are never included. */
+export type ErrorLog = {
+    readonly name: "OkmError";
+    readonly code: string;
+    readonly kind: ErrorKind;
+    readonly category: ErrorCategory;
+    readonly summary: string;
+    readonly retryable: boolean;
+    readonly batchIndex: number | null;
+    readonly fix: ErrorFix;
+    readonly fields: ErrorFields;
+    readonly table?: string;
+    readonly columns?: readonly string[];
+    readonly constraint?: string;
+    readonly sqlstate?: string;
+};
+/** Fields the constructor accepts beyond the code and the summary. */
+export type OkmErrorOptions = {
+    readonly kind?: ErrorKind;
+    readonly fix?: ErrorFix;
+    readonly table?: string;
+    readonly columns?: readonly string[];
+    /** Constraint reason stored by {@link OkmError.fields}. Defaults to the kind. */
+    readonly fieldReason?: string;
+    readonly constraint?: string;
+    readonly sqlstate?: string;
+    /** Statement index, or `null` at commit. Omitted on a single statement. */
+    readonly batchIndex?: number | null;
+    readonly cause?: unknown;
+    readonly retryable?: boolean;
+    /**
+     * Row values. Stored only when `includeValues` is set, and never logged.
+     * Development only (spec §14).
+     */
+    readonly includeValues?: boolean;
+    readonly values?: Readonly<Record<string, string>>;
+    /**
+     * Category overrides from `connect({ errors })`.
+     *
+     * {@link OkmError.toHttp} uses them when the caller does not pass statuses.
+     */
+    readonly http?: ErrorStatuses;
+};
+/** Success or a mapped {@link OkmError}. */
+export type SafeResult<T> = {
+    readonly ok: true;
+    readonly value: T;
+} | {
+    readonly ok: false;
+    readonly error: OkmError;
+};
+/**
+ * Column names on a registered table, or plain strings when it is not registered.
+ *
+ * An empty `Register` leaves every name as `string`. Augmenting `Register`
+ * narrows `users` to that table's columns.
+ */
+export type ErrorColumns<T extends string> = [TableName] extends [never] ? readonly string[] : T extends TableName ? readonly (keyof Row<T> & string)[] : readonly string[];
+type Categorised<C extends ErrorCategory> = OkmError & {
+    readonly category: C;
+};
+/**
+ * One OKModel error.
+ *
+ * Construction does not format a stack trace and does not compile a regular
+ * expression. Row values stay out unless `includeValues` was set.
+ */
+export declare class OkmError extends Error {
+    #private;
+    /** Spec code, or the kind when spec §21 does not number that kind. */
+    readonly code: string;
+    /** Spec §14 kind. */
+    readonly kind: ErrorKind;
+    /** Spec §14 category. */
+    readonly category: ErrorCategory;
+    /** Whether a declared retry may run this error again. `cancelled` never retries. */
+    readonly retryable: boolean;
+    /** What to change. */
+    readonly fix: ErrorFix;
+    /** Table the database named, when it named one. */
+    readonly table: string | undefined;
+    /** Columns the failure names. Empty when it names none. */
+    readonly columns: readonly string[];
+    /** Constraint name the database sent, when it sent one. */
+    readonly constraint: string | undefined;
+    /** SQLSTATE the database sent, when it sent one. */
+    readonly sqlstate: string | undefined;
+    /**
+     * Failing statement inside a batch, or `null` when the failure is the commit.
+     *
+     * `null` on a single statement as well: there is no statement index.
+     */
+    readonly batchIndex: number | null;
+    /** Constraint reason used by {@link fields}. */
+    readonly fieldReason: string;
+    /**
+     * Same text as `message`.
+     *
+     * @returns The summary
+     */
+    get summary(): string;
+    /**
+     * @param code - Spec code, or a kind name for an unnumbered mapped error
+     * @param message - What failed. This becomes {@link summary}
+     * @param options - Kind, columns, and fix. Omitted fields are derived
+     */
+    constructor(code: string, message: string, options?: OkmErrorOptions);
+    /**
+     * Maps a caught value to an {@link OkmError}.
+     *
+     * An {@link OkmError} is returned as itself. A driver error whose kind is
+     * `timeout`, `cancelled`, or `outcome_unknown` keeps that kind. Postgres
+     * SQLSTATE mapping is `mapPostgresError` in the Postgres dialect: this
+     * method does not interpret constraint SQLSTATEs.
+     *
+     * @param error - Any thrown value
+     * @returns An OKModel error
+     */
+    static from(error: unknown): OkmError;
+    /**
+     * Narrows `error` to one kind, and to one table's columns when `table` is set.
+     *
+     * @param error - Caught value
+     * @param kind - Expected kind
+     * @param table - Expected table. Columns are typed from `Register` when it names one
+     * @returns `true` when the kind matches and, if given, the table matches
+     */
+    static is<K extends ErrorKind>(error: unknown, kind: K): error is Omit<OkmError, "kind"> & {
+        readonly kind: K;
+    };
+    static is<K extends ErrorKind, T extends string>(error: unknown, kind: K, table: T): error is Omit<OkmError, "kind" | "table" | "columns"> & {
+        readonly kind: K;
+        readonly table: T;
+        readonly columns: ErrorColumns<T>;
+    };
+    /**
+     * Field name to constraint reason.
+     *
+     * The same object is returned on later calls. Row values are not included.
+     *
+     * @returns A map, empty when the error names no column
+     */
+    fields(): ErrorFields;
+    /**
+     * Row values, only when the error was built with `includeValues`.
+     *
+     * @returns The values, or `undefined` when they were not kept
+     */
+    values(): Readonly<Record<string, string>> | undefined;
+    /**
+     * HTTP status and a body without row values.
+     *
+     * @param statuses - Category overrides from `connect()`. Omitted categories use the spec default
+     * @returns Status and `{ code, reason, fields }`
+     */
+    toHttp(statuses?: ErrorStatuses): HttpError;
+    /**
+     * Structured record for a log. Row values are omitted.
+     *
+     * @returns The fields a log line may print
+     */
+    log(): ErrorLog;
+    /**
+     * Runs the handler for this category, or `_` when that category is omitted.
+     *
+     * @param handlers - One function per category that the caller handles, plus `_`
+     * @returns Whatever the chosen handler returns
+     */
+    match<I = never, C = never, NF = never, F = never, T = never, X = never, D = never>(handlers: {
+        readonly input?: (error: Categorised<"input">) => I;
+        readonly conflict?: (error: Categorised<"conflict">) => C;
+        readonly not_found?: (error: Categorised<"not_found">) => NF;
+        readonly forbidden?: (error: Categorised<"forbidden">) => F;
+        readonly transient?: (error: Categorised<"transient">) => T;
+        readonly internal?: (error: Categorised<"internal">) => X;
+        readonly _: (error: OkmError) => D;
+    }): I | C | NF | F | T | X | D;
+}
+/**
+ * Settles `pending` as `{ ok, value }` or `{ ok, error }`.
+ *
+ * The error is {@link OkmError.from}. Postgres constraint mapping happens
+ * before this, in the dialect, once a query throws.
+ *
+ * @param pending - Work that may throw
+ * @returns A result that does not throw
+ */
+export declare function safe<T>(pending: Promise<T>): Promise<SafeResult<T>>;
+/**
+ * Throws an {@link OkmError} for a catalog failure.
+ *
+ * @param code - Spec code
+ * @param message - What failed. Name the accepted values
+ * @param options - Fix and nearest-name suggestion
+ */
+export declare function catalogError(code: CatalogCode, message: string, options?: OkmErrorOptions): never;
+/**
+ * Throws for an unknown table, field, preset, or option.
+ *
+ * The message must already name the accepted values. A close candidate adds
+ * "Did you mean `name`?" and a {@link ErrorFix.suggestion}.
+ *
+ * @param code - Spec code for this guard
+ * @param input - The name that was rejected
+ * @param candidates - Accepted and reserved names
+ * @param message - What failed, including the accepted values
+ */
+export declare function throwNamed(code: CatalogCode | ColumnCode | QueryCode, input: string, candidates: readonly string[], message: string): never;
+/**
+ * Removes row values from a server message.
+ *
+ * `Key (email)=(ada@example.com)` becomes `Key (email)`. A `contains (...)`
+ * list becomes `contains (…)`.
+ *
+ * @param text - Driver or server text
+ * @returns Text safe to put on an error
+ */
+export declare function stripRowValues(text: string): string;
+/**
+ * Index of the parenthesis that closes the one at `open`.
+ *
+ * @param text - Source text
+ * @param open - Index of the opening `(`
+ * @returns Index of the matching `)`, or `undefined` when it is missing
+ */
+export declare function matchingParen(text: string, open: number): number | undefined;
+export {};

package/dist/contracts/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Public entry for the `okmodel` package.
+ *
+ * Application code imports `OkmError`, `safe`, the row types, and the driver
+ * types from here. Catalog builders and the helpers a dialect author calls
+ * live on `okmodel/internal`, so `table` and `index` on this entry are not a
+ * second schema API.
+ */
+export { CATALOG_CODES, COLUMN_CODES, ERROR_CATEGORIES, ERROR_KINDS, OkmError, safe, type CatalogCode, type ColumnCode, type QueryCode, type ErrorCategory, type ErrorColumns, type ErrorFields, type ErrorFix, type ErrorKind, type ErrorLog, type ErrorStatuses, type HttpError, type HttpErrorBody, type OkmErrorOptions, type SafeResult, } from "./error.js";
+export type { AnySchema, AnyTableShape, Insert, Register, Row, SchemaOf, TableName, Update, } from "./rows.js";
+export type { DescribeResult, DriverCapabilities, DriverConnection, DriverErrorFields, DriverFailureKind, DriverPool, DriverPoolConfig, DriverStats, ExecuteOptions, ExecuteResult, Notice, PreparedMode, Statement, TransactionMode, WireValue, } from "./driver.js";

package/dist/contracts/index.js

@@ -0,0 +1,16 @@
+import {
+  CATALOG_CODES2,
+  COLUMN_CODES2,
+  ERROR_KINDS2,
+  ERROR_CATEGORIES2,
+  OkmError2,
+  safe2
+} from "../shared/ycwz42az.js";
+export {
+  CATALOG_CODES2 as CATALOG_CODES,
+  COLUMN_CODES2 as COLUMN_CODES,
+  ERROR_CATEGORIES2 as ERROR_CATEGORIES,
+  ERROR_KINDS2 as ERROR_KINDS,
+  OkmError2 as OkmError,
+  safe2 as safe
+};

package/dist/contracts/internal.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Undocumented entry for `okmodel/internal`.
+ *
+ * No stability promise. Dialect authors and the sibling entries import these.
+ * Application code imports `table` and `index` from `okmodel/pg`, not the
+ * catalog builders here.
+ */
+/** @internal */
+export { catalogError, throwNamed } from "./error.js";
+/** @internal */
+export { nearestName } from "./nearest.js";
+/** @internal */
+export { sha256 } from "./sha256.js";
+/** @internal */
+export { BUILT_KINDS, CATALOG_VERSION, KIND_OPERATIONS, OBJECT_KINDS, OBJECT_OPERATIONS, OWNERS, POSTGRES_IDENTIFIER_MAX_BYTES, assertIdentifier, assertNamespace, column, constraint, deterministicName, fitIdentifier, identityKey, identityLabel, identifierLimitApplies, index, isReservedIdentifier, resolveNamespace, sameNamespace, sameRef, sequence, staticNamespace, table, templateNamespace, utf8ByteLength, type AnchoredIdentity, type BuiltKind, type Catalog, type CatalogEnvelope, type CatalogObject, type ColumnDefinition, type ColumnInput, type ColumnObject, type ConstraintDefinition, type ConstraintInput, type ConstraintKind, type ConstraintObject, type DefaultPrivilegeIdentity, type DependencyEdge, type ExtensionIdentity, type FunctionIdentity, type GrantIdentity, type GrantObjectRef, type IndexDefinition, type IndexInput, type IndexObject, type NamePurpose, type Namespace, type NamespaceIdentity, type ObjectIdentity, type ObjectKind, type ObjectOperation, type ObjectRef, type Owner, type PartitionMethod, type Provenance, type ReferentialAction, type RoleIdentity, type SequenceDefinition, type SequenceInput, type SequenceObject, type TableDefinition, type TableInput, type TableObject, } from "./catalog/index.js";

package/dist/contracts/internal.js

@@ -0,0 +1,68 @@
+import {
+  OWNERS2,
+  OBJECT_KINDS2,
+  BUILT_KINDS2,
+  OBJECT_OPERATIONS2,
+  KIND_OPERATIONS2,
+  CATALOG_VERSION2,
+  staticNamespace2,
+  templateNamespace2,
+  assertNamespace2,
+  resolveNamespace2,
+  identityKey2,
+  identifierLimitApplies2,
+  identityLabel2,
+  sameRef2,
+  sameNamespace2,
+  table3,
+  column2,
+  index3,
+  constraint2,
+  sequence2
+} from "../shared/j5cn2963.js";
+import {
+  utf8ByteLength2,
+  sha2562,
+  POSTGRES_IDENTIFIER_MAX_BYTES2,
+  isReservedIdentifier2,
+  assertIdentifier2,
+  fitIdentifier2,
+  deterministicName2
+} from "../shared/mkjmqjv4.js";
+import {
+  nearestName2,
+  catalogError2,
+  throwNamed2
+} from "../shared/ycwz42az.js";
+export {
+  BUILT_KINDS2 as BUILT_KINDS,
+  CATALOG_VERSION2 as CATALOG_VERSION,
+  KIND_OPERATIONS2 as KIND_OPERATIONS,
+  OBJECT_KINDS2 as OBJECT_KINDS,
+  OBJECT_OPERATIONS2 as OBJECT_OPERATIONS,
+  OWNERS2 as OWNERS,
+  POSTGRES_IDENTIFIER_MAX_BYTES2 as POSTGRES_IDENTIFIER_MAX_BYTES,
+  assertIdentifier2 as assertIdentifier,
+  assertNamespace2 as assertNamespace,
+  catalogError2 as catalogError,
+  column2 as column,
+  constraint2 as constraint,
+  deterministicName2 as deterministicName,
+  fitIdentifier2 as fitIdentifier,
+  identifierLimitApplies2 as identifierLimitApplies,
+  identityKey2 as identityKey,
+  identityLabel2 as identityLabel,
+  index3 as index,
+  isReservedIdentifier2 as isReservedIdentifier,
+  nearestName2 as nearestName,
+  resolveNamespace2 as resolveNamespace,
+  sameNamespace2 as sameNamespace,
+  sameRef2 as sameRef,
+  sequence2 as sequence,
+  sha2562 as sha256,
+  staticNamespace2 as staticNamespace,
+  table3 as table,
+  templateNamespace2 as templateNamespace,
+  throwNamed2 as throwNamed,
+  utf8ByteLength2 as utf8ByteLength
+};

package/dist/contracts/nearest.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Nearest-name hints for unknown tables, fields, presets, and options.
+ *
+ * One edit-distance helper. No dependency, and nothing runs at import.
+ */
+/**
+ * Closest candidate to `input`, or `undefined` when none is close.
+ *
+ * Comparison ignores ASCII case. The returned spelling is the candidate's.
+ *
+ * @param input - The name that was not accepted
+ * @param candidates - Accepted and reserved names
+ * @returns A name to show after "did you mean"
+ */
+export declare function nearestName(input: string, candidates: readonly string[]): string | undefined;

package/dist/contracts/rows.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Row lookup by table name.
+ *
+ * `Register` is declaration merging on `okmodel`. `Row`, `Insert`, and
+ * `Update` read it when the caller does not pass a schema. The shapes
+ * themselves are computed by `table()` in the dialect.
+ */
+/**
+ * Project schema slot.
+ *
+ * Augment `okmodel` with one `schema` property. `okm check` warns on a
+ * second augmentation later (OKM1025).
+ */
+export interface Register {
+}
+/**
+ * Fields a table exposes for row lookup.
+ *
+ * The dialect's table value has these phantoms. This shape stays in
+ * contracts so the package entry can name `Row` without importing a dialect.
+ */
+export type AnyTableShape = {
+    readonly "~name": string;
+    readonly "~row": unknown;
+    readonly "~insert": unknown;
+    readonly "~update": unknown;
+};
+/**
+ * A schema that can look up tables by name.
+ */
+export type AnySchema = {
+    readonly "~byName": {
+        readonly [name: string]: AnyTableShape;
+    };
+};
+/**
+ * The schema a lookup uses.
+ *
+ * An explicit argument wins. Otherwise the type is `Register["schema"]`.
+ *
+ * @typeParam S - Explicit schema, or `undefined` to read {@link Register}
+ */
+export type SchemaOf<S extends AnySchema | undefined> = S extends AnySchema ? S : Register extends {
+    readonly schema: infer R extends AnySchema;
+} ? R : never;
+/**
+ * Table names of a schema, defaulting to {@link Register}.
+ *
+ * @typeParam S - Explicit schema, or `undefined`
+ */
+export type TableName<S extends AnySchema | undefined = undefined> = keyof SchemaOf<S>["~byName"] & string;
+/**
+ * Row type. Hidden columns are already removed.
+ *
+ * @typeParam N - Table name
+ * @typeParam S - Explicit schema. Omit it to use {@link Register}
+ */
+export type Row<N extends TableName<S>, S extends AnySchema | undefined = undefined> = ShapeOf<S, N, "~row">;
+/**
+ * Insert type. Guarded, generated, and primary-key columns are already removed.
+ *
+ * @typeParam N - Table name
+ * @typeParam S - Explicit schema. Omit it to use {@link Register}
+ */
+export type Insert<N extends TableName<S>, S extends AnySchema | undefined = undefined> = ShapeOf<S, N, "~insert">;
+/**
+ * Update type. The same columns as insert, every one optional.
+ *
+ * @typeParam N - Table name
+ * @typeParam S - Explicit schema. Omit it to use {@link Register}
+ */
+export type Update<N extends TableName<S>, S extends AnySchema | undefined = undefined> = ShapeOf<S, N, "~update">;
+/**
+ * One phantom on the table named `N`.
+ *
+ * The index can include `undefined` under `noUncheckedIndexedAccess`.
+ * The conditional drops that and keeps the table's own shape.
+ *
+ * @typeParam S - Explicit schema, or `undefined`
+ * @typeParam N - Table name
+ * @typeParam K - `~row`, `~insert`, or `~update`
+ */
+type ShapeOf<S extends AnySchema | undefined, N extends string, K extends keyof AnyTableShape> = N extends keyof SchemaOf<S>["~byName"] ? SchemaOf<S>["~byName"][N] extends infer T ? T extends AnyTableShape ? T[K] : never : never : never;
+export {};

package/dist/contracts/sha256.d.ts

@@ -0,0 +1,14 @@
+/**
+ * SHA-256 (FIPS 180-4) implemented in TypeScript.
+ *
+ * Contracts must not call Bun, a host crypto API, or a Node built-in.
+ * Round constants are built on the first hash, not when this module loads.
+ * Callers in other layers use this for catalog and fixture hashes.
+ */
+/**
+ * SHA-256 of a string, encoded as UTF-8.
+ *
+ * @param text - Input text
+ * @returns Lowercase hex digest
+ */
+export declare function sha256(text: string): string;

package/dist/contracts/utf8.d.ts

@@ -0,0 +1,33 @@
+/**
+ * UTF-8 measurement and encoding.
+ *
+ * Identifier fitting and SHA-256 share this walk so neither keeps its own copy.
+ */
+/**
+ * UTF-8 byte length of a string.
+ *
+ * @param value - Text to measure
+ * @returns Byte length
+ */
+export declare function utf8ByteLength(value: string): number;
+/**
+ * UTF-8 bytes of a string.
+ *
+ * ASCII, the usual catalog text, is one pass into one buffer. Anything else
+ * uses the same width rules as {@link utf8ByteLength}.
+ *
+ * @param value - Text to encode
+ * @returns UTF-8 bytes
+ */
+export declare function encodeUtf8(value: string): Uint8Array;
+/**
+ * UTF-8 prefix of `value` that fits in `budget` bytes.
+ *
+ * A code point that would cross the budget is left off, so a surrogate pair
+ * is never split.
+ *
+ * @param value - Text to cut
+ * @param budget - Maximum UTF-8 bytes
+ * @returns The prefix
+ */
+export declare function truncateUtf8(value: string, budget: number): string;

package/dist/dialects/pg/array-literal.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Postgres array literals.
+ *
+ * Encode and decode run only when a column uses `.array()`. The scanner is
+ * created per call.
+ */
+/**
+ * Writes a nested array as a Postgres array literal.
+ *
+ * @param value - Nested arrays of scalar values
+ * @param dims - Rank, at least 1
+ * @param encode - Scalar encoder
+ * @param raw - Whether scalar tokens may stay bare
+ * @returns A `{...}` literal
+ */
+export declare function writeArray(value: unknown, dims: number, encode: (value: unknown) => string, raw: boolean): string;
+/**
+ * Reads a Postgres array literal back into nested scalars.
+ *
+ * @param wire - Literal produced by {@link writeArray}
+ * @param dims - Rank, at least 1
+ * @param decode - Scalar decoder
+ * @returns Nested arrays
+ */
+export declare function readArray(wire: string, dims: number, decode: (wire: string) => unknown): unknown;

package/dist/dialects/pg/bool.d.ts

@@ -0,0 +1,46 @@
+/**
+ * boolean and bytea.
+ */
+import { type ColumnBuilder, type PlainFlags } from "./column.js";
+/**
+ * Boolean.
+ *
+ * @returns A boolean column
+ */
+export declare function boolean(): ColumnBuilder<boolean, PlainFlags>;
+/**
+ * Binary data. Wire text is `\x` plus lowercase hex.
+ *
+ * @returns A bytea column
+ */
+export declare function bytea(): ColumnBuilder<Uint8Array, PlainFlags>;
+/**
+ * Encodes true or false.
+ *
+ * @param value - Boolean
+ * @returns `true` or `false`
+ */
+export declare function encodeBoolean(value: boolean): string;
+/**
+ * Decodes a boolean token.
+ *
+ * Accepts `true`, `false`, `t`, `f`, `1`, and `0`.
+ *
+ * @param wire - Boolean text
+ * @returns A boolean
+ */
+export declare function decodeBoolean(wire: string): boolean;
+/**
+ * Encodes bytes as `\x` hex.
+ *
+ * @param value - Bytes
+ * @returns Hex text
+ */
+export declare function encodeBytea(value: Uint8Array): string;
+/**
+ * Decodes `\x` hex into a new byte array.
+ *
+ * @param wire - Hex text
+ * @returns Bytes
+ */
+export declare function decodeBytea(wire: string): Uint8Array;