@orpc/react 0.0.0-unsafe-pr-2-20241118033608

package/dist/index.js

@@ -0,0 +1,635 @@
+import { useIsFetching, useIsMutating, useMutationState, useQuery, useInfiniteQuery, useSuspenseQuery, useSuspenseInfiniteQuery, usePrefetchQuery, usePrefetchInfiniteQuery, useMutation, useQueries } from "@tanstack/react-query";
+import { createContext, useContext } from "react";
+function createORPCContext() {
+  return createContext(void 0);
+}
+function useORPCContext(context) {
+  const value = useContext(context);
+  if (!value) {
+    throw new Error(
+      "useORPCContext must be used within a <ORPCContext.Provider>, please see the docs"
+    );
+  }
+  return value;
+}
+const orpcPathSymbol = Symbol("orpcPathSymbol");
+function getQueryKeyFromPath(path, options) {
+  const withInput = (options == null ? void 0 : options.input) !== void 0 ? { input: options == null ? void 0 : options.input } : {};
+  const withType = (options == null ? void 0 : options.type) !== void 0 ? { type: options == null ? void 0 : options.type } : {};
+  return [
+    path,
+    {
+      ...withInput,
+      ...withType
+    }
+  ];
+}
+function getMutationKeyFromPath(path) {
+  return [path];
+}
+function createGeneralHooks(options) {
+  return {
+    useIsFetching(filters) {
+      const { queryType, input, ...rest } = filters ?? {};
+      const context = useORPCContext(options.context);
+      return useIsFetching(
+        {
+          queryKey: getQueryKeyFromPath(options.path, {
+            input,
+            type: queryType
+          }),
+          ...rest
+        },
+        context.queryClient
+      );
+    },
+    useIsMutating(filters) {
+      const context = useORPCContext(options.context);
+      return useIsMutating(
+        { mutationKey: getMutationKeyFromPath(options.path), ...filters },
+        context.queryClient
+      );
+    },
+    useMutationState(options_) {
+      const context = useORPCContext(options.context);
+      return useMutationState(
+        {
+          ...options_,
+          filters: {
+            mutationKey: getMutationKeyFromPath(options.path),
+            ...options_ == null ? void 0 : options_.filters
+          }
+        },
+        context.queryClient
+      );
+    }
+  };
+}
+function createGeneralUtils(options) {
+  return {
+    getQueriesData(filters) {
+      const { input, ...rest } = filters ?? {};
+      return options.queryClient.getQueriesData({
+        queryKey: getQueryKeyFromPath(options.path, { input, type: "query" }),
+        ...rest
+      });
+    },
+    getInfiniteQueriesData(filters) {
+      const { input, ...rest } = filters ?? {};
+      return options.queryClient.getQueriesData({
+        queryKey: getQueryKeyFromPath(options.path, {
+          input,
+          type: "infinite"
+        }),
+        ...rest
+      });
+    },
+    setQueriesData(filters, updater, options_) {
+      const { input, ...rest } = filters;
+      return options.queryClient.setQueriesData(
+        {
+          queryKey: getQueryKeyFromPath(options.path, {
+            input,
+            type: "query"
+          }),
+          ...rest
+        },
+        updater,
+        options_
+      );
+    },
+    setInfiniteQueriesData(filters, updater, options_) {
+      const { input, ...rest } = filters;
+      return options.queryClient.setQueriesData(
+        {
+          queryKey: getQueryKeyFromPath(options.path, {
+            input,
+            type: "infinite"
+          }),
+          ...rest
+        },
+        updater,
+        options_
+      );
+    },
+    invalidate(filters, options_) {
+      const { input, queryType, ...rest } = filters ?? {};
+      return options.queryClient.invalidateQueries(
+        {
+          queryKey: getQueryKeyFromPath(options.path, {
+            input,
+            type: queryType
+          }),
+          ...rest
+        },
+        options_
+      );
+    },
+    refetch(filters, options_) {
+      const { input, queryType, ...rest } = filters ?? {};
+      return options.queryClient.refetchQueries(
+        {
+          queryKey: getQueryKeyFromPath(options.path, {
+            input,
+            type: queryType
+          }),
+          ...rest
+        },
+        options_
+      );
+    },
+    cancel(filters, options_) {
+      const { input, queryType, ...rest } = filters ?? {};
+      return options.queryClient.cancelQueries(
+        {
+          queryKey: getQueryKeyFromPath(options.path, {
+            input,
+            type: queryType
+          }),
+          ...rest
+        },
+        options_
+      );
+    },
+    remove(filters) {
+      const { input, queryType, ...rest } = filters ?? {};
+      return options.queryClient.removeQueries({
+        queryKey: getQueryKeyFromPath(options.path, {
+          input,
+          type: queryType
+        }),
+        ...rest
+      });
+    },
+    reset(filters, options_) {
+      const { input, queryType, ...rest } = filters ?? {};
+      return options.queryClient.resetQueries(
+        {
+          queryKey: getQueryKeyFromPath(options.path, {
+            input,
+            type: queryType
+          }),
+          ...rest
+        },
+        options_
+      );
+    },
+    isFetching(filters) {
+      const { input, queryType, ...rest } = filters ?? {};
+      return options.queryClient.isFetching({
+        queryKey: getQueryKeyFromPath(options.path, {
+          input,
+          type: queryType
+        }),
+        ...rest
+      });
+    },
+    isMutating(filters) {
+      return options.queryClient.isMutating({
+        mutationKey: getMutationKeyFromPath(options.path),
+        ...filters
+      });
+    },
+    getQueryDefaults(filters) {
+      return options.queryClient.getQueryDefaults(
+        (filters == null ? void 0 : filters.queryKey) ?? getQueryKeyFromPath(options.path, {
+          input: filters == null ? void 0 : filters.input,
+          type: "query"
+        })
+      );
+    },
+    getInfiniteQueryDefaults(filters) {
+      return options.queryClient.getQueryDefaults(
+        (filters == null ? void 0 : filters.queryKey) ?? getQueryKeyFromPath(options.path, {
+          input: filters == null ? void 0 : filters.input,
+          type: "infinite"
+        })
+      );
+    },
+    setQueryDefaults(options_, filters) {
+      return options.queryClient.setQueryDefaults(
+        (filters == null ? void 0 : filters.queryKey) ?? getQueryKeyFromPath(options.path, {
+          input: filters == null ? void 0 : filters.input,
+          type: "query"
+        }),
+        options_
+      );
+    },
+    setInfiniteQueryDefaults(options_, filters) {
+      return options.queryClient.setQueryDefaults(
+        (filters == null ? void 0 : filters.queryKey) ?? getQueryKeyFromPath(options.path, {
+          input: filters == null ? void 0 : filters.input,
+          type: "infinite"
+        }),
+        options_
+      );
+    },
+    getMutationDefaults(filters) {
+      return options.queryClient.getMutationDefaults(
+        (filters == null ? void 0 : filters.mutationKey) ?? getMutationKeyFromPath(options.path)
+      );
+    },
+    setMutationDefaults(options_, filters) {
+      return options.queryClient.setMutationDefaults(
+        (filters == null ? void 0 : filters.mutationKey) ?? getMutationKeyFromPath(options.path),
+        options_
+      );
+    }
+  };
+}
+function get(root, segments) {
+  const ref = { root };
+  let currentRef = ref;
+  let preSegment = "root";
+  for (const segment of segments) {
+    currentRef = currentRef[preSegment];
+    preSegment = segment;
+  }
+  return currentRef[preSegment];
+}
+function createProcedureHooks(options) {
+  return {
+    [orpcPathSymbol]: options.path,
+    useQuery(input, options_) {
+      const context = useORPCContext(options.context);
+      const client = get(context.client, options.path);
+      return useQuery(
+        {
+          queryKey: getQueryKeyFromPath(options.path, { input, type: "query" }),
+          queryFn: () => client(input),
+          ...options_
+        },
+        context.queryClient
+      );
+    },
+    useInfiniteQuery(options_) {
+      const { input, ...rest } = options_;
+      const context = useORPCContext(options.context);
+      const client = get(context.client, options.path);
+      return useInfiniteQuery(
+        {
+          queryKey: getQueryKeyFromPath(options.path, {
+            input,
+            type: "infinite"
+          }),
+          queryFn: ({ pageParam }) => client({ ...input, cursor: pageParam }),
+          ...rest
+        },
+        context.queryClient
+      );
+    },
+    useSuspenseQuery(input, options_) {
+      const context = useORPCContext(options.context);
+      const client = get(context.client, options.path);
+      return useSuspenseQuery(
+        {
+          queryKey: getQueryKeyFromPath(options.path, { input, type: "query" }),
+          queryFn: () => client(input),
+          ...options_
+        },
+        context.queryClient
+      );
+    },
+    useSuspenseInfiniteQuery(options_) {
+      const { input, ...rest } = options_;
+      const context = useORPCContext(options.context);
+      const client = get(context.client, options.path);
+      return useSuspenseInfiniteQuery(
+        {
+          queryKey: getQueryKeyFromPath(options.path, {
+            input,
+            type: "infinite"
+          }),
+          queryFn: ({ pageParam }) => client({ ...input, cursor: pageParam }),
+          ...rest
+        },
+        context.queryClient
+      );
+    },
+    usePrefetchQuery(input, options_) {
+      const context = useORPCContext(options.context);
+      const client = get(context.client, options.path);
+      return usePrefetchQuery(
+        {
+          queryKey: getQueryKeyFromPath(options.path, { input, type: "query" }),
+          queryFn: () => client(input),
+          ...options_
+        },
+        context.queryClient
+      );
+    },
+    usePrefetchInfiniteQuery(options_) {
+      const { input, ...rest } = options_;
+      const context = useORPCContext(options.context);
+      const client = get(context.client, options.path);
+      return usePrefetchInfiniteQuery(
+        {
+          queryKey: getQueryKeyFromPath(options.path, {
+            input,
+            type: "infinite"
+          }),
+          queryFn: ({ pageParam }) => client({ ...input, cursor: pageParam }),
+          ...rest
+        },
+        context.queryClient
+      );
+    },
+    useMutation(options_) {
+      const context = useORPCContext(options.context);
+      const client = get(context.client, options.path);
+      return useMutation(
+        {
+          mutationKey: getMutationKeyFromPath(options.path),
+          mutationFn: (input) => client(input),
+          ...options_
+        },
+        context.queryClient
+      );
+    }
+  };
+}
+function createProcedureUtils(options) {
+  return {
+    fetchQuery(input, options_) {
+      return options.queryClient.fetchQuery({
+        queryKey: getQueryKeyFromPath(options.path, { input, type: "query" }),
+        queryFn: () => options.client(input),
+        ...options_
+      });
+    },
+    fetchInfiniteQuery(options_) {
+      const { input, ...rest } = options_;
+      return options.queryClient.fetchInfiniteQuery({
+        queryKey: getQueryKeyFromPath(options.path, {
+          input,
+          type: "infinite"
+        }),
+        queryFn: ({ pageParam }) => {
+          return options.client({ ...input, pageParam });
+        },
+        ...rest
+      });
+    },
+    prefetchQuery(input, options_) {
+      return options.queryClient.prefetchQuery({
+        queryKey: getQueryKeyFromPath(options.path, {
+          input,
+          type: "query"
+        }),
+        queryFn: () => options.client(input),
+        ...options_
+      });
+    },
+    prefetchInfiniteQuery(options_) {
+      const { input, ...rest } = options_;
+      return options.queryClient.prefetchInfiniteQuery({
+        queryKey: getQueryKeyFromPath(options.path, {
+          input,
+          type: "infinite"
+        }),
+        queryFn: ({ pageParam }) => {
+          return options.client({ ...input, cursor: pageParam });
+        },
+        ...rest
+      });
+    },
+    getQueryData(input) {
+      return options.queryClient.getQueryData(
+        getQueryKeyFromPath(options.path, {
+          input,
+          type: "query"
+        })
+      );
+    },
+    getInfiniteQueryData(input) {
+      return options.queryClient.getQueryData(
+        getQueryKeyFromPath(options.path, {
+          input,
+          type: "infinite"
+        })
+      );
+    },
+    ensureQueryData(input, options_) {
+      return options.queryClient.ensureQueryData({
+        queryKey: getQueryKeyFromPath(options.path, {
+          input,
+          type: "query"
+        }),
+        queryFn: () => options.client(input),
+        ...options_
+      });
+    },
+    ensureInfiniteQueryData(options_) {
+      const { input, ...rest } = options_;
+      return options.queryClient.ensureInfiniteQueryData({
+        queryKey: getQueryKeyFromPath(options.path, {
+          input,
+          type: "infinite"
+        }),
+        queryFn: ({ pageParam }) => {
+          return options.client({ ...input, pageParam });
+        },
+        ...rest
+      });
+    },
+    getQueryState(input) {
+      return options.queryClient.getQueryState(
+        getQueryKeyFromPath(options.path, {
+          input,
+          type: "query"
+        })
+      );
+    },
+    getInfiniteQueryState(input) {
+      return options.queryClient.getQueryState(
+        getQueryKeyFromPath(options.path, {
+          input,
+          type: "infinite"
+        })
+      );
+    },
+    setQueryData(input, updater, options_) {
+      return options.queryClient.setQueryData(
+        getQueryKeyFromPath(options.path, {
+          input,
+          type: "query"
+        }),
+        updater,
+        options_
+      );
+    },
+    setInfiniteQueryData(input, updater, options_) {
+      return options.queryClient.setQueryData(
+        getQueryKeyFromPath(options.path, {
+          input,
+          type: "infinite"
+        }),
+        updater,
+        options_
+      );
+    }
+  };
+}
+function createORPCHooks(options) {
+  const path = options.path ?? [];
+  const generalHooks = createGeneralHooks({ context: options.context, path });
+  const procedureHooks = path.length ? createProcedureHooks({
+    context: options.context,
+    path
+  }) : {};
+  return new Proxy(
+    {
+      [orpcPathSymbol]: path,
+      ...generalHooks,
+      ...procedureHooks
+    },
+    {
+      get(target, key) {
+        const value = Reflect.get(target, key);
+        if (typeof key !== "string") {
+          return value;
+        }
+        const nextHooks = createORPCHooks({
+          context: options.context,
+          path: [...path, key]
+        });
+        if (typeof value !== "function") {
+          return nextHooks;
+        }
+        return new Proxy(value, {
+          get(_, key2) {
+            return Reflect.get(nextHooks, key2);
+          }
+        });
+      }
+    }
+  );
+}
+function createORPCUtils(options) {
+  const path = options.path ?? [];
+  const client = options.contextValue.client;
+  const generalUtils = createGeneralUtils({
+    queryClient: options.contextValue.queryClient,
+    path
+  });
+  const procedureUtils = path.length ? createProcedureUtils({
+    client,
+    queryClient: options.contextValue.queryClient,
+    path
+  }) : {};
+  return new Proxy(
+    {
+      ...generalUtils,
+      ...procedureUtils
+    },
+    {
+      get(target, key) {
+        const value = Reflect.get(target, key);
+        if (typeof key !== "string") {
+          return value;
+        }
+        const nextUtils = createORPCUtils({
+          ...options,
+          contextValue: {
+            ...options.contextValue,
+            client: client[key]
+          },
+          path: [...path, key]
+        });
+        if (typeof value !== "function") {
+          return nextUtils;
+        }
+        return new Proxy(value, {
+          get(_, key2) {
+            return Reflect.get(nextUtils, key2);
+          }
+        });
+      }
+    }
+  );
+}
+function createUseQueriesBuilder(options) {
+  return (input, options_) => {
+    return {
+      queryKey: getQueryKeyFromPath(options.path, { input, type: "query" }),
+      queryFn: () => options.client(input),
+      ...options_
+    };
+  };
+}
+function createUseQueriesBuilders(options) {
+  const path = options.path ?? [];
+  const client = options.client;
+  const builder = path.length ? createUseQueriesBuilder({ client, path }) : {};
+  return new Proxy(builder, {
+    get(target, key) {
+      const value = Reflect.get(target, key);
+      if (typeof key !== "string") {
+        return value;
+      }
+      const nextBuilders = createUseQueriesBuilders({
+        client: client[key],
+        path: [...path, key]
+      });
+      if (typeof value !== "function") {
+        return nextBuilders;
+      }
+      return new Proxy(value, {
+        get(_, key2) {
+          return Reflect.get(nextBuilders, key2);
+        }
+      });
+    }
+  });
+}
+function useQueriesFactory(options) {
+  const hook = (build, combine) => {
+    const orpc = useORPCContext(options.context);
+    const builders = createUseQueriesBuilders({ client: orpc.client });
+    return useQueries({
+      queries: build(builders),
+      combine
+    });
+  };
+  return hook;
+}
+function createORPCReact() {
+  const Context = createORPCContext();
+  const useContext2 = () => useORPCContext(Context);
+  const useUtils = () => createORPCUtils({ contextValue: useContext2() });
+  const useQueries2 = useQueriesFactory({ context: Context });
+  const hooks = createORPCHooks({ context: Context });
+  const orpc = new Proxy(
+    {
+      useContext: useContext2,
+      useUtils,
+      useQueries: useQueries2
+    },
+    {
+      get(target, key) {
+        const value = Reflect.get(target, key);
+        const nextHooks = Reflect.get(hooks, key);
+        if (typeof value !== "function") {
+          return nextHooks;
+        }
+        return new Proxy(value, {
+          get(_, key2) {
+            return Reflect.get(nextHooks, key2);
+          }
+        });
+      }
+    }
+  );
+  return { orpc, ORPCContext: Context };
+}
+export {
+  createGeneralHooks,
+  createGeneralUtils,
+  createORPCContext,
+  createORPCHooks,
+  createORPCReact,
+  createORPCUtils,
+  createProcedureHooks,
+  createProcedureUtils,
+  useORPCContext
+};

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

@@ -0,0 +1,24 @@
+import type { Schema, SchemaInput, SchemaOutput } from '@orpc/contract';
+import type { PartialDeep, SetOptional } from '@orpc/shared';
+import { type DefaultError, type Mutation, type MutationFilters, type MutationState } from '@tanstack/react-query';
+import { type ORPCContext } from './react-context';
+import type { ORPCQueryFilters } from './tanstack-query';
+export interface GeneralHooks<TInputSchema extends Schema, TOutputSchema extends Schema, THandlerOutput extends SchemaOutput<TOutputSchema>> {
+    useIsFetching(filers?: ORPCQueryFilters<PartialDeep<SchemaInput<TInputSchema>>>): number;
+    useIsMutating(filters?: SetOptional<MutationFilters, 'mutationKey'>): number;
+    useMutationState<UResult = MutationState<SchemaOutput<TOutputSchema, THandlerOutput>, DefaultError, SchemaInput<TInputSchema>>>(options?: {
+        filters?: SetOptional<MutationFilters, 'mutationKey'>;
+        select?: (mutation: Mutation<SchemaOutput<TOutputSchema, THandlerOutput>, DefaultError, SchemaInput<TInputSchema>>) => UResult;
+    }): UResult[];
+}
+export interface CreateGeneralHooksOptions {
+    context: ORPCContext<any>;
+    /**
+     * The path of the router or procedure on server.
+     *
+     * @internal
+     */
+    path: string[];
+}
+export declare function createGeneralHooks<TInputSchema extends Schema = undefined, TOutputSchema extends Schema = undefined, THandlerOutput extends SchemaOutput<TOutputSchema> = SchemaOutput<TOutputSchema>>(options: CreateGeneralHooksOptions): GeneralHooks<TInputSchema, TOutputSchema, THandlerOutput>;
+//# sourceMappingURL=general-hooks.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"general-hooks.d.ts","sourceRoot":"","sources":["../../src/general-hooks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AACvE,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAC5D,OAAO,EACL,KAAK,YAAY,EACjB,KAAK,QAAQ,EACb,KAAK,eAAe,EACpB,KAAK,aAAa,EAInB,MAAM,uBAAuB,CAAA;AAC9B,OAAO,EAAE,KAAK,WAAW,EAAkB,MAAM,iBAAiB,CAAA;AAElE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAA;AAExD,MAAM,WAAW,YAAY,CAC3B,YAAY,SAAS,MAAM,EAC3B,aAAa,SAAS,MAAM,EAC5B,cAAc,SAAS,YAAY,CAAC,aAAa,CAAC;IAElD,aAAa,CACX,MAAM,CAAC,EAAE,gBAAgB,CAAC,WAAW,CAAC,WAAW,CAAC,YAAY,CAAC,CAAC,CAAC,GAChE,MAAM,CAAA;IACT,aAAa,CAAC,OAAO,CAAC,EAAE,WAAW,CAAC,eAAe,EAAE,aAAa,CAAC,GAAG,MAAM,CAAA;IAE5E,gBAAgB,CACd,OAAO,GAAG,aAAa,CACrB,YAAY,CAAC,aAAa,EAAE,cAAc,CAAC,EAC3C,YAAY,EACZ,WAAW,CAAC,YAAY,CAAC,CAC1B,EACD,OAAO,CAAC,EAAE;QACV,OAAO,CAAC,EAAE,WAAW,CAAC,eAAe,EAAE,aAAa,CAAC,CAAA;QACrD,MAAM,CAAC,EAAE,CACP,QAAQ,EAAE,QAAQ,CAChB,YAAY,CAAC,aAAa,EAAE,cAAc,CAAC,EAC3C,YAAY,EACZ,WAAW,CAAC,YAAY,CAAC,CAC1B,KACE,OAAO,CAAA;KACb,GAAG,OAAO,EAAE,CAAA;CACd;AAED,MAAM,WAAW,yBAAyB;IACxC,OAAO,EAAE,WAAW,CAAC,GAAG,CAAC,CAAA;IAEzB;;;;OAIG;IACH,IAAI,EAAE,MAAM,EAAE,CAAA;CACf;AAED,wBAAgB,kBAAkB,CAChC,YAAY,SAAS,MAAM,GAAG,SAAS,EACvC,aAAa,SAAS,MAAM,GAAG,SAAS,EACxC,cAAc,SACZ,YAAY,CAAC,aAAa,CAAC,GAAG,YAAY,CAAC,aAAa,CAAC,EAE3D,OAAO,EAAE,yBAAyB,GACjC,YAAY,CAAC,YAAY,EAAE,aAAa,EAAE,cAAc,CAAC,CAsC3D"}

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

@@ -0,0 +1,41 @@
+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, THandlerOutput extends SchemaOutput<TOutputSchema>> {
+    getQueriesData(filters?: OmitKeyof<ORPCQueryFilters<PartialDeep<SchemaInput<TInputSchema>>>, 'queryType'>): [QueryKey, SchemaOutput<TOutputSchema, THandlerOutput> | undefined][];
+    getInfiniteQueriesData(filters?: OmitKeyof<ORPCQueryFilters<PartialDeep<SchemaInputForInfiniteQuery<TInputSchema>>>, 'queryType'>): [
+        QueryKey,
+        (InfiniteData<SchemaOutput<TOutputSchema, THandlerOutput>, SchemaInput<TInputSchema>['cursor']> | undefined)
+    ][];
+    setQueriesData(filters: OmitKeyof<ORPCQueryFilters<PartialDeep<SchemaInput<TInputSchema>>>, 'queryType'>, updater: Updater<SchemaOutput<TOutputSchema, THandlerOutput> | undefined, SchemaOutput<TOutputSchema, THandlerOutput> | undefined>, options?: SetDataOptions): [QueryKey, SchemaOutput<TOutputSchema, THandlerOutput> | undefined][];
+    setInfiniteQueriesData(filters: OmitKeyof<ORPCQueryFilters<PartialDeep<SchemaInputForInfiniteQuery<TInputSchema>>>, 'queryType'>, updater: Updater<InfiniteData<SchemaOutput<TOutputSchema, THandlerOutput>, SchemaInput<TInputSchema>['cursor']> | undefined, InfiniteData<SchemaOutput<TOutputSchema, THandlerOutput>, SchemaInput<TInputSchema>['cursor']> | undefined>, options?: SetDataOptions): [
+        QueryKey,
+        (InfiniteData<SchemaOutput<TOutputSchema, THandlerOutput>, SchemaInput<TInputSchema>['cursor']> | undefined)
+    ][];
+    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;
+    isMutating(filters?: SetOptional<MutationFilters, 'mutationKey'>): number;
+    getQueryDefaults(filters?: Pick<ORPCQueryFilters<PartialDeep<SchemaInput<TInputSchema>>>, 'input' | 'queryKey'>): OmitKeyof<QueryObserverOptions<SchemaOutput<TOutputSchema, THandlerOutput>>, 'queryKey'>;
+    getInfiniteQueryDefaults(filters?: Pick<ORPCQueryFilters<PartialDeep<SchemaInputForInfiniteQuery<TInputSchema>>>, 'input' | 'queryKey'>): OmitKeyof<QueryObserverOptions<SchemaOutput<TOutputSchema, THandlerOutput>, DefaultError, SchemaOutput<TOutputSchema, THandlerOutput>, InfiniteData<SchemaOutput<TOutputSchema, THandlerOutput>>, QueryKey, SchemaInput<TInputSchema>['cursor']>, 'queryKey'>;
+    setQueryDefaults(options: Partial<OmitKeyof<QueryObserverOptions<SchemaOutput<TOutputSchema, THandlerOutput>>, 'queryKey'>>, filters?: Pick<ORPCQueryFilters<PartialDeep<SchemaInput<TInputSchema>>>, 'input' | 'queryKey'>): void;
+    setInfiniteQueryDefaults(options: Partial<OmitKeyof<QueryObserverOptions<SchemaOutput<TOutputSchema, THandlerOutput>, DefaultError, SchemaOutput<TOutputSchema, THandlerOutput>, InfiniteData<SchemaOutput<TOutputSchema, THandlerOutput>>, QueryKey, SchemaInput<TInputSchema>['cursor']>, 'queryKey'>>, filters?: Pick<ORPCQueryFilters<PartialDeep<SchemaInput<TInputSchema>>>, 'input' | 'queryKey'>): void;
+    getMutationDefaults: (filters?: Pick<MutationFilters, 'mutationKey'>) => MutationObserverOptions<SchemaOutput<TOutputSchema, THandlerOutput>, DefaultError, SchemaInput<TInputSchema>>;
+    setMutationDefaults: (options: OmitKeyof<MutationObserverOptions<SchemaOutput<TOutputSchema, THandlerOutput>, DefaultError, SchemaInput<TInputSchema>>, 'mutationKey'>, filters?: Pick<MutationFilters, 'mutationKey'>) => void;
+}
+export interface CreateGeneralUtilsOptions {
+    queryClient: QueryClient;
+    /**
+     * The path of the router or procedure on server.
+     *
+     * @internal
+     */
+    path: string[];
+}
+export declare function createGeneralUtils<TInputSchema extends Schema = undefined, TOutputSchema extends Schema = undefined, THandlerOutput extends SchemaOutput<TOutputSchema> = SchemaOutput<TOutputSchema>>(options: CreateGeneralUtilsOptions): GeneralUtils<TInputSchema, TOutputSchema, THandlerOutput>;
+//# sourceMappingURL=general-utils.d.ts.map