eden2query 0.3.6 → 0.3.8

package/README.md

@@ -1,6 +1,6 @@
 # eden2query
 
-Type-safe [Eden Treaty](https://elysiajs.com/eden/overview) to [React Query](https://tanstack.com/query) helpers. Two functions, zero runtime dependencies.
+Type-safe [Eden Treaty](https://elysiajs.com/eden/overview) to [React Query](https://tanstack.com/query) helpers. Create fully type-safe React Query hooks from your Elysia API with zero runtime overhead.
 
 ## Install
 
@@ -8,138 +8,410 @@ Type-safe [Eden Treaty](https://elysiajs.com/eden/overview) to [React Query](htt
 bun add eden2query @elysiajs/eden @tanstack/react-query
 ```
 
-## Usage
+## Quick Start
 
-**Queries (GET)** — pass a thunk that calls the Treaty GET:
+### 1. Define your Elysia API
 
 ```ts
-const getOptions = treatyQueryOptions(
-  () => client.api.resource.get({ query: { q: "hello" } }),
-  { queryKey: ["resource"], refetchInterval: 1000 },
-);
+import Elysia, { t } from "elysia";
+
+const app = new Elysia({ prefix: "/api" })
+  .get("/users/:id", ({ params, query }) => {
+    return { user: { id: params.id, name: query.name } };
+  }, {
+    params: t.Object({ id: t.String() }),
+    query: t.Object({ name: t.String() }),
+    response: { 200: t.Object({ user: t.Object({ id: t.String(), name: t.String() }) }) },
+  })
+  .post("/users", ({ body }) => {
+    return { id: "123", ...body };
+  }, {
+    body: t.Object({ name: t.String(), email: t.String() }),
+    response: { 200: t.Object({ id: t.String(), name: t.String(), email: t.String() }) },
+  })
+  .put("/users/:id", ({ params, body }) => {
+    return { id: params.id, ...body };
+  }, {
+    params: t.Object({ id: t.String() }),
+    body: t.Object({ name: t.String() }),
+    response: { 200: t.Object({ id: t.String(), name: t.String() }) },
+  })
+  .delete("/users/:id", ({ params }) => {
+    return { deleted: params.id };
+  }, {
+    params: t.Object({ id: t.String() }),
+    response: { 200: t.Object({ deleted: t.String() }) },
+  });
 ```
 
-**Mutations with variables (POST, PUT, etc.)** — pass a function that receives the mutation input, or a bound Treaty method:
+### 2. Create Treaty Client
 
 ```ts
-// Wrapper when Treaty uses (body, options)
-const postOptions = treatyMutationOptions(
-  (vars: { body: { name: string }; query: { q: string } }) =>
-    client.api.resource.post(vars.body, { query: vars.query }),
-  { onSuccess: () => console.log("Success") },
-);
-
-// Parameterised routes — bind params first
-const putOptions = treatyMutationOptions(
-  client.api.resource({ id: "dummy" }).put,
-  { onSettled: () => console.log("Settled") },
-);
+import { treaty } from "@elysiajs/eden";
+
+const client = treaty<typeof app>("http://localhost:3000");
 ```
 
-**Mutations without variables (e.g. DELETE with fixed params)** — pass a no-argument function; `mutate()` is then called with no args:
+### 3. Create Type-Safe Hooks
 
 ```ts
-const deleteOptions = treatyMutationOptions(
-  () => client.api.resource({ id: "dummy" }).delete(),
-  { onMutate: () => console.log("Mutate") },
-);
+import { treatyQueryHook, treatyMutationHook } from "eden2query";
+import { useQueryClient } from "@tanstack/react-query";
+
+// GET - Query Hook (with params)
+function getUser(params: { id: string }) {
+  return client.api.users({ id: params.id }).get;
+}
+
+const useGetUser = treatyQueryHook(getUser, (request) => {
+  return {
+    queryKey: ["users", request.params.id],
+  };
+});
+
+// POST - Mutation Hook
+function createUser() {
+  return client.api.users.post;
+}
+
+const useCreateUser = treatyMutationHook(createUser, () => {
+  const queryClient = useQueryClient();
+  return {
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["users"] });
+    },
+  };
+});
+
+// PUT - Mutation Hook with Params
+function updateUser(params: { id: string }) {
+  return client.api.users({ id: params.id }).put;
+}
+
+const useUpdateUser = treatyMutationHook(updateUser, () => {
+  const queryClient = useQueryClient();
+  return {
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["users"] });
+    },
+  };
+});
+
+// DELETE - Mutation Hook with Params (no body)
+function deleteUser(params: { id: string }) {
+  return client.api.users({ id: params.id }).delete;
+}
+
+const useDeleteUser = treatyMutationHook(deleteUser, () => {
+  const queryClient = useQueryClient();
+  return {
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["users"] });
+    },
+  };
+});
 ```
 
-Use with React Query as usual:
+### 4. Use in Components
 
 ```tsx
-const { data } = useQuery(getOptions);
+function UserProfile({ userId }: { userId: string }) {
+  // Query - automatically typed
+  const { data, isLoading } = useGetUser({
+    params: { id: userId },
+    query: { name: "John" },
+  });
+
+  // Mutations - fully typed
+  const createMutation = useCreateUser({
+    onSuccess: (data) => {
+      console.log("Created:", data);
+    },
+  });
+
+  const updateMutation = useUpdateUser({
+    onSuccess: (data) => {
+      console.log("Updated:", data);
+    },
+  });
+
+  const deleteMutation = useDeleteUser({
+    onSuccess: (data) => {
+      console.log("Deleted:", data);
+    },
+  });
+
+  return (
+    <div>
+      {isLoading ? "Loading..." : <div>{data?.user.name}</div>}
+      
+      <button onClick={() => createMutation.mutate({
+        body: { name: "New User", email: "user@example.com" },
+      })}>
+        Create User
+      </button>
+
+      <button onClick={() => updateMutation.mutate({
+        params: { id: userId },
+        body: { name: "Updated Name" },
+      })}>
+        Update User
+      </button>
+
+      <button onClick={() => deleteMutation.mutate({
+        params: { id: userId },
+        // body is not required for DELETE mutations
+      })}>
+        Delete User
+      </button>
+    </div>
+  );
+}
+```
 
-const postMutation = useMutation(postOptions);
-postMutation.mutate({ body: { name: "World" }, query: { q: "hello" } });
+## API Reference
 
-const putMutation = useMutation(putOptions);
-putMutation.mutate({ name: "World" });
+### `treatyQueryHook`
 
-const deleteMutation = useMutation(deleteOptions);
-deleteMutation.mutate(); // no arguments
+Creates a type-safe React Query hook for GET requests.
+
+**Signature:**
+```ts
+function treatyQueryHook<TParams, TOption extends object, TResponse extends Record<number, unknown>>(
+  fn: TreatyQueryFunctionFactory<TParams, TOption, TResponse>,
+  useOptions: (request: TreatyQueryRequest<TParams, TOption>) => Omit<UseQueryOptions<TResponse>, "queryFn">
+): (request: TreatyQueryRequest<TParams, TOption>, options?: UseQueryOptions) => UseQueryResult
 ```
 
-Prefetch and other helpers work as usual:
+**Parameters:**
+- `fn`: A factory function that accepts params (if route has params) or no params (if route doesn't have params), and returns a Treaty query function
+- `useOptions`: A function that receives the request and returns query options (including `queryKey`)
 
+**Returns:** A hook function that accepts a request object and optional query options
+
+**Example:**
 ```ts
-const queryClient = new QueryClient();
-queryClient.prefetchQuery(getOptions);
+// With params
+function getUser(params: { id: string }) {
+  return client.api.users({ id: params.id }).get;
+}
+
+const useGetUser = treatyQueryHook(getUser, (request) => ({
+  queryKey: ["users", request.params.id], // params is required when route has params
+  staleTime: 5000,
+}));
+
+// Usage
+const { data } = useGetUser({
+  params: { id: "123" }, // Required when route has params
+  query: { name: "John" },
+});
+
+// Without params
+function getUsers() {
+  return client.api.users.get;
+}
+
+const useGetUsers = treatyQueryHook(getUsers, (request) => ({
+  queryKey: ["users"],
+}));
+
+// Usage - params are absent from the type
+const { data } = useGetUsers({
+  query: { page: "1" },
+  // params is not part of the request type
+});
 ```
 
-### Hook builders: `treatyQueryHook` / `treatyMutationHook`
+### `treatyMutationHook`
+
+Creates a type-safe React Query hook for mutations (POST, PUT, DELETE, etc.).
 
-Create reusable, pre-configured hooks for a Treaty endpoint. The first parameter is the **Treaty function**, and the second optional parameter is **`useOptions`** — a hook that returns default options (so you can use React hooks like `useQueryClient()`).
+**Signature:**
+```ts
+function treatyMutationHook<TParams, TBody, TOption, TResponse extends Record<number, unknown>>(
+  fn: TreatyMutationFunctionFactory<TParams, TBody, TOption, TResponse>,
+  useOptions: () => Omit<UseMutationOptions<TParams, TBody, TOption, TResponse>, "mutationFn">
+): (options?: UseMutationOptions) => UseMutationResult
+```
 
-**Mutation hook** — pass the mutation function and optional `useOptions`:
+**Parameters:**
+- `fn`: A factory function that accepts params (if route has params) or no params (if route doesn't have params), and returns a Treaty mutation function
+- `useOptions`: A hook function that returns default mutation options (can use React hooks like `useQueryClient`)
 
+**Returns:** A hook function that accepts optional mutation options
+
+**Example:**
 ```ts
-function myMutationFn(variables: { name: string; q: string }) {
-  return client.api.resource.post(
-    { name: variables.name },
-    { query: { q: variables.q } }
-  );
+// Without params, with body
+function createUser() {
+  return client.api.users.post;
 }
 
-const useMutationHook = treatyMutationHook(myMutationFn, () => {
+const useCreateUser = treatyMutationHook(createUser, () => {
   const queryClient = useQueryClient();
   return {
     onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["resource"] });
+      queryClient.invalidateQueries({ queryKey: ["users"] });
     },
   };
 });
 
-// In a component
-const mutationResult = useMutationHook({
-  onSuccess: (data, variables) => {
-    console.log(data, variables);
-  },
+// Usage
+const mutation = useCreateUser({
+  onSuccess: (data) => console.log(data),
+});
+
+mutation.mutate({
+  body: { name: "John", email: "john@example.com" },
+  // params is not part of the request type
+});
+
+// With params and body
+function updateUser(params: { id: string }) {
+  return client.api.users({ id: params.id }).put;
+}
+
+const useUpdateUser = treatyMutationHook(updateUser, () => ({
+  onSuccess: () => console.log("Updated"),
+}));
+
+useUpdateUser().mutate({
+  params: { id: "123" },
+  body: { name: "Updated Name" },
 });
-mutationResult.mutate({
-  name: "World",
-  q: "hello",
+
+// With params, without body
+function deleteUser(params: { id: string }) {
+  return client.api.users({ id: params.id }).delete;
+}
+
+const useDeleteUser = treatyMutationHook(deleteUser, () => ({
+  onSuccess: () => console.log("Deleted"),
+}));
+
+useDeleteUser().mutate({
+  params: { id: "123" },
+  // body is not part of the request type
 });
 ```
 
-**Query hook** — pass the query function and optional `useOptions` that receives the `request` and returns options including `queryKey`:
+## Type Safety
+
+All types are inferred end-to-end from your Elysia route definitions:
+
+- **Request types**: Automatically inferred from route params, query, and body schemas
+  - `params` and `body` are **conditionally included** in request types - they're absent (not optional) when the route doesn't require them
+  - This means you don't need to pass `undefined` or `unknown` values - the fields simply don't exist in the type
+- **Response types**: Extracted from your response schema definitions
+- **Error types**: Typed based on your error response schemas
+- **Query keys**: Type-safe based on your request structure
+
+## Patterns
+
+### Routes with Params
+
+For routes like `/users/:id`, params are **required** and included in the request type:
 
 ```ts
-function myQueryFn(request: { q: string }) {
-  return client.api.resource.get({ query: { q: request.q } });
+function getUser(params: { id: string }) {
+  return client.api.users({ id: params.id }).get;
 }
 
-const useQueryHook = treatyQueryHook(myQueryFn, (request) => ({
-  queryKey: ["resource", request] as const,
-  enabled: true,
+const useGetUser = treatyQueryHook(getUser, (request) => ({
+  queryKey: ["users", request.params.id], // params is required here
 }));
 
-// In a component
-const queryResult = useQueryHook({ q: "hello" });
+// Must provide params
+useGetUser({
+  params: { id: "123" }, // ✅ Required - params is part of the request type
+  query: { name: "John" },
+});
 ```
 
-Hooks accept the same options as `useQuery` / `useMutation`; call-time options are merged with the base options from `useOptions`. Callbacks are chained: base options run first, then `useOptions` callbacks, then call-site callbacks.
+### Routes without Params
 
-## API
+For routes without params, params are **absent** from the request type (not optional):
 
-**`treatyQueryOptions(fn, queryOptions)`** — wraps a Treaty GET call into `queryOptions`. `fn` is a **thunk** (zero-argument function) that calls the Treaty GET, e.g. `() => client.api.resource.get({ query: { ... } })`. The second argument accepts all `queryOptions` fields except `queryFn`. Extracts `data` from the response and throws on `error`.
+```ts
+function getUsers() {
+  return client.api.users.get;
+}
 
-**`treatyMutationOptions(fn, mutationOptions?)`** — wraps a Treaty mutation into `mutationOptions`. Two shapes:
+const useGetUsers = treatyQueryHook(getUsers, (request) => ({
+  queryKey: ["users"],
+}));
 
-- **No-arg:** `fn` is `() => Promise<...>`. Use when the mutation has no call-time input (e.g. DELETE with fixed path params). `mutate()` is called with no arguments.
-- **With variables:** `fn` is `(vars) => Promise<...>`. Use for POST/PUT etc. `mutate(vars)` receives a single object (e.g. `{ body, query }` or the Treaty method's first argument). You can pass the Treaty method directly when its signature matches (e.g. `client.api.resource({ id }).put`).
+// Params are absent from the type - you cannot include them
+useGetUsers({
+  query: { page: "1" },
+  // params is not part of the request type at all
+});
+```
+
+### Mutations with Body (no params)
+
+POST mutations without route params include a `body` field:
+
+```ts
+function createUser() {
+  return client.api.users.post;
+}
 
-The optional second argument accepts all `mutationOptions` fields except `mutationFn` (e.g. `onSuccess`, `onSettled`, `onMutate`).
+const useCreateUser = treatyMutationHook(createUser, () => ({}));
 
-**`treatyMutationHook(mutationFn, useOptions?)`** — returns a hook that wraps `useMutation` with the given Treaty mutation function. **`mutationFn`** is the Treaty mutation function (e.g. `myMutationFn`). **`useOptions`** is optional; it's a hook that returns default mutation options (so you can use `useQueryClient()` for invalidation). The returned hook accepts the same options as `useMutation`; callbacks are chained (base → `useOptions` → call-site).
+const mutation = useCreateUser();
+mutation.mutate({
+  body: { name: "John", email: "john@example.com" },
+  // params is not part of the request type
+});
+```
+
+### Mutations with Params and Body
+
+PUT mutations can have both params and body:
+
+```ts
+function updateUser(params: { id: string }) {
+  return client.api.users({ id: params.id }).put;
+}
+
+const useUpdateUser = treatyMutationHook(updateUser, () => ({}));
+
+const mutation = useUpdateUser();
+mutation.mutate({
+  params: { id: "123" }, // Required - params is part of the request type
+  body: { name: "Updated Name" }, // Required - body is part of the request type
+});
+```
+
+### Mutations with Only Params (no body)
+
+DELETE mutations typically only have params, and body is **absent** from the request type:
+
+```ts
+function deleteUser(params: { id: string }) {
+  return client.api.users({ id: params.id }).delete;
+}
+
+const useDeleteUser = treatyMutationHook(deleteUser, () => ({}));
+
+const mutation = useDeleteUser();
+mutation.mutate({
+  params: { id: "123" }, // Required - params is part of the request type
+  // body is not part of the request type at all
+});
+```
 
-**`treatyQueryHook(queryFn, useOptions?)`** — returns a hook that wraps `useQuery` with the given Treaty query function. **`queryFn`** is the Treaty query function (e.g. `myQueryFn`). **`useOptions`** is optional; it's a function `(request) => ...` that receives the query request and returns default query options including `queryKey` (so you can use React hooks like `useQueryClient()`). The returned hook is called with `(request, options?)`; callbacks are chained (base → `useOptions` → call-site).
+## Options Merging
 
-**`InferTreatyQueryOptions<T>`** — full `UseQueryOptions` type for a given Treaty query.
+Options are merged in this order (later options override earlier ones):
 
-**`InferTreatyMutationOptions<TVariables, TResponse>`** — full `UseMutationOptions` type for a given Treaty mutation.
+1. Base options from `useOptions` hook
+2. Options passed to the hook factory
+3. Options passed when calling the hook
 
-Data, error, and input types are inferred end-to-end from your Elysia route definitions.
+Callbacks (`onSuccess`, `onError`, etc.) are **chained** - all callbacks run in order.
 
 ## License
 

package/dist/index.d.ts

@@ -1,48 +1,70 @@
 import { Treaty } from "@elysiajs/eden";
-import { QueryKey, UseMutationOptions, UseMutationResult, UseQueryOptions, UseQueryResult } from "@tanstack/react-query";
-type TreatyFunction = (...request: any[]) => Promise<Treaty.TreatyResponse<Record<number, unknown>>>;
-type InferTreatyData<TFn extends TreatyFunction> = Awaited<ReturnType<TFn>>["data"];
-type InferTreatyError<TFn extends TreatyFunction> = Awaited<ReturnType<TFn>>["error"];
-type InferTreatyRequest<TFn extends TreatyFunction> = Parameters<TFn>[0];
-type InferTreatyMutationOptions<TFn extends TreatyFunction> = UseMutationOptions<InferTreatyData<TFn>, InferTreatyError<TFn>, InferTreatyRequest<TFn>>;
-type InferTreatyQueryOptions<
-	TFn extends TreatyFunction,
-	TQueryKey extends QueryKey = unknown[]
-> = UseQueryOptions<InferTreatyData<TFn>, InferTreatyError<TFn>, InferTreatyData<TFn>, TQueryKey>;
-declare function treatyMutationOptions<TFn extends TreatyFunction>(options: {
-	mutationFn: TFn;
-} & Omit<InferTreatyMutationOptions<TFn>, "mutationFn">): InferTreatyMutationOptions<TFn>;
-declare function treatyQueryOptions<
-	TFn extends TreatyFunction,
-	const TQueryKey extends QueryKey
->(options: {
-	queryKey: TQueryKey;
-	queryFn: TFn;
-} & Omit<InferTreatyQueryOptions<TFn, TQueryKey>, "queryKey" | "queryFn">): InferTreatyQueryOptions<TFn, TQueryKey>;
-type UseTreatyMutationResult<TFn extends TreatyFunction> = UseMutationResult<InferTreatyData<TFn>, InferTreatyError<TFn>, InferTreatyRequest<TFn>>;
-type UseTreatyQueryResult<
-	TFn extends TreatyFunction,
-	TQueryKey extends QueryKey = unknown[]
-> = UseQueryResult<InferTreatyData<TFn>, InferTreatyError<TFn>>;
-type TreatyMutationHookOptions<TFn extends TreatyFunction> = Omit<InferTreatyMutationOptions<TFn>, "mutationFn">;
-type TreatyQueryHookOptions<
-	TFn extends TreatyFunction,
-	TQueryKey extends QueryKey = unknown[]
-> = Omit<InferTreatyQueryOptions<TFn, TQueryKey>, "queryKey" | "queryFn">;
-type TreatyQueryHookUseOptions<
-	TFn extends TreatyFunction,
-	TQueryKey extends QueryKey = unknown[]
-> = {
-	queryKey: TQueryKey;
-} & TreatyQueryHookOptions<TFn, TQueryKey>;
-type TreatyMutationHook<TFn extends TreatyFunction> = (options?: TreatyMutationHookOptions<TFn>) => UseTreatyMutationResult<TFn>;
+import { UseMutationOptions, UseMutationResult, UseQueryOptions, UseQueryResult } from "@tanstack/react-query";
+type IsEmpty<T> = [T] extends [never | undefined | void] ? true : [unknown] extends [T] ? [T] extends [unknown] ? true : false : false;
+type TreatyMutationFunctionFactory<
+	TParams,
+	TBody,
+	TOption,
+	TResponse extends Record<number, unknown>
+> = IsEmpty<TParams> extends true ? () => TreatyMutationFunction<TBody, TOption, TResponse> : (params: TParams) => TreatyMutationFunction<TBody, TOption, TResponse>;
+type TreatyMutationFunction<
+	TBody,
+	TOption,
+	TResponse extends Record<number, unknown>
+> = (body: TBody, options: TOption) => Promise<Treaty.TreatyResponse<TResponse>>;
+type TreatyMutationRequest<
+	TParams,
+	TBody,
+	TOption
+> = TOption & (IsEmpty<TParams> extends true ? {} : {
+	params: TParams;
+}) & (IsEmpty<TBody> extends true ? {} : {
+	body: TBody;
+});
+type TreatyData<TResponse extends Record<number, unknown>> = Treaty.TreatyResponse<TResponse>["data"];
+type TreatyError<TResponse extends Record<number, unknown>> = Treaty.TreatyResponse<TResponse>["error"];
+type TreatyMutationOptions<
+	TParams,
+	TBody,
+	TOption,
+	TResponse extends Record<number, unknown>
+> = UseMutationOptions<TreatyData<TResponse>, TreatyError<TResponse>, TreatyMutationRequest<TParams, TBody, TOption>>;
+type TreatyMutationHook<
+	TParams,
+	TBody,
+	TOption,
+	TResponse extends Record<number, unknown>
+> = (options?: Omit<TreatyMutationOptions<TParams, TBody, TOption, TResponse>, "mutationFn">) => UseMutationResult<TreatyData<TResponse>, TreatyError<TResponse>, TreatyMutationRequest<TParams, TBody, TOption>>;
+declare function treatyMutationHook<
+	TParams,
+	TBody,
+	TOption,
+	TResponse extends Record<number, unknown>
+>(fn: TreatyMutationFunctionFactory<TParams, TBody, TOption, TResponse>, useOptions?: () => Omit<TreatyMutationOptions<TParams, TBody, TOption, TResponse>, "mutationFn">): TreatyMutationHook<TParams, TBody, TOption, TResponse>;
+type TreatyQueryFunction<
+	TOption extends object,
+	TResponse extends Record<number, unknown>
+> = (options: TOption) => Promise<Treaty.TreatyResponse<TResponse>>;
+type TreatyQueryFunctionFactory<
+	TParams,
+	TOption extends object,
+	TResponse extends Record<number, unknown>
+> = IsEmpty<TParams> extends true ? () => TreatyQueryFunction<TOption, TResponse> : (params: TParams) => TreatyQueryFunction<TOption, TResponse>;
+type TreatyQueryRequest<
+	TParams,
+	TOption extends object
+> = TOption & (IsEmpty<TParams> extends true ? {} : {
+	params: TParams;
+});
+type TreatyQueryOptions<TResponse extends Record<number, unknown>> = UseQueryOptions<TreatyData<TResponse>, TreatyError<TResponse>>;
 type TreatyQueryHook<
-	TFn extends TreatyFunction,
-	TQueryKey extends QueryKey = unknown[]
-> = (request: InferTreatyRequest<TFn>, options?: TreatyQueryHookOptions<TFn, TQueryKey>) => UseTreatyQueryResult<TFn, TQueryKey>;
-declare function treatyMutationHook<TFn extends TreatyFunction>(mutationFn: TFn, useOptions?: () => TreatyMutationHookOptions<TFn>): TreatyMutationHook<TFn>;
+	TParams,
+	TOption extends object,
+	TResponse extends Record<number, unknown>
+> = (request: TreatyQueryRequest<TParams, TOption>, options?: Omit<TreatyQueryOptions<TResponse>, "queryKey" | "queryFn">) => UseQueryResult<TreatyData<TResponse>, TreatyError<TResponse>>;
 declare function treatyQueryHook<
-	TFn extends TreatyFunction,
-	TQueryKey extends QueryKey = QueryKey
->(queryFn: TFn, useOptions?: (request: InferTreatyRequest<TFn>) => TreatyQueryHookUseOptions<TFn, TQueryKey>): TreatyQueryHook<TFn, TQueryKey>;
-export { treatyQueryOptions, treatyQueryHook, treatyMutationOptions, treatyMutationHook, InferTreatyQueryOptions, InferTreatyMutationOptions };
+	TParams,
+	TOption extends object,
+	TResponse extends Record<number, unknown>
+>(fn: TreatyQueryFunctionFactory<TParams, TOption, TResponse>, useOptions: (request: TreatyQueryRequest<TParams, TOption>) => Omit<TreatyQueryOptions<TResponse>, "queryFn">): TreatyQueryHook<TParams, TOption, TResponse>;
+export { treatyQueryHook, treatyMutationHook };

package/dist/index.js

@@ -1,5 +1,8 @@
 // src/treaty.ts
-import { mutationOptions, queryOptions, useMutation, useQuery } from "@tanstack/react-query";
+import {
+  useMutation,
+  useQuery
+} from "@tanstack/react-query";
 
 // src/utils.ts
 function mergeMutationOptions(base, options) {
@@ -36,69 +39,44 @@ function mergeMutationOptions(base, options) {
     }
   };
 }
-function mergeQueryOptions(base, options) {
-  if (!options)
-    return base;
-  return {
-    ...base,
-    ...options
-  };
-}
 
 // src/treaty.ts
-function treatyMutationOptions(options) {
-  const { mutationFn, ...rest } = options;
-  return mutationOptions({
-    ...rest,
-    mutationFn: async (variables) => {
-      const response = await mutationFn(variables);
-      const { data, error } = response;
-      if (error)
-        throw error;
-      return data;
-    }
-  });
-}
-function treatyQueryOptions(options) {
-  const { queryFn, queryKey, ...rest } = options;
-  return queryOptions({
-    ...rest,
-    queryKey,
-    queryFn: async () => {
-      const response = await queryFn();
-      const { data, error } = response;
-      if (error)
-        throw error;
-      return data;
-    }
-  });
-}
-function treatyMutationHook(mutationFn, useOptions) {
+function treatyMutationHook(fn, useOptions) {
   return (options) => {
-    const baseOptions = treatyMutationOptions({ mutationFn });
-    const defaultOptions = useOptions?.();
-    const merged = mergeMutationOptions(mergeMutationOptions(baseOptions, defaultOptions), options);
-    return useMutation(merged);
+    const baseOptions = useOptions?.() ?? {};
+    return useMutation({
+      ...mergeMutationOptions(baseOptions, options),
+      mutationFn: async (request) => {
+        const mutationFn = "params" in request && request.params !== undefined ? fn(request.params) : fn();
+        const body = "body" in request && request.body !== undefined ? request.body : undefined;
+        const { data, error } = await mutationFn(body, request);
+        if (error)
+          throw error;
+        return data;
+      }
+    });
   };
 }
-function treatyQueryHook(queryFn, useOptions) {
+function treatyQueryHook(fn, useOptions) {
   return (request, options) => {
-    const defaultOptions = useOptions?.(request);
-    const baseOptions = treatyQueryOptions({
-      queryKey: defaultOptions?.queryKey ?? ["resource", request],
-      queryFn: () => queryFn(request),
-      ...defaultOptions
+    const queryFn = "params" in request && request.params !== undefined ? fn(request.params) : fn();
+    const baseOptions = useOptions(request);
+    return useQuery({
+      ...options,
+      ...baseOptions,
+      queryFn: async () => {
+        const { data, error } = await queryFn(request);
+        if (error)
+          throw error;
+        return data;
+      }
     });
-    const merged = mergeQueryOptions(baseOptions, options);
-    return useQuery(merged);
   };
 }
 export {
-  treatyQueryOptions,
   treatyQueryHook,
-  treatyMutationOptions,
   treatyMutationHook
 };
 
-//# debugId=3974E80E199B9F8064756E2164756E21
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["src\\treaty.ts", "src\\utils.ts"],
  "sourcesContent": [
    "import type { Treaty } from \"@elysiajs/eden\";\r\nimport { mutationOptions, queryOptions, useMutation, useQuery, type QueryKey, type UseMutationOptions, type UseMutationResult, type UseQueryOptions, type UseQueryResult } from \"@tanstack/react-query\";\r\nimport { mergeMutationOptions, mergeQueryOptions } from \"./utils\";\r\n\r\ntype TreatyFunction = (...request: any[]) => \r\n  Promise<Treaty.TreatyResponse<Record<number, unknown>>>;\r\n\r\nexport type InferTreatyData<\r\n  TFn extends TreatyFunction,\r\n> = Awaited<ReturnType<TFn>>[\"data\"];\r\n\r\nexport type InferTreatyError<\r\n  TFn extends TreatyFunction,\r\n> = Awaited<ReturnType<TFn>>[\"error\"];\r\n\r\nexport type InferTreatyRequest<\r\n  TFn extends TreatyFunction,\r\n> = Parameters<TFn>[0];\r\n\r\nexport type InferTreatyMutationOptions<\r\n  TFn extends TreatyFunction,\r\n> = UseMutationOptions<\r\n  InferTreatyData<TFn>,\r\n  InferTreatyError<TFn>,\r\n  InferTreatyRequest<TFn>\r\n>;\r\n\r\nexport type InferTreatyQueryOptions<\r\n  TFn extends TreatyFunction,\r\n  TQueryKey extends QueryKey = unknown[],\r\n> = UseQueryOptions<\r\n  InferTreatyData<TFn>,\r\n  InferTreatyError<TFn>,\r\n  InferTreatyData<TFn>,\r\n  TQueryKey\r\n>;\r\n\r\nexport function treatyMutationOptions<TFn extends TreatyFunction>(\r\n  options: {\r\n    mutationFn: TFn;\r\n  } & Omit<\r\n    InferTreatyMutationOptions<TFn>,\r\n    \"mutationFn\"\r\n  >\r\n): InferTreatyMutationOptions<TFn> {\r\n  type TData = InferTreatyData<TFn>;\r\n  type TError = InferTreatyError<TFn>;\r\n  type TVariables = InferTreatyRequest<TFn>;\r\n  const { mutationFn, ...rest } = options;\r\n  return mutationOptions<TData, TError, TVariables>({\r\n    ...rest,\r\n    mutationFn: async (variables) => {\r\n      const response = await mutationFn(variables);\r\n      const { data, error } = response;\r\n      if (error) throw error;\r\n      return data;\r\n    },\r\n  });\r\n}\r\n\r\nexport function treatyQueryOptions<\r\n  TFn extends TreatyFunction,\r\n  const TQueryKey extends QueryKey,\r\n>(\r\n  options: {\r\n    queryKey: TQueryKey;\r\n    queryFn: TFn;\r\n  } & Omit<\r\n    InferTreatyQueryOptions<TFn, TQueryKey>,\r\n    \"queryKey\" | \"queryFn\"\r\n  >\r\n): InferTreatyQueryOptions<TFn, TQueryKey> {\r\n  type TData = InferTreatyData<TFn>;\r\n  type TError = InferTreatyError<TFn>;\r\n  const { queryFn, queryKey, ...rest } = options;\r\n  return queryOptions<TData, TError, TData, TQueryKey>({\r\n    ...rest,\r\n    queryKey,\r\n    queryFn: async () => {\r\n      const response = await queryFn();\r\n      const { data, error } = response;\r\n      if (error) throw error;\r\n      return data;\r\n    },\r\n  });\r\n}\r\n\r\nexport type UseTreatyMutationResult<TFn extends TreatyFunction> = UseMutationResult<\r\n  InferTreatyData<TFn>,\r\n  InferTreatyError<TFn>,\r\n  InferTreatyRequest<TFn>\r\n>;\r\n\r\nexport type UseTreatyQueryResult<\r\n  TFn extends TreatyFunction,\r\n  TQueryKey extends QueryKey = unknown[],\r\n> = UseQueryResult<\r\n  InferTreatyData<TFn>,\r\n  InferTreatyError<TFn>\r\n>;\r\n\r\nexport type TreatyMutationHookOptions<TFn extends TreatyFunction> = Omit<\r\n  InferTreatyMutationOptions<TFn>,\r\n  \"mutationFn\"\r\n>;\r\n\r\nexport type TreatyQueryHookOptions<\r\n  TFn extends TreatyFunction,\r\n  TQueryKey extends QueryKey = unknown[],\r\n> = Omit<\r\n  InferTreatyQueryOptions<TFn, TQueryKey>,\r\n  \"queryKey\" | \"queryFn\"\r\n>;\r\n\r\nexport type TreatyQueryHookUseOptions<\r\n  TFn extends TreatyFunction,\r\n  TQueryKey extends QueryKey = unknown[],\r\n> = {\r\n  queryKey: TQueryKey;\r\n} & TreatyQueryHookOptions<TFn, TQueryKey>;\r\n\r\nexport type TreatyMutationHook<TFn extends TreatyFunction> = (\r\n  options?: TreatyMutationHookOptions<TFn>\r\n) => UseTreatyMutationResult<TFn>;\r\n\r\nexport type TreatyQueryHook<\r\n  TFn extends TreatyFunction,\r\n  TQueryKey extends QueryKey = unknown[],\r\n> = (\r\n  request: InferTreatyRequest<TFn>,\r\n  options?: TreatyQueryHookOptions<TFn, TQueryKey>\r\n) => UseTreatyQueryResult<TFn, TQueryKey>;\r\n\r\nexport function treatyMutationHook<TFn extends TreatyFunction>(\r\n  mutationFn: TFn,\r\n  useOptions?: () => TreatyMutationHookOptions<TFn>\r\n): TreatyMutationHook<TFn> {\r\n  return (options) => {\r\n    const baseOptions = treatyMutationOptions({ mutationFn });\r\n    const defaultOptions = useOptions?.();\r\n    const merged = mergeMutationOptions(\r\n      mergeMutationOptions(baseOptions, defaultOptions),\r\n      options\r\n    );\r\n    return useMutation(merged);\r\n  };\r\n}\r\n\r\nexport function treatyQueryHook<\r\n  TFn extends TreatyFunction,\r\n  TQueryKey extends QueryKey = QueryKey,\r\n>(\r\n  queryFn: TFn,\r\n  useOptions?: (\r\n    request: InferTreatyRequest<TFn>\r\n  ) => TreatyQueryHookUseOptions<TFn, TQueryKey>\r\n): TreatyQueryHook<TFn, TQueryKey> {\r\n  return (request, options) => {\r\n    const defaultOptions = useOptions?.(request);\r\n    const baseOptions = treatyQueryOptions({\r\n      queryKey: (defaultOptions?.queryKey ?? ([\"resource\", request] as unknown)) as TQueryKey,\r\n      queryFn: (() => queryFn(request)) as TFn,\r\n      ...defaultOptions,\r\n    });\r\n    const merged = mergeQueryOptions(\r\n      baseOptions,\r\n      options as UseQueryOptions<\r\n        InferTreatyData<TFn>,\r\n        InferTreatyError<TFn>,\r\n        InferTreatyData<TFn>,\r\n        TQueryKey\r\n      > | undefined\r\n    );\r\n    return useQuery(merged);\r\n  };\r\n}",
    "import type { QueryKey, UseMutationOptions, UseQueryOptions } from \"@tanstack/react-query\";\r\n\r\nexport function mergeMutationOptions<TData, TError, TVariables, TContext>(\r\n  base: UseMutationOptions<TData, TError, TVariables, TContext>,\r\n  options?: Partial<UseMutationOptions<TData, TError, TVariables, TContext>>\r\n): UseMutationOptions<TData, TError, TVariables, TContext> {\r\n  if (!options) return base;\r\n  const { onSuccess, onError, onSettled, onMutate, ...rest } = options;\r\n  return {\r\n    ...base,\r\n    ...rest,\r\n    ...(onMutate !== undefined && {\r\n      onMutate: async (variables, context) => {\r\n        const prev = await base.onMutate?.(variables, context);\r\n        const next = await options.onMutate?.(variables, context);\r\n        return (next !== undefined ? next : prev) as TContext;\r\n      },\r\n    }),\r\n    ...(onSuccess !== undefined && {\r\n      onSuccess: async (data, variables, onMutateResult, context) => {\r\n        await base.onSuccess?.(data, variables, onMutateResult, context);\r\n        await options.onSuccess?.(data, variables, onMutateResult, context);\r\n      },\r\n    }),\r\n    ...(onError !== undefined && {\r\n      onError: async (error, variables, onMutateResult, context) => {\r\n        await base.onError?.(error, variables, onMutateResult, context);\r\n        await options.onError?.(error, variables, onMutateResult, context);\r\n      },\r\n    }),\r\n    ...(onSettled !== undefined && {\r\n      onSettled: async (data, error, variables, onMutateResult, context) => {\r\n        await base.onSettled?.(data, error, variables, onMutateResult, context);\r\n        await options.onSettled?.(data, error, variables, onMutateResult, context);\r\n      },\r\n    }),\r\n  };\r\n}\r\n\r\nexport function mergeQueryOptions<TData, TError, TQueryKey extends QueryKey>(\r\n  base: UseQueryOptions<TData, TError, TData, TQueryKey>,\r\n  options?: Partial<UseQueryOptions<TData, TError, TData, TQueryKey>>\r\n): UseQueryOptions<TData, TError, TData, TQueryKey> {\r\n  if (!options) return base;\r\n  return {\r\n    ...base,\r\n    ...options,\r\n  };\r\n}\r\n"
  ],
  "mappings": "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",
  "debugId": "3974E80E199B9F8064756E2164756E21",
  "names": []
}
+//# debugId=89C48BF36DA4F8BA64756E2164756E21
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["src\\treaty.ts", "src\\utils.ts"],
  "sourcesContent": [
    "import type { Treaty } from \"@elysiajs/eden\";\r\nimport {\r\n  useMutation,\r\n  useQuery,\r\n  type QueryKey,\r\n  type UseMutationOptions,\r\n  type UseMutationResult,\r\n  type UseQueryOptions,\r\n  type UseQueryResult,\r\n} from \"@tanstack/react-query\";\r\nimport { mergeMutationOptions } from \"./utils\";\r\n\r\n// Helper type to check if a type represents \"no params\" (absent/empty)\r\n// Checks for never, undefined, void, and also handles unknown when it represents an unconstrained type\r\ntype IsEmpty<T> = \r\n  // Check for never, undefined, void\r\n  [T] extends [never | undefined | void] \r\n    ? true\r\n    // Check if T is unknown (unconstrained type parameter)\r\n    : [unknown] extends [T]\r\n      ? [T] extends [unknown]\r\n        ? true\r\n        : false\r\n      : false;\r\n\r\ntype TreatyMutationFunctionFactory<\r\n  TParams,\r\n  TBody,\r\n  TOption,\r\n  TResponse extends Record<number, unknown>,\r\n> = IsEmpty<TParams> extends true\r\n  ? () => TreatyMutationFunction<TBody, TOption, TResponse> \r\n  : (params: TParams) => TreatyMutationFunction<TBody, TOption, TResponse>;\r\n\r\ntype TreatyMutationFunction<\r\n  TBody,\r\n  TOption,\r\n  TResponse extends Record<number, unknown>,\r\n> = (\r\n  body: TBody,\r\n  options: TOption,\r\n) => Promise<Treaty.TreatyResponse<TResponse>>;\r\n\r\ntype TreatyMutationRequest<\r\n  TParams,\r\n  TBody,\r\n  TOption,\r\n> = TOption &\r\n  (IsEmpty<TParams> extends true ? {} : { params: TParams }) &\r\n  (IsEmpty<TBody> extends true ? {} : { body: TBody });\r\n\r\ntype TreatyData<TResponse extends Record<number, unknown>> =\r\n  Treaty.TreatyResponse<TResponse>[\"data\"];\r\n\r\ntype TreatyError<TResponse extends Record<number, unknown>> =\r\n  Treaty.TreatyResponse<TResponse>[\"error\"];\r\n\r\ntype TreatyMutationOptions<\r\n  TParams,\r\n  TBody,\r\n  TOption,\r\n  TResponse extends Record<number, unknown>,\r\n> = UseMutationOptions<\r\n  TreatyData<TResponse>,\r\n  TreatyError<TResponse>,\r\n  TreatyMutationRequest<TParams, TBody, TOption>\r\n>;\r\n\r\ntype TreatyMutationHook<\r\n  TParams,\r\n  TBody,\r\n  TOption,\r\n  TResponse extends Record<number, unknown>,\r\n> = (\r\n  options?: Omit<\r\n    TreatyMutationOptions<TParams, TBody, TOption, TResponse>,\r\n    \"mutationFn\"\r\n  >,\r\n) => UseMutationResult<\r\n  TreatyData<TResponse>,\r\n  TreatyError<TResponse>,\r\n  TreatyMutationRequest<TParams, TBody, TOption>\r\n>;\r\n\r\nexport function treatyMutationHook<\r\n  TParams,\r\n  TBody,\r\n  TOption,\r\n  TResponse extends Record<number, unknown>,\r\n>(\r\n  fn: TreatyMutationFunctionFactory<TParams, TBody, TOption, TResponse>,\r\n  useOptions?: () => Omit<\r\n    TreatyMutationOptions<TParams, TBody, TOption, TResponse>,\r\n    \"mutationFn\"\r\n  >,\r\n): TreatyMutationHook<TParams, TBody, TOption, TResponse> {\r\n  return (options) => {\r\n    const baseOptions = useOptions?.() ?? {};\r\n    return useMutation({\r\n      ...mergeMutationOptions(baseOptions, options),\r\n      mutationFn: async (request) => {\r\n        // Handle optional params: if params exists, pass it; otherwise call fn() without args\r\n        const mutationFn =\r\n          \"params\" in request && request.params !== undefined\r\n            ? (fn as (params: TParams) => TreatyMutationFunction<TBody, TOption, TResponse>)(request.params)\r\n            : (fn as () => TreatyMutationFunction<TBody, TOption, TResponse>)();\r\n        \r\n        // Handle optional body: if body exists, pass it; otherwise pass undefined\r\n        const body = \"body\" in request && request.body !== undefined ? request.body : (undefined as TBody);\r\n        const { data, error } = await mutationFn(body, request);\r\n        if (error) throw error;\r\n        return data;\r\n      },\r\n    });\r\n  };\r\n}\r\n\r\ntype TreatyQueryFunction<\r\n  TOption extends object,\r\n  TResponse extends Record<number, unknown>,\r\n> = (options: TOption) => Promise<Treaty.TreatyResponse<TResponse>>;\r\n\r\ntype TreatyQueryFunctionFactory<\r\n  TParams,\r\n  TOption extends object,\r\n  TResponse extends Record<number, unknown>,\r\n> = IsEmpty<TParams> extends true\r\n  ? () => TreatyQueryFunction<TOption, TResponse>\r\n  : (params: TParams) => TreatyQueryFunction<TOption, TResponse>;\r\n\r\ntype TreatyQueryRequest<\r\n  TParams,\r\n  TOption extends object,\r\n> = TOption &\r\n  (IsEmpty<TParams> extends true ? {} : { params: TParams });\r\n\r\ntype TreatyQueryOptions<TResponse extends Record<number, unknown>> =\r\n  UseQueryOptions<TreatyData<TResponse>, TreatyError<TResponse>>;\r\n\r\ntype TreatyQueryHook<\r\n  TParams,\r\n  TOption extends object,\r\n  TResponse extends Record<number, unknown>,\r\n> = (\r\n  request: TreatyQueryRequest<TParams, TOption>,\r\n  options?: Omit<TreatyQueryOptions<TResponse>, \"queryKey\" | \"queryFn\">,\r\n) => UseQueryResult<TreatyData<TResponse>, TreatyError<TResponse>>;\r\n\r\nexport function treatyQueryHook<\r\n  TParams,\r\n  TOption extends object,\r\n  TResponse extends Record<number, unknown>,\r\n>(\r\n  fn: TreatyQueryFunctionFactory<TParams, TOption, TResponse>,\r\n  useOptions: (\r\n    request: TreatyQueryRequest<TParams, TOption>,\r\n  ) => Omit<TreatyQueryOptions<TResponse>, \"queryFn\">,\r\n): TreatyQueryHook<TParams, TOption, TResponse> {\r\n  return (request, options) => {\r\n    // Handle optional params: if params exists, pass it; otherwise call fn() without args\r\n    const queryFn =\r\n      \"params\" in request && request.params !== undefined\r\n        ? (fn as (params: TParams) => TreatyQueryFunction<TOption, TResponse>)(request.params)\r\n        : (fn as () => TreatyQueryFunction<TOption, TResponse>)();\r\n    const baseOptions = useOptions(request);\r\n    return useQuery({\r\n      ...options,\r\n      ...baseOptions,\r\n      queryFn: async () => {\r\n        const { data, error } = await queryFn(request);\r\n        if (error) throw error;\r\n        return data;\r\n      },\r\n    });\r\n  };\r\n}\r\n",
    "import type {\r\n  QueryKey,\r\n  UseMutationOptions,\r\n  UseQueryOptions,\r\n} from \"@tanstack/react-query\";\r\n\r\nexport function mergeMutationOptions<TData, TError, TVariables, TContext>(\r\n  base: UseMutationOptions<TData, TError, TVariables, TContext>,\r\n  options?: Partial<UseMutationOptions<TData, TError, TVariables, TContext>>,\r\n): UseMutationOptions<TData, TError, TVariables, TContext> {\r\n  if (!options) return base;\r\n  const { onSuccess, onError, onSettled, onMutate, ...rest } = options;\r\n  return {\r\n    ...base,\r\n    ...rest,\r\n    ...(onMutate !== undefined && {\r\n      onMutate: async (variables, context) => {\r\n        const prev = await base.onMutate?.(variables, context);\r\n        const next = await options.onMutate?.(variables, context);\r\n        return (next !== undefined ? next : prev) as TContext;\r\n      },\r\n    }),\r\n    ...(onSuccess !== undefined && {\r\n      onSuccess: async (data, variables, onMutateResult, context) => {\r\n        await base.onSuccess?.(data, variables, onMutateResult, context);\r\n        await options.onSuccess?.(data, variables, onMutateResult, context);\r\n      },\r\n    }),\r\n    ...(onError !== undefined && {\r\n      onError: async (error, variables, onMutateResult, context) => {\r\n        await base.onError?.(error, variables, onMutateResult, context);\r\n        await options.onError?.(error, variables, onMutateResult, context);\r\n      },\r\n    }),\r\n    ...(onSettled !== undefined && {\r\n      onSettled: async (data, error, variables, onMutateResult, context) => {\r\n        await base.onSettled?.(data, error, variables, onMutateResult, context);\r\n        await options.onSettled?.(\r\n          data,\r\n          error,\r\n          variables,\r\n          onMutateResult,\r\n          context,\r\n        );\r\n      },\r\n    }),\r\n  };\r\n}\r\n"
  ],
  "mappings": ";AACA;AAAA;AAAA;AAAA;;;ACKO,SAAS,oBAAyD,CACvE,MACA,SACyD;AAAA,EACzD,IAAI,CAAC;AAAA,IAAS,OAAO;AAAA,EACrB,QAAQ,WAAW,SAAS,WAAW,aAAa,SAAS;AAAA,EAC7D,OAAO;AAAA,OACF;AAAA,OACA;AAAA,OACC,aAAa,aAAa;AAAA,MAC5B,UAAU,OAAO,WAAW,YAAY;AAAA,QACtC,MAAM,OAAO,MAAM,KAAK,WAAW,WAAW,OAAO;AAAA,QACrD,MAAM,OAAO,MAAM,QAAQ,WAAW,WAAW,OAAO;AAAA,QACxD,OAAQ,SAAS,YAAY,OAAO;AAAA;AAAA,IAExC;AAAA,OACI,cAAc,aAAa;AAAA,MAC7B,WAAW,OAAO,MAAM,WAAW,gBAAgB,YAAY;AAAA,QAC7D,MAAM,KAAK,YAAY,MAAM,WAAW,gBAAgB,OAAO;AAAA,QAC/D,MAAM,QAAQ,YAAY,MAAM,WAAW,gBAAgB,OAAO;AAAA;AAAA,IAEtE;AAAA,OACI,YAAY,aAAa;AAAA,MAC3B,SAAS,OAAO,OAAO,WAAW,gBAAgB,YAAY;AAAA,QAC5D,MAAM,KAAK,UAAU,OAAO,WAAW,gBAAgB,OAAO;AAAA,QAC9D,MAAM,QAAQ,UAAU,OAAO,WAAW,gBAAgB,OAAO;AAAA;AAAA,IAErE;AAAA,OACI,cAAc,aAAa;AAAA,MAC7B,WAAW,OAAO,MAAM,OAAO,WAAW,gBAAgB,YAAY;AAAA,QACpE,MAAM,KAAK,YAAY,MAAM,OAAO,WAAW,gBAAgB,OAAO;AAAA,QACtE,MAAM,QAAQ,YACZ,MACA,OACA,WACA,gBACA,OACF;AAAA;AAAA,IAEJ;AAAA,EACF;AAAA;;;ADsCK,SAAS,kBAKf,CACC,IACA,YAIwD;AAAA,EACxD,OAAO,CAAC,YAAY;AAAA,IAClB,MAAM,cAAc,aAAa,KAAK,CAAC;AAAA,IACvC,OAAO,YAAY;AAAA,SACd,qBAAqB,aAAa,OAAO;AAAA,MAC5C,YAAY,OAAO,YAAY;AAAA,QAE7B,MAAM,aACJ,YAAY,WAAW,QAAQ,WAAW,YACrC,GAA8E,QAAQ,MAAM,IAC5F,GAA+D;AAAA,QAGtE,MAAM,OAAO,UAAU,WAAW,QAAQ,SAAS,YAAY,QAAQ,OAAQ;AAAA,QAC/E,QAAQ,MAAM,UAAU,MAAM,WAAW,MAAM,OAAO;AAAA,QACtD,IAAI;AAAA,UAAO,MAAM;AAAA,QACjB,OAAO;AAAA;AAAA,IAEX,CAAC;AAAA;AAAA;AAmCE,SAAS,eAIf,CACC,IACA,YAG8C;AAAA,EAC9C,OAAO,CAAC,SAAS,YAAY;AAAA,IAE3B,MAAM,UACJ,YAAY,WAAW,QAAQ,WAAW,YACrC,GAAoE,QAAQ,MAAM,IAClF,GAAqD;AAAA,IAC5D,MAAM,cAAc,WAAW,OAAO;AAAA,IACtC,OAAO,SAAS;AAAA,SACX;AAAA,SACA;AAAA,MACH,SAAS,YAAY;AAAA,QACnB,QAAQ,MAAM,UAAU,MAAM,QAAQ,OAAO;AAAA,QAC7C,IAAI;AAAA,UAAO,MAAM;AAAA,QACjB,OAAO;AAAA;AAAA,IAEX,CAAC;AAAA;AAAA;",
  "debugId": "89C48BF36DA4F8BA64756E2164756E21",
  "names": []
}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "eden2query",
   "description": "Type-safe Eden Treaty to React Query helpers",
-  "version": "0.3.6",
+  "version": "0.3.8",
   "type": "module",
   "files": [
     "dist"