@orpc/react-query 0.0.0-next.e7d7758 → 0.0.0-next.e7ee5a9

package/README.md

@@ -0,0 +1,110 @@
+<div align="center">
+  <image align="center" src="https://orpc.unnoq.com/logo.webp" width=280 alt="oRPC logo" />
+</div>
+
+<h1></h1>
+
+<div align="center">
+  <a href="https://codecov.io/gh/unnoq/orpc">
+    <img alt="codecov" src="https://codecov.io/gh/unnoq/orpc/branch/main/graph/badge.svg">
+  </a>
+  <a href="https://www.npmjs.com/package/@orpc/react-query">
+    <img alt="weekly downloads" src="https://img.shields.io/npm/dw/%40orpc%2Freact-query?logo=npm" />
+  </a>
+  <a href="https://github.com/unnoq/orpc/blob/main/LICENSE">
+    <img alt="MIT License" src="https://img.shields.io/github/license/unnoq/orpc?logo=open-source-initiative" />
+  </a>
+  <a href="https://discord.gg/TXEbwRBvQn">
+    <img alt="Discord" src="https://img.shields.io/discord/1308966753044398161?color=7389D8&label&logo=discord&logoColor=ffffff" />
+  </a>
+</div>
+
+<h3 align="center">Typesafe APIs Made Simple 🪄</h3>
+
+**oRPC is a powerful combination of RPC and OpenAPI**, makes it easy to build APIs that are end-to-end type-safe and adhere to OpenAPI standards, ensuring a smooth and enjoyable developer experience.
+
+---
+
+## Highlights
+
+- **End-to-End Type Safety 🔒**: Ensure complete type safety from inputs to outputs and errors, bridging server and client seamlessly.
+- **First-Class OpenAPI 📄**: Adheres to the OpenAPI standard out of the box, ensuring seamless integration and comprehensive API documentation.
+- **Contract-First Development 📜**: (Optional) Define your API contract upfront and implement it with confidence.
+- **Exceptional Developer Experience ✨**: Enjoy a streamlined workflow with robust typing and clear, in-code documentation.
+- **Multi-Runtime Support 🌍**: Run your code seamlessly on Cloudflare, Deno, Bun, Node.js, and more.
+- **Framework Integrations 🧩**: Supports Tanstack Query (React, Vue), Pinia Colada, and more.
+- **Server Actions ⚡️**: Fully compatible with React Server Actions on Next.js, TanStack Start, and more.
+- **Standard Schema Support 🗂️**: Effortlessly work with Zod, Valibot, ArkType, and others right out of the box.
+- **Fast & Lightweight 💨**: Built on native APIs across all runtimes – optimized for speed and efficiency.
+- **Native Types 📦**: Enjoy built-in support for Date, File, Blob, BigInt, URL and more with no extra setup.
+- **Lazy Router ⏱️**: Improve cold start times with our lazy routing feature.
+- **SSE & Streaming 📡**: Provides SSE and streaming features – perfect for real-time notifications and AI-powered streaming responses.
+- **Reusability 🔄**: Write once and reuse your code across multiple purposes effortlessly.
+- **Extendability 🔌**: Easily enhance oRPC with plugins, middleware, and interceptors.
+- **Reliability 🛡️**: Well-tested, fully TypeScript, production-ready, and MIT licensed for peace of mind.
+- **Simplicity 💡**: Enjoy straightforward, clean code with no hidden magic.
+
+## Documentation
+
+You can find the full documentation [here](https://orpc.unnoq.com).
+
+## Packages
+
+- [@orpc/contract](https://www.npmjs.com/package/@orpc/contract): Build your API contract.
+- [@orpc/server](https://www.npmjs.com/package/@orpc/server): Build your API or implement API contract.
+- [@orpc/client](https://www.npmjs.com/package/@orpc/client): Consume your API on the client with type-safety.
+- [@orpc/react-query](https://www.npmjs.com/package/@orpc/react-query): Integration with [React Query](https://tanstack.com/query/latest/docs/framework/react/overview).
+- [@orpc/vue-query](https://www.npmjs.com/package/@orpc/vue-query): Integration with [Vue Query](https://tanstack.com/query/latest/docs/framework/vue/overview).
+- [@orpc/vue-colada](https://www.npmjs.com/package/@orpc/vue-colada): Integration with [Pinia Colada](https://pinia-colada.esm.dev/).
+- [@orpc/openapi](https://www.npmjs.com/package/@orpc/openapi): Generate OpenAPI specs and handle OpenAPI requests.
+- [@orpc/zod](https://www.npmjs.com/package/@orpc/zod): More schemas that [Zod](https://zod.dev/) doesn't support yet.
+
+## `@orpc/react-query`
+
+Integration with [React Query](https://tanstack.com/query/latest/docs/framework/react/overview). Read the [documentation](https://orpc.unnoq.com/docs/tanstack-query/react) for more information.
+
+```ts
+export function Example() {
+  const query = useQuery(orpc.planet.find.queryOptions({
+    input: { id: 123 }, // Specify input if needed
+    context: { cache: true }, // Provide client context if needed
+  // additional options...
+  }))
+
+  const query = useInfiniteQuery(orpc.planet.list.infiniteOptions({
+    input: (pageParam: number | undefined) => ({ limit: 10, offset: pageParam }),
+    context: { cache: true }, // Provide client context if needed
+    initialPageParam: undefined,
+    getNextPageParam: lastPage => lastPage.nextPageParam,
+  // additional options...
+  }))
+
+  const mutation = useMutation(orpc.planet.create.mutationOptions({
+    context: { cache: true }, // Provide client context if needed
+  // additional options...
+  }))
+
+  mutation.mutate({ name: 'Earth' })
+
+  const queryClient = useQueryClient()
+
+  // Invalidate all planet queries
+  queryClient.invalidateQueries({
+    queryKey: orpc.planet.key(),
+  })
+
+  // Invalidate only regular (non-infinite) planet queries
+  queryClient.invalidateQueries({
+    queryKey: orpc.planet.key({ type: 'query' })
+  })
+
+  // Invalidate the planet find query with id 123
+  queryClient.invalidateQueries({
+    queryKey: orpc.planet.find.key({ input: { id: 123 } })
+  })
+}
+```
+
+## License
+
+Distributed under the MIT License. See [LICENSE](https://github.com/unnoq/orpc/blob/main/LICENSE) for more information.

package/dist/index.d.mts

@@ -0,0 +1,76 @@
+import { ClientContext, Client, NestedClient } from '@orpc/client';
+import { QueryKey, UseQueryOptions, QueryFunctionContext, UseInfiniteQueryOptions, UseMutationOptions, InfiniteData } from '@tanstack/react-query';
+import { PartialDeep, SetOptional, MaybeOptionalOptions } from '@orpc/shared';
+
+type KeyType = 'query' | 'infinite' | 'mutation' | undefined;
+interface BuildKeyOptions<TType extends KeyType, TInput> {
+    type?: TType;
+    input?: TType extends 'mutation' ? never : PartialDeep<TInput>;
+}
+declare function buildKey<TType extends KeyType, TInput>(path: string[], options?: BuildKeyOptions<TType, TInput>): QueryKey;
+
+/**
+ * Utils at any level (procedure or router)
+ */
+interface GeneralUtils<TInput> {
+    key<UType extends KeyType = undefined>(options?: BuildKeyOptions<UType, TInput>): QueryKey;
+}
+declare function createGeneralUtils<TInput>(path: string[]): GeneralUtils<TInput>;
+
+type QueryOptionsIn<TClientContext extends ClientContext, TInput, TOutput, TError extends Error, TSelectData> = (undefined extends TInput ? {
+    input?: TInput;
+} : {
+    input: TInput;
+}) & (Record<never, never> extends TClientContext ? {
+    context?: TClientContext;
+} : {
+    context: TClientContext;
+}) & SetOptional<UseQueryOptions<TOutput, TError, TSelectData>, 'queryKey'>;
+interface QueryOptionsBase<TOutput, TError extends Error> {
+    queryKey: QueryKey;
+    queryFn(ctx: QueryFunctionContext): Promise<TOutput>;
+    retry?(failureCount: number, error: TError): boolean;
+}
+type InfiniteOptionsIn<TClientContext extends ClientContext, TInput, TOutput, TError extends Error, TSelectData, TPageParam> = {
+    input: (pageParam: TPageParam) => TInput;
+} & (Record<never, never> extends TClientContext ? {
+    context?: TClientContext;
+} : {
+    context: TClientContext;
+}) & SetOptional<UseInfiniteQueryOptions<TOutput, TError, TSelectData, TOutput, QueryKey, TPageParam>, 'queryKey'>;
+interface InfiniteOptionsBase<TOutput, TError extends Error, TPageParam> {
+    queryKey: QueryKey;
+    queryFn(ctx: QueryFunctionContext<QueryKey, TPageParam>): Promise<TOutput>;
+    retry?(failureCount: number, error: TError): boolean;
+}
+type MutationOptionsIn<TClientContext extends ClientContext, TInput, TOutput, TError extends Error, TMutationContext> = (Record<never, never> extends TClientContext ? {
+    context?: TClientContext;
+} : {
+    context: TClientContext;
+}) & UseMutationOptions<TOutput, TError, TInput, TMutationContext>;
+interface MutationOptionsBase<TInput, TOutput, TError extends Error> {
+    mutationKey: QueryKey;
+    mutationFn(input: TInput): Promise<TOutput>;
+    retry?(failureCount: number, error: TError): boolean;
+}
+
+interface ProcedureUtils<TClientContext extends ClientContext, TInput, TOutput, TError extends Error> {
+    call: Client<TClientContext, TInput, TOutput, TError>;
+    queryOptions<U, USelectData = TOutput>(...rest: MaybeOptionalOptions<U & QueryOptionsIn<TClientContext, TInput, TOutput, TError, USelectData>>): NoInfer<U & Omit<QueryOptionsBase<TOutput, TError>, keyof U>>;
+    infiniteOptions<U, UPageParam, USelectData = InfiniteData<TOutput, UPageParam>>(options: U & InfiniteOptionsIn<TClientContext, TInput, TOutput, TError, USelectData, UPageParam>): NoInfer<U & Omit<InfiniteOptionsBase<TOutput, TError, UPageParam>, keyof U>>;
+    mutationOptions<U, UMutationContext>(...rest: MaybeOptionalOptions<U & MutationOptionsIn<TClientContext, TInput, TOutput, TError, UMutationContext>>): NoInfer<U & Omit<MutationOptionsBase<TInput, TOutput, TError>, keyof U>>;
+}
+declare function createProcedureUtils<TClientContext extends ClientContext, TInput, TOutput, TError extends Error>(client: Client<TClientContext, TInput, TOutput, TError>, path: string[]): ProcedureUtils<TClientContext, TInput, TOutput, TError>;
+
+type RouterUtils<T extends NestedClient<any>> = T extends Client<infer UClientContext, infer UInput, infer UOutput, infer UError> ? ProcedureUtils<UClientContext, UInput, UOutput, UError> & GeneralUtils<UInput> : {
+    [K in keyof T]: T[K] extends NestedClient<any> ? RouterUtils<T[K]> : never;
+} & GeneralUtils<unknown>;
+/**
+ * @param client - Any kind of oRPC clients: `createRouterClient`, `createORPCClient`, ...
+ * @param path - The base path for query key, when it it will be prefix to all keys
+ */
+declare function createRouterUtils<T extends NestedClient<any>>(client: T, path?: string[]): RouterUtils<T>;
+
+declare const createORPCReactQueryUtils: typeof createRouterUtils;
+
+export { type BuildKeyOptions, type GeneralUtils, type InfiniteOptionsBase, type InfiniteOptionsIn, type KeyType, type MutationOptionsBase, type MutationOptionsIn, type ProcedureUtils, type QueryOptionsBase, type QueryOptionsIn, type RouterUtils, buildKey, createGeneralUtils, createORPCReactQueryUtils, createProcedureUtils, createRouterUtils };

package/dist/index.d.ts

@@ -0,0 +1,76 @@
+import { ClientContext, Client, NestedClient } from '@orpc/client';
+import { QueryKey, UseQueryOptions, QueryFunctionContext, UseInfiniteQueryOptions, UseMutationOptions, InfiniteData } from '@tanstack/react-query';
+import { PartialDeep, SetOptional, MaybeOptionalOptions } from '@orpc/shared';
+
+type KeyType = 'query' | 'infinite' | 'mutation' | undefined;
+interface BuildKeyOptions<TType extends KeyType, TInput> {
+    type?: TType;
+    input?: TType extends 'mutation' ? never : PartialDeep<TInput>;
+}
+declare function buildKey<TType extends KeyType, TInput>(path: string[], options?: BuildKeyOptions<TType, TInput>): QueryKey;
+
+/**
+ * Utils at any level (procedure or router)
+ */
+interface GeneralUtils<TInput> {
+    key<UType extends KeyType = undefined>(options?: BuildKeyOptions<UType, TInput>): QueryKey;
+}
+declare function createGeneralUtils<TInput>(path: string[]): GeneralUtils<TInput>;
+
+type QueryOptionsIn<TClientContext extends ClientContext, TInput, TOutput, TError extends Error, TSelectData> = (undefined extends TInput ? {
+    input?: TInput;
+} : {
+    input: TInput;
+}) & (Record<never, never> extends TClientContext ? {
+    context?: TClientContext;
+} : {
+    context: TClientContext;
+}) & SetOptional<UseQueryOptions<TOutput, TError, TSelectData>, 'queryKey'>;
+interface QueryOptionsBase<TOutput, TError extends Error> {
+    queryKey: QueryKey;
+    queryFn(ctx: QueryFunctionContext): Promise<TOutput>;
+    retry?(failureCount: number, error: TError): boolean;
+}
+type InfiniteOptionsIn<TClientContext extends ClientContext, TInput, TOutput, TError extends Error, TSelectData, TPageParam> = {
+    input: (pageParam: TPageParam) => TInput;
+} & (Record<never, never> extends TClientContext ? {
+    context?: TClientContext;
+} : {
+    context: TClientContext;
+}) & SetOptional<UseInfiniteQueryOptions<TOutput, TError, TSelectData, TOutput, QueryKey, TPageParam>, 'queryKey'>;
+interface InfiniteOptionsBase<TOutput, TError extends Error, TPageParam> {
+    queryKey: QueryKey;
+    queryFn(ctx: QueryFunctionContext<QueryKey, TPageParam>): Promise<TOutput>;
+    retry?(failureCount: number, error: TError): boolean;
+}
+type MutationOptionsIn<TClientContext extends ClientContext, TInput, TOutput, TError extends Error, TMutationContext> = (Record<never, never> extends TClientContext ? {
+    context?: TClientContext;
+} : {
+    context: TClientContext;
+}) & UseMutationOptions<TOutput, TError, TInput, TMutationContext>;
+interface MutationOptionsBase<TInput, TOutput, TError extends Error> {
+    mutationKey: QueryKey;
+    mutationFn(input: TInput): Promise<TOutput>;
+    retry?(failureCount: number, error: TError): boolean;
+}
+
+interface ProcedureUtils<TClientContext extends ClientContext, TInput, TOutput, TError extends Error> {
+    call: Client<TClientContext, TInput, TOutput, TError>;
+    queryOptions<U, USelectData = TOutput>(...rest: MaybeOptionalOptions<U & QueryOptionsIn<TClientContext, TInput, TOutput, TError, USelectData>>): NoInfer<U & Omit<QueryOptionsBase<TOutput, TError>, keyof U>>;
+    infiniteOptions<U, UPageParam, USelectData = InfiniteData<TOutput, UPageParam>>(options: U & InfiniteOptionsIn<TClientContext, TInput, TOutput, TError, USelectData, UPageParam>): NoInfer<U & Omit<InfiniteOptionsBase<TOutput, TError, UPageParam>, keyof U>>;
+    mutationOptions<U, UMutationContext>(...rest: MaybeOptionalOptions<U & MutationOptionsIn<TClientContext, TInput, TOutput, TError, UMutationContext>>): NoInfer<U & Omit<MutationOptionsBase<TInput, TOutput, TError>, keyof U>>;
+}
+declare function createProcedureUtils<TClientContext extends ClientContext, TInput, TOutput, TError extends Error>(client: Client<TClientContext, TInput, TOutput, TError>, path: string[]): ProcedureUtils<TClientContext, TInput, TOutput, TError>;
+
+type RouterUtils<T extends NestedClient<any>> = T extends Client<infer UClientContext, infer UInput, infer UOutput, infer UError> ? ProcedureUtils<UClientContext, UInput, UOutput, UError> & GeneralUtils<UInput> : {
+    [K in keyof T]: T[K] extends NestedClient<any> ? RouterUtils<T[K]> : never;
+} & GeneralUtils<unknown>;
+/**
+ * @param client - Any kind of oRPC clients: `createRouterClient`, `createORPCClient`, ...
+ * @param path - The base path for query key, when it it will be prefix to all keys
+ */
+declare function createRouterUtils<T extends NestedClient<any>>(client: T, path?: string[]): RouterUtils<T>;
+
+declare const createORPCReactQueryUtils: typeof createRouterUtils;
+
+export { type BuildKeyOptions, type GeneralUtils, type InfiniteOptionsBase, type InfiniteOptionsIn, type KeyType, type MutationOptionsBase, type MutationOptionsIn, type ProcedureUtils, type QueryOptionsBase, type QueryOptionsIn, type RouterUtils, buildKey, createGeneralUtils, createORPCReactQueryUtils, createProcedureUtils, createRouterUtils };

package/dist/{index.js → index.mjs}

@@ -1,18 +1,12 @@
-// src/key.ts
 function buildKey(path, options) {
   const withInput = options?.input !== void 0 ? { input: options?.input } : {};
   const withType = options?.type !== void 0 ? { type: options?.type } : {};
-  return [
-    "__ORPC__",
-    path,
-    {
-      ...withInput,
-      ...withType
-    }
-  ];
+  return [path, {
+    ...withInput,
+    ...withType
+  }];
 }
 
-// src/utils-general.ts
 function createGeneralUtils(path) {
   return {
     key(options) {
@@ -21,36 +15,35 @@ function createGeneralUtils(path) {
   };
 }
 
-// src/utils-procedure.ts
 function createProcedureUtils(client, path) {
   return {
-    queryOptions(...[options]) {
-      const input = options?.input;
+    call: client,
+    queryOptions(...[{ input, context, ...rest } = {}]) {
       return {
         queryKey: buildKey(path, { type: "query", input }),
-        queryFn: ({ signal }) => client(input, { signal, context: options?.context }),
-        ...options
+        queryFn: ({ signal }) => client(input, { signal, context }),
+        ...rest
       };
     },
-    infiniteOptions(options) {
-      const input = options.input;
+    infiniteOptions({ input, context, ...rest }) {
       return {
-        queryKey: buildKey(path, { type: "infinite", input }),
-        queryFn: ({ pageParam, signal }) => client({ ...input, cursor: pageParam }, { signal, context: options.context }),
-        ...options
+        queryKey: buildKey(path, { type: "infinite", input: input(rest.initialPageParam) }),
+        queryFn: ({ pageParam, signal }) => {
+          return client(input(pageParam), { signal, context });
+        },
+        ...rest
       };
     },
-    mutationOptions(...[options]) {
+    mutationOptions(...[{ context, ...rest } = {}]) {
       return {
         mutationKey: buildKey(path, { type: "mutation" }),
-        mutationFn: (input) => client(input, { context: options?.context }),
-        ...options
+        mutationFn: (input) => client(input, { context }),
+        ...rest
       };
     }
   };
 }
 
-// src/utils-router.ts
 function createRouterUtils(client, path = []) {
   const generalUtils = createGeneralUtils(path);
   const procedureUtils = createProcedureUtils(client, path);
@@ -77,13 +70,6 @@ function createRouterUtils(client, path = []) {
   return recursive;
 }
 
-// src/index.ts
-var createORPCReactQueryUtils = createRouterUtils;
-export {
-  buildKey,
-  createGeneralUtils,
-  createORPCReactQueryUtils,
-  createProcedureUtils,
-  createRouterUtils
-};
-//# sourceMappingURL=index.js.map
+const createORPCReactQueryUtils = createRouterUtils;
+
+export { buildKey, createGeneralUtils, createORPCReactQueryUtils, createProcedureUtils, createRouterUtils };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/react-query",
   "type": "module",
-  "version": "0.0.0-next.e7d7758",
+  "version": "0.0.0-next.e7ee5a9",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -18,34 +18,27 @@
   ],
   "exports": {
     ".": {
-      "types": "./dist/src/index.d.ts",
-      "import": "./dist/index.js",
-      "default": "./dist/index.js"
-    },
-    "./🔒/*": {
-      "types": "./dist/src/*.d.ts"
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
     }
   },
   "files": [
-    "!**/*.map",
-    "!**/*.tsbuildinfo",
     "dist"
   ],
   "peerDependencies": {
     "@tanstack/react-query": ">=5.59.0",
     "react": ">=18.3.0",
-    "@orpc/client": "0.0.0-next.e7d7758",
-    "@orpc/contract": "0.0.0-next.e7d7758",
-    "@orpc/server": "0.0.0-next.e7d7758"
+    "@orpc/client": "0.0.0-next.e7ee5a9"
   },
   "dependencies": {
-    "@orpc/shared": "0.0.0-next.e7d7758"
+    "@orpc/shared": "0.0.0-next.e7ee5a9"
   },
   "devDependencies": {
     "zod": "^3.24.1"
   },
   "scripts": {
-    "build": "tsup --clean --sourcemap --entry.index=src/index.ts --format=esm --onSuccess='tsc -b --noCheck'",
+    "build": "unbuild",
     "build:watch": "pnpm run build --watch",
     "type:check": "tsc -b"
   }

package/dist/src/index.d.ts

@@ -1,8 +0,0 @@
-import { createRouterUtils } from './utils-router';
-export * from './key';
-export * from './types';
-export * from './utils-general';
-export * from './utils-procedure';
-export * from './utils-router';
-export declare const createORPCReactQueryUtils: typeof createRouterUtils;
-//# sourceMappingURL=index.d.ts.map

package/dist/src/key.d.ts

@@ -1,9 +0,0 @@
-import type { PartialDeep } from '@orpc/shared';
-import type { QueryKey } from '@tanstack/react-query';
-export type KeyType = 'query' | 'infinite' | 'mutation' | undefined;
-export interface BuildKeyOptions<TType extends KeyType, TInput> {
-    type?: TType;
-    input?: TType extends 'mutation' ? never : PartialDeep<TInput>;
-}
-export declare function buildKey<TType extends KeyType, TInput>(path: string[], options?: BuildKeyOptions<TType, TInput>): QueryKey;
-//# sourceMappingURL=key.d.ts.map

package/dist/src/types.d.ts

@@ -1,29 +0,0 @@
-import type { SetOptional } from '@orpc/shared';
-import type { DefaultError, QueryKey, UndefinedInitialDataInfiniteOptions, UndefinedInitialDataOptions, UseMutationOptions } from '@tanstack/react-query';
-export type InferCursor<T> = T extends {
-    cursor?: any;
-} ? T['cursor'] : never;
-export type QueryOptions<TInput, TOutput, TClientContext, TSelectData> = (undefined extends TInput ? {
-    input?: TInput;
-} : {
-    input: TInput;
-}) & (undefined extends TClientContext ? {
-    context?: TClientContext;
-} : {
-    context: TClientContext;
-}) & (SetOptional<UndefinedInitialDataOptions<TOutput, DefaultError, TSelectData, QueryKey>, 'queryKey'>);
-export type InfiniteOptions<TInput, TOutput, TClientContext, TSelectData> = (undefined extends TInput ? {
-    input?: Omit<TInput, 'cursor'>;
-} : {
-    input: Omit<TInput, 'cursor'>;
-}) & (undefined extends TClientContext ? {
-    context?: TClientContext;
-} : {
-    context: TClientContext;
-}) & (SetOptional<UndefinedInitialDataInfiniteOptions<TOutput, DefaultError, TSelectData, QueryKey, InferCursor<TInput>>, 'queryKey' | (undefined extends InferCursor<TInput> ? 'initialPageParam' : never)>);
-export type MutationOptions<TInput, TOutput, TClientContext> = (undefined extends TClientContext ? {
-    context?: TClientContext;
-} : {
-    context: TClientContext;
-}) & UseMutationOptions<TOutput, DefaultError, TInput>;
-//# sourceMappingURL=types.d.ts.map

package/dist/src/utils-general.d.ts

@@ -1,10 +0,0 @@
-import type { QueryKey } from '@tanstack/react-query';
-import type { BuildKeyOptions, KeyType } from './key';
-/**
- * Utils at any level (procedure or router)
- */
-export interface GeneralUtils<TInput> {
-    key: <UType extends KeyType = undefined>(options?: BuildKeyOptions<UType, TInput>) => QueryKey;
-}
-export declare function createGeneralUtils<TInput>(path: string[]): GeneralUtils<TInput>;
-//# sourceMappingURL=utils-general.d.ts.map

package/dist/src/utils-procedure.d.ts

@@ -1,30 +0,0 @@
-import type { ProcedureClient } from '@orpc/server';
-import type { IsEqual } from '@orpc/shared';
-import type { QueryFunctionContext, QueryKey } from '@tanstack/react-query';
-import type { InferCursor, InfiniteOptions, MutationOptions, QueryOptions } from './types';
-/**
- * Utils at procedure level
- */
-export interface ProcedureUtils<TInput, TOutput, TClientContext> {
-    queryOptions: <U extends QueryOptions<TInput, TOutput, TClientContext, any>>(...opts: [options: U] | (undefined extends TInput & TClientContext ? [] : never)) => IsEqual<U, QueryOptions<TInput, TOutput, TClientContext, any>> extends true ? {
-        queryKey: QueryKey;
-        queryFn: (ctx: QueryFunctionContext) => Promise<TOutput>;
-    } : Omit<{
-        queryKey: QueryKey;
-        queryFn: (ctx: QueryFunctionContext) => Promise<TOutput>;
-    }, keyof U> & U;
-    infiniteOptions: <U extends InfiniteOptions<TInput, TOutput, TClientContext, any>>(options: U) => Omit<{
-        queryKey: QueryKey;
-        queryFn: (ctx: QueryFunctionContext<QueryKey, InferCursor<TInput>>) => Promise<TOutput>;
-        initialPageParam: undefined;
-    }, keyof U> & U;
-    mutationOptions: <U extends MutationOptions<TInput, TOutput, TClientContext>>(...opt: [options: U] | (undefined extends TClientContext ? [] : never)) => IsEqual<U, MutationOptions<TInput, TOutput, TClientContext>> extends true ? {
-        mutationKey: QueryKey;
-        mutationFn: (input: TInput) => Promise<TOutput>;
-    } : Omit<{
-        mutationKey: QueryKey;
-        mutationFn: (input: TInput) => Promise<TOutput>;
-    }, keyof U> & U;
-}
-export declare function createProcedureUtils<TInput, TOutput, TClientContext>(client: ProcedureClient<TInput, TOutput, TClientContext>, path: string[]): ProcedureUtils<TInput, TOutput, TClientContext>;
-//# sourceMappingURL=utils-procedure.d.ts.map

package/dist/src/utils-router.d.ts

@@ -1,12 +0,0 @@
-import type { ProcedureClient, RouterClient } from '@orpc/server';
-import { type GeneralUtils } from './utils-general';
-import { type ProcedureUtils } from './utils-procedure';
-export type RouterUtils<T extends RouterClient<any, any>> = T extends ProcedureClient<infer TInput, infer TOutput, infer TClientContext> ? ProcedureUtils<TInput, TOutput, TClientContext> & GeneralUtils<TInput> : {
-    [K in keyof T]: T[K] extends RouterClient<any, any> ? RouterUtils<T[K]> : never;
-} & GeneralUtils<unknown>;
-/**
- * @param client - The client create form `@orpc/client`
- * @param path - The base path for query key
- */
-export declare function createRouterUtils<T extends RouterClient<any, any>>(client: T, path?: string[]): RouterUtils<T>;
-//# sourceMappingURL=utils-router.d.ts.map