@querykitjs/prisma-pg 1.0.0

package/dist/index.d.cts

@@ -0,0 +1,494 @@
+import { Types } from '@prisma/client/runtime/library';
+import * as _querykitjs_core from '@querykitjs/core';
+import { SkippedCondition } from '@querykitjs/core';
+export { f } from '@querykitjs/core';
+
+/**
+ * Model metadata — the Prisma counterpart of drizzle's `columns.ts` and
+ * mongoose's `fields.ts`.
+ *
+ * Prisma's `where` is keyed by **model field name** (camelCase), never by the DB
+ * column — but a client may well send `created_at`, which drizzle-pg accepts. So
+ * each field's `@map`ped column is recorded as an alias and `resolveField`
+ * translates it back, keeping the two Postgres adapters interchangeable.
+ *
+ * Getting the field list without importing the generated client is the other
+ * half of the job: this package must typecheck with no generated client present,
+ * so metadata is read off the client **instance** at runtime, through a fallback
+ * chain.
+ */
+/** One model field, normalized across every metadata source. */
+interface FieldMeta {
+    name: string;
+    /** Prisma type name: `"Int"`, `"String"`, `"DateTime"`, an enum or model name, … */
+    type: string;
+    kind: "scalar" | "enum" | "object" | "unsupported";
+    isId: boolean;
+    /** `@updatedAt` — Prisma bumps these itself, so the adapter must not. */
+    isUpdatedAt: boolean;
+    isList: boolean;
+    /** The `@map`ped database column, when it differs from the field name. */
+    dbName?: string;
+}
+/** Everything the repository needs to know about one model. */
+interface ModelMeta {
+    /** Prisma model name (`"User"`) — used as the diagnostics `source`. */
+    name: string;
+    fields: Map<string, FieldMeta>;
+    /** `@map`ped DB column → Prisma field name, so `created_at` also resolves. */
+    byDbName: Map<string, string>;
+    /** The `@id` field name; undefined for a composite `@@id`. */
+    idField: string | undefined;
+    /** Fields that uniquely address a row — one `@id`, or every `@@id` field. */
+    primaryKey: string[];
+    /** Prisma's name for a composite key (`@@id(name:)`), else the joined fields. */
+    primaryKeyName: string | undefined;
+    hasDeletedAt: boolean;
+    /** Present only when the field exists **and** is not `@updatedAt`-managed. */
+    stampUpdatedAt: string | undefined;
+    hasCreatedAt: boolean;
+}
+
+/**
+ * QueryKit Prisma adapter — public types. The DSL/filter/meta types come from
+ * `@querykitjs/core` (shared with the drizzle-pg and mongoose adapters); they are
+ * only re-specialized here over a Prisma **model delegate** (`TDelegate`), with
+ * the raw escape-hatch bound to that model's native `WhereInput`.
+ *
+ * The public surface mirrors `@querykitjs/drizzle-pg` and `@querykitjs/mongoose`
+ * so the same frontend request contract works regardless of backend: same option
+ * names, same semantics, one shared source in core.
+ *
+ * ⚠️ This file must never import from `@prisma/client` itself — only from
+ * `@prisma/client/runtime/library`, which exists whether or not a client has been
+ * generated. That is what lets the package typecheck and build in CI with no
+ * `prisma generate` step, while still inferring exact row types in a consumer's
+ * project. `Types.Public.*` are Prisma's own public type utilities; the generated
+ * client re-exports the very same ones as `Prisma.Result` / `Prisma.Args`.
+ */
+
+/** Structural minimum of a Prisma model delegate (`prisma.user`). */
+interface AnyDelegate {
+    findMany(args?: any): any;
+    findFirst(args?: any): any;
+    count(args?: any): any;
+}
+/** Any Prisma client (or interactive-transaction client). */
+type AnyClient = Record<string, any>;
+/**
+ * The model keys of a Prisma client — `"user" | "post"`. Prisma names its
+ * delegates in camelCase, so model `LegalEntity` is `prisma.legalEntity`.
+ */
+type ModelKey<TClient> = {
+    [K in keyof TClient & string]: K extends `$${string}` | `_${string}` ? never : TClient[K] extends AnyDelegate ? K : never;
+}[keyof TClient & string];
+/** The delegate behind a model key. */
+type DelegateOf<TClient, TKey extends ModelKey<TClient>> = TClient[TKey];
+type ArgsOf<TDelegate, TOperation extends Types.Public.Operation> = Types.Public.Args<TDelegate, TOperation>;
+/** One row with the given Prisma args applied (`select` / `include`). */
+type RowWith<TDelegate, TArgs> = Types.Public.Result<TDelegate, TArgs, "findFirstOrThrow">;
+/** Full row shape of a model (what reads return with no `columns`/`with`). */
+type Row<TDelegate> = RowWith<TDelegate, Record<string, never>>;
+/** Insertable shape — the model's `create` data. */
+type Insert<TDelegate> = ArgsOf<TDelegate, "create">["data"];
+/**
+ * Raw Prisma predicate — the filter escape hatch (`TRaw`), i.e. this model's
+ * `Prisma.<Model>WhereInput`.
+ */
+type RawWhere<TDelegate> = NonNullable<ArgsOf<TDelegate, "findMany">["where"]>;
+/** This model's `Prisma.<Model>Select`. */
+type SelectInput<TDelegate> = NonNullable<ArgsOf<TDelegate, "findMany">["select"]>;
+/** This model's `Prisma.<Model>Include`. */
+type IncludeInput<TDelegate> = NonNullable<ArgsOf<TDelegate, "findMany">["include"]>;
+/** Value accepted anywhere an id is expected. */
+type Id = string | number;
+/** Union of a model's scalar field keys. */
+type FieldKey<TDelegate> = keyof Row<TDelegate> & string;
+/**
+ * A field key that also accepts any `string`. Filter/sort keys arrive from the
+ * wire as plain strings and the adapter skips the ones it cannot resolve, so a
+ * validated payload can go straight into a repository call with no `as` cast.
+ * Autocomplete still suggests the model's real fields.
+ */
+type LooseFieldKey<TDelegate> = _querykitjs_core.LooseKey<FieldKey<TDelegate>>;
+type FilterOperator = _querykitjs_core.FilterOperator;
+type FilterScalar = _querykitjs_core.FilterScalar;
+type FilterValue = _querykitjs_core.FilterValue;
+type FieldCondition<TDelegate = AnyDelegate> = _querykitjs_core.FieldCondition<LooseFieldKey<TDelegate>>;
+type AndGroup<TDelegate = AnyDelegate> = _querykitjs_core.AndGroup<LooseFieldKey<TDelegate>, RawWhere<TDelegate>>;
+type OrGroup<TDelegate = AnyDelegate> = _querykitjs_core.OrGroup<LooseFieldKey<TDelegate>, RawWhere<TDelegate>>;
+type NotGroup<TDelegate = AnyDelegate> = _querykitjs_core.NotGroup<LooseFieldKey<TDelegate>, RawWhere<TDelegate>>;
+/**
+ * Any node in a filter tree: a field comparison, a logical group, or a raw
+ * Prisma `where` object (escape hatch for predicates the DSL can't express).
+ */
+type FilterNode<TDelegate = AnyDelegate> = _querykitjs_core.FilterNode<LooseFieldKey<TDelegate>, RawWhere<TDelegate>>;
+/**
+ * Public filter input. Either a filter tree/node, or a flat array of conditions
+ * (treated as implicit AND — backward compatible with db-service).
+ */
+type Filter<TDelegate = AnyDelegate> = _querykitjs_core.Filter<LooseFieldKey<TDelegate>, RawWhere<TDelegate>>;
+type SortDirection = _querykitjs_core.SortDirection;
+type SortItem<TDelegate = AnyDelegate> = _querykitjs_core.SortItem<LooseFieldKey<TDelegate>>;
+/**
+ * Sort — **always an array** of `{ key, direction }` (multi-field). This is the
+ * exact shape the querykit frontend sends (`@querykitjs/web` decodes its
+ * `sortType=-createdAt,id` URL string into it).
+ */
+type Sort<TDelegate = AnyDelegate> = SortItem<TDelegate>[];
+/** Inclusion-only column selection — `{ id: true, email: true }`. */
+type ColumnSelection<TDelegate = AnyDelegate> = Partial<Record<FieldKey<TDelegate>, boolean>>;
+/** Relations to load — forwarded to Prisma's `include` (or nested `select`). */
+type WithRelations = Record<string, unknown>;
+interface QueryParams<TDelegate = AnyDelegate> {
+    filter?: Filter<TDelegate>;
+    sort?: Sort<TDelegate>;
+    columns?: ColumnSelection<TDelegate>;
+    with?: WithRelations;
+    /** Include soft-deleted rows (models with a `deletedAt` field). */
+    withDeleted?: boolean;
+}
+/** Equality scope applied to every operation of a scoped repository. */
+type Scope<TDelegate = AnyDelegate> = _querykitjs_core.Scope<FieldKey<TDelegate>>;
+interface ByIdParams<TDelegate = AnyDelegate> extends QueryParams<TDelegate> {
+    /** Field to match against the id. Defaults to `"id"` (→ the model's `@id`). */
+    idKey?: LooseFieldKey<TDelegate>;
+}
+/** Options for {@link Repository.upsert} / {@link Repository.upsertMany}. */
+type UpsertOptions<TDelegate = AnyDelegate> = _querykitjs_core.UpsertOptions<FieldKey<TDelegate>, Insert<TDelegate>>;
+/** Aggregate query specification (`count`/`sum`/`avg`/`min`/`max` + `groupBy`). */
+type AggregateSpec<TDelegate = AnyDelegate> = _querykitjs_core.AggregateSpec<FieldKey<TDelegate>, Filter<TDelegate>>;
+/** One aggregated result row (group fields + aggregate values). */
+type AggregateRow = Record<string, unknown>;
+/** Offset (classic page-based) pagination. */
+interface OffsetParams<TDelegate = AnyDelegate> extends QueryParams<TDelegate> {
+    page?: number;
+    perPage?: number;
+}
+type OffsetMeta = _querykitjs_core.OffsetMeta;
+interface OffsetResult<T> {
+    data: T[];
+    meta: OffsetMeta;
+}
+/** Offset-window pagination tuned for infinite scroll (limit + offset). */
+interface InfiniteParams<TDelegate = AnyDelegate> extends QueryParams<TDelegate> {
+    limit?: number;
+    offset?: number;
+}
+type InfiniteMeta = _querykitjs_core.InfiniteMeta;
+interface InfiniteResult<T> {
+    data: T[];
+    meta: InfiniteMeta;
+}
+/** Keyset (cursor) pagination — stable under inserts, ideal for feeds. */
+interface CursorParams<TDelegate = AnyDelegate> extends QueryParams<TDelegate> {
+    limit?: number;
+    /** Opaque cursor token from a previous result's meta. */
+    cursor?: string | null;
+    /** Field the cursor walks over. Must be unique & sortable. Defaults to `"id"`. */
+    cursorKey?: LooseFieldKey<TDelegate>;
+    /** Stable order of the dataset. Defaults to `"asc"`. */
+    order?: SortDirection;
+    /** Navigation relative to the cursor. Defaults to `"forward"`. */
+    direction?: "forward" | "backward";
+}
+type CursorMeta = _querykitjs_core.CursorMeta;
+interface CursorResult<T> {
+    data: T[];
+    meta: CursorMeta;
+}
+type TrueKeys<T> = {
+    [K in keyof T]: T[K] extends true ? K : never;
+}[keyof T];
+/** Relation keys that are actually loaded — `true` or a nested config object. */
+type LoadedKeys<T> = {
+    [K in keyof T]-?: T[K] extends false | undefined | null ? never : K;
+}[keyof T];
+type HasColumns<T> = T extends object ? ([TrueKeys<T>] extends [never] ? false : true) : false;
+type HasWith<T> = T extends object ? ([LoadedKeys<T>] extends [never] ? false : true) : false;
+/**
+ * The result row for a given `columns` selection and loaded `with` relations.
+ * An empty/all-false `columns` yields the full row, matching the runtime
+ * (inclusion-only projection) and the other two adapters.
+ */
+type ResultFor<TDelegate, TColumns, TWith> = HasColumns<TColumns> extends true ? HasWith<TWith> extends true ? RowWith<TDelegate, {
+    select: TColumns & TWith;
+}> : RowWith<TDelegate, {
+    select: TColumns;
+}> : HasWith<TWith> extends true ? RowWith<TDelegate, {
+    include: TWith;
+}> : Row<TDelegate>;
+/** Params whose `columns`/`with` are typed to the passed selection (drives inference). */
+type Params<TBase, TColumns, TWith> = Omit<TBase, "columns" | "with"> & {
+    columns?: TColumns;
+    with?: TWith;
+};
+/**
+ * Model-scoped repository. Read methods infer their return type from the
+ * `columns` and `with` arguments, mirroring `@querykitjs/drizzle-pg`.
+ */
+interface Repository<TDelegate = AnyDelegate> {
+    /** The underlying Prisma model delegate — escape hatch for custom queries. */
+    readonly delegate: TDelegate;
+    /**
+     * Returns **all** rows matching the filter (no pagination).
+     *
+     * @example
+     * ```ts
+     * const active = await usersRepository.findAll({
+     *   filter: [{ key: "status", operation: "=", value: "active" }],
+     *   sort: [{ key: "createdAt", direction: "desc" }],
+     * });
+     * ```
+     */
+    findAll<const TColumns extends ColumnSelection<TDelegate> | undefined = undefined, const TWith extends WithRelations | undefined = undefined>(params?: Params<QueryParams<TDelegate>, TColumns, TWith>): Promise<ResultFor<TDelegate, TColumns, TWith>[]>;
+    /** Returns the **first** matching row (or `undefined`). */
+    findOne<const TColumns extends ColumnSelection<TDelegate> | undefined = undefined, const TWith extends WithRelations | undefined = undefined>(params?: Params<QueryParams<TDelegate>, TColumns, TWith>): Promise<ResultFor<TDelegate, TColumns, TWith> | undefined>;
+    /** Returns one row by id (or `undefined`). Use `params.idKey` for another field. */
+    findById<const TColumns extends ColumnSelection<TDelegate> | undefined = undefined, const TWith extends WithRelations | undefined = undefined>(id: Id, params?: Params<ByIdParams<TDelegate>, TColumns, TWith>): Promise<ResultFor<TDelegate, TColumns, TWith> | undefined>;
+    /**
+     * **Offset (page-based) pagination** — with `total_items`/`total_pages`.
+     *
+     * @example
+     * ```ts
+     * const { data, meta } = await usersRepository.findList({ page: 2, perPage: 20 });
+     * ```
+     */
+    findList<const TColumns extends ColumnSelection<TDelegate> | undefined = undefined, const TWith extends WithRelations | undefined = undefined>(params?: Params<OffsetParams<TDelegate>, TColumns, TWith>): Promise<OffsetResult<ResultFor<TDelegate, TColumns, TWith>>>;
+    /** **Infinite-scroll pagination** — `limit`+`offset`, no `COUNT`. */
+    findInfinite<const TColumns extends ColumnSelection<TDelegate> | undefined = undefined, const TWith extends WithRelations | undefined = undefined>(params?: Params<InfiniteParams<TDelegate>, TColumns, TWith>): Promise<InfiniteResult<ResultFor<TDelegate, TColumns, TWith>>>;
+    /** **Cursor (keyset) pagination** — stable under inserts, ideal for feeds. */
+    findCursor<const TColumns extends ColumnSelection<TDelegate> | undefined = undefined, const TWith extends WithRelations | undefined = undefined>(params?: Params<CursorParams<TDelegate>, TColumns, TWith>): Promise<CursorResult<ResultFor<TDelegate, TColumns, TWith>>>;
+    /** Number of rows matching the filter. */
+    count(filter?: Filter<TDelegate>): Promise<number>;
+    /** Whether any row matches the filter (`count > 0`). */
+    exists(filter?: Filter<TDelegate>): Promise<boolean>;
+    /** Create one row and return it. */
+    create(values: Insert<TDelegate>): Promise<Row<TDelegate>>;
+    /** Create many rows, returning them in input order. */
+    createMany(values: Insert<TDelegate>[]): Promise<Row<TDelegate>[]>;
+    /** Insert, or update on `target` conflict (Prisma `upsert`). */
+    upsert(values: Insert<TDelegate>, options: UpsertOptions<TDelegate>): Promise<Row<TDelegate>>;
+    /** Bulk upsert (chunked); returns rows in input order. */
+    upsertMany(values: Insert<TDelegate>[], options: UpsertOptions<TDelegate>): Promise<Row<TDelegate>[]>;
+    /** Update one row by id; returns the updated row (or `undefined`). */
+    updateById(id: Id, patch: Partial<Insert<TDelegate>>, idKey?: FieldKey<TDelegate>): Promise<Row<TDelegate> | undefined>;
+    /** Update every row matching the filter; returns the updated rows. */
+    updateWhere(filter: Filter<TDelegate>, patch: Partial<Insert<TDelegate>>): Promise<Row<TDelegate>[]>;
+    /** Hard-delete one row by id; returns the deleted row (or `undefined`). */
+    deleteById(id: Id, idKey?: FieldKey<TDelegate>): Promise<Row<TDelegate> | undefined>;
+    /** Hard-delete every row matching the filter; returns the deleted rows. */
+    deleteWhere(filter: Filter<TDelegate>): Promise<Row<TDelegate>[]>;
+    /** Soft-delete (set `deletedAt`); requires a `deletedAt` field. */
+    softDelete(id: Id, idKey?: FieldKey<TDelegate>): Promise<Row<TDelegate> | undefined>;
+    /** Restore a soft-deleted row (`deletedAt = null`). */
+    restore(id: Id, idKey?: FieldKey<TDelegate>): Promise<Row<TDelegate> | undefined>;
+    /** Aggregate: `count`/`sum`/`avg`/`min`/`max` with optional `groupBy`. */
+    aggregate(spec: AggregateSpec<TDelegate>): Promise<AggregateRow[]>;
+    /**
+     * **Scoped repository** — adds a constant equality filter to every read/write
+     * and defaults it on inserts (scope wins). For RBAC / multi-tenancy.
+     */
+    scoped(scope: Scope<TDelegate>): Repository<TDelegate>;
+}
+/** Extends a base repository with custom, model-specific methods. */
+type RepositoryExtender<TDelegate, TExt extends Record<string, unknown>> = (base: Repository<TDelegate>) => TExt;
+/** {@link createRegistry} options — pagination defaults and bounds. */
+interface RegistryOptions {
+    /** `findList` default page size (core `DEFAULT_PER_PAGE` = 20). */
+    defaultPerPage?: number;
+    /** `findInfinite`/`findCursor` default limit (core `DEFAULT_LIMIT` = 20). */
+    defaultLimit?: number;
+    /**
+     * Upper bound for `perPage` (core `DEFAULT_MAX_PER_PAGE` = 200). Applied even
+     * when validation was bypassed — defense in depth. Disable with `Infinity`.
+     */
+    maxPerPage?: number;
+    /** Upper bound for `limit` (`findInfinite`/`findCursor`, core `DEFAULT_MAX_LIMIT` = 200). */
+    maxLimit?: number;
+    /**
+     * **Strict mode.** An unknown filter/sort key, or a value the operator cannot
+     * use, is no longer dropped silently — a `QueryKitError` is thrown (the backend
+     * maps it to a 400). Defaults to `false`, matching the other adapters.
+     *
+     * Why it matters: a filter is meant to **narrow** a result set, so a mistyped
+     * key that vanishes silently makes the endpoint return **more** data than
+     * intended, with nothing in the log to show it.
+     */
+    strict?: boolean;
+    /**
+     * Called for every dropped condition (also when `strict` is off). Migration
+     * path: watch with the hook first, flip `strict: true` once the log is clean.
+     */
+    onSkippedCondition?: (info: _querykitjs_core.SkippedCondition) => void;
+}
+/**
+ * Options for `registry.repository(model, options)`.
+ *
+ * Philosophy: the guard lives in the **repository**, not the route — `scope`
+ * (RBAC) already worked that way and projection joins it. Same names and same
+ * semantics as the drizzle-pg and mongoose adapters.
+ *
+ * ⚠️ `forcedColumns`/`allowedColumns` affect **read** methods only
+ * (`findAll`/`findOne`/`findById`/`findList`/`findInfinite`/`findCursor` +
+ * `aggregate`). Write methods return the full `Row` by type contract — trimming
+ * it at runtime would make the type a lie. Re-read with `findById`, or map it
+ * yourself, before handing a write result to a client.
+ */
+interface RepositoryOptions<TDelegate = AnyDelegate> {
+    /** Constant equality filter added to every read/write (RBAC / multi-tenancy). */
+    scope?: Scope<TDelegate>;
+    /**
+     * Forced projection — the client's `columns` is **ignored entirely**. Keeps a
+     * password out of a `users` response without a `{ ...params, columns }` trick
+     * in every route. Must select at least one field, else building throws.
+     */
+    forcedColumns?: ColumnSelection<TDelegate>;
+    /**
+     * Allowlist — the client's `columns` is intersected with it. An empty
+     * intersection yields the allowlist itself, **never** the full row. An empty
+     * array throws (a projection selecting nothing means "everything").
+     */
+    allowedColumns?: readonly FieldKey<TDelegate>[];
+    /**
+     * Explicit field metadata. Only needed when this adapter cannot read it off
+     * the Prisma client itself (it tries `_runtimeDataModel`, then the public
+     * `delegate.fields`) — e.g. behind an unusual client wrapper.
+     */
+    fields?: readonly FieldMeta[];
+}
+/** DB registry: created once, yields model repositories. */
+interface Registry<TClient extends AnyClient = AnyClient> {
+    /** The Prisma client the registry was created with. */
+    readonly client: TClient;
+    /**
+     * Repository for a model — addressed either by the model handle
+     * (`prisma.user`, like the drizzle-pg and mongoose registries take a table or
+     * a Model) or by its Prisma delegate key (`"user"`, camelCase).
+     *
+     * @example
+     * ```ts
+     * export const usersRepository = registry.repository(prisma.user);
+     * // …or, equivalently:
+     * export const usersRepository = registry.repository("user");
+     * ```
+     */
+    repository<TKey extends ModelKey<TClient>>(model: TKey): Repository<DelegateOf<TClient, TKey>>;
+    /** …extended with custom methods (2nd-arg extender fn — same as the other adapters). */
+    repository<TKey extends ModelKey<TClient>, TExt extends Record<string, unknown>>(model: TKey, extend: RepositoryExtender<DelegateOf<TClient, TKey>, TExt>): Repository<DelegateOf<TClient, TKey>> & TExt;
+    /** …with per-repository options (`scope`, `forcedColumns`, `allowedColumns`). */
+    repository<TKey extends ModelKey<TClient>>(model: TKey, options: RepositoryOptions<DelegateOf<TClient, TKey>>): Repository<DelegateOf<TClient, TKey>>;
+    /** …with both options and custom methods. */
+    repository<TKey extends ModelKey<TClient>, TExt extends Record<string, unknown>>(model: TKey, options: RepositoryOptions<DelegateOf<TClient, TKey>>, extend: RepositoryExtender<DelegateOf<TClient, TKey>, TExt>): Repository<DelegateOf<TClient, TKey>> & TExt;
+    repository<TDelegate extends AnyDelegate>(model: TDelegate): Repository<TDelegate>;
+    repository<TDelegate extends AnyDelegate, TExt extends Record<string, unknown>>(model: TDelegate, extend: RepositoryExtender<TDelegate, TExt>): Repository<TDelegate> & TExt;
+    repository<TDelegate extends AnyDelegate>(model: TDelegate, options: RepositoryOptions<TDelegate>): Repository<TDelegate>;
+    repository<TDelegate extends AnyDelegate, TExt extends Record<string, unknown>>(model: TDelegate, options: RepositoryOptions<TDelegate>, extend: RepositoryExtender<TDelegate, TExt>): Repository<TDelegate> & TExt;
+    /**
+     * Runs `fn` inside a Prisma interactive transaction. Repositories used inside
+     * it automatically run on that transaction client (ambient context).
+     *
+     * ⚠️ Prisma has no savepoints, so a **nested** call reuses the ambient
+     * transaction instead of opening a new one (same as the mongoose adapter;
+     * drizzle-pg creates a real savepoint there).
+     */
+    transaction<T>(fn: () => Promise<T>): Promise<T>;
+}
+
+/**
+ * Create the DB **registry** once. It holds the Prisma client (for transactions)
+ * and yields a {@link Repository} per model. Transactions flow ambiently via
+ * AsyncLocalStorage — repositories used inside `registry.transaction(...)`
+ * automatically run on that transaction client, with no `tx` threading.
+ *
+ * Framework-agnostic by design: this package knows nothing about HTTP, so the
+ * same registry serves Express, Hono, NestJS or a background worker. Parse and
+ * validate the request in your app (`@querykitjs/zod` or
+ * `@querykitjs/class-validator`), then hand the params straight to a repository.
+ *
+ * @param prisma - your `PrismaClient` instance.
+ * @param options - pagination defaults/bounds and diagnostics; defaults come
+ *   from `@querykitjs/core` (`DEFAULT_PER_PAGE`/`DEFAULT_LIMIT` = 20).
+ * @example
+ * ```ts
+ * // registry.ts (once)
+ * export const registry = createRegistry(prisma);
+ *
+ * // users.repository.ts — with custom methods
+ * export const usersRepository = registry.repository("user", base => ({
+ *   findByEmail: (email: string) => base.findOne({ filter: [{ key: "email", value: email }] }),
+ * }));
+ * ```
+ */
+declare function createRegistry<TClient extends AnyClient>(prisma: TClient, options?: RegistryOptions): Registry<TClient>;
+
+/**
+ * A Prisma client or interactive-transaction client. The adapter only ever needs
+ * model delegates off it, so it is kept structural — this file never imports
+ * `@prisma/client` (see the package README: the generated client is a peer).
+ */
+type AnyExecutor = Record<string, unknown>;
+
+/** Shared, registry-level runtime injected into every repository. */
+interface RepoRuntime {
+    /** Base (non-transactional) Prisma client. */
+    baseClient: AnyExecutor;
+    /** Current executor — the active transaction client if any, else `baseClient`. */
+    getExecutor: () => AnyExecutor;
+    /** Default page size for `findList` when `perPage` is omitted. */
+    defaultPerPage: number;
+    /** Default `limit` for `findInfinite`/`findCursor` when omitted. */
+    defaultLimit: number;
+    /** Upper bound for `perPage`, applied even when validation was bypassed. */
+    maxPerPage: number;
+    /** Upper bound for `limit` (`findInfinite`/`findCursor`). */
+    maxLimit: number;
+    /** Throw `QueryKitError` instead of dropping an unresolvable condition. */
+    strict: boolean;
+    /** Called for every dropped condition (also when `strict` is off). */
+    onSkippedCondition?: (info: SkippedCondition) => void;
+}
+/**
+ * Build a model-scoped repository. `runtime` (client + ambient transaction
+ * context) comes from the registry, so this file never touches the app's
+ * database handle directly.
+ */
+declare function buildRepository<TDelegate>(runtime: RepoRuntime, modelKey: string, config?: RepositoryOptions<TDelegate>): Repository<TDelegate>;
+
+/**
+ * Typed, ergonomic filter builders for a model (field-name autocomplete). A thin
+ * wrapper over `@querykitjs/core`'s builder — the key type is the model's field
+ * key, the raw escape hatch is that model's native `WhereInput`.
+ *
+ * @example
+ * ```ts
+ * const uf = createFilters<typeof prisma.user>();
+ * await usersRepository.findAll({ filter: uf.and(uf.eq("status", "active"), uf.gte("age", 18)) });
+ * ```
+ */
+declare function createFilters<TDelegate>(): {
+    eq: (key: FieldKey<TDelegate>, value: _querykitjs_core.FilterValue) => _querykitjs_core.FieldCondition<FieldKey<TDelegate>>;
+    ne: (key: FieldKey<TDelegate>, value: _querykitjs_core.FilterValue) => _querykitjs_core.FieldCondition<FieldKey<TDelegate>>;
+    gt: (key: FieldKey<TDelegate>, value: _querykitjs_core.FilterValue) => _querykitjs_core.FieldCondition<FieldKey<TDelegate>>;
+    gte: (key: FieldKey<TDelegate>, value: _querykitjs_core.FilterValue) => _querykitjs_core.FieldCondition<FieldKey<TDelegate>>;
+    lt: (key: FieldKey<TDelegate>, value: _querykitjs_core.FilterValue) => _querykitjs_core.FieldCondition<FieldKey<TDelegate>>;
+    lte: (key: FieldKey<TDelegate>, value: _querykitjs_core.FilterValue) => _querykitjs_core.FieldCondition<FieldKey<TDelegate>>;
+    contains: (key: FieldKey<TDelegate>, value: string) => _querykitjs_core.FieldCondition<FieldKey<TDelegate>>;
+    startsWith: (key: FieldKey<TDelegate>, value: string) => _querykitjs_core.FieldCondition<FieldKey<TDelegate>>;
+    endsWith: (key: FieldKey<TDelegate>, value: string) => _querykitjs_core.FieldCondition<FieldKey<TDelegate>>;
+    like: (key: FieldKey<TDelegate>, value: string) => _querykitjs_core.FieldCondition<FieldKey<TDelegate>>;
+    ilike: (key: FieldKey<TDelegate>, value: string) => _querykitjs_core.FieldCondition<FieldKey<TDelegate>>;
+    notLike: (key: FieldKey<TDelegate>, value: string) => _querykitjs_core.FieldCondition<FieldKey<TDelegate>>;
+    in: (key: FieldKey<TDelegate>, value: Array<string | number>) => _querykitjs_core.FieldCondition<FieldKey<TDelegate>>;
+    notIn: (key: FieldKey<TDelegate>, value: Array<string | number>) => _querykitjs_core.FieldCondition<FieldKey<TDelegate>>;
+    between: (key: FieldKey<TDelegate>, min: _querykitjs_core.FilterScalar | Date, max: _querykitjs_core.FilterScalar | Date) => _querykitjs_core.FieldCondition<FieldKey<TDelegate>>;
+    notBetween: (key: FieldKey<TDelegate>, min: _querykitjs_core.FilterScalar | Date, max: _querykitjs_core.FilterScalar | Date) => _querykitjs_core.FieldCondition<FieldKey<TDelegate>>;
+    range: (key: FieldKey<TDelegate>, from: _querykitjs_core.FilterScalar | Date, to: _querykitjs_core.FilterScalar | Date) => _querykitjs_core.FieldCondition<FieldKey<TDelegate>>[];
+    isNull: (key: FieldKey<TDelegate>) => _querykitjs_core.FieldCondition<FieldKey<TDelegate>>;
+    isNotNull: (key: FieldKey<TDelegate>) => _querykitjs_core.FieldCondition<FieldKey<TDelegate>>;
+    and: (...nodes: _querykitjs_core.FilterNode<FieldKey<TDelegate>, RawWhere<TDelegate>>[]) => _querykitjs_core.AndGroup<FieldKey<TDelegate>, RawWhere<TDelegate>>;
+    or: (...nodes: _querykitjs_core.FilterNode<FieldKey<TDelegate>, RawWhere<TDelegate>>[]) => _querykitjs_core.OrGroup<FieldKey<TDelegate>, RawWhere<TDelegate>>;
+    not: (node: _querykitjs_core.FilterNode<FieldKey<TDelegate>, RawWhere<TDelegate>>) => _querykitjs_core.NotGroup<FieldKey<TDelegate>, RawWhere<TDelegate>>;
+};
+
+export { type AggregateRow, type AggregateSpec, type AndGroup, type AnyClient, type AnyDelegate, type ByIdParams, type ColumnSelection, type CursorMeta, type CursorParams, type CursorResult, type DelegateOf, type FieldCondition, type FieldKey, type FieldMeta, type Filter, type FilterNode, type FilterOperator, type FilterScalar, type FilterValue, type Id, type IncludeInput, type InfiniteMeta, type InfiniteParams, type InfiniteResult, type Insert, type LooseFieldKey, type ModelKey, type ModelMeta, type NotGroup, type OffsetMeta, type OffsetParams, type OffsetResult, type OrGroup, type QueryParams, type RawWhere, type Registry, type RegistryOptions, type RepoRuntime, type Repository, type RepositoryExtender, type RepositoryOptions, type ResultFor, type Row, type Scope, type SelectInput, type Sort, type SortDirection, type SortItem, type UpsertOptions, type WithRelations, buildRepository, createFilters, createRegistry };