prest-js-sdk 0.2.0

package/.changeset/config.json

@@ -0,0 +1,11 @@
+{
+  "$schema": "https://unpkg.com/@changesets/config@3.0.0/schema.json",
+  "changelog": "@changesets/cli/changelog",
+  "commit": false,
+  "fixed": [],
+  "linked": [],
+  "access": "public",
+  "baseBranch": "master",
+  "updateInternalDependencies": "patch",
+  "ignore": []
+}

package/.github/workflows/release.yml

@@ -0,0 +1,42 @@
+name: Release
+
+on:
+  push:
+    branches:
+      - master
+
+concurrency: ${{ github.workflow }}-${{ github.ref }}
+
+jobs:
+  release:
+    name: Create Release Pull Request or Publish
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      pull-requests: write
+      id-token: write
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 20
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Create Release Pull Request or Publish to npm
+        uses: changesets/action@v1
+        with:
+          publish: npm run release
+          version: npm run version-packages
+          commit: "chore(release): version packages"
+          title: "chore(release): version packages"
+          setupGitUser: true
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}

package/CHANGELOG.md

@@ -0,0 +1,9 @@
+# prest-js-sdk
+
+## 0.2.0
+
+### Minor Changes
+
+- 6012e3a: Initial release. PrestClient with catalog, CRUD, stored-query, health, and login methods;
+  typed Filter / SelectOpts DSL that serializes to pREST's `?field=op.value` URL syntax;
+  fromKratosSession() factory for forward-compat with the planned Kratos auth integration.

package/CLAUDE.md

@@ -0,0 +1,203 @@
+# prest-js-sdk
+
+TypeScript SDK for pREST (PostgreSQL REST API). Wraps pREST's HTTP routes with route-shaped methods and a typed filter DSL.
+
+## Repository
+
+- GitHub: https://github.com/yudaprama/prest-js-sdk (publish target)
+- npm: https://www.npmjs.com/package/prest-js-sdk (publish target)
+- Base branch: `master`
+- Node: 20
+
+## Sibling project
+
+This SDK mirrors `alist-kratos-sdk/` (the AList SDK in the parent `ai-orchestration` workspace). Same shape:
+
+- Single-file SDK at `src/index.ts` (~500 lines)
+- tsc direct build, ESM-only
+- Changesets + GitHub Actions release flow
+- `fromKratosSession()` static factory (forward-compat — pREST submodule does not yet wire Kratos)
+
+When adding capabilities here, check whether `alist-kratos-sdk` has an analogous pattern to follow.
+
+## Project layout
+
+```
+src/                 TypeScript source (entry: src/index.ts)
+examples/            Standalone scripts (filter serializer test, smoke test)
+dist/                Build output (gitignored)
+.changeset/          Changeset markdown files (one per unreleased change)
+.github/workflows/   GitHub Actions release.yml
+.npmrc               Auth for npm publish (uses NPM_TOKEN)
+package.json         Version, scripts, deps
+```
+
+## Build
+
+```bash
+npm ci                # install (CI uses lockfile)
+npm run build         # tsc -> dist/
+node examples/filters.ts   # sanity check the filter serializer
+```
+
+## pREST HTTP surface (the contract this SDK wraps)
+
+The `prest/` submodule in the parent workspace is vanilla upstream pREST v2.0.0.
+Routes (from `prest/router/router.go:17`):
+
+| Method | Route | SDK method |
+|---|---|---|
+| GET | `/databases` | `databases()` |
+| GET | `/schemas` | `schemas()` |
+| GET | `/tables` | `tables()` |
+| GET | `/{database}/{schema}` | `tablesIn(db, schema)` |
+| GET | `/show/{database}/{schema}/{table}` | `showTable(db, schema, table)` |
+| GET | `/{database}/{schema}/{table}` | `select(...)` |
+| POST | `/{database}/{schema}/{table}` | `insert(...)` |
+| POST | `/batch/{database}/{schema}/{table}` | `insertBatch(...)` |
+| PUT, PATCH | `/{database}/{schema}/{table}` | `update(...)` |
+| DELETE | `/{database}/{schema}/{table}` | `delete(...)` |
+| ANY | `/_QUERIES/{location}/{script}` | `query(location, script, params)` |
+| GET | `/_health` | `health()` |
+| POST | `/auth` | `login(username, password)` |
+
+**Filter URL syntax** (verified against `prest/adapters/postgres/postgres.go`):
+- `?field=op.value` — operator-prefixed (op defaults to `eq` when bare)
+- Multi-value ops: `?field=in.(1,2,3)` — parens, comma-separated
+- Value-less ops: `?field=null`, `?field=true` — no trailing dot
+- Reserved params (start with `_`): `_select`, `_order`, `_groupby`, `_join`, `_where`, `_count`, `_count_first`, `_limit`, `_offset`, `_page`, `_size`, `_distinct`, `_returning`, `_or`
+
+Operators (`prest/adapters/postgres/postgres.go:1474` GetQueryOperator):
+`eq, ne, gt, gte, lt, lte, in, nin, any, some, all, null, notnull, true, nottrue, false, notfalse, like, ilike, nlike, nilike` (+ ltree ops, not exposed in v0.1).
+
+## Release workflow
+
+Publishing is fully automated via **changesets** + GitHub Actions. **Do not run `npm version` or push tags manually.**
+
+### How a release happens
+
+1. A PR or direct push to `master` contains one or more `.changeset/<name>.md` files.
+2. The `Release` workflow runs on push to `master`:
+   - **If a "Version Packages" PR is already open**, it updates that PR with the new changesets.
+   - **If no PR is open**, it creates one titled `chore(release): version packages`. This PR:
+     - bumps `version` in `package.json` (consuming the changesets)
+     - regenerates `CHANGELOG.md`
+     - deletes the consumed changeset files
+3. When a maintainer **merges the "Version Packages" PR**:
+   - The same workflow runs on the merge commit
+   - There are no more pending changesets, so it skips versioning and runs `npm run release` (`tsc` + `changeset publish`)
+   - npm publish uses the `NPM_TOKEN` secret (granular token with **Bypass 2FA** enabled)
+
+### Authoring a changeset
+
+When a PR changes user-facing behavior, add a file under `.changeset/`:
+
+```bash
+npm run changeset
+```
+
+…or create the file manually:
+
+```markdown
+---
+"prest-js-sdk": minor
+---
+
+Describe what changed and why. This text goes into CHANGELOG.md and the GitHub release notes.
+```
+
+Bump levels:
+- `patch` — bug fix, internal refactor
+- `minor` — new feature, backward-compatible
+- `major` — breaking change
+
+Skip a changeset for docs-only or CI-only changes.
+
+### One-time setup (do this once when first publishing)
+
+- `NPM_TOKEN` secret in repo Settings → Secrets → Actions (granular token, Bypass 2FA, Publish scope)
+- Repo Settings → Actions → General → Workflow permissions: **Read and write permissions**, **Allow GitHub Actions to create and approve pull requests** enabled
+- `NPM_TOKEN` env var is passed to the workflow and consumed by the repo's `.npmrc`
+
+### Triggering the first publish
+
+1. Ensure at least one `.changeset/*.md` exists on `master` (the `initial.md` is already there).
+2. Push to `master` → workflow opens the "Version Packages" PR.
+3. Review the PR (version bump, CHANGELOG entries look right).
+4. Merge it → workflow publishes to npm.
+
+### Manual override (emergency only)
+
+```bash
+npm login
+npm run version-packages
+npm run release
+git push --follow-tags
+```
+
+**Do not do this routinely** — it bypasses the CHANGELOG PR review.
+
+## Secrets & tokens
+
+| Secret | Used by | Notes |
+|---|---|---|
+| `NPM_TOKEN` | Release workflow | Granular token, Bypass 2FA, Publish scope. Rotate if leaked. |
+| `GITHUB_TOKEN` | Release workflow | Auto-provided by GitHub Actions; needs write perms + PR creation enabled. |
+
+## Common tasks
+
+| Task | Command |
+|---|---|
+| Add a changeset interactively | `npm run changeset` |
+| Preview the next version locally | `npm run version-packages -- --snapshot` |
+| Build types only | `npm run build` |
+| Watch TS | `npm run dev` |
+| Run filter test | `node examples/filters.ts` |
+| Smoke test against running prest | `node examples/smoke.ts` (requires `planoctl up`) |
+| Inspect a workflow run | `gh run list --repo yudaprama/prest-js-sdk --workflow=release.yml` |
+| View logs | `gh run view <id> --repo yudaprama/prest-js-sdk --log` |
+| Re-run a failed workflow | `gh run rerun <id> --repo yudaprama/prest-js-sdk` |
+
+## Troubleshooting
+
+- **`E404 Not Found` on publish** — `NPM_TOKEN` not reaching the publish step. Confirm `.npmrc` uses `//registry.npmjs.org/:_authToken=${NPM_TOKEN}` and the env var is set on the `changesets/action` step.
+- **`E403 ... 2FA required`** — The token was generated without "Bypass 2FA". Regenerate a granular token with that option enabled.
+- **`GitHub Actions is not permitted to create or approve pull requests`** — Repo Settings → Actions → General → Workflow permissions: enable "Allow GitHub Actions to create and approve pull requests".
+- **No "Version Packages" PR appears** — No `.changeset/*.md` files exist on `master`. Add one and push.
+- **`npm ci` fails: lockfile out of sync** — Run `npm install` locally, commit `package-lock.json`, push.
+
+## SDK API quick reference
+
+```ts
+import { PrestClient } from "prest-js-sdk";
+
+const client = new PrestClient("http://localhost:3000");
+
+// Catalog
+await client.databases();
+await client.schemas();
+await client.tables();
+await client.tablesIn("yarsew", "public");
+await client.showTable("yarsew", "public", "users");
+
+// CRUD with typed filter
+await client.select("yarsew", "public", "billing_balances", {
+  where: { actor_id: 42, status: { eq: "active" } },
+  select: ["id", "amount"],
+  order: ["amount:desc"],
+  page: 1, size: 20,
+});
+await client.insert("yarsew", "public", "billing_balances", { actor_id: 42, amount: 100 });
+await client.insertBatch("yarsew", "public", "billing_balances", [/* ... */]);
+await client.update("yarsew", "public", "billing_balances", { actor_id: 42 }, { status: "frozen" });
+await client.delete("yarsew", "public", "billing_balances", { actor_id: 42 });
+
+// Stored SQL
+await client.query("reports", "top_balances", { min: 1000 });
+
+// Health + auth
+await client.health();           // → boolean
+await client.login("alice", "hunter2");  // → JWT, also stores internally
+```
+
+See `README.md` for full type definitions and the auth flow.

package/README.md

@@ -0,0 +1,219 @@
+# prest-js-sdk
+
+TypeScript SDK for [pREST](https://github.com/prest/prest) — PostgreSQL REST API. Route-shaped methods for catalog/CRUD/stored-queries, plus a typed filter DSL that serializes to pREST's `?field=op.value` URL syntax.
+
+## Install
+
+```bash
+npm install prest-js-sdk
+```
+
+## Quick start
+
+```ts
+import { PrestClient } from "prest-js-sdk";
+
+// Option 1: explicit URL (no auth — open prest)
+const client = new PrestClient("http://localhost:3000");
+
+// Option 2: URL + auth token (JWT from POST /auth, or Kratos session)
+const client = new PrestClient({
+  prestUrl: "http://localhost:3000",
+  authToken: "eyJhbGci...",
+});
+
+// Option 3: auto-detect Kratos session (forward-compat — see Auth section)
+const client = await PrestClient.fromKratosSession(
+  "http://localhost:4433",   // Kratos public URL
+  "http://localhost:3000",   // pREST URL (optional)
+);
+if (!client) throw new Error("No valid Kratos session");
+```
+
+## Catalog
+
+```ts
+await client.databases();                 // GET /databases
+await client.schemas();                   // GET /schemas
+await client.tables();                    // GET /tables
+await client.tablesIn("yarsew", "public");          // GET /yarsew/public
+await client.showTable("yarsew", "public", "users");  // GET /show/yarsew/public/users
+```
+
+## Select with typed filter
+
+```ts
+interface Balance { id: number; actor_id: number; amount: number; status: string }
+
+const rows = await client.select<Balance>("yarsew", "public", "billing_balances", {
+  where: {
+    actor_id: 42,                       // shorthand → eq.42
+    status: { eq: "active" },
+    amount: { gte: 100 },
+    name: { like: "foo%" },
+  },
+  select: ["id", "amount", "status"],
+  order: ["amount:desc"],
+  page: 1,
+  size: 20,
+});
+```
+
+## Insert / Update / Delete
+
+```ts
+// Insert single row
+const [created] = await client.insert<Balance>(
+  "yarsew", "public", "billing_balances",
+  { actor_id: 42, amount: 99.95, status: "active" },
+);
+
+// Insert batch
+await client.insertBatch("yarsew", "public", "billing_balances", [
+  { actor_id: 1, amount: 10 },
+  { actor_id: 2, amount: 20 },
+]);
+
+// Update — filter rows, then mutate
+await client.update<Balance>(
+  "yarsew", "public", "billing_balances",
+  { actor_id: 42 },                       // WHERE
+  { status: "frozen" },                   // SET
+);
+
+// Delete — filter rows
+await client.delete("yarsew", "public", "billing_balances", { actor_id: 42 });
+```
+
+## Stored SQL queries
+
+SQL files live under `<prest queries dir>/<location>/<script>.sql` and are invoked by name:
+
+```ts
+// Calls /_QUERIES/reports/top_balances?min=1000
+const top = await client.query<Balance>("reports", "top_balances", { min: 1000 });
+```
+
+Inside the `.sql` file, params are available via pREST's template helpers:
+
+```sql
+SELECT * FROM billing_balances
+WHERE amount >= {{ sqlVal "min" }}
+ORDER BY amount DESC
+LIMIT 100
+```
+
+## Filter DSL reference
+
+| JS shape | URL emitted | SQL |
+|---|---|---|
+| `{ field: 42 }` | `?field=eq.42` | `field = 42` |
+| `{ field: "x" }` | `?field=eq.x` | `field = 'x'` |
+| `{ field: { ne: 42 } }` | `?field=ne.42` | `field != 42` |
+| `{ field: { gt: 100 } }` | `?field=gt.100` | `field > 100` |
+| `{ field: { gte: 100 } }` | `?field=gte.100` | `field >= 100` |
+| `{ field: { lt: 100 } }` | `?field=lt.100` | `field < 100` |
+| `{ field: { lte: 100 } }` | `?field=lte.100` | `field <= 100` |
+| `{ field: { in: [1,2,3] } }` | `?field=in.(1,2,3)` | `field IN (1,2,3)` |
+| `{ field: { nin: [1,2] } }` | `?field=nin.(1,2)` | `field NOT IN (1,2)` |
+| `{ field: { like: "foo%" } }` | `?field=like.foo%25` | `field LIKE 'foo%'` |
+| `{ field: { ilike: "foo%" } }` | `?field=ilike.foo%25` | `field ILIKE 'foo%'` |
+| `{ field: null }` | `?field=null` | `field IS NULL` |
+| `{ field: { notnull: true } }` | `?field=notnull` | `field IS NOT NULL` |
+| `{ field: true }` | `?field=true` | `field IS TRUE` |
+
+Multiple fields are AND-ed. For OR across fields, use `SelectOpts.or`:
+
+```ts
+client.select(..., {
+  or: [
+    { status: "active" },
+    { amount: { gt: 1000 } },
+  ],
+});
+// → ?_or=status=eq.active,amount=gt.1000
+```
+
+### `SelectOpts`
+
+| Field | Maps to | Notes |
+|---|---|---|
+| `where` | `?field=op.value` | AND-ed; see table above |
+| `select` | `_select=col1,col2` | column projection |
+| `order` | `_order=col1,col2:desc` | suffix `:asc` / `:desc` per column |
+| `page` + `size` | `_page`, `_size` | 1-indexed pagination |
+| `limit` + `offset` | `_limit`, `_offset` | alternative pagination |
+| `distinct` | `_distinct=true` | |
+| `count` | `_count=true` | return row counts |
+| `countFirst` | `_count_first=true` | single count object |
+| `groupBy` | `_groupby=col1,col2` | |
+| `or` | `_or=field=op.value,...` | OR-clause inside parens |
+| `returning` | `_returning=col1,col2` | for update/delete |
+
+## Auth
+
+pREST supports two auth modes:
+
+### 1. Database-backed (`[auth]` block in `prest.toml`)
+
+```ts
+const client = new PrestClient("http://localhost:3000");
+const token = await client.login("alice", "hunter2");
+// subsequent requests now carry Authorization: Bearer <token>
+```
+
+### 2. Kratos session (forward-compat)
+
+The pREST submodule is vanilla upstream — it does not yet wire Ory Kratos. The
+parent `ai-orchestration` project documents a planned `[auth.kratos]` integration;
+once that lands, `PrestClient.fromKratosSession()` will work exactly like the
+sibling `alist-kratos-sdk`:
+
+```ts
+const client = await PrestClient.fromKratosSession(
+  "http://localhost:4433",
+  "http://localhost:3000",
+);
+```
+
+In Node (no cookie jar), pass the session token explicitly:
+
+```ts
+const client = await PrestClient.fromKratosSession(
+  "http://localhost:4433",
+  "http://localhost:3000",
+  process.env.KRATOS_SESSION_TOKEN,
+);
+```
+
+## Low-level escape hatch
+
+For endpoints not wrapped by the typed methods:
+
+```ts
+const res = await client.request<{ some: shape }>("GET", "/custom/path", {
+  params: new URLSearchParams({ foo: "bar" }),
+  headers: { "X-Custom": "value" },
+});
+```
+
+Throws `PrestApiError` (with `.status` and `.body`) on non-2xx.
+
+## Browser vs Node
+
+The SDK works in both browsers and Node 18+:
+
+- `fromKratosSession()` reads the `ory_kratos_session` cookie in browsers; in Node pass the token explicitly.
+- `fetch` is available natively in both runtimes.
+- No DOM dependencies (only used for cookie reading).
+
+## Development
+
+```bash
+npm install
+npm run build      # tsc → dist/
+npm run dev        # tsc --watch
+node examples/filters.ts   # verify filter serializer
+```
+
+Releases are automated via changesets + GitHub Actions — see `CLAUDE.md` for the full flow.

package/dist/index.d.ts

@@ -0,0 +1,207 @@
+/**
+ * prest-js-sdk
+ *
+ * TypeScript SDK for pREST (PostgreSQL REST API). Provides route-shaped methods
+ * for catalog/CRUD/stored-queries plus a typed filter DSL that serializes to
+ * pREST's `?field=op.value` URL syntax.
+ *
+ * Usage:
+ *   import { PrestClient } from "prest-js-sdk";
+ *
+ *   const client = new PrestClient("http://localhost:3000");
+ *
+ *   // Catalog
+ *   const dbs = await client.databases();
+ *
+ *   // Query with typed filter
+ *   const rows = await client.select<Balance>("yarsew", "public", "billing_balances", {
+ *     where: { actor_id: { eq: 42 }, status: "active" },
+ *     select: ["id", "balance"],
+ *     order: ["balance:desc"],
+ *     limit: 10,
+ *   });
+ *
+ *   // Insert
+ *   const [row] = await client.insert<Balance>("yarsew", "public", "billing_balances", {
+ *     actor_id: 42, balance: 100.50, status: "active",
+ *   });
+ *
+ *   // Update (filter + new values)
+ *   const updated = await client.update<Balance>(
+ *     "yarsew", "public", "billing_balances",
+ *     { actor_id: 42 },
+ *     { status: "frozen" },
+ *   );
+ *
+ *   // Delete
+ *   await client.delete("yarsew", "public", "billing_balances", { actor_id: 42 });
+ *
+ *   // Stored SQL (prest/etc/queries/reports/top_balances.sql)
+ *   const top = await client.query<Balance>("reports", "top_balances", { min: 1000 });
+ *
+ *   // Forward-compat Kratos auth (works once [auth.kratos] is wired into prest)
+ *   const authed = await PrestClient.fromKratosSession(
+ *     "http://localhost:4433",
+ *     "http://localhost:3000",
+ *   );
+ */
+export interface PrestConfig {
+    /** pREST base URL, e.g. http://localhost:3000 */
+    prestUrl: string;
+    /** Optional bearer token (JWT from POST /auth, or Kratos session for forward-compat) */
+    authToken?: string;
+    /** Optional: pre-built Authorization header value (skips "Bearer " prefix) */
+    rawAuthHeader?: string;
+    /** Optional: extra headers merged into every request */
+    headers?: Record<string, string>;
+}
+/**
+ * Filter operators supported by pREST's `?field=op.value` syntax.
+ * Mirrors `prest/adapters/postgres/postgres.go` GetQueryOperator (line ~1474).
+ */
+export type Operator = "eq" | "ne" | "gt" | "gte" | "lt" | "lte" | "in" | "nin" | "any" | "some" | "all" | "null" | "notnull" | "true" | "nottrue" | "false" | "notfalse" | "like" | "ilike" | "nlike" | "nilike";
+export type OpValue = string | number | (string | number)[];
+/**
+ * Filter on table columns.
+ *
+ * - `{ field: value }` — shorthand for `{ field: { eq: value } }`
+ * - `{ field: null }` — IS NULL
+ * - `{ field: { op: value } }` — operator form, e.g. `{ age: { gt: 30 } }`
+ *
+ * Multiple fields are AND-ed. For OR across fields, use `SelectOpts.or`.
+ */
+export type Filter = {
+    [field: string]: string | number | boolean | null | {
+        [op in Operator]?: OpValue;
+    };
+};
+export interface SelectOpts {
+    /** WHERE clause — AND-ed across fields */
+    where?: Filter;
+    /** Column selection — `_select=col1,col2` */
+    select?: string[];
+    /** Order — `_order=col1,col2:desc` */
+    order?: string[];
+    /** Page-based pagination (1-indexed) — `_page=N&_size=M` */
+    page?: number;
+    size?: number;
+    /** Offset-based pagination — `_limit=N&_offset=M` */
+    limit?: number;
+    offset?: number;
+    /** DISTINCT — `_distinct=true` */
+    distinct?: boolean;
+    /** COUNT rows instead of returning them — `_count=true` */
+    count?: boolean;
+    /** Return just the count as a single object — `_count_first=true` */
+    countFirst?: boolean;
+    /** GROUP BY columns — `_groupby=col1,col2` */
+    groupBy?: string[];
+    /** OR-clauses for the WHERE — joined with OR inside parens */
+    or?: Filter[];
+    /** Columns to return from update/delete — `_returning=col1,col2` */
+    returning?: string[];
+}
+export declare class PrestApiError extends Error {
+    readonly status: number;
+    readonly body?: unknown | undefined;
+    constructor(status: number, message: string, body?: unknown | undefined);
+}
+/**
+ * Serialize a Filter into pREST URL query params.
+ *
+ * Each field becomes one or more entries: `field=op.value`. Multiple ops on the
+ * same field are emitted as repeated query params (pREST AND-s them).
+ *
+ * @example
+ *   serializeFilter({ actor_id: 42 })
+ *   // → "actor_id=eq.42"
+ *   serializeFilter({ age: { gt: 30 }, name: { like: "foo%" } })
+ *   // → "age=gt.30&name=like.foo%25"
+ *   serializeFilter({ id: { in: [1, 2, 3] }, status: null })
+ *   // → "id=in.(1,2,3)&status=null"
+ */
+export declare function serializeFilter(filter: Filter): URLSearchParams;
+/**
+ * Serialize full SelectOpts into URLSearchParams (filter + modifiers).
+ */
+export declare function serializeSelectOpts(opts: SelectOpts): URLSearchParams;
+export declare class PrestClient {
+    private readonly prestUrl;
+    private authHeader;
+    private readonly extraHeaders;
+    constructor(config: PrestConfig | string);
+    /**
+     * Forward-compat factory: validate a Kratos session and build a PrestClient.
+     *
+     * The vanilla pREST submodule does not yet wire Kratos (the planned
+     * `[auth.kratos]` middleware is documented in the parent project's CLAUDE.md
+     * but not merged into the submodule). This helper validates the session
+     * against Kratos and stores it as a Bearer header, so it will Just Work
+     * once the integration lands. Today it's useful if you're running a patched
+     * prest build with Kratos auth.
+     *
+     * @param kratosUrl - Kratos public URL, e.g. http://localhost:4433
+     * @param prestUrl - pREST base URL, defaults to http://localhost:3000
+     * @param sessionToken - Optional token. Reads `ory_kratos_session` cookie if omitted (browser).
+     * @returns PrestClient, or null if no valid session was found.
+     */
+    static fromKratosSession(kratosUrl: string, prestUrl?: string, sessionToken?: string): Promise<PrestClient | null>;
+    /**
+     * Set or replace the auth token after construction.
+     * Useful after calling `login()`. Returns `this` for chaining.
+     */
+    setAuthToken(token: string): this;
+    /**
+     * Escape hatch for endpoints not covered by the typed methods.
+     * Throws PrestApiError on non-2xx.
+     */
+    request<T = unknown>(method: string, path: string, init?: {
+        body?: BodyInit | null;
+        headers?: Record<string, string>;
+        params?: URLSearchParams;
+    }): Promise<T>;
+    /** `GET /databases` — list database names. */
+    databases(): Promise<unknown>;
+    /** `GET /schemas` — list schema names. */
+    schemas(): Promise<unknown>;
+    /** `GET /tables` — list table names. */
+    tables(): Promise<unknown>;
+    /** `GET /{database}/{schema}` — list tables in a specific database/schema. */
+    tablesIn(database: string, schema: string): Promise<unknown>;
+    /** `GET /show/{database}/{schema}/{table}` — table description / columns. */
+    showTable(database: string, schema: string, table: string): Promise<Record<string, unknown>>;
+    /** `GET /{db}/{schema}/{table}` — SELECT with typed filter DSL. */
+    select<T = unknown>(database: string, schema: string, table: string, opts?: SelectOpts): Promise<T[]>;
+    /** `POST /{db}/{schema}/{table}` — insert a single row. */
+    insert<T = unknown>(database: string, schema: string, table: string, data: Record<string, unknown>): Promise<T[]>;
+    /** `POST /batch/{db}/{schema}/{table}` — insert multiple rows in one call. */
+    insertBatch<T = unknown>(database: string, schema: string, table: string, rows: Record<string, unknown>[]): Promise<T[]>;
+    /** `PUT /{db}/{schema}/{table}?filter` — update rows matching filter. */
+    update<T = unknown>(database: string, schema: string, table: string, where: Filter, data: Record<string, unknown>): Promise<T[]>;
+    /** `DELETE /{db}/{schema}/{table}?filter` — delete rows matching filter. */
+    delete<T = unknown>(database: string, schema: string, table: string, where: Filter): Promise<T[]>;
+    /**
+     * Execute a stored SQL script: `GET /_QUERIES/{location}/{script}`.
+     *
+     * Scripts live in `<prest queries dir>/<location>/<script>.sql` and can
+     * reference params as `{{ sqlVal "key" }}` / `{{ sqlList "key" }}` in
+     * pREST's template syntax.
+     *
+     * @param location - Folder name under prest's `queries` directory.
+     * @param script - `.sql` filename without the extension.
+     * @param params - Rendered as URL query params; accessible in the SQL template.
+     */
+    query<T = unknown>(location: string, script: string, params?: Record<string, string | number | boolean>): Promise<T[]>;
+    /** `GET /_health` — returns true on 2xx, false otherwise. */
+    health(): Promise<boolean>;
+    /**
+     * `POST /auth` — exchange username/password for a JWT.
+     * Stores the returned token and attaches it as `Authorization: Bearer <token>`
+     * on subsequent requests.
+     *
+     * Only works when pREST's `[auth]` block is enabled in `prest.toml`.
+     * Returns the token string.
+     */
+    login(username: string, password: string): Promise<string>;
+}
+//# sourceMappingURL=index.d.ts.map