@gettersethya/mira-tanstack-adapter 0.1.0-alpha.21 → 0.1.0-alpha.22

package/README.md

@@ -1,160 +1,158 @@
-# @gettersethya/mira-tanstack-adapter
-
-[![npm](https://img.shields.io/npm/v/@gettersethya/mira-tanstack-adapter)](https://www.npmjs.com/package/@gettersethya/mira-tanstack-adapter)
-
-> **Early pre-alpha.** Breaking changes may occur without notice.
-
-TanStack Query adapters for [@gettersethya/mira-client](https://www.npmjs.com/package/@gettersethya/mira-client). Wraps collection client methods with `queryOptions` and `mutationOptions`, with structured query keys for fine-grained cache invalidation.
-
-Supports React, Svelte, and Solid via separate entry points.
-
-## Installation
-
-```bash
-# React
-npm install @gettersethya/mira-tanstack-adapter @tanstack/react-query
-
-# Svelte
-npm install @gettersethya/mira-tanstack-adapter @tanstack/svelte-query
-
-# Solid
-npm install @gettersethya/mira-tanstack-adapter @tanstack/solid-query
-```
-
-`@gettersethya/mira-client` is a required peer dependency. Only install the TanStack package for the framework you use.
-
-## Setup
-
-```typescript
-import { createMiraClient } from "@gettersethya/mira-client"
-import { collectionAdapter } from "@gettersethya/mira-tanstack-adapter/react"
-// import { collectionAdapter } from "@gettersethya/mira-tanstack-adapter/solid"
-import { Posts } from "./collections.js"
-
-const mira     = createMiraClient("/api").withCollections({ posts: Posts })
-const postsApi = collectionAdapter(mira, "posts")
-```
-
-Svelte uses a small factory instead of a pre-built adapter (its v6 option
-types cannot be re-exported from another package's declarations):
-
-```typescript
-import { mutationOptions, queryOptions } from "@tanstack/svelte-query"
-import { createSvelteCollectionAdapter } from "@gettersethya/mira-tanstack-adapter/svelte"
-
-const collectionAdapter = createSvelteCollectionAdapter(queryOptions, mutationOptions)
-const postsApi = collectionAdapter(mira, "posts")
-```
-
-The framework-agnostic factory also lives at the package root for custom setups:
-
-```typescript
-import { queryOptions, mutationOptions } from "@tanstack/react-query"
-import { createCollectionAdapter } from "@gettersethya/mira-tanstack-adapter"
-
-const collectionAdapter = createCollectionAdapter(queryOptions, mutationOptions)
-```
-
-## Queries
-
-```tsx
-import { useQuery } from "@tanstack/react-query"
-import { postsApi } from "./setup.js"
-
-function PostList() {
-  const { data, isLoading } = useQuery(
-    postsApi.getList({
-      filter: (f) => f.field("published").eq(true),
-      limit:  10,
-    }).queryOptions
-  )
-
-  if (isLoading) return <p>Loading...</p>
-  return <ul>{data?.items.map(p => <li key={p.id}>{p.title}</li>)}</ul>
-}
-
-function PostDetail({ id }: { id: string }) {
-  const { data } = useQuery(postsApi.getOne(id).queryOptions)
-  return <h1>{data?.title}</h1>
-}
-```
-
-## Mutations
-
-```tsx
-import { useMutation, useQueryClient } from "@tanstack/react-query"
-import { postsApi } from "./setup.js"
-
-function PostActions() {
-  const queryClient = useQueryClient()
-
-  const create = useMutation({
-    ...postsApi.create().mutationOptions,
-    onSuccess: () => postsApi.invalidateAll(queryClient),
-  })
-
-  const update = useMutation({
-    ...postsApi.update().mutationOptions,
-    onSuccess: (post) => postsApi.invalidateOne(queryClient, post.id),
-  })
-
-  const remove = useMutation({
-    ...postsApi.delete().mutationOptions,
-    onSuccess: () => postsApi.invalidateAll(queryClient),
-  })
-
-  return (
-    <button onClick={() => create.mutate({ title: "New Post", published: false })}>
-      Create
-    </button>
-  )
-}
-```
-
-## Svelte and Solid
-
-React and Solid expose a pre-built `collectionAdapter`. Svelte exposes a
-`createSvelteCollectionAdapter(queryOptions, mutationOptions)` factory instead
-(see Setup above). Svelte v6 reads options through reactive getters:
-
-```typescript
-// Svelte
-import { createSvelteCollectionAdapter } from "@gettersethya/mira-tanstack-adapter/svelte"
-// use with createQuery / createMutation from @tanstack/svelte-query
-const query = createQuery(() => api.getList({ limit: 10 }).queryOptions)
-
-// Solid
-import { collectionAdapter } from "@gettersethya/mira-tanstack-adapter/solid"
-// use with createQuery / createMutation from @tanstack/solid-query
-```
-
-## Query key structure
-
-The adapter produces structured query keys for fine-grained cache invalidation:
-
-```typescript
-// ["posts", "getList",        { limit, filter, sort, order, cursor, select, expand }]
-// ["posts", "getOne",         "post-id"]
-// ["posts", "getFirstOrNone", { filter, sort, order, select, expand }]
-// ["posts", "getFullList",    { limit, filter, sort, order, select, expand }]
-
-// Invalidate all queries for a collection
-queryClient.invalidateQueries({ queryKey: ["posts"] })
-
-// Invalidate only list queries
-queryClient.invalidateQueries({ queryKey: ["posts", "getList"] })
-
-// Invalidate a specific record
-queryClient.invalidateQueries({ queryKey: ["posts", "getOne", "post-id"] })
-```
-
-The adapter also exposes two helpers:
-
-```typescript
-postsApi.invalidateAll(queryClient)         // invalidates all posts queries
-postsApi.invalidateOne(queryClient, postId) // invalidates the getOne query for postId
-```
-
-## More
-
-See the [Mira root README](https://github.com/gettersethya/mira) for collection definitions, field types, rules, and client usage.
+# @gettersethya/mira-tanstack-adapter
+
+[![npm](https://img.shields.io/npm/v/@gettersethya/mira-tanstack-adapter)](https://www.npmjs.com/package/@gettersethya/mira-tanstack-adapter)
+
+> **Early pre-alpha.** Breaking changes may occur without notice.
+
+Framework-agnostic TanStack Query adapter for
+[@gettersethya/mira-client](https://www.npmjs.com/package/@gettersethya/mira-client).
+Wraps a collection client's methods with `queryOptions` and `mutationOptions`,
+with structured query keys for fine-grained cache invalidation.
+
+The option objects are plain `{ queryKey, queryFn }` / `{ mutationFn }` shapes,
+so this package has **no runtime dependency on TanStack** — `useQuery` /
+`useMutation` (React, Solid) and `createQuery` / `createMutation` (Svelte) all
+accept them and infer `data`.
+
+## Installation
+
+```bash
+npm install @gettersethya/mira-tanstack-adapter
+```
+
+`@gettersethya/mira-client` is a required peer dependency. Install whichever
+TanStack Query package your framework uses separately.
+
+## Setup
+
+Pass `collectionAdapter` to `withCollections` and every accessor is enriched in
+one call:
+
+```typescript
+import { createMiraClient } from "@gettersethya/mira-client"
+import { collectionAdapter } from "@gettersethya/mira-tanstack-adapter"
+import { Posts, Users } from "./collections.js"
+
+export const client = createMiraClient("/api").withCollections(
+  { posts: Posts, users: Users },
+  { adapter: collectionAdapter },
+)
+```
+
+## Queries
+
+```tsx
+import { useQuery } from "@tanstack/react-query"
+import { client } from "./setup.js"
+
+function PostList() {
+  const { data, isLoading } = useQuery(
+    client.posts.getList({
+      filter: (f) => f.field("published").eq(true),
+      limit:  10,
+    }).queryOptions
+  )
+
+  if (isLoading) return <p>Loading...</p>
+  return <ul>{data?.items.map(p => <li key={p.id}>{p.title}</li>)}</ul>
+}
+
+function PostDetail({ id }: { id: string }) {
+  const { data } = useQuery(client.posts.getOne(id).queryOptions)
+  return <h1>{data?.title}</h1>
+}
+```
+
+## Mutations
+
+```tsx
+import { useMutation, useQueryClient } from "@tanstack/react-query"
+import { client } from "./setup.js"
+
+function PostActions() {
+  const queryClient = useQueryClient()
+
+  const create = useMutation({
+    ...client.posts.create().mutationOptions,
+    onSuccess: () => client.posts.invalidateAll(queryClient),
+  })
+
+  const update = useMutation({
+    ...client.posts.update().mutationOptions,
+    onSuccess: (post) => client.posts.invalidateOne(queryClient, post.id),
+  })
+
+  const remove = useMutation({
+    ...client.posts.delete().mutationOptions,
+    onSuccess: () => client.posts.invalidateAll(queryClient),
+  })
+
+  return (
+    <button onClick={() => create.mutate({ title: "New Post", published: false })}>
+      Create
+    </button>
+  )
+}
+```
+
+## Solid and Svelte
+
+The same call shape works everywhere — the adapter is framework-agnostic:
+
+```typescript
+// Solid — createQuery / createMutation from @tanstack/solid-query
+createQuery(() => client.posts.getList({ limit: 10 }).queryOptions)
+
+// Svelte — reactive getters from @tanstack/svelte-query
+createQuery(() => client.posts.getList({ limit: 10 }).queryOptions)
+```
+
+## Per-collection usage
+
+If you prefer to adapt a single collection (for example with `createMiraClient().collection(def)`),
+call the adapter directly:
+
+```typescript
+import { collectionAdapter } from "@gettersethya/mira-tanstack-adapter"
+
+const postsApi = collectionAdapter(client.collection(Posts), Posts.name, Posts.schema["x-collection-kind"])
+```
+
+Or build one yourself with the framework-agnostic factory:
+
+```typescript
+import { createCollectionAdapter } from "@gettersethya/mira-tanstack-adapter"
+
+const collectionAdapter = createCollectionAdapter()
+```
+
+## Query key structure
+
+The adapter produces structured query keys for fine-grained cache invalidation:
+
+```typescript
+// ["posts", "getList",        { limit, filter, sort, order, cursor, select, expand }]
+// ["posts", "getOne",         "post-id", {}]
+// ["posts", "getFirstOrNone", { filter, sort, order, select, expand }]
+// ["posts", "getFullList",    { limit, filter, sort, order, select, expand }]
+
+// Invalidate all queries for a collection
+queryClient.invalidateQueries({ queryKey: ["posts"] })
+
+// Invalidate only list queries
+queryClient.invalidateQueries({ queryKey: ["posts", "getList"] })
+
+// Invalidate a specific record
+queryClient.invalidateQueries({ queryKey: ["posts", "getOne", "post-id"] })
+```
+
+The adapter also exposes two helpers:
+
+```typescript
+client.posts.invalidateAll(queryClient)         // invalidates all posts queries
+client.posts.invalidateOne(queryClient, postId) // invalidates the getOne query for postId
+```
+
+## More
+
+See the [Mira root README](https://github.com/gettersethya/mira) for collection definitions, field types, rules, and client usage.

package/dist/_core.d.ts

@@ -1,47 +1,25 @@
-import type { CollectionClient, FieldsMap, FilterBuilder, FilterNode } from "@gettersethya/mira-client";
+import type { AdaptedCollectionClient, AdaptedMutationOptions, AdaptedQueryOptions, CollectionClient, CollectionKind, FieldsMap } from "@gettersethya/mira-client";
 /**
  * A readonly array of unknown values used as a TanStack Query query key.
  *
  * @example
  * ```ts
- * const key: QueryKey = ["posts", "getList", { limit: 10 }]
+ * const key: QueryKey = ["todos", "getList", { limit: 10 }]
  * ```
  */
 export type QueryKey = ReadonlyArray<unknown>;
 /**
- * Shape expected by TanStack Query's `queryOptions` for a query returning `T`.
+ * Shape expected by TanStack Query's `useQuery` for a query returning `T`.
  *
- * @template T - The data type returned by the query function.
+ * The adapter produces plain objects of this shape (it does not import the
+ * framework): `useQuery` / `createQuery` accept them directly and infer `data`.
  */
-export type QueryOptionsShape<T> = {
-    queryKey: QueryKey;
-    queryFn: () => Promise<T>;
-};
-/**
- * Shape expected by TanStack Query's `mutationOptions` for a mutation consuming `TInput` and returning `TData`.
- *
- * @template TData - The data type returned by the mutation function.
- * @template TInput - The input data type consumed by the mutation function.
- */
-export type MutationOptionsShape<TData, TInput> = {
-    mutationFn: (input: TInput) => Promise<TData>;
-};
-/**
- * Signature for the framework-provided `queryOptions` factory.
- * TanStack Query in each framework exports a `queryOptions` function that accepts
- * a {@link QueryOptionsShape} and returns a framework-specific options object.
- * The return type is intentionally `unknown`: each framework returns its own
- * options shape, which callers narrow via `ReturnType` in {@link enrichQuery}.
- */
-export type MakeQueryOptions = <T>(opts: QueryOptionsShape<T>) => unknown;
+export type QueryOptionsShape<T> = AdaptedQueryOptions<T>;
 /**
- * Signature for the framework-provided `mutationOptions` factory.
- * TanStack Query in each framework exports a `mutationOptions` function that accepts
- * a {@link MutationOptionsShape} and returns a framework-specific options object.
- * The return type is intentionally `unknown`: each framework returns its own
- * options shape, which callers narrow via `ReturnType` in {@link enrichMutation}.
+ * Shape expected by TanStack Query's `useMutation` for a mutation consuming
+ * `TInput` and returning `TData`.
  */
-export type MakeMutationOptions = <TData, TInput>(opts: MutationOptionsShape<TData, TInput>) => unknown;
+export type MutationOptionsShape<TData, TInput> = AdaptedMutationOptions<TData, TInput>;
 /**
  * A map of human-readable action names to their string key values.
  * Used internally to build structured query keys that include the action being performed.
@@ -65,209 +43,85 @@ export type ActionKey = (typeof ActionKeys)[keyof typeof ActionKeys];
 /**
  * Extends a query handler with a `queryKey` and pre-built `queryOptions` object.
  *
- * Uses the provided {@link MakeQueryOptions} factory to convert the handler into
- * a TanStack Query-compatible options object. The returned handler retains all
- * original methods (e.g. `raw()`, `toEffect()`) with `queryKey` and `queryOptions`
- * added as extra properties via `Object.assign`.
+ * The returned handler retains all original methods (e.g. `raw()`, `toEffect()`)
+ * with `queryKey` and `queryOptions` added as extra properties via `Object.assign`.
  *
  * @template T - The data type returned by the underlying handler.
  * @template H - The handler type, constrained to objects with a zero-arg `raw()` method returning `Promise<T>`.
- * @template F - The framework `queryOptions` factory. Its return type is preserved
- *   via `ReturnType`, so framework-specific option fields survive.
  * @param handler - The original handler (e.g. from `client.getList()`).
  * @param key - The query key array to associate with this query.
- * @param makeQueryOptions - Framework-specific `queryOptions` factory.
  * @returns The original handler augmented with `queryKey` and `queryOptions`.
  * @see enrichMutation For the mutation equivalent.
  */
-export declare function enrichQuery<T, H extends {
-    raw(): Promise<T>;
-}, F extends (opts: QueryOptionsShape<T>) => unknown>(handler: H, key: QueryKey, makeQueryOptions: F): H & {
+export declare function enrichQuery<H extends {
+    raw(): Promise<unknown>;
+}>(handler: H, key: QueryKey): H & {
     queryKey: QueryKey;
-    queryOptions: ReturnType<F>;
+    queryOptions: {
+        queryKey: QueryKey;
+        queryFn: H["raw"];
+    };
 };
 /**
  * Extends a mutation handler with a pre-built `mutationOptions` object.
  *
- * Uses the provided {@link MakeMutationOptions} factory to convert the handler into
- * a TanStack Query-compatible mutation options object. The returned handler retains all
- * original methods with `mutationOptions` added as an extra property via `Object.assign`.
- *
  * @template TData - The data type returned by the mutation handler.
  * @template TInput - The input data type consumed by the mutation handler.
- * @template H - The handler type, constrained to objects with a single-arg `raw(input)` method returning `Promise<TData>`.
- * @template F - The framework `mutationOptions` factory. Its return type is preserved
- *   via `ReturnType`, so framework-specific option fields survive.
+ * @template H - The handler type, constrained to objects with a single-arg `raw(input)` method.
  * @param handler - The original handler (e.g. from `client.create()`).
- * @param makeMutationOptions - Framework-specific `mutationOptions` factory.
  * @returns The original handler augmented with `mutationOptions`.
  * @see enrichQuery For the query equivalent.
  */
-export declare function enrichMutation<TData, TInput, H extends {
-    raw(input: TInput): Promise<TData>;
-}, F extends (opts: MutationOptionsShape<TData, TInput>) => unknown>(handler: H, makeMutationOptions: F): H & {
-    mutationOptions: ReturnType<F>;
+export declare function enrichMutation<H extends {
+    raw(input: never): Promise<unknown>;
+}>(handler: H): H & {
+    mutationOptions: {
+        mutationFn: H["raw"];
+    };
 };
 /**
- * Creates a TanStack Query adapter for any {@link CollectionClient}.
+ * Creates a framework-agnostic collection adapter.
  *
- * Returns a function that wraps a `CollectionClient` and enriches every query method
- * (getList, getOne, getFirstOrNone, getFullList) with `queryKey` and `queryOptions`,
- * and every mutation method (create, update, delete) with `mutationOptions`.
+ * The adapter wraps a `CollectionClient` and enriches every query method
+ * (getList, getOne, getFirstOrNone, getFullList) with `queryKey` and
+ * `queryOptions`, and every mutation method (create, update, delete, register)
+ * with `mutationOptions`. The produced option objects are plain
+ * `{ queryKey, queryFn }` / `{ mutationFn }` shapes, accepted by TanStack Query
+ * in every framework — so the package has no runtime dependency on TanStack.
  *
- * Query keys follow a structured pattern: `[collectionName, actionKey, ...params]`.
- * This enables fine-grained cache invalidation — for example, invalidating only
- * `getOne` queries for a specific record by referencing key `["posts", "getOne", id]`.
+ * Query keys follow a structured pattern: `[collectionName, actionKey, ...params]`,
+ * enabling fine-grained cache invalidation (e.g. `[name, "getOne", id]`).
  *
  * The returned object also exposes `invalidateAll(queryClient)` and
- * `invalidateOne(queryClient, id)` convenience methods that call
- * `queryClient.invalidateQueries` with the appropriate key prefix.
+ * `invalidateOne(queryClient, id)` helpers.
  *
- * @param makeQueryOptions - Framework-specific `queryOptions` factory
- *   (e.g. from `@tanstack/react-query`, `@tanstack/svelte-query`, or `@tanstack/solid-query`).
- * @param makeMutationOptions - Framework-specific `mutationOptions` factory.
- * @returns An adapter function that takes a `CollectionClient` and collection name,
- *   and returns an enhanced client with query/mutation metadata.
+ * @returns An adapter function that takes a `CollectionClient` and collection
+ *   name, and returns an enhanced client with query/mutation metadata.
  *
  * @example
  * ```ts
- * import { queryOptions, mutationOptions } from "@tanstack/react-query"
+ * import { collectionAdapter } from "@gettersethya/mira-tanstack-adapter"
  * import { createMiraClient } from "@gettersethya/mira-client"
- * import { createCollectionAdapter } from "@gettersethya/mira-tanstack-adapter"
  *
- * const adapt = createCollectionAdapter(queryOptions, mutationOptions)
- * const client = createMiraClient({ url: "/api" }).withCollections({ posts: PostCollection })
- * const adapted = adapt(client, "posts")
+ * const client = createMiraClient("/api").withCollections(
+ *   { posts: PostCollection },
+ *   { adapter: collectionAdapter },
+ * )
  *
- * // Use in a React component:
- * const { data } = useQuery(adapted.getList({ limit: 10 }).queryOptions)
- * const mutation = useMutation(adapted.create().mutationOptions)
- *
- * // Invalidate after mutation:
- * adapted.invalidateAll(queryClient)
- * adapted.invalidateOne(queryClient, recordId)
+ * const { data } = useQuery(client.posts.getList({ limit: 10 }).queryOptions)
+ * const mutation = useMutation(client.posts.create().mutationOptions)
  * ```
  *
  * @see enrichQuery
  * @see enrichMutation
- * @see MakeQueryOptions
- * @see MakeMutationOptions
  */
-export declare function createCollectionAdapter<FQ extends MakeQueryOptions, FM extends MakeMutationOptions>(makeQueryOptions: FQ, makeMutationOptions: FM): <F extends FieldsMap>(client: CollectionClient<F>, name: string) => {
-    /**
-     * Invalidates all cached queries for this collection.
-     * Calls `queryClient.invalidateQueries` with key prefix `[name]`.
-     *
-     * @param queryClient - Any TanStack Query client with `invalidateQueries`.
-     */
-    invalidateAll: (queryClient: {
-        invalidateQueries(opts: {
-            queryKey: QueryKey;
-        }): unknown;
-    }) => unknown;
-    /**
-     * Invalidates only the `getOne` cache entry for a specific record.
-     * Calls `queryClient.invalidateQueries` with key `[name, "getOne", id]`.
-     *
-     * @param queryClient - Any TanStack Query client with `invalidateQueries`.
-     * @param id - The record ID whose cached `getOne` entry should be invalidated.
-     */
-    invalidateOne: (queryClient: {
-        invalidateQueries(opts: {
-            queryKey: QueryKey;
-        }): unknown;
-    }, id: string) => unknown;
-    register?: (() => import("@gettersethya/mira-client").ClientHandler<import("@gettersethya/mira-collection").InferRecord<F>, import("@gettersethya/mira-collection").RegisterInput<F>>) | undefined;
-    /**
-     * Enriched version of `getList` that also returns `queryKey` and `queryOptions`.
-     * Query key: `[name, "getList", options]`.
-     */
-    getList: (options?: Parameters<CollectionClient<F>["getList"]>[0]) => {
-        raw(): Promise<{
-            items: import("@gettersethya/mira-collection").WithExpand<F, readonly import("@gettersethya/mira-collection").RelationKeys<F>[]>[];
-            nextCursor: number | null;
-        }>;
-        toEffect(): import("effect/Effect").Effect<{
-            items: import("@gettersethya/mira-collection").WithExpand<F, readonly import("@gettersethya/mira-collection").RelationKeys<F>[]>[];
-            nextCursor: number | null;
-        }, import("@gettersethya/mira-client").MiraError, import("effect/http/HttpClient").HttpClient>;
-    } & {
-        queryKey: QueryKey;
-        queryOptions: ReturnType<FQ>;
-    };
-    /**
-     * Enriched version of `getOne` that also returns `queryKey` and `queryOptions`.
-     * Query key: `[name, "getOne", id, options]`.
-     */
-    getOne: (id: string, options?: Parameters<CollectionClient<F>["getOne"]>[1]) => {
-        raw(): Promise<import("@gettersethya/mira-collection").WithExpand<F, readonly import("@gettersethya/mira-collection").RelationKeys<F>[]>>;
-        toEffect(): import("effect/Effect").Effect<import("@gettersethya/mira-collection").WithExpand<F, readonly import("@gettersethya/mira-collection").RelationKeys<F>[]>, import("@gettersethya/mira-client").MiraError, import("effect/http/HttpClient").HttpClient>;
-    } & {
-        queryKey: QueryKey;
-        queryOptions: ReturnType<FQ>;
-    };
-    /**
-     * Enriched version of `getFirstOrNone` that also returns `queryKey` and `queryOptions`.
-     * Query key: `[name, "getFirstOrNone", options]`.
-     */
-    getFirstOrNone: (filter: (f: FilterBuilder<F>) => FilterNode, options?: Parameters<CollectionClient<F>["getFirstOrNone"]>[1]) => {
-        raw(): Promise<import("effect/Option").Option<import("@gettersethya/mira-collection").WithExpand<F, readonly import("@gettersethya/mira-collection").RelationKeys<F>[]>>>;
-        toEffect(): import("effect/Effect").Effect<import("effect/Option").Option<import("@gettersethya/mira-collection").WithExpand<F, readonly import("@gettersethya/mira-collection").RelationKeys<F>[]>>, import("@gettersethya/mira-client").MiraError, import("effect/http/HttpClient").HttpClient>;
-    } & {
-        queryKey: QueryKey;
-        queryOptions: ReturnType<FQ>;
-    };
-    /**
-     * Enriched version of `getFullList` that also returns `queryKey` and `queryOptions`.
-     * Query key: `[name, "getFullList", options]`.
-     */
-    getFullList: (options?: Parameters<CollectionClient<F>["getFullList"]>[0]) => {
-        raw(): Promise<import("@gettersethya/mira-collection").WithExpand<F, readonly import("@gettersethya/mira-collection").RelationKeys<F>[]>[]>;
-        toEffect(): import("effect/Effect").Effect<import("@gettersethya/mira-collection").WithExpand<F, readonly import("@gettersethya/mira-collection").RelationKeys<F>[]>[], import("@gettersethya/mira-client").MiraError, import("effect/http/HttpClient").HttpClient>;
-    } & {
-        queryKey: QueryKey;
-        queryOptions: ReturnType<FQ>;
-    };
-    /**
-     * Enriched mutation for creating records. Call `raw(input)` to execute.
-     */
-    create: () => import("@gettersethya/mira-client").ClientHandler<import("@gettersethya/mira-collection").InferRecord<F>, Omit<import("@gettersethya/mira-collection").InferMutationInput<F>, "emailVerified">> & {
-        mutationOptions: ReturnType<FM>;
-    };
-    /**
-     * Enriched mutation for updating records. Call `raw(input)` to execute.
-     */
-    update: () => {
-        raw(input: import("@gettersethya/mira-collection").UpdateInput<F, "base">): Promise<import("@gettersethya/mira-collection").InferRecord<F>>;
-        toEffect(input: import("@gettersethya/mira-collection").UpdateInput<F, "base">): import("effect/Effect").Effect<import("@gettersethya/mira-collection").InferRecord<F>, import("@gettersethya/mira-client").MiraError, import("effect/http/HttpClient").HttpClient>;
-    } & {
-        mutationOptions: ReturnType<FM>;
-    };
-    /**
-     * Enriched mutation for deleting records. Call `raw(input)` to execute.
-     */
-    delete: () => {
-        raw(input: string): Promise<void>;
-        toEffect(input: string): import("effect/Effect").Effect<void, import("@gettersethya/mira-client").MiraError, import("effect/http/HttpClient").HttpClient>;
-    } & {
-        mutationOptions: ReturnType<FM>;
-    };
-    authWithPassword?(): {
-        raw(input: {
-            email: string;
-            password: string;
-        }): Promise<{
-            token: string;
-            record: import("@gettersethya/mira-collection").InferRecord<F>;
-        }>;
-        toEffect(input: {
-            email: string;
-            password: string;
-        }): import("effect/Effect").Effect<{
-            token: string;
-            record: import("@gettersethya/mira-collection").InferRecord<F>;
-        }, import("@gettersethya/mira-client").MiraError, import("effect/http/HttpClient").HttpClient>;
-    };
-    fields: import("@gettersethya/mira-client").CollectionFileFields<F>;
-};
+export declare function createCollectionAdapter(): <F extends FieldsMap, K extends CollectionKind = "base">(client: CollectionClient<F, K>, name: string, kind: K) => AdaptedCollectionClient<F, K>;
+/**
+ * A pre-built {@link createCollectionAdapter | collection adapter}.
+ *
+ * Framework-agnostic — the option objects it produces satisfy TanStack Query's
+ * `useQuery` / `useMutation` (React, Solid) and `createQuery` / `createMutation`
+ * (Svelte) inputs.
+ */
+export declare const collectionAdapter: <F extends FieldsMap, K extends CollectionKind = "base">(client: CollectionClient<F, K>, name: string, kind: K) => AdaptedCollectionClient<F, K>;
 //# sourceMappingURL=_core.d.ts.map