@barandurakk/query-api-router 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Baran Durak
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,439 @@
+# Query API Router
+Type-safe endpoint definitions on top of TanStack Query for clean, reusable, low-boilerplate data hooks.
+
+Build API “routers” once, then use consistent `useQuery`, `useMutation`, `useSuspenseQuery`, `useInfiniteQuery`, `getKey`, and `getOptions` everywhere.
+
+## Why This Exists
+
+TanStack Query is powerful, but large apps often drift into:
+
+- Repeated query key strings
+- Repeated `queryFn` wiring
+- Inconsistent invalidation logic
+- Loader/prefetch code that duplicates component query logic
+- Hard-to-find endpoint behavior and defaults
+
+`Query API Router` solves this by making endpoint definitions the single source of truth.
+
+You define each endpoint once, and get:
+
+- Reusable hooks
+- Centralized keys
+- Reusable query options for loaders/prefetch/fetchQuery
+- Built-in mutation-driven invalidation
+- Strong TypeScript inference
+
+## Key Features
+
+- Endpoint router pattern: organize by domain (`users`, `orders`, `attachments`, etc.)
+- Typed query/mutation/infinite-query definitions
+- Generated hook API per endpoint
+- `getKey()` for stable key access and manual invalidation
+- `getOptions()` for `ensureQueryData`, `fetchQuery`, `useQueries`, and non-React usage
+- TanStack `QueryFunctionContext` access for cancellation, metadata, keys, and the active client
+- Automatic invalidation via `invalidateQueries` callback on mutations
+- Layered defaults:
+  - API-level defaults
+  - Endpoint-level defaults
+  - Call-site overrides
+- Transport-agnostic (Axios, fetch, GraphQL client, anything async)
+
+## Installation
+
+```bash
+pnpm add @barandurakk/query-api-router @tanstack/react-query react
+```
+
+## Compatibility
+
+- TanStack React Query: `>=5.90.18 <6`
+- React: `>=18`
+- Package format: ESM
+
+CI verifies the library on maintained Node.js releases and tests the packed artifact against both the exact minimum peer versions and the latest compatible TanStack Query v5/React release. The compatibility matrix also runs weekly so newly published compatible peer versions are exercised even when this repository has no new commits.
+
+## Quick Start
+
+### 1) Create QueryClient
+
+```ts
+import { QueryClient } from '@tanstack/react-query';
+
+export const queryClient = new QueryClient({
+  defaultOptions: {
+    queries: {
+      retry: 2,
+      refetchOnWindowFocus: false,
+    },
+  },
+});
+```
+
+Pass this client to `QueryClientProvider` as usual. Generated mutations use that active client for invalidation unless the router explicitly supplies a different client.
+
+### 2) Define an API router
+
+```ts
+import type { QueryKey } from '@tanstack/react-query';
+import api from '@barandurakk/query-api-router';
+import { apiClient } from './http'; // axios/fetch wrapper
+
+type ApiError = unknown;
+type UserProfile = { id: string; email: string; language: string };
+type Response<T> = { data: T; success: boolean; message: string };
+
+// The invalidation callback receives this explicit router contract. This keeps
+// endpoint names and state arguments type-safe without changing endpoint syntax.
+type UsersInvalidationApi = {
+  getKey: () => QueryKey;
+  getProfile: {
+    getKey: () => QueryKey;
+  };
+};
+
+export const usersApi = api(
+  'users',
+  {
+    getProfile: api.query<Response<UserProfile>, void, ApiError>({
+      queryFn: async () => (await apiClient.get('/users/profile')).data,
+    }),
+
+    updateLanguage: api.mutation<
+      Response<{ language: string }>,
+      { language: string },
+      ApiError,
+      UsersInvalidationApi
+    >({
+      mutationFn: async (body) => (await apiClient.put('/users/profile/language', body)).data,
+      invalidateQueries: (router) => [router.getProfile.getKey()],
+    }),
+  },
+  {
+    queryOptions: {
+      staleTime: 60_000,
+    },
+  }
+);
+```
+
+### 3) Use in components
+
+```tsx
+function ProfileSection() {
+  const { data, isLoading } = usersApi.getProfile.useQuery();
+  const { mutateAsync: updateLanguage, isPending } = usersApi.updateLanguage.useMutation();
+
+  if (isLoading) return <div>Loading...</div>;
+
+  return (
+    <button
+      disabled={isPending}
+      onClick={() => updateLanguage({ language: 'ru' })}
+    >
+      Current language: {data?.data.language}
+    </button>
+  );
+}
+```
+
+## Core Concepts
+
+## 1) API Router
+
+`api(baseKey, endpoints, defaults?)`
+
+- `baseKey` becomes the root query key namespace (example: `'orders'`)
+- `endpoints` is an object of `query`, `mutation`, `infiniteQuery`
+- `defaults` can inject:
+  - `queryClient` (optional explicit invalidation-client override)
+  - shared `queryOptions`
+  - shared `mutationOptions`
+
+Mutation invalidation uses the `QueryClient` from the active mutation context by default. Supply `queryClient` only when invalidation intentionally needs to target a different client.
+
+Shared defaults use TanStack Query's default-option contracts, so misspelled or unsupported option names fail TypeScript checks.
+
+## 2) Endpoint Definition Types
+
+- `api.query({ queryFn, options? })`
+- `api.mutation({ mutationFn, options?, invalidateQueries? })`
+- `api.infiniteQuery({ queryFn, options })`
+
+## 3) Generated Endpoint API
+
+For a `query` endpoint:
+
+- `useQuery(state?, options?)`
+- `useSuspenseQuery(state?, options?)`
+- `getKey(state?)`
+- `getOptions(state?)`
+
+For a `mutation` endpoint:
+
+- `useMutation(options?)`
+- `getKey()`
+
+For an `infiniteQuery` endpoint:
+
+- `useInfiniteQuery(state?, options?)`
+- `getKey(state?)`
+- `getOptions(state?)`
+
+## 4) Automatic Invalidation
+
+Mutations can invalidate related queries centrally:
+
+```ts
+type OrdersInvalidationApi = {
+  getKey: () => QueryKey;
+  list: { getKey: () => QueryKey };
+  myOrders: { getKey: () => QueryKey };
+  getById: { getKey: (state: { orderId: string }) => QueryKey };
+};
+
+createOrder: api.mutation<
+  Response<Order>,
+  { body: CreateOrder },
+  ApiError,
+  OrdersInvalidationApi
+>({
+  mutationFn: async ({ body }) => (await apiClient.post('/orders', body)).data,
+  invalidateQueries: (router, variables, result, onMutateResult, context) => [
+    router.list.getKey(),
+    router.myOrders.getKey(),
+    router.getById.getKey({ orderId: result.data.id }),
+  ],
+});
+```
+
+This removes invalidation duplication from components.
+
+## 5) Option Layering (important)
+
+Final options are merged in this order:
+
+1. API defaults
+2. Endpoint options
+3. Call-site options
+
+This gives global consistency with local flexibility.
+
+Call sites may intentionally override a generated query key:
+
+```ts
+const query = usersApi.getProfile.useQuery(undefined, {
+  queryKey: ['users', 'profile', 'embedded-view'],
+});
+```
+
+`getKey()` still returns the canonical endpoint key. When a call site uses a different key, that call site owns invalidation of the alternate key.
+
+## Real Usage Patterns
+
+## Pattern: Router Loaders / Prefetch
+
+Use the exact same endpoint definition in route loaders:
+
+```ts
+await queryClient.ensureQueryData(
+  ordersApi.getById.getOptions({ orderId })
+);
+```
+
+No duplicate keys. No duplicate fetch logic.
+
+## Pattern: Suspense
+
+```tsx
+const { data } = ordersApi.getById.useSuspenseQuery({ orderId });
+```
+
+## Pattern: Query cancellation and context
+
+Standard query functions receive state first and TanStack's `QueryFunctionContext` second:
+
+```ts
+download: api.query<Blob, { documentId: string }, ApiError>({
+  queryFn: async ({ documentId }, { signal }) => {
+    const response = await fetch(`/documents/${documentId}`, { signal });
+    return response.blob();
+  },
+});
+```
+
+Existing query functions that only need state may omit the second parameter.
+
+## Pattern: `useQueries` composition
+
+```ts
+const results = useQueries({
+  queries: [
+    ordersApi.myOrders.getOptions({ page: 1, limit: 100 }),
+    ticketApi.myTickets.getOptions({ page: 1, limit: 100 }),
+    usersApi.getProfile.getOptions(),
+  ],
+});
+```
+
+## Pattern: Dynamic endpoint selection
+
+When context decides which endpoint to call, compose with `getOptions()`:
+
+```ts
+const options =
+  context === 'invoice'
+    ? invoicesApi.getDownloadUrl.getOptions({ invoiceId: id })
+    : attachmentsApi.getDownloadUrl.getOptions({ attachmentId: id });
+
+const result = await queryClient.fetchQuery({ ...options, staleTime: 0 });
+```
+
+## Pattern: Infinite query endpoint definition
+
+```ts
+const addressesApi = api(
+  'addresses',
+  {
+    infiniteList: api.infiniteQuery<Paginated<Address[]>, void, number, ApiError>({
+      queryFn: async (_state, { pageParam }) =>
+        (await apiClient.get(`/account/addresses?page=${pageParam}&limit=10`)).data,
+      options: {
+        initialPageParam: 1,
+        getNextPageParam: (lastPage) =>
+          lastPage.pagination.totalPages > lastPage.pagination.page
+            ? lastPage.pagination.page + 1
+            : undefined,
+      },
+    }),
+  },
+);
+```
+
+Usage:
+
+```tsx
+const listQuery = addressesApi.infiniteList.useInfiniteQuery();
+```
+
+Required pagination behavior lives with the endpoint so `getOptions()` is also complete. Components can still provide partial overrides as the second argument.
+
+## Pattern: Manual invalidation when needed
+
+You still have full QueryClient control:
+
+```ts
+await queryClient.invalidateQueries({
+  queryKey: ordersApi.getById.getKey({ orderId }),
+});
+```
+
+## API Reference
+
+## `api(baseKey, endpoints, defaultOptions?)`
+
+- `baseKey: string`
+- `endpoints: Record<string, EndpointDefinition>`
+- `defaultOptions?: { queryClient?: QueryClient; queryOptions?: ApiQueryOptions; mutationOptions?: ApiMutationOptions }`
+
+Returns an API instance with:
+
+- `getKey(): QueryKey` for base namespace
+- endpoint objects with generated helpers/hooks
+
+## `api.query<TQueryFnData, TState, TError, TData = TQueryFnData>(definition)`
+
+`definition`:
+
+- `queryFn: (state: TState, context: QueryFunctionContext) => Promise<TQueryFnData>`
+- `options?: UseQueryOptions without queryKey/queryFn`
+
+## `api.mutation<TData, TVariables, TError, TApi, TOnMutateResult>(definition)`
+
+`definition`:
+
+- `mutationFn: (variables: TVariables) => Promise<TData>`
+- `options?: UseMutationOptions without mutationFn`
+- `invalidateQueries?: (api, variables, data, onMutateResult, context) => Array<QueryKey | InvalidateQueryFilters>`
+
+`TApi` is an explicit router contract for invalidation callbacks. Query state, results, hook options, and mutation values remain inferred from their endpoint definitions.
+
+## `api.infiniteQuery<TQueryFnData, TState, TPageParam, TError, TData = InfiniteData<TQueryFnData, TPageParam>>(definition)`
+
+`definition`:
+
+- `queryFn: (state: TState, ctx: QueryFunctionContext) => Promise<TQueryFnData>`
+- `options: UseInfiniteQueryOptions without queryKey/queryFn`
+
+`options` must include `initialPageParam` and `getNextPageParam`. This guarantees that both the generated hook and `getOptions()` are valid TanStack infinite-query configurations.
+
+## Why Teams Like It
+
+- Less boilerplate than raw hooks per endpoint
+- Better consistency across large codebases
+- Easy discoverability: “all order endpoints are in `ordersApi`”
+- Shared patterns for components, loaders, and utilities
+- Safer refactors with central key ownership
+- Easy onboarding for new team members
+
+## Before vs After
+
+Raw React Query style:
+
+```ts
+useQuery({
+  queryKey: ['orders', 'getById', { orderId }],
+  queryFn: () => apiClient.get(`/orders/${orderId}`).then((r) => r.data),
+});
+```
+
+With Query API Router:
+
+```ts
+ordersApi.getById.useQuery({ orderId });
+```
+
+And for loaders:
+
+```ts
+await queryClient.ensureQueryData(ordersApi.getById.getOptions({ orderId }));
+```
+
+One endpoint definition, reused everywhere.
+
+## Best Practices
+
+- Keep one router per domain (`usersApi`, `ordersApi`, `ticketApi`)
+- Use descriptive endpoint names (`getById`, `list`, `update`, `activate`)
+- Keep `state` objects serializable and stable
+- Put cache policy (`staleTime`, `gcTime`, polling) at endpoint level
+- Prefer mutation `invalidateQueries` over scattered component invalidation
+- Use `getOptions()` for non-hook contexts (loaders, utility flows, background tasks)
+- Use API-level defaults for cross-cutting behavior (retry/error handling)
+
+## FAQ
+
+## Does this replace TanStack Query?
+
+No. It is a structured layer on top of TanStack Query.
+
+## Can I still use QueryClient directly?
+
+Yes. Fully compatible. `getKey()` and `getOptions()` are designed for that.
+
+## Can I use it without Axios?
+
+Yes. Axios is not a dependency or peer dependency. Any async client works, and applications define their own error types.
+
+## Does it support Suspense and Infinite Query?
+
+Yes. `useSuspenseQuery` and `useInfiniteQuery` are first-class.
+
+## Is this good for large apps?
+
+Yes, that is the primary use case.
+
+## Package and License
+
+The package publishes ESM JavaScript, TypeScript declarations, declaration maps, runtime source maps, and their TypeScript sources. Runtime maps embed their source content, while declaration maps resolve to the shipped `src/` tree. This keeps debugging and editor navigation working from the installed package; the export map still prevents unsupported source-level imports.
+
+Query API Router is available under the [MIT License](./LICENSE).

package/dist/api.d.ts

@@ -0,0 +1,10 @@
+import type { InfiniteData } from '@tanstack/react-query';
+import { AnyEndpointDefinition, ApiInstance, ApiOptions, InfiniteQueryEndpointDefinition, InfiniteQueryEndpointOptions, InvalidationApi, MutationEndpointDefinition, MutationEndpointOptions, QueryEndpointDefinition, QueryEndpointOptions } from './types.js';
+declare const api: {
+    <TBaseKey extends string, TEndpoints extends Record<string, AnyEndpointDefinition>>(baseKey: TBaseKey, endpoints: TEndpoints, defaultOptions?: ApiOptions): ApiInstance<TBaseKey, TEndpoints>;
+    query<TQueryFnData = unknown, TState = void, TError = unknown, TData = TQueryFnData>(definition: QueryEndpointOptions<TQueryFnData, TState, TData, TError>): QueryEndpointDefinition<TQueryFnData, TState, TData, TError>;
+    infiniteQuery<TQueryFnData = unknown, TState = void, TPageParam = unknown, TError = unknown, TData = InfiniteData<TQueryFnData, TPageParam>>(definition: InfiniteQueryEndpointOptions<TQueryFnData, TState, TPageParam, TError, TData>): InfiniteQueryEndpointDefinition<TQueryFnData, TState, TPageParam, TData, TError>;
+    mutation<TData = unknown, TState = unknown, TError = unknown, TApi = InvalidationApi, TOnMutateResult = unknown>(definition: MutationEndpointOptions<TData, TState, TError, TApi, TOnMutateResult>): MutationEndpointDefinition<TData, TState, TError, TApi, TOnMutateResult>;
+};
+export default api;
+//# sourceMappingURL=api.d.ts.map

package/dist/api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api.d.ts","sourceRoot":"","sources":["../src/api.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAkC,MAAM,uBAAuB,CAAC;AAE1F,OAAO,EACH,qBAAqB,EACrB,WAAW,EACX,UAAU,EACV,+BAA+B,EAC/B,4BAA4B,EAC5B,eAAe,EACf,0BAA0B,EAC1B,uBAAuB,EACvB,uBAAuB,EACvB,oBAAoB,EACvB,MAAM,YAAY,CAAC;AAIpB,QAAA,MAAM,GAAG;KAAI,QAAQ,SAAS,MAAM,EAAE,UAAU,SAAS,MAAM,CAAC,MAAM,EAAE,qBAAqB,CAAC,WACjF,QAAQ,aACN,UAAU,mBACJ,UAAU,GAC5B,WAAW,CAAC,QAAQ,EAAE,UAAU,CAAC;UAwGvB,YAAY,YAAY,MAAM,SAAS,MAAM,YAAY,KAAK,6BAC3D,oBAAoB,CAAC,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,CAAC,GACtE,uBAAuB,CAAC,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,CAAC;kBAM3D,YAAY,YACZ,MAAM,SACN,UAAU,YACV,MAAM,YACN,KAAK,uDAEO,4BAA4B,CAAC,YAAY,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,KAAK,CAAC,GAC1F,+BAA+B,CAAC,YAAY,EAAE,MAAM,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,CAAC;aAKnE,KAAK,YAAY,MAAM,YAAY,MAAM,YAAY,IAAI,oBAAoB,eAAe,wBAC5F,uBAAuB,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,eAAe,CAAC,GAClF,0BAA0B,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,eAAe,CAAC;CAzB1E,CAAC;AA8BF,eAAe,GAAG,CAAC"}

package/dist/api.js

@@ -0,0 +1,115 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { useInfiniteQuery, useMutation, useQuery, useSuspenseQuery } from '@tanstack/react-query';
+import { createEndpointKey, handleMutationSuccess } from './internal.js';
+// --- API Builder ---
+const api = (baseKey, endpoints, defaultOptions) => {
+    const configuredQueryClient = defaultOptions?.queryClient;
+    const apiInstance = {
+        getKey: () => [baseKey],
+    };
+    for (const key in endpoints) {
+        const definition = endpoints[key];
+        if (definition.type === 'query') {
+            const queryDefinition = definition;
+            apiInstance[key] = {
+                getKey: (state) => createEndpointKey(baseKey, key, state),
+                useQuery: (state, options = {}) => {
+                    const queryKey = createEndpointKey(baseKey, key, state);
+                    return useQuery({
+                        queryKey,
+                        queryFn: (context) => queryDefinition.queryFn(state, context),
+                        ...defaultOptions?.queryOptions,
+                        ...queryDefinition.options,
+                        ...options,
+                    });
+                },
+                useSuspenseQuery: (state, options = {}) => {
+                    const queryKey = createEndpointKey(baseKey, key, state);
+                    return useSuspenseQuery({
+                        queryKey,
+                        queryFn: (context) => queryDefinition.queryFn(state, context),
+                        ...defaultOptions?.queryOptions,
+                        ...queryDefinition.options,
+                        ...options,
+                    });
+                },
+                getOptions: (state) => ({
+                    queryKey: createEndpointKey(baseKey, key, state),
+                    queryFn: (context) => queryDefinition.queryFn(state, context),
+                    ...defaultOptions?.queryOptions,
+                    ...queryDefinition.options,
+                }),
+            };
+        }
+        else if (definition.type === 'infiniteQuery') {
+            const queryDefinition = definition;
+            apiInstance[key] = {
+                getKey: (state) => createEndpointKey(baseKey, key, state),
+                useInfiniteQuery: (state, options = {}) => {
+                    const queryKey = createEndpointKey(baseKey, key, state);
+                    return useInfiniteQuery({
+                        queryKey,
+                        ...defaultOptions?.queryOptions,
+                        ...queryDefinition.options,
+                        ...options,
+                        queryFn: (context) => queryDefinition.queryFn(state, context),
+                    });
+                },
+                getOptions: (state) => ({
+                    queryKey: createEndpointKey(baseKey, key, state),
+                    queryFn: (context) => queryDefinition.queryFn(state, context),
+                    ...defaultOptions?.queryOptions,
+                    ...queryDefinition.options,
+                }),
+            };
+        }
+        else if (definition.type === 'mutation') {
+            const mutationDefinition = definition;
+            apiInstance[key] = {
+                getKey: () => [baseKey, key],
+                useMutation: (options = {}) => {
+                    const mutationKey = [baseKey, key];
+                    const defaultMutationOptions = defaultOptions?.mutationOptions;
+                    const endpointMutationOptions = mutationDefinition.options;
+                    return useMutation({
+                        mutationKey,
+                        mutationFn: mutationDefinition.mutationFn,
+                        ...defaultMutationOptions,
+                        ...endpointMutationOptions,
+                        ...options,
+                        onSuccess: async (data, variables, onMutateResult, context) => {
+                            await handleMutationSuccess({
+                                apiInstance,
+                                callSiteOnSuccess: options?.onSuccess,
+                                context,
+                                data,
+                                defaultOnSuccess: defaultMutationOptions?.onSuccess,
+                                endpointOnSuccess: endpointMutationOptions?.onSuccess,
+                                invalidateQueries: mutationDefinition.invalidateQueries,
+                                onMutateResult,
+                                queryClient: configuredQueryClient ?? context.client,
+                                variables,
+                            });
+                        },
+                    });
+                },
+            };
+        }
+    }
+    return apiInstance;
+};
+// --- Attach factory functions ---
+api.query = (definition) => ({
+    ...definition,
+    type: 'query',
+});
+api.infiniteQuery = (definition) => ({
+    ...definition,
+    type: 'infiniteQuery',
+});
+api.mutation = (definition) => ({
+    ...definition,
+    type: 'mutation',
+});
+export default api;
+//# sourceMappingURL=api.js.map

package/dist/api.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api.js","sourceRoot":"","sources":["../src/api.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { useInfiniteQuery, useMutation, useQuery, useSuspenseQuery } from '@tanstack/react-query';\nimport type { InfiniteData, QueryFunctionContext, QueryKey } from '@tanstack/react-query';\n\nimport {\n    AnyEndpointDefinition,\n    ApiInstance,\n    ApiOptions,\n    InfiniteQueryEndpointDefinition,\n    InfiniteQueryEndpointOptions,\n    InvalidationApi,\n    MutationEndpointDefinition,\n    MutationEndpointOptions,\n    QueryEndpointDefinition,\n    QueryEndpointOptions,\n} from './types.js';\nimport { createEndpointKey, handleMutationSuccess } from './internal.js';\n\n// --- API Builder ---\nconst api = <TBaseKey extends string, TEndpoints extends Record<string, AnyEndpointDefinition>>(\n    baseKey: TBaseKey,\n    endpoints: TEndpoints,\n    defaultOptions?: ApiOptions,\n): ApiInstance<TBaseKey, TEndpoints> => {\n    const configuredQueryClient = defaultOptions?.queryClient;\n\n    const apiInstance: Record<string, unknown> & { getKey: () => QueryKey } = {\n        getKey: () => [baseKey],\n    };\n\n    for (const key in endpoints) {\n        const definition = endpoints[key];\n\n        if (definition.type === 'query') {\n            const queryDefinition = definition as QueryEndpointDefinition<any, any, any, any>;\n\n            apiInstance[key] = {\n                getKey: (state: unknown) => createEndpointKey(baseKey, key, state),\n                useQuery: (state: unknown, options: any = {}) => {\n                    const queryKey = createEndpointKey(baseKey, key, state);\n                    return useQuery({\n                        queryKey,\n                        queryFn: (context) => queryDefinition.queryFn(state, context),\n                        ...defaultOptions?.queryOptions,\n                        ...queryDefinition.options,\n                        ...options,\n                    });\n                },\n                useSuspenseQuery: (state: unknown, options: any = {}) => {\n                    const queryKey = createEndpointKey(baseKey, key, state);\n                    return useSuspenseQuery({\n                        queryKey,\n                        queryFn: (context) => queryDefinition.queryFn(state, context),\n                        ...defaultOptions?.queryOptions,\n                        ...queryDefinition.options,\n                        ...options,\n                    });\n                },\n                getOptions: (state: unknown) => ({\n                    queryKey: createEndpointKey(baseKey, key, state),\n                    queryFn: (context: QueryFunctionContext<QueryKey>) => queryDefinition.queryFn(state, context),\n                    ...defaultOptions?.queryOptions,\n                    ...queryDefinition.options,\n                }),\n            };\n        } else if (definition.type === 'infiniteQuery') {\n            const queryDefinition = definition as InfiniteQueryEndpointDefinition<any, any, any, any, any>;\n\n            apiInstance[key] = {\n                getKey: (state: unknown) => createEndpointKey(baseKey, key, state),\n                useInfiniteQuery: (state: unknown, options: any = {}) => {\n                    const queryKey = createEndpointKey(baseKey, key, state);\n                    return useInfiniteQuery({\n                        queryKey,\n                        ...defaultOptions?.queryOptions,\n                        ...queryDefinition.options,\n                        ...options,\n                        queryFn: (context: QueryFunctionContext<QueryKey, unknown>) => queryDefinition.queryFn(state, context),\n                    });\n                },\n                getOptions: (state: unknown) => ({\n                    queryKey: createEndpointKey(baseKey, key, state),\n                    queryFn: (context: QueryFunctionContext<QueryKey, unknown>) => queryDefinition.queryFn(state, context),\n                    ...defaultOptions?.queryOptions,\n                    ...queryDefinition.options,\n                }),\n            };\n        } else if (definition.type === 'mutation') {\n            const mutationDefinition = definition as MutationEndpointDefinition<any, any, any, any, any>;\n\n            apiInstance[key] = {\n                getKey: () => [baseKey, key],\n                useMutation: (options: any = {}) => {\n                    const mutationKey = [baseKey, key];\n                    const defaultMutationOptions = defaultOptions?.mutationOptions;\n                    const endpointMutationOptions = mutationDefinition.options;\n\n                    return useMutation({\n                        mutationKey,\n                        mutationFn: mutationDefinition.mutationFn,\n                        ...defaultMutationOptions,\n                        ...endpointMutationOptions,\n                        ...options,\n                        onSuccess: async (data, variables, onMutateResult, context) => {\n                            await handleMutationSuccess({\n                                apiInstance,\n                                callSiteOnSuccess: options?.onSuccess,\n                                context,\n                                data,\n                                defaultOnSuccess: defaultMutationOptions?.onSuccess,\n                                endpointOnSuccess: endpointMutationOptions?.onSuccess,\n                                invalidateQueries: mutationDefinition.invalidateQueries,\n                                onMutateResult,\n                                queryClient: configuredQueryClient ?? context.client,\n                                variables,\n                            });\n                        },\n                    });\n                },\n            };\n        }\n    }\n\n    return apiInstance as ApiInstance<TBaseKey, TEndpoints>;\n};\n\n// --- Attach factory functions ---\napi.query = <TQueryFnData = unknown, TState = void, TError = unknown, TData = TQueryFnData>(\n    definition: QueryEndpointOptions<TQueryFnData, TState, TData, TError>,\n): QueryEndpointDefinition<TQueryFnData, TState, TData, TError> => ({\n    ...definition,\n    type: 'query',\n});\n\napi.infiniteQuery = <\n    TQueryFnData = unknown,\n    TState = void,\n    TPageParam = unknown,\n    TError = unknown,\n    TData = InfiniteData<TQueryFnData, TPageParam>,\n>(\n    definition: InfiniteQueryEndpointOptions<TQueryFnData, TState, TPageParam, TError, TData>,\n): InfiniteQueryEndpointDefinition<TQueryFnData, TState, TPageParam, TData, TError> => ({\n    ...definition,\n    type: 'infiniteQuery',\n});\n\napi.mutation = <TData = unknown, TState = unknown, TError = unknown, TApi = InvalidationApi, TOnMutateResult = unknown>(\n    definition: MutationEndpointOptions<TData, TState, TError, TApi, TOnMutateResult>,\n): MutationEndpointDefinition<TData, TState, TError, TApi, TOnMutateResult> => ({\n    ...definition,\n    type: 'mutation',\n});\n\nexport default api;\n"]}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { default } from './api.js';
+export * from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AACnC,cAAc,YAAY,CAAC"}

package/dist/index.js

@@ -0,0 +1,3 @@
+export { default } from './api.js';
+export * from './types.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AACnC,cAAc,YAAY,CAAC","sourcesContent":["export { default } from './api.js';\nexport * from './types.js';\n"]}

package/dist/internal.d.ts

@@ -0,0 +1,20 @@
+import type { InvalidateQueryFilters, MutationFunctionContext, QueryClient, QueryKey } from '@tanstack/react-query';
+export type InvalidateQueryTarget = QueryKey | InvalidateQueryFilters;
+export type MutationSuccessHandlerOptions<TApi, TData, TVariables, TOnMutateResult> = {
+    apiInstance: TApi;
+    callSiteOnSuccess?: MutationOnSuccess<TData, TVariables, TOnMutateResult>;
+    context: MutationFunctionContext;
+    data: TData;
+    defaultOnSuccess?: MutationOnSuccess<TData, TVariables, TOnMutateResult>;
+    endpointOnSuccess?: MutationOnSuccess<TData, TVariables, TOnMutateResult>;
+    invalidateQueries?: (api: TApi, variables: TVariables, data: TData, onMutateResult: TOnMutateResult, context: MutationFunctionContext) => readonly InvalidateQueryTarget[];
+    onMutateResult: TOnMutateResult;
+    queryClient: Pick<QueryClient, 'invalidateQueries'>;
+    variables: TVariables;
+};
+type MutationOnSuccess<TData, TVariables, TOnMutateResult> = (data: TData, variables: TVariables, onMutateResult: TOnMutateResult, context: MutationFunctionContext) => Promise<unknown> | unknown;
+export declare const createEndpointKey: (baseKey: string, endpointKey: string, state?: unknown) => QueryKey;
+export declare const normalizeInvalidateQueryTarget: (target: InvalidateQueryTarget) => InvalidateQueryFilters;
+export declare const handleMutationSuccess: <TApi, TData, TVariables, TOnMutateResult>({ apiInstance, callSiteOnSuccess, context, data, defaultOnSuccess, endpointOnSuccess, invalidateQueries, onMutateResult, queryClient, variables, }: MutationSuccessHandlerOptions<TApi, TData, TVariables, TOnMutateResult>) => Promise<void>;
+export {};
+//# sourceMappingURL=internal.d.ts.map

package/dist/internal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal.d.ts","sourceRoot":"","sources":["../src/internal.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,uBAAuB,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAEpH,MAAM,MAAM,qBAAqB,GAAG,QAAQ,GAAG,sBAAsB,CAAC;AAEtE,MAAM,MAAM,6BAA6B,CAAC,IAAI,EAAE,KAAK,EAAE,UAAU,EAAE,eAAe,IAAI;IAClF,WAAW,EAAE,IAAI,CAAC;IAClB,iBAAiB,CAAC,EAAE,iBAAiB,CAAC,KAAK,EAAE,UAAU,EAAE,eAAe,CAAC,CAAC;IAC1E,OAAO,EAAE,uBAAuB,CAAC;IACjC,IAAI,EAAE,KAAK,CAAC;IACZ,gBAAgB,CAAC,EAAE,iBAAiB,CAAC,KAAK,EAAE,UAAU,EAAE,eAAe,CAAC,CAAC;IACzE,iBAAiB,CAAC,EAAE,iBAAiB,CAAC,KAAK,EAAE,UAAU,EAAE,eAAe,CAAC,CAAC;IAC1E,iBAAiB,CAAC,EAAE,CAChB,GAAG,EAAE,IAAI,EACT,SAAS,EAAE,UAAU,EACrB,IAAI,EAAE,KAAK,EACX,cAAc,EAAE,eAAe,EAC/B,OAAO,EAAE,uBAAuB,KAC/B,SAAS,qBAAqB,EAAE,CAAC;IACtC,cAAc,EAAE,eAAe,CAAC;IAChC,WAAW,EAAE,IAAI,CAAC,WAAW,EAAE,mBAAmB,CAAC,CAAC;IACpD,SAAS,EAAE,UAAU,CAAC;CACzB,CAAC;AAEF,KAAK,iBAAiB,CAAC,KAAK,EAAE,UAAU,EAAE,eAAe,IAAI,CACzD,IAAI,EAAE,KAAK,EACX,SAAS,EAAE,UAAU,EACrB,cAAc,EAAE,eAAe,EAC/B,OAAO,EAAE,uBAAuB,KAC/B,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC;AAEhC,eAAO,MAAM,iBAAiB,GAAI,SAAS,MAAM,EAAE,aAAa,MAAM,EAAE,QAAQ,OAAO,KAAG,QAEzF,CAAC;AAEF,eAAO,MAAM,8BAA8B,GAAI,QAAQ,qBAAqB,KAAG,sBAE9E,CAAC;AAEF,eAAO,MAAM,qBAAqB,GAAU,IAAI,EAAE,KAAK,EAAE,UAAU,EAAE,eAAe,EAAE,oJAWnF,6BAA6B,CAAC,IAAI,EAAE,KAAK,EAAE,UAAU,EAAE,eAAe,CAAC,KAAG,OAAO,CAAC,IAAI,CAcxF,CAAC"}

package/dist/internal.js

@@ -0,0 +1,12 @@
+export const createEndpointKey = (baseKey, endpointKey, state) => (state === undefined ? [baseKey, endpointKey] : [baseKey, endpointKey, state]);
+export const normalizeInvalidateQueryTarget = (target) => (Array.isArray(target) ? { queryKey: target } : target);
+export const handleMutationSuccess = async ({ apiInstance, callSiteOnSuccess, context, data, defaultOnSuccess, endpointOnSuccess, invalidateQueries, onMutateResult, queryClient, variables, }) => {
+    if (invalidateQueries) {
+        const invalidationTargets = invalidateQueries(apiInstance, variables, data, onMutateResult, context);
+        await Promise.all(invalidationTargets.map((invalidationTarget) => (queryClient.invalidateQueries(normalizeInvalidateQueryTarget(invalidationTarget)))));
+    }
+    await defaultOnSuccess?.(data, variables, onMutateResult, context);
+    await endpointOnSuccess?.(data, variables, onMutateResult, context);
+    await callSiteOnSuccess?.(data, variables, onMutateResult, context);
+};
+//# sourceMappingURL=internal.js.map

package/dist/internal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal.js","sourceRoot":"","sources":["../src/internal.ts"],"names":[],"mappings":"AA8BA,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,OAAe,EAAE,WAAmB,EAAE,KAAe,EAAY,EAAE,CAAC,CAClG,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,CAAC,OAAO,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,EAAE,WAAW,EAAE,KAAK,CAAC,CAC/E,CAAC;AAEF,MAAM,CAAC,MAAM,8BAA8B,GAAG,CAAC,MAA6B,EAA0B,EAAE,CAAC,CACrG,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAkB,EAAE,CAAC,CAAC,CAAC,MAAgC,CAC9F,CAAC;AAEF,MAAM,CAAC,MAAM,qBAAqB,GAAG,KAAK,EAA4C,EAClF,WAAW,EACX,iBAAiB,EACjB,OAAO,EACP,IAAI,EACJ,gBAAgB,EAChB,iBAAiB,EACjB,iBAAiB,EACjB,cAAc,EACd,WAAW,EACX,SAAS,GAC6D,EAAiB,EAAE;IACzF,IAAI,iBAAiB,EAAE,CAAC;QACpB,MAAM,mBAAmB,GAAG,iBAAiB,CAAC,WAAW,EAAE,SAAS,EAAE,IAAI,EAAE,cAAc,EAAE,OAAO,CAAC,CAAC;QAErG,MAAM,OAAO,CAAC,GAAG,CACb,mBAAmB,CAAC,GAAG,CAAC,CAAC,kBAAkB,EAAE,EAAE,CAAC,CAC5C,WAAW,CAAC,iBAAiB,CAAC,8BAA8B,CAAC,kBAAkB,CAAC,CAAC,CACpF,CAAC,CACL,CAAC;IACN,CAAC;IAED,MAAM,gBAAgB,EAAE,CAAC,IAAI,EAAE,SAAS,EAAE,cAAc,EAAE,OAAO,CAAC,CAAC;IACnE,MAAM,iBAAiB,EAAE,CAAC,IAAI,EAAE,SAAS,EAAE,cAAc,EAAE,OAAO,CAAC,CAAC;IACpE,MAAM,iBAAiB,EAAE,CAAC,IAAI,EAAE,SAAS,EAAE,cAAc,EAAE,OAAO,CAAC,CAAC;AACxE,CAAC,CAAC","sourcesContent":["import type { InvalidateQueryFilters, MutationFunctionContext, QueryClient, QueryKey } from '@tanstack/react-query';\n\nexport type InvalidateQueryTarget = QueryKey | InvalidateQueryFilters;\n\nexport type MutationSuccessHandlerOptions<TApi, TData, TVariables, TOnMutateResult> = {\n    apiInstance: TApi;\n    callSiteOnSuccess?: MutationOnSuccess<TData, TVariables, TOnMutateResult>;\n    context: MutationFunctionContext;\n    data: TData;\n    defaultOnSuccess?: MutationOnSuccess<TData, TVariables, TOnMutateResult>;\n    endpointOnSuccess?: MutationOnSuccess<TData, TVariables, TOnMutateResult>;\n    invalidateQueries?: (\n        api: TApi,\n        variables: TVariables,\n        data: TData,\n        onMutateResult: TOnMutateResult,\n        context: MutationFunctionContext,\n    ) => readonly InvalidateQueryTarget[];\n    onMutateResult: TOnMutateResult;\n    queryClient: Pick<QueryClient, 'invalidateQueries'>;\n    variables: TVariables;\n};\n\ntype MutationOnSuccess<TData, TVariables, TOnMutateResult> = (\n    data: TData,\n    variables: TVariables,\n    onMutateResult: TOnMutateResult,\n    context: MutationFunctionContext,\n) => Promise<unknown> | unknown;\n\nexport const createEndpointKey = (baseKey: string, endpointKey: string, state?: unknown): QueryKey => (\n    state === undefined ? [baseKey, endpointKey] : [baseKey, endpointKey, state]\n);\n\nexport const normalizeInvalidateQueryTarget = (target: InvalidateQueryTarget): InvalidateQueryFilters => (\n    Array.isArray(target) ? { queryKey: target as QueryKey } : target as InvalidateQueryFilters\n);\n\nexport const handleMutationSuccess = async <TApi, TData, TVariables, TOnMutateResult>({\n    apiInstance,\n    callSiteOnSuccess,\n    context,\n    data,\n    defaultOnSuccess,\n    endpointOnSuccess,\n    invalidateQueries,\n    onMutateResult,\n    queryClient,\n    variables,\n}: MutationSuccessHandlerOptions<TApi, TData, TVariables, TOnMutateResult>): Promise<void> => {\n    if (invalidateQueries) {\n        const invalidationTargets = invalidateQueries(apiInstance, variables, data, onMutateResult, context);\n\n        await Promise.all(\n            invalidationTargets.map((invalidationTarget) => (\n                queryClient.invalidateQueries(normalizeInvalidateQueryTarget(invalidationTarget))\n            )),\n        );\n    }\n\n    await defaultOnSuccess?.(data, variables, onMutateResult, context);\n    await endpointOnSuccess?.(data, variables, onMutateResult, context);\n    await callSiteOnSuccess?.(data, variables, onMutateResult, context);\n};\n"]}

package/dist/types.d.ts

@@ -0,0 +1,68 @@
+import { DefaultOptions, InfiniteData, InvalidateQueryFilters, MutationFunction, MutationFunctionContext, MutationKey, QueryClient, QueryFunctionContext, QueryKey, UseInfiniteQueryOptions, UseInfiniteQueryResult, UseMutationOptions, UseMutationResult, UseQueryOptions, UseQueryResult, UseSuspenseQueryOptions, UseSuspenseQueryResult } from '@tanstack/react-query';
+export type QueryEndpointOptions<TQueryFnData = unknown, TState = void, TData = TQueryFnData, TError = unknown> = {
+    queryFn: (state: TState, context: QueryFunctionContext<QueryKey>) => Promise<TQueryFnData>;
+    options?: Omit<UseQueryOptions<TQueryFnData, TError, TData>, 'queryKey' | 'queryFn'>;
+};
+export type InfiniteQueryEndpointOptions<TQueryFnData = unknown, TState = void, TPageParam = unknown, TError = unknown, TData = InfiniteData<TQueryFnData, TPageParam>> = {
+    queryFn: (state: TState, context: QueryFunctionContext<QueryKey, TPageParam>) => Promise<TQueryFnData>;
+    options: Omit<UseInfiniteQueryOptions<TQueryFnData, TError, TData, QueryKey, TPageParam>, 'queryKey' | 'queryFn'>;
+};
+export type InvalidateQueryTarget = QueryKey | InvalidateQueryFilters;
+export type InvalidationApi = {
+    getKey: () => QueryKey;
+};
+export type MutationInvalidateQueries<TApi = InvalidationApi, TData = unknown, TState = unknown, TOnMutateResult = unknown> = (api: TApi, variables: TState, data: TData, onMutateResult: TOnMutateResult, context: MutationFunctionContext) => readonly InvalidateQueryTarget[];
+export type MutationEndpointOptions<TData = unknown, TState = unknown, TError = unknown, TApi = InvalidationApi, TOnMutateResult = unknown> = {
+    mutationFn: MutationFunction<TData, TState>;
+    options?: Omit<UseMutationOptions<TData, TError, TState, TOnMutateResult>, 'mutationFn'>;
+    invalidateQueries?: MutationInvalidateQueries<TApi, TData, TState, TOnMutateResult>;
+};
+export type QueryEndpointDefinition<TQueryFnData, TState, TData, TError> = QueryEndpointOptions<TQueryFnData, TState, TData, TError> & {
+    type: 'query';
+};
+export type InfiniteQueryEndpointDefinition<TQueryFnData, TState, TPageParam, TData, TError> = InfiniteQueryEndpointOptions<TQueryFnData, TState, TPageParam, TError, TData> & {
+    type: 'infiniteQuery';
+};
+export type MutationEndpointDefinition<TData = unknown, TState = unknown, TError = unknown, TApi = InvalidationApi, TOnMutateResult = unknown> = MutationEndpointOptions<TData, TState, TError, TApi, TOnMutateResult> & {
+    type: 'mutation';
+};
+export type AnyEndpointDefinition = QueryEndpointDefinition<any, any, any, any> | InfiniteQueryEndpointDefinition<any, any, any, any, any> | MutationEndpointDefinition<any, any, any, any, any>;
+export type ApiQueryOptions = NonNullable<DefaultOptions<unknown>['queries']> & {
+    queryKey?: QueryKey;
+};
+export type ApiMutationOptions = NonNullable<DefaultOptions<unknown>['mutations']>;
+export interface ApiOptions {
+    queryClient?: QueryClient;
+    queryOptions?: ApiQueryOptions;
+    mutationOptions?: ApiMutationOptions;
+}
+type MaybeStateArgs<TState> = undefined extends TState ? [state?: TState] : [state: TState];
+type StateAndOptionsArgs<TState, TOptions> = undefined extends TState ? [state?: TState, options?: TOptions] : [state: TState, options?: TOptions];
+type QueryCallSiteOptions<TQueryFnData, TError, TData> = Omit<UseQueryOptions<TQueryFnData, TError, TData, QueryKey>, 'queryKey' | 'queryFn'> & {
+    queryKey?: QueryKey;
+};
+type SuspenseQueryCallSiteOptions<TQueryFnData, TError, TData> = Omit<UseSuspenseQueryOptions<TQueryFnData, TError, TData, QueryKey>, 'queryKey' | 'queryFn'> & {
+    queryKey?: QueryKey;
+};
+type InfiniteQueryCallSiteOptions<TQueryFnData, TError, TData, TPageParam> = Partial<Omit<UseInfiniteQueryOptions<TQueryFnData, TError, TData, QueryKey, TPageParam>, 'queryKey' | 'queryFn'>> & {
+    queryKey?: QueryKey;
+};
+export type ApiInstance<_TBaseKey extends string, TEndpoints extends Record<string, AnyEndpointDefinition>> = {
+    getKey: () => QueryKey;
+} & {
+    [K in keyof TEndpoints]: K extends string ? TEndpoints[K] extends QueryEndpointDefinition<infer TQueryFnData, infer TState, infer TData, infer TError> ? {
+        getKey: (...args: MaybeStateArgs<TState>) => QueryKey;
+        getOptions: (...args: MaybeStateArgs<TState>) => UseQueryOptions<TQueryFnData, TError, TData, QueryKey>;
+        useQuery: <TQueryData = TData>(...args: StateAndOptionsArgs<TState, QueryCallSiteOptions<TQueryFnData, TError, TQueryData>>) => UseQueryResult<TQueryData, TError>;
+        useSuspenseQuery: <TSuspenseData = TData>(...args: StateAndOptionsArgs<TState, SuspenseQueryCallSiteOptions<TQueryFnData, TError, TSuspenseData>>) => UseSuspenseQueryResult<TSuspenseData, TError>;
+    } : TEndpoints[K] extends InfiniteQueryEndpointDefinition<infer TQueryFnData, infer TState, infer TPageParam, infer TData, infer TError> ? {
+        getKey: (...args: MaybeStateArgs<TState>) => QueryKey;
+        getOptions: (...args: MaybeStateArgs<TState>) => UseInfiniteQueryOptions<TQueryFnData, TError, TData, QueryKey, TPageParam>;
+        useInfiniteQuery: <TQueryData = TData>(...args: StateAndOptionsArgs<TState, InfiniteQueryCallSiteOptions<TQueryFnData, TError, TQueryData, TPageParam>>) => UseInfiniteQueryResult<TQueryData, TError>;
+    } : TEndpoints[K] extends MutationEndpointDefinition<infer TData, infer TState, infer TError, infer _TApi, infer TOnMutateResult> ? {
+        useMutation: (options?: Omit<UseMutationOptions<TData, TError, TState, TOnMutateResult>, 'mutationFn'>) => UseMutationResult<TData, TError, TState, TOnMutateResult>;
+        getKey: () => MutationKey;
+    } : never : never;
+};
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

package/dist/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"","sourcesContent":["import {\n    DefaultOptions,\n    InfiniteData,\n    InvalidateQueryFilters,\n    MutationFunction,\n    MutationFunctionContext,\n    MutationKey,\n    QueryClient,\n    QueryFunctionContext,\n    QueryKey,\n    UseInfiniteQueryOptions,\n    UseInfiniteQueryResult,\n    UseMutationOptions,\n    UseMutationResult,\n    UseQueryOptions,\n    UseQueryResult,\n    UseSuspenseQueryOptions,\n    UseSuspenseQueryResult,\n} from '@tanstack/react-query';\n\n// --- Core Types ---\nexport type QueryEndpointOptions<\n    TQueryFnData = unknown,\n    TState = void,\n    TData = TQueryFnData,\n    TError = unknown,\n> = {\n    queryFn: (state: TState, context: QueryFunctionContext<QueryKey>) => Promise<TQueryFnData>;\n    options?: Omit<UseQueryOptions<TQueryFnData, TError, TData>, 'queryKey' | 'queryFn'>;\n};\n\nexport type InfiniteQueryEndpointOptions<\n    TQueryFnData = unknown,\n    TState = void,\n    TPageParam = unknown,\n    TError = unknown,\n    TData = InfiniteData<TQueryFnData, TPageParam>,\n> = {\n    queryFn: (state: TState, context: QueryFunctionContext<QueryKey, TPageParam>) => Promise<TQueryFnData>;\n    options: Omit<UseInfiniteQueryOptions<TQueryFnData, TError, TData, QueryKey, TPageParam>, 'queryKey' | 'queryFn'>;\n};\n\nexport type InvalidateQueryTarget = QueryKey | InvalidateQueryFilters;\n\nexport type InvalidationApi = {\n    getKey: () => QueryKey;\n};\n\nexport type MutationInvalidateQueries<\n    TApi = InvalidationApi,\n    TData = unknown,\n    TState = unknown,\n    TOnMutateResult = unknown,\n> = (\n    api: TApi,\n    variables: TState,\n    data: TData,\n    onMutateResult: TOnMutateResult,\n    context: MutationFunctionContext,\n) => readonly InvalidateQueryTarget[];\n\nexport type MutationEndpointOptions<\n    TData = unknown,\n    TState = unknown,\n    TError = unknown,\n    TApi = InvalidationApi,\n    TOnMutateResult = unknown,\n> = {\n    mutationFn: MutationFunction<TData, TState>;\n    options?: Omit<UseMutationOptions<TData, TError, TState, TOnMutateResult>, 'mutationFn'>;\n    invalidateQueries?: MutationInvalidateQueries<TApi, TData, TState, TOnMutateResult>;\n};\n\nexport type QueryEndpointDefinition<TQueryFnData, TState, TData, TError> = QueryEndpointOptions<TQueryFnData, TState, TData, TError> & {\n    type: 'query';\n};\n\nexport type InfiniteQueryEndpointDefinition<TQueryFnData, TState, TPageParam, TData, TError> = InfiniteQueryEndpointOptions<\n    TQueryFnData,\n    TState,\n    TPageParam,\n    TError,\n    TData\n> & {\n    type: 'infiniteQuery';\n};\n\nexport type MutationEndpointDefinition<\n    TData = unknown,\n    TState = unknown,\n    TError = unknown,\n    TApi = InvalidationApi,\n    TOnMutateResult = unknown,\n> = MutationEndpointOptions<TData, TState, TError, TApi, TOnMutateResult> & {\n    type: 'mutation';\n};\n\nexport type AnyEndpointDefinition =\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    | QueryEndpointDefinition<any, any, any, any>\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    | InfiniteQueryEndpointDefinition<any, any, any, any, any>\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    | MutationEndpointDefinition<any, any, any, any, any>;\n\nexport type ApiQueryOptions = NonNullable<DefaultOptions<unknown>['queries']> & {\n    queryKey?: QueryKey;\n};\n\nexport type ApiMutationOptions = NonNullable<DefaultOptions<unknown>['mutations']>;\n\nexport interface ApiOptions {\n    queryClient?: QueryClient;\n    queryOptions?: ApiQueryOptions;\n    mutationOptions?: ApiMutationOptions;\n}\n\ntype MaybeStateArgs<TState> = undefined extends TState ? [state?: TState] : [state: TState];\n\ntype StateAndOptionsArgs<TState, TOptions> = undefined extends TState\n    ? [state?: TState, options?: TOptions]\n    : [state: TState, options?: TOptions];\n\ntype QueryCallSiteOptions<TQueryFnData, TError, TData> = Omit<\n    UseQueryOptions<TQueryFnData, TError, TData, QueryKey>,\n    'queryKey' | 'queryFn'\n> & {\n    queryKey?: QueryKey;\n};\n\ntype SuspenseQueryCallSiteOptions<TQueryFnData, TError, TData> = Omit<\n    UseSuspenseQueryOptions<TQueryFnData, TError, TData, QueryKey>,\n    'queryKey' | 'queryFn'\n> & {\n    queryKey?: QueryKey;\n};\n\ntype InfiniteQueryCallSiteOptions<TQueryFnData, TError, TData, TPageParam> = Partial<\n    Omit<UseInfiniteQueryOptions<TQueryFnData, TError, TData, QueryKey, TPageParam>, 'queryKey' | 'queryFn'>\n> & {\n    queryKey?: QueryKey;\n};\n\n// --- API Instance Type ---\nexport type ApiInstance<_TBaseKey extends string, TEndpoints extends Record<string, AnyEndpointDefinition>> = {\n    getKey: () => QueryKey;\n} & {\n    [K in keyof TEndpoints]: K extends string\n        ? TEndpoints[K] extends QueryEndpointDefinition<infer TQueryFnData, infer TState, infer TData, infer TError>\n            ? {\n                  getKey: (...args: MaybeStateArgs<TState>) => QueryKey;\n                  getOptions: (...args: MaybeStateArgs<TState>) => UseQueryOptions<TQueryFnData, TError, TData, QueryKey>;\n                  useQuery: <TQueryData = TData>(\n                      ...args: StateAndOptionsArgs<TState, QueryCallSiteOptions<TQueryFnData, TError, TQueryData>>\n                  ) => UseQueryResult<TQueryData, TError>;\n                  useSuspenseQuery: <TSuspenseData = TData>(\n                      ...args: StateAndOptionsArgs<\n                          TState,\n                          SuspenseQueryCallSiteOptions<TQueryFnData, TError, TSuspenseData>\n                      >\n                  ) => UseSuspenseQueryResult<TSuspenseData, TError>;\n              }\n            : TEndpoints[K] extends InfiniteQueryEndpointDefinition<infer TQueryFnData, infer TState, infer TPageParam, infer TData, infer TError>\n              ? {\n                    getKey: (...args: MaybeStateArgs<TState>) => QueryKey;\n                    getOptions: (...args: MaybeStateArgs<TState>) => UseInfiniteQueryOptions<TQueryFnData, TError, TData, QueryKey, TPageParam>;\n                    useInfiniteQuery: <TQueryData = TData>(\n                        ...args: StateAndOptionsArgs<\n                            TState,\n                            InfiniteQueryCallSiteOptions<TQueryFnData, TError, TQueryData, TPageParam>\n                        >\n                    ) => UseInfiniteQueryResult<TQueryData, TError>;\n                }\n              : TEndpoints[K] extends MutationEndpointDefinition<infer TData, infer TState, infer TError, infer _TApi, infer TOnMutateResult>\n                ? {\n                      useMutation: (\n                          options?: Omit<UseMutationOptions<TData, TError, TState, TOnMutateResult>, 'mutationFn'>\n                      ) => UseMutationResult<TData, TError, TState, TOnMutateResult>;\n                      getKey: () => MutationKey;\n                  }\n                : never\n        : never;\n};\n"]}

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@barandurakk/query-api-router",
+  "version": "0.1.0",
+  "description": "Type-safe endpoint router helpers for TanStack Query.",
+  "keywords": [
+    "tanstack-query",
+    "react-query",
+    "typescript",
+    "query-keys",
+    "data-fetching"
+  ],
+  "homepage": "https://github.com/barandurakk/query-api-router#readme",
+  "bugs": {
+    "url": "https://github.com/barandurakk/query-api-router/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/barandurakk/query-api-router.git"
+  },
+  "license": "MIT",
+  "author": {
+    "name": "Baran Durak",
+    "url": "https://github.com/barandurakk"
+  },
+  "type": "module",
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "packageManager": "pnpm@10.18.2",
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "test": "pnpm run build && node --test tests/*.test.mjs",
+    "test:consumer": "node scripts/test-packed-consumer.mjs",
+    "type-check": "tsc -p tsconfig.json --noEmit && tsc -p tsconfig.type-tests.json --noEmit",
+    "verify": "pnpm run type-check && pnpm test",
+    "prepack": "pnpm run verify"
+  },
+  "peerDependencies": {
+    "@tanstack/react-query": "^5.90.18",
+    "react": ">=18.0.0 || >=19.0.0"
+  },
+  "devDependencies": {
+    "@tanstack/react-query": "^5.90.18",
+    "@types/react": "^19.2.8",
+    "@types/react-test-renderer": "^19.1.0",
+    "react": "^19.2.3",
+    "react-test-renderer": "^19.2.7",
+    "typescript": "^5.9.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/api.ts

@@ -0,0 +1,155 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { useInfiniteQuery, useMutation, useQuery, useSuspenseQuery } from '@tanstack/react-query';
+import type { InfiniteData, QueryFunctionContext, QueryKey } from '@tanstack/react-query';
+
+import {
+    AnyEndpointDefinition,
+    ApiInstance,
+    ApiOptions,
+    InfiniteQueryEndpointDefinition,
+    InfiniteQueryEndpointOptions,
+    InvalidationApi,
+    MutationEndpointDefinition,
+    MutationEndpointOptions,
+    QueryEndpointDefinition,
+    QueryEndpointOptions,
+} from './types.js';
+import { createEndpointKey, handleMutationSuccess } from './internal.js';
+
+// --- API Builder ---
+const api = <TBaseKey extends string, TEndpoints extends Record<string, AnyEndpointDefinition>>(
+    baseKey: TBaseKey,
+    endpoints: TEndpoints,
+    defaultOptions?: ApiOptions,
+): ApiInstance<TBaseKey, TEndpoints> => {
+    const configuredQueryClient = defaultOptions?.queryClient;
+
+    const apiInstance: Record<string, unknown> & { getKey: () => QueryKey } = {
+        getKey: () => [baseKey],
+    };
+
+    for (const key in endpoints) {
+        const definition = endpoints[key];
+
+        if (definition.type === 'query') {
+            const queryDefinition = definition as QueryEndpointDefinition<any, any, any, any>;
+
+            apiInstance[key] = {
+                getKey: (state: unknown) => createEndpointKey(baseKey, key, state),
+                useQuery: (state: unknown, options: any = {}) => {
+                    const queryKey = createEndpointKey(baseKey, key, state);
+                    return useQuery({
+                        queryKey,
+                        queryFn: (context) => queryDefinition.queryFn(state, context),
+                        ...defaultOptions?.queryOptions,
+                        ...queryDefinition.options,
+                        ...options,
+                    });
+                },
+                useSuspenseQuery: (state: unknown, options: any = {}) => {
+                    const queryKey = createEndpointKey(baseKey, key, state);
+                    return useSuspenseQuery({
+                        queryKey,
+                        queryFn: (context) => queryDefinition.queryFn(state, context),
+                        ...defaultOptions?.queryOptions,
+                        ...queryDefinition.options,
+                        ...options,
+                    });
+                },
+                getOptions: (state: unknown) => ({
+                    queryKey: createEndpointKey(baseKey, key, state),
+                    queryFn: (context: QueryFunctionContext<QueryKey>) => queryDefinition.queryFn(state, context),
+                    ...defaultOptions?.queryOptions,
+                    ...queryDefinition.options,
+                }),
+            };
+        } else if (definition.type === 'infiniteQuery') {
+            const queryDefinition = definition as InfiniteQueryEndpointDefinition<any, any, any, any, any>;
+
+            apiInstance[key] = {
+                getKey: (state: unknown) => createEndpointKey(baseKey, key, state),
+                useInfiniteQuery: (state: unknown, options: any = {}) => {
+                    const queryKey = createEndpointKey(baseKey, key, state);
+                    return useInfiniteQuery({
+                        queryKey,
+                        ...defaultOptions?.queryOptions,
+                        ...queryDefinition.options,
+                        ...options,
+                        queryFn: (context: QueryFunctionContext<QueryKey, unknown>) => queryDefinition.queryFn(state, context),
+                    });
+                },
+                getOptions: (state: unknown) => ({
+                    queryKey: createEndpointKey(baseKey, key, state),
+                    queryFn: (context: QueryFunctionContext<QueryKey, unknown>) => queryDefinition.queryFn(state, context),
+                    ...defaultOptions?.queryOptions,
+                    ...queryDefinition.options,
+                }),
+            };
+        } else if (definition.type === 'mutation') {
+            const mutationDefinition = definition as MutationEndpointDefinition<any, any, any, any, any>;
+
+            apiInstance[key] = {
+                getKey: () => [baseKey, key],
+                useMutation: (options: any = {}) => {
+                    const mutationKey = [baseKey, key];
+                    const defaultMutationOptions = defaultOptions?.mutationOptions;
+                    const endpointMutationOptions = mutationDefinition.options;
+
+                    return useMutation({
+                        mutationKey,
+                        mutationFn: mutationDefinition.mutationFn,
+                        ...defaultMutationOptions,
+                        ...endpointMutationOptions,
+                        ...options,
+                        onSuccess: async (data, variables, onMutateResult, context) => {
+                            await handleMutationSuccess({
+                                apiInstance,
+                                callSiteOnSuccess: options?.onSuccess,
+                                context,
+                                data,
+                                defaultOnSuccess: defaultMutationOptions?.onSuccess,
+                                endpointOnSuccess: endpointMutationOptions?.onSuccess,
+                                invalidateQueries: mutationDefinition.invalidateQueries,
+                                onMutateResult,
+                                queryClient: configuredQueryClient ?? context.client,
+                                variables,
+                            });
+                        },
+                    });
+                },
+            };
+        }
+    }
+
+    return apiInstance as ApiInstance<TBaseKey, TEndpoints>;
+};
+
+// --- Attach factory functions ---
+api.query = <TQueryFnData = unknown, TState = void, TError = unknown, TData = TQueryFnData>(
+    definition: QueryEndpointOptions<TQueryFnData, TState, TData, TError>,
+): QueryEndpointDefinition<TQueryFnData, TState, TData, TError> => ({
+    ...definition,
+    type: 'query',
+});
+
+api.infiniteQuery = <
+    TQueryFnData = unknown,
+    TState = void,
+    TPageParam = unknown,
+    TError = unknown,
+    TData = InfiniteData<TQueryFnData, TPageParam>,
+>(
+    definition: InfiniteQueryEndpointOptions<TQueryFnData, TState, TPageParam, TError, TData>,
+): InfiniteQueryEndpointDefinition<TQueryFnData, TState, TPageParam, TData, TError> => ({
+    ...definition,
+    type: 'infiniteQuery',
+});
+
+api.mutation = <TData = unknown, TState = unknown, TError = unknown, TApi = InvalidationApi, TOnMutateResult = unknown>(
+    definition: MutationEndpointOptions<TData, TState, TError, TApi, TOnMutateResult>,
+): MutationEndpointDefinition<TData, TState, TError, TApi, TOnMutateResult> => ({
+    ...definition,
+    type: 'mutation',
+});
+
+export default api;

package/src/index.ts

@@ -0,0 +1,2 @@
+export { default } from './api.js';
+export * from './types.js';

package/src/internal.ts

@@ -0,0 +1,64 @@
+import type { InvalidateQueryFilters, MutationFunctionContext, QueryClient, QueryKey } from '@tanstack/react-query';
+
+export type InvalidateQueryTarget = QueryKey | InvalidateQueryFilters;
+
+export type MutationSuccessHandlerOptions<TApi, TData, TVariables, TOnMutateResult> = {
+    apiInstance: TApi;
+    callSiteOnSuccess?: MutationOnSuccess<TData, TVariables, TOnMutateResult>;
+    context: MutationFunctionContext;
+    data: TData;
+    defaultOnSuccess?: MutationOnSuccess<TData, TVariables, TOnMutateResult>;
+    endpointOnSuccess?: MutationOnSuccess<TData, TVariables, TOnMutateResult>;
+    invalidateQueries?: (
+        api: TApi,
+        variables: TVariables,
+        data: TData,
+        onMutateResult: TOnMutateResult,
+        context: MutationFunctionContext,
+    ) => readonly InvalidateQueryTarget[];
+    onMutateResult: TOnMutateResult;
+    queryClient: Pick<QueryClient, 'invalidateQueries'>;
+    variables: TVariables;
+};
+
+type MutationOnSuccess<TData, TVariables, TOnMutateResult> = (
+    data: TData,
+    variables: TVariables,
+    onMutateResult: TOnMutateResult,
+    context: MutationFunctionContext,
+) => Promise<unknown> | unknown;
+
+export const createEndpointKey = (baseKey: string, endpointKey: string, state?: unknown): QueryKey => (
+    state === undefined ? [baseKey, endpointKey] : [baseKey, endpointKey, state]
+);
+
+export const normalizeInvalidateQueryTarget = (target: InvalidateQueryTarget): InvalidateQueryFilters => (
+    Array.isArray(target) ? { queryKey: target as QueryKey } : target as InvalidateQueryFilters
+);
+
+export const handleMutationSuccess = async <TApi, TData, TVariables, TOnMutateResult>({
+    apiInstance,
+    callSiteOnSuccess,
+    context,
+    data,
+    defaultOnSuccess,
+    endpointOnSuccess,
+    invalidateQueries,
+    onMutateResult,
+    queryClient,
+    variables,
+}: MutationSuccessHandlerOptions<TApi, TData, TVariables, TOnMutateResult>): Promise<void> => {
+    if (invalidateQueries) {
+        const invalidationTargets = invalidateQueries(apiInstance, variables, data, onMutateResult, context);
+
+        await Promise.all(
+            invalidationTargets.map((invalidationTarget) => (
+                queryClient.invalidateQueries(normalizeInvalidateQueryTarget(invalidationTarget))
+            )),
+        );
+    }
+
+    await defaultOnSuccess?.(data, variables, onMutateResult, context);
+    await endpointOnSuccess?.(data, variables, onMutateResult, context);
+    await callSiteOnSuccess?.(data, variables, onMutateResult, context);
+};

package/src/types.ts

@@ -0,0 +1,183 @@
+import {
+    DefaultOptions,
+    InfiniteData,
+    InvalidateQueryFilters,
+    MutationFunction,
+    MutationFunctionContext,
+    MutationKey,
+    QueryClient,
+    QueryFunctionContext,
+    QueryKey,
+    UseInfiniteQueryOptions,
+    UseInfiniteQueryResult,
+    UseMutationOptions,
+    UseMutationResult,
+    UseQueryOptions,
+    UseQueryResult,
+    UseSuspenseQueryOptions,
+    UseSuspenseQueryResult,
+} from '@tanstack/react-query';
+
+// --- Core Types ---
+export type QueryEndpointOptions<
+    TQueryFnData = unknown,
+    TState = void,
+    TData = TQueryFnData,
+    TError = unknown,
+> = {
+    queryFn: (state: TState, context: QueryFunctionContext<QueryKey>) => Promise<TQueryFnData>;
+    options?: Omit<UseQueryOptions<TQueryFnData, TError, TData>, 'queryKey' | 'queryFn'>;
+};
+
+export type InfiniteQueryEndpointOptions<
+    TQueryFnData = unknown,
+    TState = void,
+    TPageParam = unknown,
+    TError = unknown,
+    TData = InfiniteData<TQueryFnData, TPageParam>,
+> = {
+    queryFn: (state: TState, context: QueryFunctionContext<QueryKey, TPageParam>) => Promise<TQueryFnData>;
+    options: Omit<UseInfiniteQueryOptions<TQueryFnData, TError, TData, QueryKey, TPageParam>, 'queryKey' | 'queryFn'>;
+};
+
+export type InvalidateQueryTarget = QueryKey | InvalidateQueryFilters;
+
+export type InvalidationApi = {
+    getKey: () => QueryKey;
+};
+
+export type MutationInvalidateQueries<
+    TApi = InvalidationApi,
+    TData = unknown,
+    TState = unknown,
+    TOnMutateResult = unknown,
+> = (
+    api: TApi,
+    variables: TState,
+    data: TData,
+    onMutateResult: TOnMutateResult,
+    context: MutationFunctionContext,
+) => readonly InvalidateQueryTarget[];
+
+export type MutationEndpointOptions<
+    TData = unknown,
+    TState = unknown,
+    TError = unknown,
+    TApi = InvalidationApi,
+    TOnMutateResult = unknown,
+> = {
+    mutationFn: MutationFunction<TData, TState>;
+    options?: Omit<UseMutationOptions<TData, TError, TState, TOnMutateResult>, 'mutationFn'>;
+    invalidateQueries?: MutationInvalidateQueries<TApi, TData, TState, TOnMutateResult>;
+};
+
+export type QueryEndpointDefinition<TQueryFnData, TState, TData, TError> = QueryEndpointOptions<TQueryFnData, TState, TData, TError> & {
+    type: 'query';
+};
+
+export type InfiniteQueryEndpointDefinition<TQueryFnData, TState, TPageParam, TData, TError> = InfiniteQueryEndpointOptions<
+    TQueryFnData,
+    TState,
+    TPageParam,
+    TError,
+    TData
+> & {
+    type: 'infiniteQuery';
+};
+
+export type MutationEndpointDefinition<
+    TData = unknown,
+    TState = unknown,
+    TError = unknown,
+    TApi = InvalidationApi,
+    TOnMutateResult = unknown,
+> = MutationEndpointOptions<TData, TState, TError, TApi, TOnMutateResult> & {
+    type: 'mutation';
+};
+
+export type AnyEndpointDefinition =
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    | QueryEndpointDefinition<any, any, any, any>
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    | InfiniteQueryEndpointDefinition<any, any, any, any, any>
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    | MutationEndpointDefinition<any, any, any, any, any>;
+
+export type ApiQueryOptions = NonNullable<DefaultOptions<unknown>['queries']> & {
+    queryKey?: QueryKey;
+};
+
+export type ApiMutationOptions = NonNullable<DefaultOptions<unknown>['mutations']>;
+
+export interface ApiOptions {
+    queryClient?: QueryClient;
+    queryOptions?: ApiQueryOptions;
+    mutationOptions?: ApiMutationOptions;
+}
+
+type MaybeStateArgs<TState> = undefined extends TState ? [state?: TState] : [state: TState];
+
+type StateAndOptionsArgs<TState, TOptions> = undefined extends TState
+    ? [state?: TState, options?: TOptions]
+    : [state: TState, options?: TOptions];
+
+type QueryCallSiteOptions<TQueryFnData, TError, TData> = Omit<
+    UseQueryOptions<TQueryFnData, TError, TData, QueryKey>,
+    'queryKey' | 'queryFn'
+> & {
+    queryKey?: QueryKey;
+};
+
+type SuspenseQueryCallSiteOptions<TQueryFnData, TError, TData> = Omit<
+    UseSuspenseQueryOptions<TQueryFnData, TError, TData, QueryKey>,
+    'queryKey' | 'queryFn'
+> & {
+    queryKey?: QueryKey;
+};
+
+type InfiniteQueryCallSiteOptions<TQueryFnData, TError, TData, TPageParam> = Partial<
+    Omit<UseInfiniteQueryOptions<TQueryFnData, TError, TData, QueryKey, TPageParam>, 'queryKey' | 'queryFn'>
+> & {
+    queryKey?: QueryKey;
+};
+
+// --- API Instance Type ---
+export type ApiInstance<_TBaseKey extends string, TEndpoints extends Record<string, AnyEndpointDefinition>> = {
+    getKey: () => QueryKey;
+} & {
+    [K in keyof TEndpoints]: K extends string
+        ? TEndpoints[K] extends QueryEndpointDefinition<infer TQueryFnData, infer TState, infer TData, infer TError>
+            ? {
+                  getKey: (...args: MaybeStateArgs<TState>) => QueryKey;
+                  getOptions: (...args: MaybeStateArgs<TState>) => UseQueryOptions<TQueryFnData, TError, TData, QueryKey>;
+                  useQuery: <TQueryData = TData>(
+                      ...args: StateAndOptionsArgs<TState, QueryCallSiteOptions<TQueryFnData, TError, TQueryData>>
+                  ) => UseQueryResult<TQueryData, TError>;
+                  useSuspenseQuery: <TSuspenseData = TData>(
+                      ...args: StateAndOptionsArgs<
+                          TState,
+                          SuspenseQueryCallSiteOptions<TQueryFnData, TError, TSuspenseData>
+                      >
+                  ) => UseSuspenseQueryResult<TSuspenseData, TError>;
+              }
+            : TEndpoints[K] extends InfiniteQueryEndpointDefinition<infer TQueryFnData, infer TState, infer TPageParam, infer TData, infer TError>
+              ? {
+                    getKey: (...args: MaybeStateArgs<TState>) => QueryKey;
+                    getOptions: (...args: MaybeStateArgs<TState>) => UseInfiniteQueryOptions<TQueryFnData, TError, TData, QueryKey, TPageParam>;
+                    useInfiniteQuery: <TQueryData = TData>(
+                        ...args: StateAndOptionsArgs<
+                            TState,
+                            InfiniteQueryCallSiteOptions<TQueryFnData, TError, TQueryData, TPageParam>
+                        >
+                    ) => UseInfiniteQueryResult<TQueryData, TError>;
+                }
+              : TEndpoints[K] extends MutationEndpointDefinition<infer TData, infer TState, infer TError, infer _TApi, infer TOnMutateResult>
+                ? {
+                      useMutation: (
+                          options?: Omit<UseMutationOptions<TData, TError, TState, TOnMutateResult>, 'mutationFn'>
+                      ) => UseMutationResult<TData, TError, TState, TOnMutateResult>;
+                      getKey: () => MutationKey;
+                  }
+                : never
+        : never;
+};