@orpc/react 0.0.0-next.ef3ba82 → 0.0.0-next.fd1db03

package/dist/index.js

@@ -275,7 +275,7 @@ function createProcedureHooks(options) {
       return useQuery(
         {
           queryKey: getQueryKeyFromPath(options.path, { input, type: "query" }),
-          queryFn: () => client(input),
+          queryFn: ({ signal }) => client(input, { signal }),
           ...options_
         },
         context.queryClient
@@ -291,7 +291,7 @@ function createProcedureHooks(options) {
             input,
             type: "infinite"
           }),
-          queryFn: ({ pageParam }) => client({ ...input, cursor: pageParam }),
+          queryFn: ({ pageParam, signal }) => client({ ...input, cursor: pageParam }, { signal }),
           ...rest
         },
         context.queryClient
@@ -303,7 +303,7 @@ function createProcedureHooks(options) {
       return useSuspenseQuery(
         {
           queryKey: getQueryKeyFromPath(options.path, { input, type: "query" }),
-          queryFn: () => client(input),
+          queryFn: ({ signal }) => client(input, { signal }),
           ...options_
         },
         context.queryClient
@@ -319,7 +319,7 @@ function createProcedureHooks(options) {
             input,
             type: "infinite"
           }),
-          queryFn: ({ pageParam }) => client({ ...input, cursor: pageParam }),
+          queryFn: ({ pageParam, signal }) => client({ ...input, cursor: pageParam }, { signal }),
           ...rest
         },
         context.queryClient
@@ -331,7 +331,7 @@ function createProcedureHooks(options) {
       return usePrefetchQuery(
         {
           queryKey: getQueryKeyFromPath(options.path, { input, type: "query" }),
-          queryFn: () => client(input),
+          queryFn: ({ signal }) => client(input, { signal }),
           ...options_
         },
         context.queryClient
@@ -347,7 +347,7 @@ function createProcedureHooks(options) {
             input,
             type: "infinite"
           }),
-          queryFn: ({ pageParam }) => client({ ...input, cursor: pageParam }),
+          queryFn: ({ pageParam, signal }) => client({ ...input, cursor: pageParam }, { signal }),
           ...rest
         },
         context.queryClient
@@ -374,7 +374,7 @@ function createProcedureUtils(options) {
     fetchQuery(input, options_) {
       return options.queryClient.fetchQuery({
         queryKey: getQueryKeyFromPath(options.path, { input, type: "query" }),
-        queryFn: () => options.client(input),
+        queryFn: ({ signal }) => options.client(input, { signal }),
         ...options_
       });
     },
@@ -385,8 +385,8 @@ function createProcedureUtils(options) {
           input,
           type: "infinite"
         }),
-        queryFn: ({ pageParam }) => {
-          return options.client({ ...input, pageParam });
+        queryFn: ({ pageParam, signal }) => {
+          return options.client({ ...input, pageParam }, { signal });
         },
         ...rest
       });
@@ -397,7 +397,7 @@ function createProcedureUtils(options) {
           input,
           type: "query"
         }),
-        queryFn: () => options.client(input),
+        queryFn: ({ signal }) => options.client(input, { signal }),
         ...options_
       });
     },
@@ -408,8 +408,8 @@ function createProcedureUtils(options) {
           input,
           type: "infinite"
         }),
-        queryFn: ({ pageParam }) => {
-          return options.client({ ...input, cursor: pageParam });
+        queryFn: ({ pageParam, signal }) => {
+          return options.client({ ...input, cursor: pageParam }, { signal });
         },
         ...rest
       });
@@ -436,7 +436,7 @@ function createProcedureUtils(options) {
           input,
           type: "query"
         }),
-        queryFn: () => options.client(input),
+        queryFn: ({ signal }) => options.client(input, { signal }),
         ...options_
       });
     },
@@ -447,8 +447,8 @@ function createProcedureUtils(options) {
           input,
           type: "infinite"
         }),
-        queryFn: ({ pageParam }) => {
-          return options.client({ ...input, pageParam });
+        queryFn: ({ pageParam, signal }) => {
+          return options.client({ ...input, pageParam }, { signal });
         },
         ...rest
       });
@@ -496,10 +496,10 @@ function createProcedureUtils(options) {
 function createORPCHooks(options) {
   const path = options.path ?? [];
   const generalHooks = createGeneralHooks({ context: options.context, path });
-  const procedureHooks = path.length ? createProcedureHooks({
+  const procedureHooks = createProcedureHooks({
     context: options.context,
     path
-  }) : {};
+  });
   return new Proxy(
     {
       [orpcPathSymbol]: path,
@@ -575,16 +575,14 @@ function createORPCUtils(options) {
 }
 
 // src/use-queries/hook.ts
-import {
-  useQueries
-} from "@tanstack/react-query";
+import { useQueries } from "@tanstack/react-query";
 
 // src/use-queries/builder.ts
 function createUseQueriesBuilder(options) {
   return (input, options_) => {
     return {
       queryKey: getQueryKeyFromPath(options.path, { input, type: "query" }),
-      queryFn: () => options.client(input),
+      queryFn: ({ signal }) => options.client(input, { signal }),
       ...options_
     };
   };
@@ -671,3 +669,4 @@ export {
   createProcedureUtils,
   useORPCContext
 };
+//# sourceMappingURL=index.js.map

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

@@ -1,14 +1,13 @@
-import type { Schema, SchemaInput, SchemaOutput } from '@orpc/contract';
 import type { PartialDeep, SetOptional } from '@orpc/shared';
 import type { ORPCQueryFilters } from './tanstack-query';
 import { type DefaultError, type Mutation, type MutationFilters, type MutationState } from '@tanstack/react-query';
 import { type ORPCContext } from './react-context';
-export interface GeneralHooks<TInputSchema extends Schema, TOutputSchema extends Schema, TFuncOutput extends SchemaOutput<TOutputSchema>> {
-    useIsFetching: (filers?: ORPCQueryFilters<PartialDeep<SchemaInput<TInputSchema>>>) => number;
+export interface GeneralHooks<TInput, TOutput> {
+    useIsFetching: (filers?: ORPCQueryFilters<PartialDeep<TInput>>) => number;
     useIsMutating: (filters?: SetOptional<MutationFilters, 'mutationKey'>) => number;
-    useMutationState: <UResult = MutationState<SchemaOutput<TOutputSchema, TFuncOutput>, DefaultError, SchemaInput<TInputSchema>>>(options?: {
+    useMutationState: <UResult = MutationState<TOutput, DefaultError, TInput>>(options?: {
         filters?: SetOptional<MutationFilters, 'mutationKey'>;
-        select?: (mutation: Mutation<SchemaOutput<TOutputSchema, TFuncOutput>, DefaultError, SchemaInput<TInputSchema>>) => UResult;
+        select?: (mutation: Mutation<TOutput, DefaultError, TInput>) => UResult;
     }) => UResult[];
 }
 export interface CreateGeneralHooksOptions {
@@ -20,4 +19,5 @@ export interface CreateGeneralHooksOptions {
      */
     path: string[];
 }
-export declare function createGeneralHooks<TInputSchema extends Schema = undefined, TOutputSchema extends Schema = undefined, TFuncOutput extends SchemaOutput<TOutputSchema> = SchemaOutput<TOutputSchema>>(options: CreateGeneralHooksOptions): GeneralHooks<TInputSchema, TOutputSchema, TFuncOutput>;
+export declare function createGeneralHooks<TInput, TOutput>(options: CreateGeneralHooksOptions): GeneralHooks<TInput, TOutput>;
+//# sourceMappingURL=general-hooks.d.ts.map

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

@@ -1,32 +1,31 @@
-import type { Schema, SchemaInput, SchemaOutput } from '@orpc/contract';
 import type { PartialDeep, SetOptional } from '@orpc/shared';
 import type { CancelOptions, DefaultError, InfiniteData, InvalidateOptions, MutationFilters, MutationObserverOptions, OmitKeyof, QueryClient, QueryKey, QueryObserverOptions, RefetchOptions, ResetOptions, SetDataOptions, Updater } from '@tanstack/react-query';
 import type { ORPCInvalidateQueryFilters, ORPCQueryFilters } from './tanstack-query';
-import type { SchemaInputForInfiniteQuery } from './types';
-export interface GeneralUtils<TInputSchema extends Schema, TOutputSchema extends Schema, TFuncOutput extends SchemaOutput<TOutputSchema>> {
-    getQueriesData: (filters?: OmitKeyof<ORPCQueryFilters<PartialDeep<SchemaInput<TInputSchema>>>, 'queryType'>) => [QueryKey, SchemaOutput<TOutputSchema, TFuncOutput> | undefined][];
-    getInfiniteQueriesData: (filters?: OmitKeyof<ORPCQueryFilters<PartialDeep<SchemaInputForInfiniteQuery<TInputSchema>>>, 'queryType'>) => [
+import type { InferCursor, SchemaInputForInfiniteQuery } from './types';
+export interface GeneralUtils<TInput, TOutput> {
+    getQueriesData: (filters?: OmitKeyof<ORPCQueryFilters<PartialDeep<TInput>>, 'queryType'>) => [QueryKey, TOutput | undefined][];
+    getInfiniteQueriesData: (filters?: OmitKeyof<ORPCQueryFilters<PartialDeep<SchemaInputForInfiniteQuery<TInput>>>, 'queryType'>) => [
         QueryKey,
-        undefined | InfiniteData<SchemaOutput<TOutputSchema, TFuncOutput>, SchemaInput<TInputSchema>['cursor']>
+        undefined | InfiniteData<TOutput, InferCursor<TInput>>
     ][];
-    setQueriesData: (filters: OmitKeyof<ORPCQueryFilters<PartialDeep<SchemaInput<TInputSchema>>>, 'queryType'>, updater: Updater<SchemaOutput<TOutputSchema, TFuncOutput> | undefined, SchemaOutput<TOutputSchema, TFuncOutput> | undefined>, options?: SetDataOptions) => [QueryKey, SchemaOutput<TOutputSchema, TFuncOutput> | undefined][];
-    setInfiniteQueriesData: (filters: OmitKeyof<ORPCQueryFilters<PartialDeep<SchemaInputForInfiniteQuery<TInputSchema>>>, 'queryType'>, updater: Updater<InfiniteData<SchemaOutput<TOutputSchema, TFuncOutput>, SchemaInput<TInputSchema>['cursor']> | undefined, InfiniteData<SchemaOutput<TOutputSchema, TFuncOutput>, SchemaInput<TInputSchema>['cursor']> | undefined>, options?: SetDataOptions) => [
+    setQueriesData: (filters: OmitKeyof<ORPCQueryFilters<PartialDeep<TInput>>, 'queryType'>, updater: Updater<TOutput | undefined, TOutput | undefined>, options?: SetDataOptions) => [QueryKey, TOutput | undefined][];
+    setInfiniteQueriesData: (filters: OmitKeyof<ORPCQueryFilters<PartialDeep<SchemaInputForInfiniteQuery<TInput>>>, 'queryType'>, updater: Updater<InfiniteData<TOutput, InferCursor<TInput>> | undefined, InfiniteData<TOutput, InferCursor<TInput>> | undefined>, options?: SetDataOptions) => [
         QueryKey,
-        undefined | InfiniteData<SchemaOutput<TOutputSchema, TFuncOutput>, SchemaInput<TInputSchema>['cursor']>
+        undefined | InfiniteData<TOutput, InferCursor<TInput>>
     ][];
-    invalidate: (filters?: ORPCInvalidateQueryFilters<PartialDeep<SchemaInput<TInputSchema>>>, options?: InvalidateOptions) => Promise<void>;
-    refetch: (filters?: ORPCQueryFilters<PartialDeep<SchemaInput<TInputSchema>>>, options?: RefetchOptions) => Promise<void>;
-    cancel: (filters?: ORPCQueryFilters<PartialDeep<SchemaInput<TInputSchema>>>, options?: CancelOptions) => Promise<void>;
-    remove: (filters?: ORPCQueryFilters<PartialDeep<SchemaInput<TInputSchema>>>) => void;
-    reset: (filters?: ORPCQueryFilters<PartialDeep<SchemaInput<TInputSchema>>>, options?: ResetOptions) => Promise<void>;
-    isFetching: (filters?: ORPCQueryFilters<PartialDeep<SchemaInput<TInputSchema>>>) => number;
+    invalidate: (filters?: ORPCInvalidateQueryFilters<PartialDeep<TInput>>, options?: InvalidateOptions) => Promise<void>;
+    refetch: (filters?: ORPCQueryFilters<PartialDeep<TInput>>, options?: RefetchOptions) => Promise<void>;
+    cancel: (filters?: ORPCQueryFilters<PartialDeep<TInput>>, options?: CancelOptions) => Promise<void>;
+    remove: (filters?: ORPCQueryFilters<PartialDeep<TInput>>) => void;
+    reset: (filters?: ORPCQueryFilters<PartialDeep<TInput>>, options?: ResetOptions) => Promise<void>;
+    isFetching: (filters?: ORPCQueryFilters<PartialDeep<TInput>>) => number;
     isMutating: (filters?: SetOptional<MutationFilters, 'mutationKey'>) => number;
-    getQueryDefaults: (filters?: Pick<ORPCQueryFilters<PartialDeep<SchemaInput<TInputSchema>>>, 'input' | 'queryKey'>) => OmitKeyof<QueryObserverOptions<SchemaOutput<TOutputSchema, TFuncOutput>>, 'queryKey'>;
-    getInfiniteQueryDefaults: (filters?: Pick<ORPCQueryFilters<PartialDeep<SchemaInputForInfiniteQuery<TInputSchema>>>, 'input' | 'queryKey'>) => OmitKeyof<QueryObserverOptions<SchemaOutput<TOutputSchema, TFuncOutput>, DefaultError, SchemaOutput<TOutputSchema, TFuncOutput>, InfiniteData<SchemaOutput<TOutputSchema, TFuncOutput>>, QueryKey, SchemaInput<TInputSchema>['cursor']>, 'queryKey'>;
-    setQueryDefaults: (options: Partial<OmitKeyof<QueryObserverOptions<SchemaOutput<TOutputSchema, TFuncOutput>>, 'queryKey'>>, filters?: Pick<ORPCQueryFilters<PartialDeep<SchemaInput<TInputSchema>>>, 'input' | 'queryKey'>) => void;
-    setInfiniteQueryDefaults: (options: Partial<OmitKeyof<QueryObserverOptions<SchemaOutput<TOutputSchema, TFuncOutput>, DefaultError, SchemaOutput<TOutputSchema, TFuncOutput>, InfiniteData<SchemaOutput<TOutputSchema, TFuncOutput>>, QueryKey, SchemaInput<TInputSchema>['cursor']>, 'queryKey'>>, filters?: Pick<ORPCQueryFilters<PartialDeep<SchemaInput<TInputSchema>>>, 'input' | 'queryKey'>) => void;
-    getMutationDefaults: (filters?: Pick<MutationFilters, 'mutationKey'>) => MutationObserverOptions<SchemaOutput<TOutputSchema, TFuncOutput>, DefaultError, SchemaInput<TInputSchema>>;
-    setMutationDefaults: (options: OmitKeyof<MutationObserverOptions<SchemaOutput<TOutputSchema, TFuncOutput>, DefaultError, SchemaInput<TInputSchema>>, 'mutationKey'>, filters?: Pick<MutationFilters, 'mutationKey'>) => void;
+    getQueryDefaults: (filters?: Pick<ORPCQueryFilters<PartialDeep<TInput>>, 'input' | 'queryKey'>) => OmitKeyof<QueryObserverOptions<TOutput>, 'queryKey'>;
+    getInfiniteQueryDefaults: (filters?: Pick<ORPCQueryFilters<PartialDeep<SchemaInputForInfiniteQuery<TInput>>>, 'input' | 'queryKey'>) => OmitKeyof<QueryObserverOptions<TOutput, DefaultError, TOutput, InfiniteData<TOutput>, QueryKey, InferCursor<TInput>>, 'queryKey'>;
+    setQueryDefaults: (options: Partial<OmitKeyof<QueryObserverOptions<TOutput>, 'queryKey'>>, filters?: Pick<ORPCQueryFilters<PartialDeep<TInput>>, 'input' | 'queryKey'>) => void;
+    setInfiniteQueryDefaults: (options: Partial<OmitKeyof<QueryObserverOptions<TOutput, DefaultError, TOutput, InfiniteData<TOutput>, QueryKey, InferCursor<TInput>>, 'queryKey'>>, filters?: Pick<ORPCQueryFilters<PartialDeep<TInput>>, 'input' | 'queryKey'>) => void;
+    getMutationDefaults: (filters?: Pick<MutationFilters, 'mutationKey'>) => MutationObserverOptions<TOutput, DefaultError, TInput>;
+    setMutationDefaults: (options: OmitKeyof<MutationObserverOptions<TOutput, DefaultError, TInput>, 'mutationKey'>, filters?: Pick<MutationFilters, 'mutationKey'>) => void;
 }
 export interface CreateGeneralUtilsOptions {
     queryClient: QueryClient;
@@ -37,4 +36,5 @@ export interface CreateGeneralUtilsOptions {
      */
     path: string[];
 }
-export declare function createGeneralUtils<TInputSchema extends Schema = undefined, TOutputSchema extends Schema = undefined, TFuncOutput extends SchemaOutput<TOutputSchema> = SchemaOutput<TOutputSchema>>(options: CreateGeneralUtilsOptions): GeneralUtils<TInputSchema, TOutputSchema, TFuncOutput>;
+export declare function createGeneralUtils<TInput, TOutput>(options: CreateGeneralUtilsOptions): GeneralUtils<TInput, TOutput>;
+//# sourceMappingURL=general-utils.d.ts.map

package/dist/src/index.d.ts

@@ -6,3 +6,4 @@ export * from './react';
 export * from './react-context';
 export * from './react-hooks';
 export * from './react-utils';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/orpc-path.d.ts

@@ -1,4 +1,5 @@
 import type { ProcedureHooks } from './procedure-hooks';
-import type { ORPCHooksWithContractRouter, ORPCHooksWithRouter } from './react-hooks';
+import type { ORPCHooks } from './react-hooks';
 export declare const orpcPathSymbol: unique symbol;
-export declare function getORPCPath(orpc: ORPCHooksWithContractRouter<any> | ORPCHooksWithRouter<any> | ProcedureHooks<any, any, any>): string[];
+export declare function getORPCPath(orpc: ORPCHooks<any> | ProcedureHooks<any, any>): string[];
+//# sourceMappingURL=orpc-path.d.ts.map

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

@@ -1,22 +1,21 @@
-import type { Schema, SchemaInput, SchemaOutput } from '@orpc/contract';
-import type { SchemaInputForInfiniteQuery } from './types';
+import type { InferCursor, SchemaInputForInfiniteQuery } from './types';
 import { type PartialOnUndefinedDeep, type SetOptional } from '@orpc/shared';
 import { type DefaultError, type FetchInfiniteQueryOptions, type FetchQueryOptions, type InfiniteData, type QueryKey, type UseInfiniteQueryOptions, type UseInfiniteQueryResult, type UseMutationOptions, type UseMutationResult, type UseQueryOptions, type UseQueryResult, type UseSuspenseInfiniteQueryOptions, type UseSuspenseInfiniteQueryResult, type UseSuspenseQueryOptions, type UseSuspenseQueryResult } from '@tanstack/react-query';
 import { type ORPCContext } from './react-context';
-export interface ProcedureHooks<TInputSchema extends Schema, TOutputSchema extends Schema, TFuncOutput extends SchemaOutput<TOutputSchema>> {
-    useQuery: <USelectData = SchemaOutput<TOutputSchema, TFuncOutput>>(input: SchemaInput<TInputSchema>, options?: SetOptional<UseQueryOptions<SchemaOutput<TOutputSchema, TFuncOutput>, DefaultError, USelectData>, 'queryFn' | 'queryKey'>) => UseQueryResult<USelectData>;
-    useInfiniteQuery: <USelectData = InfiniteData<SchemaOutput<TOutputSchema, TFuncOutput>, SchemaInput<TInputSchema>['cursor']>>(options: PartialOnUndefinedDeep<SetOptional<UseInfiniteQueryOptions<SchemaOutput<TOutputSchema, TFuncOutput>, DefaultError, USelectData, SchemaOutput<TOutputSchema, TFuncOutput>, QueryKey, SchemaInput<TInputSchema>['cursor']>, 'queryFn' | 'queryKey'> & {
-        input: SchemaInputForInfiniteQuery<TInputSchema>;
+export interface ProcedureHooks<TInput, TOutput> {
+    useQuery: <USelectData = TOutput>(input: TInput, options?: SetOptional<UseQueryOptions<TOutput, DefaultError, USelectData>, 'queryFn' | 'queryKey'>) => UseQueryResult<USelectData>;
+    useInfiniteQuery: <USelectData = InfiniteData<TOutput, InferCursor<TInput>>>(options: PartialOnUndefinedDeep<SetOptional<UseInfiniteQueryOptions<TOutput, DefaultError, USelectData, TOutput, QueryKey, InferCursor<TInput>>, 'queryFn' | 'queryKey'> & {
+        input: SchemaInputForInfiniteQuery<TInput>;
     }>) => UseInfiniteQueryResult<USelectData>;
-    useSuspenseQuery: <USelectData = SchemaOutput<TOutputSchema, TFuncOutput>>(input: SchemaInput<TInputSchema>, options?: SetOptional<UseSuspenseQueryOptions<SchemaOutput<TOutputSchema, TFuncOutput>, DefaultError, USelectData>, 'queryFn' | 'queryKey'>) => UseSuspenseQueryResult<USelectData>;
-    useSuspenseInfiniteQuery: <USelectData = InfiniteData<SchemaOutput<TOutputSchema, TFuncOutput>, SchemaInput<TInputSchema>['cursor']>>(options: PartialOnUndefinedDeep<SetOptional<UseSuspenseInfiniteQueryOptions<SchemaOutput<TOutputSchema, TFuncOutput>, DefaultError, USelectData, SchemaOutput<TOutputSchema, TFuncOutput>, QueryKey, SchemaInput<TInputSchema>['cursor']>, 'queryFn' | 'queryKey'> & {
-        input: SchemaInputForInfiniteQuery<TInputSchema>;
+    useSuspenseQuery: <USelectData = TOutput>(input: TInput, options?: SetOptional<UseSuspenseQueryOptions<TOutput, DefaultError, USelectData>, 'queryFn' | 'queryKey'>) => UseSuspenseQueryResult<USelectData>;
+    useSuspenseInfiniteQuery: <USelectData = InfiniteData<TOutput, InferCursor<TInput>>>(options: PartialOnUndefinedDeep<SetOptional<UseSuspenseInfiniteQueryOptions<TOutput, DefaultError, USelectData, TOutput, QueryKey, InferCursor<TInput>>, 'queryFn' | 'queryKey'> & {
+        input: SchemaInputForInfiniteQuery<TInput>;
     }>) => UseSuspenseInfiniteQueryResult<USelectData>;
-    usePrefetchQuery: (input: SchemaInput<TInputSchema>, options?: FetchQueryOptions<SchemaOutput<TOutputSchema, TFuncOutput>>) => void;
-    usePrefetchInfiniteQuery: (options: PartialOnUndefinedDeep<SetOptional<FetchInfiniteQueryOptions<SchemaOutput<TOutputSchema, TFuncOutput>, DefaultError, SchemaOutput<TOutputSchema, TFuncOutput>, QueryKey, SchemaInput<TInputSchema>['cursor']>, 'queryKey' | 'queryFn'> & {
-        input: SchemaInputForInfiniteQuery<TInputSchema>;
+    usePrefetchQuery: (input: TInput, options?: FetchQueryOptions<TOutput>) => void;
+    usePrefetchInfiniteQuery: (options: PartialOnUndefinedDeep<SetOptional<FetchInfiniteQueryOptions<TOutput, DefaultError, TOutput, QueryKey, InferCursor<TInput>>, 'queryKey' | 'queryFn'> & {
+        input: SchemaInputForInfiniteQuery<TInput>;
     }>) => void;
-    useMutation: (options?: SetOptional<UseMutationOptions<SchemaOutput<TOutputSchema, TFuncOutput>, DefaultError, SchemaInput<TInputSchema>>, 'mutationFn' | 'mutationKey'>) => UseMutationResult<SchemaOutput<TOutputSchema, TFuncOutput>, DefaultError, SchemaInput<TInputSchema>>;
+    useMutation: (options?: SetOptional<UseMutationOptions<TOutput, DefaultError, TInput>, 'mutationFn' | 'mutationKey'>) => UseMutationResult<TOutput, DefaultError, TInput>;
 }
 export interface CreateProcedureHooksOptions {
     context: ORPCContext<any>;
@@ -27,4 +26,5 @@ export interface CreateProcedureHooksOptions {
      */
     path: string[];
 }
-export declare function createProcedureHooks<TInputSchema extends Schema = undefined, TOutputSchema extends Schema = undefined, TFuncOutput extends SchemaOutput<TOutputSchema> = SchemaOutput<TOutputSchema>>(options: CreateProcedureHooksOptions): ProcedureHooks<TInputSchema, TOutputSchema, TFuncOutput>;
+export declare function createProcedureHooks<TInput, TOutput>(options: CreateProcedureHooksOptions): ProcedureHooks<TInput, TOutput>;
+//# sourceMappingURL=procedure-hooks.d.ts.map

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

@@ -1,34 +1,34 @@
-import type { ProcedureClient } from '@orpc/client';
-import type { Schema, SchemaInput, SchemaOutput } from '@orpc/contract';
+import type { ProcedureClient } from '@orpc/server';
 import type { PartialOnUndefinedDeep, SetOptional } from '@orpc/shared';
 import type { DefaultError, EnsureInfiniteQueryDataOptions, EnsureQueryDataOptions, FetchInfiniteQueryOptions, FetchQueryOptions, InfiniteData, QueryClient, QueryKey, QueryState, SetDataOptions, Updater } from '@tanstack/react-query';
-import type { SchemaInputForInfiniteQuery } from './types';
-export interface ProcedureUtils<TInputSchema extends Schema, TOutputSchema extends Schema, TFuncOutput extends SchemaOutput<TOutputSchema>> {
-    fetchQuery: (input: SchemaInput<TInputSchema>, options?: SetOptional<FetchQueryOptions<SchemaOutput<TOutputSchema, TFuncOutput>>, 'queryKey' | 'queryFn'>) => Promise<SchemaOutput<TOutputSchema, TFuncOutput>>;
-    fetchInfiniteQuery: (options: PartialOnUndefinedDeep<SetOptional<FetchInfiniteQueryOptions<SchemaOutput<TOutputSchema, TFuncOutput>, DefaultError, SchemaOutput<TOutputSchema, TFuncOutput>, QueryKey, SchemaInput<TInputSchema>['cursor']>, 'queryKey' | 'queryFn'> & {
-        input: SchemaInputForInfiniteQuery<TInputSchema>;
-    }>) => Promise<InfiniteData<SchemaOutput<TOutputSchema, TFuncOutput>, SchemaInput<TInputSchema>['cursor']>>;
-    prefetchQuery: (input: SchemaInput<TInputSchema>, options?: SetOptional<FetchQueryOptions<SchemaOutput<TOutputSchema, TFuncOutput>>, 'queryKey' | 'queryFn'>) => Promise<void>;
-    prefetchInfiniteQuery: (options: PartialOnUndefinedDeep<SetOptional<FetchInfiniteQueryOptions<SchemaOutput<TOutputSchema, TFuncOutput>, DefaultError, SchemaOutput<TOutputSchema, TFuncOutput>, QueryKey, SchemaInput<TInputSchema>['cursor']>, 'queryKey' | 'queryFn'> & {
-        input: SchemaInputForInfiniteQuery<TInputSchema>;
+import type { InferCursor, SchemaInputForInfiniteQuery } from './types';
+export interface ProcedureUtils<TInput, TOutput> {
+    fetchQuery: (input: TInput, options?: SetOptional<FetchQueryOptions<TOutput>, 'queryKey' | 'queryFn'>) => Promise<TOutput>;
+    fetchInfiniteQuery: (options: PartialOnUndefinedDeep<SetOptional<FetchInfiniteQueryOptions<TOutput, DefaultError, TOutput, QueryKey, InferCursor<TInput>>, 'queryKey' | 'queryFn'> & {
+        input: SchemaInputForInfiniteQuery<TInput>;
+    }>) => Promise<InfiniteData<TOutput, InferCursor<TInput>>>;
+    prefetchQuery: (input: TInput, options?: SetOptional<FetchQueryOptions<TOutput>, 'queryKey' | 'queryFn'>) => Promise<void>;
+    prefetchInfiniteQuery: (options: PartialOnUndefinedDeep<SetOptional<FetchInfiniteQueryOptions<TOutput, DefaultError, TOutput, QueryKey, InferCursor<TInput>>, 'queryKey' | 'queryFn'> & {
+        input: SchemaInputForInfiniteQuery<TInput>;
     }>) => Promise<void>;
-    getQueryData: (input: SchemaInput<TInputSchema>) => SchemaOutput<TOutputSchema, TFuncOutput> | undefined;
-    getInfiniteQueryData: (input: SchemaInputForInfiniteQuery<TInputSchema>) => InfiniteData<SchemaOutput<TOutputSchema, TFuncOutput>, SchemaInput<TInputSchema>['cursor']> | undefined;
-    ensureQueryData: (input: SchemaInput<TInputSchema>, options?: SetOptional<EnsureQueryDataOptions<SchemaOutput<TOutputSchema, TFuncOutput>>, 'queryFn' | 'queryKey'>) => Promise<SchemaOutput<TOutputSchema, TFuncOutput>>;
-    ensureInfiniteQueryData: (options: PartialOnUndefinedDeep<SetOptional<EnsureInfiniteQueryDataOptions<SchemaOutput<TOutputSchema, TFuncOutput>, DefaultError, SchemaOutput<TOutputSchema, TFuncOutput>, QueryKey, SchemaInput<TInputSchema>['cursor']>, 'queryKey' | 'queryFn'> & {
-        input: SchemaInputForInfiniteQuery<TInputSchema>;
-    }>) => Promise<InfiniteData<SchemaOutput<TOutputSchema, TFuncOutput>, SchemaInput<TInputSchema>['cursor']>>;
-    getQueryState: (input: SchemaInput<TInputSchema>) => QueryState<SchemaOutput<TOutputSchema, TFuncOutput>> | undefined;
-    getInfiniteQueryState: (input: SchemaInputForInfiniteQuery<TInputSchema>) => QueryState<InfiniteData<SchemaOutput<TOutputSchema, TFuncOutput>, SchemaInput<TInputSchema>['cursor']>> | undefined;
-    setQueryData: (input: SchemaInput<TInputSchema>, updater: Updater<SchemaOutput<TOutputSchema, TFuncOutput> | undefined, SchemaOutput<TOutputSchema, TFuncOutput> | undefined>, options?: SetDataOptions) => SchemaOutput<TOutputSchema, TFuncOutput> | undefined;
-    setInfiniteQueryData: (input: SchemaInputForInfiniteQuery<TInputSchema>, updater: Updater<InfiniteData<SchemaOutput<TOutputSchema, TFuncOutput>, SchemaInput<TInputSchema>['cursor']> | undefined, InfiniteData<SchemaOutput<TOutputSchema, TFuncOutput>, SchemaInput<TInputSchema>['cursor']> | undefined>, options?: SetDataOptions) => InfiniteData<SchemaOutput<TOutputSchema, TFuncOutput>, SchemaInput<TInputSchema>['cursor']> | undefined;
+    getQueryData: (input: TInput) => TOutput | undefined;
+    getInfiniteQueryData: (input: SchemaInputForInfiniteQuery<TInput>) => InfiniteData<TOutput, InferCursor<TInput>> | undefined;
+    ensureQueryData: (input: TInput, options?: SetOptional<EnsureQueryDataOptions<TOutput>, 'queryFn' | 'queryKey'>) => Promise<TOutput>;
+    ensureInfiniteQueryData: (options: PartialOnUndefinedDeep<SetOptional<EnsureInfiniteQueryDataOptions<TOutput, DefaultError, TOutput, QueryKey, InferCursor<TInput>>, 'queryKey' | 'queryFn'> & {
+        input: SchemaInputForInfiniteQuery<TInput>;
+    }>) => Promise<InfiniteData<TOutput, InferCursor<TInput>>>;
+    getQueryState: (input: TInput) => QueryState<TOutput> | undefined;
+    getInfiniteQueryState: (input: SchemaInputForInfiniteQuery<TInput>) => QueryState<InfiniteData<TOutput, InferCursor<TInput>>> | undefined;
+    setQueryData: (input: TInput, updater: Updater<TOutput | undefined, TOutput | undefined>, options?: SetDataOptions) => TOutput | undefined;
+    setInfiniteQueryData: (input: SchemaInputForInfiniteQuery<TInput>, updater: Updater<InfiniteData<TOutput, InferCursor<TInput>> | undefined, InfiniteData<TOutput, InferCursor<TInput>> | undefined>, options?: SetDataOptions) => InfiniteData<TOutput, InferCursor<TInput>> | undefined;
 }
-export interface CreateProcedureUtilsOptions<TInputSchema extends Schema = undefined, TOutputSchema extends Schema = undefined, TFuncOutput extends SchemaOutput<TOutputSchema> = SchemaOutput<TOutputSchema>> {
-    client: ProcedureClient<TInputSchema, TOutputSchema, TFuncOutput>;
+export interface CreateProcedureUtilsOptions<TInput, TOutput> {
+    client: ProcedureClient<TInput, TOutput, any>;
     queryClient: QueryClient;
     /**
      * The path of procedure on sever
      */
     path: string[];
 }
-export declare function createProcedureUtils<TInputSchema extends Schema, TOutputSchema extends Schema, TFuncOutput extends SchemaOutput<TOutputSchema>>(options: CreateProcedureUtilsOptions<TInputSchema, TOutputSchema, TFuncOutput>): ProcedureUtils<TInputSchema, TOutputSchema, TFuncOutput>;
+export declare function createProcedureUtils<TInput, TOutput>(options: CreateProcedureUtilsOptions<TInput, TOutput>): ProcedureUtils<TInput, TOutput>;
+//# sourceMappingURL=procedure-utils.d.ts.map

package/dist/src/react-context.d.ts

@@ -1,12 +1,11 @@
-import type { RouterClientWithContractRouter, RouterClientWithRouter } from '@orpc/client';
-import type { ContractRouter } from '@orpc/contract';
-import type { Router } from '@orpc/server';
+import type { RouterClient } from '@orpc/server';
 import type { QueryClient } from '@tanstack/react-query';
 import { type Context } from 'react';
-export interface ORPCContextValue<TRouter extends ContractRouter | Router<any>> {
-    client: TRouter extends ContractRouter ? RouterClientWithContractRouter<TRouter> : TRouter extends Router<any> ? RouterClientWithRouter<TRouter> : never;
+export interface ORPCContextValue<T extends RouterClient<any, any>> {
+    client: T;
     queryClient: QueryClient;
 }
-export type ORPCContext<TRouter extends ContractRouter | Router<any>> = Context<ORPCContextValue<TRouter> | undefined>;
-export declare function createORPCContext<TRouter extends ContractRouter | Router<any>>(): ORPCContext<TRouter>;
-export declare function useORPCContext<TRouter extends ContractRouter | Router<any>>(context: ORPCContext<TRouter>): ORPCContextValue<TRouter>;
+export type ORPCContext<T extends RouterClient<any, any>> = Context<ORPCContextValue<T> | undefined>;
+export declare function createORPCContext<T extends RouterClient<any, any>>(): ORPCContext<T>;
+export declare function useORPCContext<T extends RouterClient<any, any>>(context: ORPCContext<T>): ORPCContextValue<T>;
+//# sourceMappingURL=react-context.d.ts.map

package/dist/src/react-hooks.d.ts

@@ -1,16 +1,12 @@
-import type { ContractProcedure, ContractRouter, SchemaOutput } from '@orpc/contract';
-import type { Procedure, Router } from '@orpc/server';
+import type { ProcedureClient, RouterClient } from '@orpc/server';
 import type { ORPCContext } from './react-context';
 import { type GeneralHooks } from './general-hooks';
 import { type ProcedureHooks } from './procedure-hooks';
-export type ORPCHooksWithContractRouter<TRouter extends ContractRouter> = {
-    [K in keyof TRouter]: TRouter[K] extends ContractProcedure<infer UInputSchema, infer UOutputSchema> ? ProcedureHooks<UInputSchema, UOutputSchema, SchemaOutput<UOutputSchema>> & GeneralHooks<UInputSchema, UOutputSchema, SchemaOutput<UOutputSchema>> : TRouter[K] extends ContractRouter ? ORPCHooksWithContractRouter<TRouter[K]> : never;
-} & GeneralHooks<undefined, undefined, unknown>;
-export type ORPCHooksWithRouter<TRouter extends Router<any>> = {
-    [K in keyof TRouter]: TRouter[K] extends Procedure<any, any, infer UInputSchema, infer UOutputSchema, infer UFuncOutput> ? ProcedureHooks<UInputSchema, UOutputSchema, UFuncOutput> & GeneralHooks<UInputSchema, UOutputSchema, UFuncOutput> : TRouter[K] extends Router<any> ? ORPCHooksWithRouter<TRouter[K]> : never;
-} & GeneralHooks<undefined, undefined, unknown>;
-export interface CreateORPCHooksOptions<TRouter extends ContractRouter | Router<any>> {
-    context: ORPCContext<TRouter>;
+export type ORPCHooks<T extends RouterClient<any, any>> = T extends ProcedureClient<infer TInput, infer TOutput, any> ? ProcedureHooks<TInput, TOutput> & GeneralHooks<TInput, TOutput> : {
+    [K in keyof T]: T[K] extends RouterClient<any, any> ? ORPCHooks<T[K]> : never;
+} & GeneralHooks<unknown, unknown>;
+export interface CreateORPCHooksOptions<T extends RouterClient<any, any>> {
+    context: ORPCContext<T>;
     /**
      * The path of the router.
      *
@@ -18,4 +14,5 @@ export interface CreateORPCHooksOptions<TRouter extends ContractRouter | Router<
      */
     path?: string[];
 }
-export declare function createORPCHooks<TRouter extends ContractRouter | Router<any>>(options: CreateORPCHooksOptions<TRouter>): TRouter extends Router<any> ? ORPCHooksWithRouter<TRouter> : TRouter extends ContractRouter ? ORPCHooksWithContractRouter<TRouter> : never;
+export declare function createORPCHooks<T extends RouterClient<any, any>>(options: CreateORPCHooksOptions<T>): ORPCHooks<T>;
+//# sourceMappingURL=react-hooks.d.ts.map

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

@@ -1,16 +1,12 @@
-import type { ContractProcedure, ContractRouter, SchemaOutput } from '@orpc/contract';
-import type { Procedure, Router } from '@orpc/server';
+import type { ProcedureClient, RouterClient } from '@orpc/server';
 import type { ORPCContextValue } from './react-context';
 import { type GeneralUtils } from './general-utils';
 import { type ProcedureUtils } from './procedure-utils';
-export type ORPCUtilsWithContractRouter<TRouter extends ContractRouter> = {
-    [K in keyof TRouter]: TRouter[K] extends ContractProcedure<infer UInputSchema, infer UOutputSchema> ? ProcedureUtils<UInputSchema, UOutputSchema, SchemaOutput<UOutputSchema>> & GeneralUtils<UInputSchema, UOutputSchema, SchemaOutput<UOutputSchema>> : TRouter[K] extends ContractRouter ? ORPCUtilsWithContractRouter<TRouter[K]> : never;
-} & GeneralUtils<undefined, undefined, unknown>;
-export type ORPCUtilsWithRouter<TRouter extends Router<any>> = {
-    [K in keyof TRouter]: TRouter[K] extends Procedure<any, any, infer UInputSchema, infer UOutputSchema, infer UFuncOutput> ? ProcedureUtils<UInputSchema, UOutputSchema, UFuncOutput> & GeneralUtils<UInputSchema, UOutputSchema, UFuncOutput> : TRouter[K] extends Router<any> ? ORPCUtilsWithRouter<TRouter[K]> : never;
-} & GeneralUtils<undefined, undefined, unknown>;
-export interface CreateORPCUtilsOptions<TRouter extends ContractRouter | Router<any>> {
-    contextValue: ORPCContextValue<TRouter>;
+export type ORPCUtils<T extends RouterClient<any, any>> = T extends ProcedureClient<infer TInput, infer TOutput, any> ? ProcedureUtils<TInput, TOutput> & GeneralUtils<TInput, TOutput> : {
+    [K in keyof T]: T[K] extends RouterClient<any, any> ? ORPCUtils<T[K]> : never;
+} & GeneralUtils<unknown, unknown>;
+export interface CreateORPCUtilsOptions<T extends RouterClient<any, any>> {
+    contextValue: ORPCContextValue<T>;
     /**
      * The path of the router.
      *
@@ -18,4 +14,5 @@ export interface CreateORPCUtilsOptions<TRouter extends ContractRouter | Router<
      */
     path?: string[];
 }
-export declare function createORPCUtils<TRouter extends ContractRouter | Router<any>>(options: CreateORPCUtilsOptions<TRouter>): TRouter extends Router<any> ? ORPCUtilsWithRouter<TRouter> : TRouter extends ContractRouter ? ORPCUtilsWithContractRouter<TRouter> : never;
+export declare function createORPCUtils<T extends RouterClient<any, any>>(options: CreateORPCUtilsOptions<T>): ORPCUtils<T>;
+//# sourceMappingURL=react-utils.d.ts.map

package/dist/src/react.d.ts

@@ -1,20 +1,15 @@
-import type { ContractRouter } from '@orpc/contract';
-import type { Router } from '@orpc/server';
-import { type ORPCContext, type ORPCContextValue } from './react-context';
-import { type ORPCHooksWithContractRouter, type ORPCHooksWithRouter } from './react-hooks';
-import { type ORPCUtilsWithContractRouter, type ORPCUtilsWithRouter } from './react-utils';
-import { type UseQueriesWithContractRouter, type UseQueriesWithRouter } from './use-queries/hook';
-export type ORPCReactWithContractRouter<TRouter extends ContractRouter> = ORPCHooksWithContractRouter<TRouter> & {
-    useContext: () => ORPCContextValue<TRouter>;
-    useUtils: () => ORPCUtilsWithContractRouter<TRouter>;
-    useQueries: UseQueriesWithContractRouter<TRouter>;
+import type { RouterClient } from '@orpc/server';
+import type { ORPCContext, ORPCContextValue } from './react-context';
+import type { ORPCHooks } from './react-hooks';
+import type { ORPCUtils } from './react-utils';
+import type { UseQueries } from './use-queries/hook';
+export type ORPCReact<T extends RouterClient<any, any>> = ORPCHooks<T> & {
+    useContext: () => ORPCContextValue<T>;
+    useUtils: () => ORPCUtils<T>;
+    useQueries: UseQueries<T>;
 };
-export type ORPCReactWithRouter<TRouter extends Router<any>> = ORPCHooksWithRouter<TRouter> & {
-    useContext: () => ORPCContextValue<TRouter>;
-    useUtils: () => ORPCUtilsWithRouter<TRouter>;
-    useQueries: UseQueriesWithRouter<TRouter>;
-};
-export declare function createORPCReact<TRouter extends ContractRouter | Router<any>>(): {
-    orpc: TRouter extends Router<any> ? ORPCReactWithRouter<TRouter> : TRouter extends ContractRouter ? ORPCReactWithContractRouter<TRouter> : never;
-    ORPCContext: ORPCContext<TRouter>;
+export declare function createORPCReact<T extends RouterClient<any, any>>(): {
+    orpc: ORPCReact<T>;
+    ORPCContext: ORPCContext<T>;
 };
+//# sourceMappingURL=react.d.ts.map

package/dist/src/tanstack-key.d.ts

@@ -1,14 +1,14 @@
-import type { SchemaInput } from '@orpc/contract';
 import type { PartialDeep } from '@orpc/shared';
 import type { MutationKey, QueryKey } from '@tanstack/react-query';
 import type { ProcedureHooks } from './procedure-hooks';
-import type { ORPCHooksWithContractRouter, ORPCHooksWithRouter } from './react-hooks';
+import type { ORPCHooks } from './react-hooks';
 export type QueryType = 'query' | 'infinite' | undefined;
 export interface GetQueryKeyOptions<TInput> {
     input?: TInput;
     type?: QueryType;
 }
-export declare function getQueryKey<T extends ORPCHooksWithContractRouter<any> | ORPCHooksWithRouter<any> | ProcedureHooks<any, any, any>>(orpc: T, options?: GetQueryKeyOptions<T extends ProcedureHooks<infer UInputSchema, any, any> ? PartialDeep<SchemaInput<UInputSchema>> : unknown>): QueryKey;
+export declare function getQueryKey<T extends ORPCHooks<any> | ProcedureHooks<any, any>>(orpc: T, options?: GetQueryKeyOptions<T extends ProcedureHooks<infer UInput, any> ? PartialDeep<UInput> : unknown>): QueryKey;
 export declare function getQueryKeyFromPath(path: string[], options?: GetQueryKeyOptions<unknown>): QueryKey;
-export declare function getMutationKey<T extends ORPCHooksWithContractRouter<any> | ORPCHooksWithRouter<any> | ProcedureHooks<any, any, any>>(orpc: T): MutationKey;
+export declare function getMutationKey<T extends ORPCHooks<any> | ProcedureHooks<any, any>>(orpc: T): MutationKey;
 export declare function getMutationKeyFromPath(path: string[]): MutationKey;
+//# sourceMappingURL=tanstack-key.d.ts.map

package/dist/src/tanstack-query.d.ts

@@ -16,3 +16,4 @@ export interface ORPCQueryFilters<TFilterInput> extends SetOptional<QueryFilters
 }
 export interface ORPCInvalidateQueryFilters<TFilterInput> extends SetOptional<InvalidateQueryFilters, 'queryKey'>, ORPCAdditionalQueryFilters<TFilterInput> {
 }
+//# sourceMappingURL=tanstack-query.d.ts.map

package/dist/src/types.d.ts

@@ -1,4 +1,5 @@
-import type { Schema, SchemaInput } from '@orpc/contract';
-export type SchemaInputForInfiniteQuery<TInputSchema extends Schema> = Omit<SchemaInput<TInputSchema>, 'cursor'> & (Record<string | number, any> & {
-    cursor?: never;
-});
+export type SchemaInputForInfiniteQuery<TInput> = Omit<TInput, 'cursor'>;
+export type InferCursor<TInput> = TInput extends {
+    cursor?: any;
+} ? TInput['cursor'] : never;
+//# sourceMappingURL=types.d.ts.map

package/dist/src/use-queries/builder.d.ts

@@ -1,19 +1,19 @@
-import type { ProcedureClient } from '@orpc/client';
-import type { Schema, SchemaInput, SchemaOutput } from '@orpc/contract';
+import type { ProcedureClient } from '@orpc/server';
 import type { SetOptional } from '@orpc/shared';
 import type { DefaultError, OmitKeyof, QueriesPlaceholderDataFunction, QueryKey, UseQueryOptions } from '@tanstack/react-query';
 type UseQueryOptionsForUseQueries<TQueryFnData, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = OmitKeyof<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'placeholderData'> & {
     placeholderData?: TQueryFnData | QueriesPlaceholderDataFunction<TQueryFnData>;
 };
-export interface UseQueriesBuilder<TInputSchema extends Schema, TOutputSchema extends Schema, TFuncOutput extends SchemaOutput<TOutputSchema>> {
-    (input: SchemaInput<TInputSchema>, options?: SetOptional<UseQueryOptionsForUseQueries<SchemaOutput<TOutputSchema, TFuncOutput>>, 'queryFn' | 'queryKey'>): UseQueryOptionsForUseQueries<SchemaOutput<TOutputSchema, TFuncOutput>>;
+export interface UseQueriesBuilder<TInput, TOutput> {
+    (input: TInput, options?: SetOptional<UseQueryOptionsForUseQueries<TOutput>, 'queryFn' | 'queryKey'>): UseQueryOptionsForUseQueries<TOutput>;
 }
-export interface CreateUseQueriesBuilderOptions<TInputSchema extends Schema, TOutputSchema extends Schema, TFuncOutput extends SchemaOutput<TOutputSchema>> {
-    client: ProcedureClient<TInputSchema, TOutputSchema, TFuncOutput>;
+export interface CreateUseQueriesBuilderOptions<TInput, TOutput> {
+    client: ProcedureClient<TInput, TOutput, any>;
     /**
      * The path of procedure on server
      */
     path: string[];
 }
-export declare function createUseQueriesBuilder<TInputSchema extends Schema = undefined, TOutputSchema extends Schema = undefined, TFuncOutput extends SchemaOutput<TOutputSchema> = SchemaOutput<TOutputSchema>>(options: CreateUseQueriesBuilderOptions<TInputSchema, TOutputSchema, TFuncOutput>): UseQueriesBuilder<TInputSchema, TOutputSchema, TFuncOutput>;
+export declare function createUseQueriesBuilder<TInput, TOutput>(options: CreateUseQueriesBuilderOptions<TInput, TOutput>): UseQueriesBuilder<TInput, TOutput>;
 export {};
+//# sourceMappingURL=builder.d.ts.map

package/dist/src/use-queries/builders.d.ts

@@ -1,18 +1,14 @@
-import type { RouterClientWithContractRouter, RouterClientWithRouter } from '@orpc/client';
-import type { ContractProcedure, ContractRouter, SchemaOutput } from '@orpc/contract';
-import type { Procedure, Router } from '@orpc/server';
+import type { ProcedureClient, RouterClient } from '@orpc/server';
 import { type UseQueriesBuilder } from './builder';
-export type UseQueriesBuildersWithContractRouter<TRouter extends ContractRouter> = {
-    [K in keyof TRouter]: TRouter[K] extends ContractProcedure<infer UInputSchema, infer UOutputSchema> ? UseQueriesBuilder<UInputSchema, UOutputSchema, SchemaOutput<UOutputSchema>> : TRouter[K] extends ContractRouter ? UseQueriesBuildersWithContractRouter<TRouter[K]> : never;
+export type UseQueriesBuilders<T extends RouterClient<any, any>> = T extends ProcedureClient<infer UInput, infer UOutput, any> ? UseQueriesBuilder<UInput, UOutput> : {
+    [K in keyof T]: T[K] extends RouterClient<any, any> ? UseQueriesBuilders<T[K]> : never;
 };
-export type UseQueriesBuildersWithRouter<TRouter extends Router<any>> = {
-    [K in keyof TRouter]: TRouter[K] extends Procedure<any, any, infer UInputSchema, infer UOutputSchema, infer UFuncOutput> ? UseQueriesBuilder<UInputSchema, UOutputSchema, UFuncOutput> : TRouter[K] extends Router<any> ? UseQueriesBuildersWithRouter<TRouter[K]> : never;
-};
-export interface CreateUseQueriesBuildersOptions<TRouter extends Router<any> | ContractRouter> {
-    client: TRouter extends Router<any> ? RouterClientWithRouter<TRouter> : TRouter extends ContractRouter ? RouterClientWithContractRouter<TRouter> : never;
+export interface CreateUseQueriesBuildersOptions<T extends RouterClient<any, any>> {
+    client: T;
     /**
      * The path of router on server
      */
     path?: string[];
 }
-export declare function createUseQueriesBuilders<TRouter extends Router<any> | ContractRouter>(options: CreateUseQueriesBuildersOptions<TRouter>): TRouter extends Router<any> ? UseQueriesBuildersWithRouter<TRouter> : TRouter extends ContractRouter ? UseQueriesBuildersWithContractRouter<TRouter> : never;
+export declare function createUseQueriesBuilders<T extends RouterClient<any, any>>(options: CreateUseQueriesBuildersOptions<T>): UseQueriesBuilders<T>;
+//# sourceMappingURL=builders.d.ts.map

package/dist/src/use-queries/hook.d.ts

@@ -1,15 +1,12 @@
-import type { ContractRouter } from '@orpc/contract';
-import type { Router } from '@orpc/server';
-import { type QueriesOptions, type QueriesResults } from '@tanstack/react-query';
-import { type ORPCContext } from '../react-context';
-import { type UseQueriesBuildersWithContractRouter, type UseQueriesBuildersWithRouter } from './builders';
-export interface UseQueriesWithContractRouter<TRouter extends ContractRouter> {
-    <T extends Array<any> = [], TCombinedResult = QueriesResults<T>>(build: (builders: UseQueriesBuildersWithContractRouter<TRouter>) => [...QueriesOptions<T>], combine?: (result: QueriesResults<T>) => TCombinedResult): TCombinedResult;
+import type { RouterClient } from '@orpc/server';
+import type { QueriesOptions, QueriesResults } from '@tanstack/react-query';
+import type { ORPCContext } from '../react-context';
+import type { UseQueriesBuilders } from './builders';
+export interface UseQueries<T extends RouterClient<any, any>> {
+    <U extends Array<any> = [], UCombinedResult = QueriesResults<U>>(build: (builders: UseQueriesBuilders<T>) => [...QueriesOptions<U>], combine?: (result: QueriesResults<U>) => UCombinedResult): UCombinedResult;
 }
-export interface UseQueriesWithRouter<TRouter extends Router<any>> {
-    <T extends Array<any> = [], TCombinedResult = QueriesResults<T>>(build: (builders: UseQueriesBuildersWithRouter<TRouter>) => [...QueriesOptions<T>], combine?: (result: QueriesResults<T>) => TCombinedResult): TCombinedResult;
+export interface UseQueriesFactoryOptions<T extends RouterClient<any, any>> {
+    context: ORPCContext<T>;
 }
-export interface UseQueriesFactoryOptions<TRouter extends Router<any> | ContractRouter> {
-    context: ORPCContext<TRouter>;
-}
-export declare function useQueriesFactory<TRouter extends Router<any> | ContractRouter>(options: UseQueriesFactoryOptions<TRouter>): TRouter extends Router<any> ? UseQueriesWithRouter<TRouter> : TRouter extends ContractRouter ? UseQueriesWithContractRouter<TRouter> : never;
+export declare function useQueriesFactory<T extends RouterClient<any, any>>(options: UseQueriesFactoryOptions<T>): UseQueries<T>;
+//# sourceMappingURL=hook.d.ts.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/react",
   "type": "module",
-  "version": "0.0.0-next.ef3ba82",
+  "version": "0.0.0-next.fd1db03",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -24,24 +24,25 @@
     }
   },
   "files": [
-    "!dist/*.tsbuildinfo",
+    "!**/*.map",
+    "!**/*.tsbuildinfo",
     "dist"
   ],
   "peerDependencies": {
-    "@tanstack/react-query": ">=5.59.0",
+    "@tanstack/react-query": ">=5.55.0",
     "react": ">=18.3.0",
-    "@orpc/contract": "0.0.0-next.ef3ba82",
-    "@orpc/server": "0.0.0-next.ef3ba82",
-    "@orpc/client": "0.0.0-next.ef3ba82"
+    "@orpc/client": "0.0.0-next.fd1db03",
+    "@orpc/server": "0.0.0-next.fd1db03",
+    "@orpc/contract": "0.0.0-next.fd1db03"
   },
   "dependencies": {
-    "@orpc/shared": "0.0.0-next.ef3ba82"
+    "@orpc/shared": "0.0.0-next.fd1db03"
   },
   "devDependencies": {
-    "zod": "^3.23.8"
+    "zod": "^3.24.1"
   },
   "scripts": {
-    "build": "tsup --clean --entry.index=src/index.ts --format=esm --onSuccess='tsc -b --noCheck'",
+    "build": "tsup --clean --sourcemap --entry.index=src/index.ts --format=esm --onSuccess='tsc -b --noCheck'",
     "build:watch": "pnpm run build --watch",
     "type:check": "tsc -b"
   }