From a06004e498af28371b5a8a69b5d3be1376efd23e Mon Sep 17 00:00:00 2001
From: Eugen Istoc <eugenistoc@gmail.com>
Date: Tue, 17 Mar 2026 09:03:08 -0400
Subject: [PATCH 1/4] feat(clients): add ExtResult support to TanStack Query
 hooks

Add InferSchema, InferOptions, and InferExtResult type utilities to client-helpers. Update React, Vue, and Svelte adapters to accept ClientContract type parameter, enabling computed fields from plugins to be reflected in result types. Simplify useClientQueries API by inferring schema and options from the client type. Update sliced-client tests to use new API surface.
---
 packages/clients/client-helpers/src/types.ts  |  20 +++
 packages/clients/tanstack-query/src/react.ts  | 162 ++++++++++--------
 .../tanstack-query/src/svelte/index.svelte.ts | 125 ++++++++------
 packages/clients/tanstack-query/src/vue.ts    | 126 ++++++++------
 .../test/react-sliced-client.test-d.ts        |  76 ++++----
 .../test/svelte-sliced-client.test-d.ts       |  76 ++++----
 .../test/vue-sliced-client.test-d.ts          |  76 ++++----
 7 files changed, 380 insertions(+), 281 deletions(-)

diff --git a/packages/clients/client-helpers/src/types.ts b/packages/clients/client-helpers/src/types.ts
index da66f9483..5f30ac613 100644
--- a/packages/clients/client-helpers/src/types.ts
+++ b/packages/clients/client-helpers/src/types.ts
@@ -1,8 +1,28 @@
+import type { ClientContract, QueryOptions } from '@zenstackhq/orm';
+import type { SchemaDef } from '@zenstackhq/schema';
+
 /**
  * A type that represents either a value of type T or a Promise that resolves to type T.
  */
 export type MaybePromise<T> = T | Promise<T> | PromiseLike<T>;
 
+/**
+ * Infers the schema definition from a client contract type, or passes through a raw SchemaDef.
+ */
+export type InferSchema<T> = T extends { $schema: infer S extends SchemaDef } ? S : T extends SchemaDef ? T : never;
+
+/**
+ * Extracts the ExtResult type from a client contract, or defaults to `{}`.
+ */
+export type InferExtResult<T> = T extends ClientContract<any, any, any, any, infer E> ? E : {};
+
+/**
+ * Infers query options from a client contract type, or defaults to `QueryOptions<Schema>`.
+ */
+export type InferOptions<T, Schema extends SchemaDef> = T extends { $options: infer O extends QueryOptions<Schema> }
+    ? O
+    : QueryOptions<Schema>;
+
 /**
  * List of ORM write actions.
  */
diff --git a/packages/clients/tanstack-query/src/react.ts b/packages/clients/tanstack-query/src/react.ts
index 5129750bf..ddfa49037 100644
--- a/packages/clients/tanstack-query/src/react.ts
+++ b/packages/clients/tanstack-query/src/react.ts
@@ -19,13 +19,14 @@ import {
     type UseSuspenseQueryOptions,
     type UseSuspenseQueryResult,
 } from '@tanstack/react-query';
-import { createInvalidator, createOptimisticUpdater, DEFAULT_QUERY_ENDPOINT } from '@zenstackhq/client-helpers';
+import { createInvalidator, createOptimisticUpdater, DEFAULT_QUERY_ENDPOINT, type InferExtResult, type InferOptions, type InferSchema } from '@zenstackhq/client-helpers';
 import { fetcher, makeUrl, marshal } from '@zenstackhq/client-helpers/fetch';
 import { lowerCaseFirst } from '@zenstackhq/common-helpers';
 import type {
     AggregateArgs,
     AggregateResult,
     BatchResult,
+    ClientContract,
     CountArgs,
     CountResult,
     CreateArgs,
@@ -34,6 +35,7 @@ import type {
     DeleteArgs,
     DeleteManyArgs,
     ExistsArgs,
+    ExtResultBase,
     FindFirstArgs,
     FindManyArgs,
     FindUniqueArgs,
@@ -68,6 +70,8 @@ import type {
     WithOptimistic,
 } from './common/types.js';
 export type { FetchFn } from '@zenstackhq/client-helpers/fetch';
+export type { InferExtResult, InferOptions, InferSchema } from '@zenstackhq/client-helpers';
+export type { SchemaDef } from '@zenstackhq/schema';
 
 type ProcedureHookFn<
     Schema extends SchemaDef,
@@ -142,15 +146,20 @@ export type ModelMutationModelResult<
     TArgs,
     Array extends boolean = false,
     Options extends QueryOptions<Schema> = QueryOptions<Schema>,
-> = Omit<ModelMutationResult<SimplifiedResult<Schema, Model, TArgs, Options, false, Array>, TArgs>, 'mutateAsync'> & {
+    ExtResult extends ExtResultBase<Schema> = {},
+> = Omit<ModelMutationResult<SimplifiedResult<Schema, Model, TArgs, Options, false, Array, ExtResult>, TArgs>, 'mutateAsync'> & {
     mutateAsync<T extends TArgs>(
         args: T,
-        options?: ModelMutationOptions<SimplifiedResult<Schema, Model, T, Options, false, Array>, T>,
-    ): Promise<SimplifiedResult<Schema, Model, T, Options, false, Array>>;
+        options?: ModelMutationOptions<SimplifiedResult<Schema, Model, T, Options, false, Array, ExtResult>, T>,
+    ): Promise<SimplifiedResult<Schema, Model, T, Options, false, Array, ExtResult>>;
 };
 
-export type ClientHooks<Schema extends SchemaDef, Options extends QueryOptions<Schema> = QueryOptions<Schema>> = {
-    [Model in GetSlicedModels<Schema, Options> as `${Uncapitalize<Model>}`]: ModelQueryHooks<Schema, Model, Options>;
+export type ClientHooks<
+    Schema extends SchemaDef,
+    Options extends QueryOptions<Schema> = QueryOptions<Schema>,
+    ExtResult extends ExtResultBase<Schema> = {},
+> = {
+    [Model in GetSlicedModels<Schema, Options> as `${Uncapitalize<Model>}`]: ModelQueryHooks<Schema, Model, Options, ExtResult>;
 } & ProcedureHooks<Schema, Options>;
 
 type ProcedureHookGroup<Schema extends SchemaDef, Options extends QueryOptions<Schema>> = {
@@ -213,87 +222,88 @@ export type ModelQueryHooks<
     Schema extends SchemaDef,
     Model extends GetModels<Schema>,
     Options extends QueryOptions<Schema> = QueryOptions<Schema>,
+    ExtResult extends ExtResultBase<Schema> = {},
 > = TrimSlicedOperations<
     Schema,
     Model,
     Options,
     {
-        useFindUnique<T extends FindUniqueArgs<Schema, Model, Options>>(
-            args: SelectSubset<T, FindUniqueArgs<Schema, Model, Options>>,
-            options?: ModelQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options> | null>,
-        ): ModelQueryResult<SimplifiedPlainResult<Schema, Model, T, Options> | null>;
-
-        useSuspenseFindUnique<T extends FindUniqueArgs<Schema, Model, Options>>(
-            args: SelectSubset<T, FindUniqueArgs<Schema, Model, Options>>,
-            options?: ModelSuspenseQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options> | null>,
-        ): ModelSuspenseQueryResult<SimplifiedPlainResult<Schema, Model, T, Options> | null>;
-
-        useFindFirst<T extends FindFirstArgs<Schema, Model, Options>>(
-            args?: SelectSubset<T, FindFirstArgs<Schema, Model, Options>>,
-            options?: ModelQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options> | null>,
-        ): ModelQueryResult<SimplifiedPlainResult<Schema, Model, T, Options> | null>;
-
-        useSuspenseFindFirst<T extends FindFirstArgs<Schema, Model, Options>>(
-            args?: SelectSubset<T, FindFirstArgs<Schema, Model, Options>>,
-            options?: ModelSuspenseQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options> | null>,
-        ): ModelSuspenseQueryResult<SimplifiedPlainResult<Schema, Model, T, Options> | null>;
+        useFindUnique<T extends FindUniqueArgs<Schema, Model, Options, {}, ExtResult>>(
+            args: SelectSubset<T, FindUniqueArgs<Schema, Model, Options, {}, ExtResult>>,
+            options?: ModelQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult> | null>,
+        ): ModelQueryResult<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult> | null>;
+
+        useSuspenseFindUnique<T extends FindUniqueArgs<Schema, Model, Options, {}, ExtResult>>(
+            args: SelectSubset<T, FindUniqueArgs<Schema, Model, Options, {}, ExtResult>>,
+            options?: ModelSuspenseQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult> | null>,
+        ): ModelSuspenseQueryResult<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult> | null>;
+
+        useFindFirst<T extends FindFirstArgs<Schema, Model, Options, {}, ExtResult>>(
+            args?: SelectSubset<T, FindFirstArgs<Schema, Model, Options, {}, ExtResult>>,
+            options?: ModelQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult> | null>,
+        ): ModelQueryResult<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult> | null>;
+
+        useSuspenseFindFirst<T extends FindFirstArgs<Schema, Model, Options, {}, ExtResult>>(
+            args?: SelectSubset<T, FindFirstArgs<Schema, Model, Options, {}, ExtResult>>,
+            options?: ModelSuspenseQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult> | null>,
+        ): ModelSuspenseQueryResult<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult> | null>;
 
         useExists<T extends ExistsArgs<Schema, Model, Options>>(
             args?: Subset<T, ExistsArgs<Schema, Model, Options>>,
             options?: ModelQueryOptions<boolean>,
         ): ModelQueryResult<boolean>;
 
-        useFindMany<T extends FindManyArgs<Schema, Model, Options>>(
-            args?: SelectSubset<T, FindManyArgs<Schema, Model, Options>>,
-            options?: ModelQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options>[]>,
-        ): ModelQueryResult<SimplifiedPlainResult<Schema, Model, T, Options>[]>;
+        useFindMany<T extends FindManyArgs<Schema, Model, Options, {}, ExtResult>>(
+            args?: SelectSubset<T, FindManyArgs<Schema, Model, Options, {}, ExtResult>>,
+            options?: ModelQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[]>,
+        ): ModelQueryResult<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[]>;
 
-        useSuspenseFindMany<T extends FindManyArgs<Schema, Model, Options>>(
-            args?: SelectSubset<T, FindManyArgs<Schema, Model, Options>>,
-            options?: ModelSuspenseQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options>[]>,
-        ): ModelSuspenseQueryResult<SimplifiedPlainResult<Schema, Model, T, Options>[]>;
+        useSuspenseFindMany<T extends FindManyArgs<Schema, Model, Options, {}, ExtResult>>(
+            args?: SelectSubset<T, FindManyArgs<Schema, Model, Options, {}, ExtResult>>,
+            options?: ModelSuspenseQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[]>,
+        ): ModelSuspenseQueryResult<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[]>;
 
-        useInfiniteFindMany<T extends FindManyArgs<Schema, Model, Options>>(
-            args?: SelectSubset<T, FindManyArgs<Schema, Model, Options>>,
-            options?: ModelInfiniteQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options>[]>,
-        ): ModelInfiniteQueryResult<InfiniteData<SimplifiedPlainResult<Schema, Model, T, Options>[]>>;
+        useInfiniteFindMany<T extends FindManyArgs<Schema, Model, Options, {}, ExtResult>>(
+            args?: SelectSubset<T, FindManyArgs<Schema, Model, Options, {}, ExtResult>>,
+            options?: ModelInfiniteQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[]>,
+        ): ModelInfiniteQueryResult<InfiniteData<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[]>>;
 
-        useSuspenseInfiniteFindMany<T extends FindManyArgs<Schema, Model, Options>>(
-            args?: SelectSubset<T, FindManyArgs<Schema, Model, Options>>,
-            options?: ModelSuspenseInfiniteQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options>[]>,
-        ): ModelSuspenseInfiniteQueryResult<InfiniteData<SimplifiedPlainResult<Schema, Model, T, Options>[]>>;
+        useSuspenseInfiniteFindMany<T extends FindManyArgs<Schema, Model, Options, {}, ExtResult>>(
+            args?: SelectSubset<T, FindManyArgs<Schema, Model, Options, {}, ExtResult>>,
+            options?: ModelSuspenseInfiniteQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[]>,
+        ): ModelSuspenseInfiniteQueryResult<InfiniteData<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[]>>;
 
-        useCreate<T extends CreateArgs<Schema, Model, Options>>(
-            options?: ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options>, T>,
-        ): ModelMutationModelResult<Schema, Model, T, false, Options>;
+        useCreate<T extends CreateArgs<Schema, Model, Options, {}, ExtResult>>(
+            options?: ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>, T>,
+        ): ModelMutationModelResult<Schema, Model, T, false, Options, ExtResult>;
 
         useCreateMany<T extends CreateManyArgs<Schema, Model>>(
             options?: ModelMutationOptions<BatchResult, T>,
         ): ModelMutationResult<BatchResult, T>;
 
-        useCreateManyAndReturn<T extends CreateManyAndReturnArgs<Schema, Model, Options>>(
-            options?: ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options>[], T>,
-        ): ModelMutationModelResult<Schema, Model, T, true, Options>;
+        useCreateManyAndReturn<T extends CreateManyAndReturnArgs<Schema, Model, Options, {}, ExtResult>>(
+            options?: ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[], T>,
+        ): ModelMutationModelResult<Schema, Model, T, true, Options, ExtResult>;
 
-        useUpdate<T extends UpdateArgs<Schema, Model, Options>>(
-            options?: ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options>, T>,
-        ): ModelMutationModelResult<Schema, Model, T, false, Options>;
+        useUpdate<T extends UpdateArgs<Schema, Model, Options, {}, ExtResult>>(
+            options?: ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>, T>,
+        ): ModelMutationModelResult<Schema, Model, T, false, Options, ExtResult>;
 
         useUpdateMany<T extends UpdateManyArgs<Schema, Model, Options>>(
             options?: ModelMutationOptions<BatchResult, T>,
         ): ModelMutationResult<BatchResult, T>;
 
-        useUpdateManyAndReturn<T extends UpdateManyAndReturnArgs<Schema, Model, Options>>(
-            options?: ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options>[], T>,
-        ): ModelMutationModelResult<Schema, Model, T, true, Options>;
+        useUpdateManyAndReturn<T extends UpdateManyAndReturnArgs<Schema, Model, Options, {}, ExtResult>>(
+            options?: ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[], T>,
+        ): ModelMutationModelResult<Schema, Model, T, true, Options, ExtResult>;
 
-        useUpsert<T extends UpsertArgs<Schema, Model, Options>>(
-            options?: ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options>, T>,
-        ): ModelMutationModelResult<Schema, Model, T, false, Options>;
+        useUpsert<T extends UpsertArgs<Schema, Model, Options, {}, ExtResult>>(
+            options?: ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>, T>,
+        ): ModelMutationModelResult<Schema, Model, T, false, Options, ExtResult>;
 
-        useDelete<T extends DeleteArgs<Schema, Model, Options>>(
-            options?: ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options>, T>,
-        ): ModelMutationModelResult<Schema, Model, T, false, Options>;
+        useDelete<T extends DeleteArgs<Schema, Model, Options, {}, ExtResult>>(
+            options?: ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>, T>,
+        ): ModelMutationModelResult<Schema, Model, T, false, Options, ExtResult>;
 
         useDeleteMany<T extends DeleteManyArgs<Schema, Model, Options>>(
             options?: ModelMutationOptions<BatchResult, T>,
@@ -334,23 +344,38 @@ export type ModelQueryHooks<
 /**
  * Gets data query hooks for all models in the schema.
  *
+ * Accepts either a raw `SchemaDef` or a `ClientContract` type (e.g. `typeof db`) as the generic parameter.
+ * When a `ClientContract` type is provided, computed fields from plugins are reflected in the result types.
+ *
+ * @example
+ * ```typescript
+ * // Basic usage with schema
+ * const client = useClientQueries(schema)
+ *
+ * // With server client type for computed field support
+ * import type { DbType } from '~/server/db'
+ * const client = useClientQueries<DbType>(schema)
+ * ```
+ *
  * @param schema The schema.
  * @param options Options for all queries originated from this hook.
  */
-export function useClientQueries<Schema extends SchemaDef, Options extends QueryOptions<Schema> = QueryOptions<Schema>>(
-    schema: Schema,
+export function useClientQueries<
+    Client extends SchemaDef | ClientContract<any, any, any, any, any>,
+>(
+    schema: InferSchema<Client>,
     options?: QueryContext,
-): ClientHooks<Schema, Options> {
+): ClientHooks<InferSchema<Client>, InferOptions<Client, InferSchema<Client>>, InferExtResult<Client> extends ExtResultBase<InferSchema<Client>> ? InferExtResult<Client> : {}> {
     const result = Object.keys(schema.models).reduce(
         (acc, model) => {
-            (acc as any)[lowerCaseFirst(model)] = useModelQueries<Schema, GetModels<Schema>, Options>(
-                schema,
-                model as GetModels<Schema>,
+            (acc as any)[lowerCaseFirst(model)] = useModelQueries(
+                schema as any,
+                model as any,
                 options,
             );
             return acc;
         },
-        {} as ClientHooks<Schema, Options>,
+        {} as any,
     );
 
     const procedures = (schema as any).procedures as Record<string, { mutation?: boolean }> | undefined;
@@ -407,7 +432,8 @@ export function useModelQueries<
     Schema extends SchemaDef,
     Model extends GetModels<Schema>,
     Options extends QueryOptions<Schema>,
->(schema: Schema, model: Model, rootOptions?: QueryContext): ModelQueryHooks<Schema, Model, Options> {
+    ExtResult extends ExtResultBase<Schema> = {},
+>(schema: Schema, model: Model, rootOptions?: QueryContext): ModelQueryHooks<Schema, Model, Options, ExtResult> {
     const modelDef = Object.values(schema.models).find((m) => m.name.toLowerCase() === model.toLowerCase());
     if (!modelDef) {
         throw new Error(`Model "${model}" not found in schema`);
@@ -517,7 +543,7 @@ export function useModelQueries<
         useSuspenseGroupBy: (args: any, options?: any) => {
             return useInternalSuspenseQuery(schema, modelName, 'groupBy', args, { ...rootOptions, ...options });
         },
-    } as ModelQueryHooks<Schema, Model, Options>;
+    } as ModelQueryHooks<Schema, Model, Options, ExtResult>;
 }
 
 export function useInternalQuery<TQueryFnData, TData>(
diff --git a/packages/clients/tanstack-query/src/svelte/index.svelte.ts b/packages/clients/tanstack-query/src/svelte/index.svelte.ts
index 45af47cb3..e690fcfc9 100644
--- a/packages/clients/tanstack-query/src/svelte/index.svelte.ts
+++ b/packages/clients/tanstack-query/src/svelte/index.svelte.ts
@@ -19,6 +19,9 @@ import {
     createInvalidator,
     createOptimisticUpdater,
     DEFAULT_QUERY_ENDPOINT,
+    type InferExtResult,
+    type InferOptions,
+    type InferSchema,
     type InvalidationPredicate,
 } from '@zenstackhq/client-helpers';
 import { fetcher, makeUrl, marshal } from '@zenstackhq/client-helpers/fetch';
@@ -27,6 +30,7 @@ import type {
     AggregateArgs,
     AggregateResult,
     BatchResult,
+    ClientContract,
     CountArgs,
     CountResult,
     CreateArgs,
@@ -35,6 +39,7 @@ import type {
     DeleteArgs,
     DeleteManyArgs,
     ExistsArgs,
+    ExtResultBase,
     FindFirstArgs,
     FindManyArgs,
     FindUniqueArgs,
@@ -69,6 +74,8 @@ import type {
     WithOptimistic,
 } from '../common/types.js';
 export type { FetchFn } from '@zenstackhq/client-helpers/fetch';
+export type { InferExtResult, InferOptions, InferSchema } from '@zenstackhq/client-helpers';
+export type { SchemaDef } from '@zenstackhq/schema';
 
 type ProcedureHookFn<
     Schema extends SchemaDef,
@@ -139,15 +146,20 @@ export type ModelMutationModelResult<
     TArgs,
     Array extends boolean = false,
     Options extends QueryOptions<Schema> = QueryOptions<Schema>,
-> = Omit<ModelMutationResult<SimplifiedResult<Schema, Model, TArgs, Options, false, Array>, TArgs>, 'mutateAsync'> & {
+    ExtResult extends ExtResultBase<Schema> = {},
+> = Omit<ModelMutationResult<SimplifiedResult<Schema, Model, TArgs, Options, false, Array, ExtResult>, TArgs>, 'mutateAsync'> & {
     mutateAsync<T extends TArgs>(
         args: T,
-        options?: ModelMutationOptions<SimplifiedResult<Schema, Model, T, Options, false, Array>, T>,
-    ): Promise<SimplifiedResult<Schema, Model, T, Options, false, Array>>;
+        options?: ModelMutationOptions<SimplifiedResult<Schema, Model, T, Options, false, Array, ExtResult>, T>,
+    ): Promise<SimplifiedResult<Schema, Model, T, Options, false, Array, ExtResult>>;
 };
 
-export type ClientHooks<Schema extends SchemaDef, Options extends QueryOptions<Schema> = QueryOptions<Schema>> = {
-    [Model in GetSlicedModels<Schema, Options> as `${Uncapitalize<Model>}`]: ModelQueryHooks<Schema, Model, Options>;
+export type ClientHooks<
+    Schema extends SchemaDef,
+    Options extends QueryOptions<Schema> = QueryOptions<Schema>,
+    ExtResult extends ExtResultBase<Schema> = {},
+> = {
+    [Model in GetSlicedModels<Schema, Options> as `${Uncapitalize<Model>}`]: ModelQueryHooks<Schema, Model, Options, ExtResult>;
 } & ProcedureHooks<Schema, Options>;
 
 type ProcedureHookGroup<Schema extends SchemaDef, Options extends QueryOptions<Schema>> = {
@@ -200,65 +212,66 @@ export type ModelQueryHooks<
     Schema extends SchemaDef,
     Model extends GetModels<Schema>,
     Options extends QueryOptions<Schema> = QueryOptions<Schema>,
+    ExtResult extends ExtResultBase<Schema> = {},
 > = TrimSlicedOperations<
     Schema,
     Model,
     Options,
     {
-        useFindUnique<T extends FindUniqueArgs<Schema, Model, Options>>(
-            args: Accessor<SelectSubset<T, FindUniqueArgs<Schema, Model, Options>>>,
-            options?: Accessor<ModelQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options> | null>>,
-        ): ModelQueryResult<SimplifiedPlainResult<Schema, Model, T, Options> | null>;
+        useFindUnique<T extends FindUniqueArgs<Schema, Model, Options, {}, ExtResult>>(
+            args: Accessor<SelectSubset<T, FindUniqueArgs<Schema, Model, Options, {}, ExtResult>>>,
+            options?: Accessor<ModelQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult> | null>>,
+        ): ModelQueryResult<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult> | null>;
 
-        useFindFirst<T extends FindFirstArgs<Schema, Model, Options>>(
-            args?: Accessor<SelectSubset<T, FindFirstArgs<Schema, Model, Options>>>,
-            options?: Accessor<ModelQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options> | null>>,
-        ): ModelQueryResult<SimplifiedPlainResult<Schema, Model, T, Options> | null>;
+        useFindFirst<T extends FindFirstArgs<Schema, Model, Options, {}, ExtResult>>(
+            args?: Accessor<SelectSubset<T, FindFirstArgs<Schema, Model, Options, {}, ExtResult>>>,
+            options?: Accessor<ModelQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult> | null>>,
+        ): ModelQueryResult<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult> | null>;
 
         useExists<T extends ExistsArgs<Schema, Model, Options>>(
             args?: Accessor<Subset<T, ExistsArgs<Schema, Model, Options>>>,
             options?: Accessor<ModelQueryOptions<boolean>>,
         ): ModelQueryResult<boolean>;
 
-        useFindMany<T extends FindManyArgs<Schema, Model, Options>>(
-            args?: Accessor<SelectSubset<T, FindManyArgs<Schema, Model, Options>>>,
-            options?: Accessor<ModelQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options>[]>>,
-        ): ModelQueryResult<SimplifiedPlainResult<Schema, Model, T, Options>[]>;
+        useFindMany<T extends FindManyArgs<Schema, Model, Options, {}, ExtResult>>(
+            args?: Accessor<SelectSubset<T, FindManyArgs<Schema, Model, Options, {}, ExtResult>>>,
+            options?: Accessor<ModelQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[]>>,
+        ): ModelQueryResult<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[]>;
 
-        useInfiniteFindMany<T extends FindManyArgs<Schema, Model, Options>>(
-            args?: Accessor<SelectSubset<T, FindManyArgs<Schema, Model, Options>>>,
-            options?: Accessor<ModelInfiniteQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options>[]>>,
-        ): ModelInfiniteQueryResult<InfiniteData<SimplifiedPlainResult<Schema, Model, T, Options>[]>>;
+        useInfiniteFindMany<T extends FindManyArgs<Schema, Model, Options, {}, ExtResult>>(
+            args?: Accessor<SelectSubset<T, FindManyArgs<Schema, Model, Options, {}, ExtResult>>>,
+            options?: Accessor<ModelInfiniteQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[]>>,
+        ): ModelInfiniteQueryResult<InfiniteData<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[]>>;
 
-        useCreate<T extends CreateArgs<Schema, Model, Options>>(
-            options?: Accessor<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options>, T>>,
-        ): ModelMutationModelResult<Schema, Model, T, false, Options>;
+        useCreate<T extends CreateArgs<Schema, Model, Options, {}, ExtResult>>(
+            options?: Accessor<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>, T>>,
+        ): ModelMutationModelResult<Schema, Model, T, false, Options, ExtResult>;
 
         useCreateMany<T extends CreateManyArgs<Schema, Model>>(
             options?: Accessor<ModelMutationOptions<BatchResult, T>>,
         ): ModelMutationResult<BatchResult, T>;
 
-        useCreateManyAndReturn<T extends CreateManyAndReturnArgs<Schema, Model, Options>>(
-            options?: Accessor<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options>[], T>>,
-        ): ModelMutationModelResult<Schema, Model, T, true, Options>;
+        useCreateManyAndReturn<T extends CreateManyAndReturnArgs<Schema, Model, Options, {}, ExtResult>>(
+            options?: Accessor<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[], T>>,
+        ): ModelMutationModelResult<Schema, Model, T, true, Options, ExtResult>;
 
-        useUpdate<T extends UpdateArgs<Schema, Model, Options>>(
-            options?: Accessor<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options>, T>>,
-        ): ModelMutationModelResult<Schema, Model, T, false, Options>;
+        useUpdate<T extends UpdateArgs<Schema, Model, Options, {}, ExtResult>>(
+            options?: Accessor<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>, T>>,
+        ): ModelMutationModelResult<Schema, Model, T, false, Options, ExtResult>;
         useUpdateMany<T extends UpdateManyArgs<Schema, Model, Options>>(
             options?: Accessor<ModelMutationOptions<BatchResult, T>>,
         ): ModelMutationResult<BatchResult, T>;
 
-        useUpdateManyAndReturn<T extends UpdateManyAndReturnArgs<Schema, Model, Options>>(
-            options?: Accessor<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options>[], T>>,
-        ): ModelMutationModelResult<Schema, Model, T, true, Options>;
+        useUpdateManyAndReturn<T extends UpdateManyAndReturnArgs<Schema, Model, Options, {}, ExtResult>>(
+            options?: Accessor<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[], T>>,
+        ): ModelMutationModelResult<Schema, Model, T, true, Options, ExtResult>;
 
-        useUpsert<T extends UpsertArgs<Schema, Model, Options>>(
-            options?: Accessor<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options>, T>>,
-        ): ModelMutationModelResult<Schema, Model, T, false, Options>;
-        useDelete<T extends DeleteArgs<Schema, Model, Options>>(
-            options?: Accessor<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options>, T>>,
-        ): ModelMutationModelResult<Schema, Model, T, false, Options>;
+        useUpsert<T extends UpsertArgs<Schema, Model, Options, {}, ExtResult>>(
+            options?: Accessor<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>, T>>,
+        ): ModelMutationModelResult<Schema, Model, T, false, Options, ExtResult>;
+        useDelete<T extends DeleteArgs<Schema, Model, Options, {}, ExtResult>>(
+            options?: Accessor<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>, T>>,
+        ): ModelMutationModelResult<Schema, Model, T, false, Options, ExtResult>;
 
         useDeleteMany<T extends DeleteManyArgs<Schema, Model, Options>>(
             options?: Accessor<ModelMutationOptions<BatchResult, T>>,
@@ -283,21 +296,36 @@ export type ModelQueryHooks<
 
 /**
  * Gets data query hooks for all models in the schema.
+ *
+ * Accepts either a raw `SchemaDef` or a `ClientContract` type (e.g. `typeof db`) as the generic parameter.
+ * When a `ClientContract` type is provided, computed fields from plugins are reflected in the result types.
+ *
+ * @example
+ * ```typescript
+ * // Basic usage with schema
+ * const client = useClientQueries(schema)
+ *
+ * // With server client type for computed field support
+ * import type { DbType } from '~/server/db'
+ * const client = useClientQueries<DbType>(schema)
+ * ```
  */
-export function useClientQueries<Schema extends SchemaDef, Options extends QueryOptions<Schema> = QueryOptions<Schema>>(
-    schema: Schema,
+export function useClientQueries<
+    Client extends SchemaDef | ClientContract<any, any, any, any, any>,
+>(
+    schema: InferSchema<Client>,
     options?: Accessor<QueryContext>,
-): ClientHooks<Schema, Options> {
+): ClientHooks<InferSchema<Client>, InferOptions<Client, InferSchema<Client>>, InferExtResult<Client> extends ExtResultBase<InferSchema<Client>> ? InferExtResult<Client> : {}> {
     const result = Object.keys(schema.models).reduce(
         (acc, model) => {
-            (acc as any)[lowerCaseFirst(model)] = useModelQueries<Schema, GetModels<Schema>, Options>(
-                schema,
-                model as GetModels<Schema>,
+            (acc as any)[lowerCaseFirst(model)] = useModelQueries(
+                schema as any,
+                model as any,
                 options,
             );
             return acc;
         },
-        {} as ClientHooks<Schema, Options>,
+        {} as any,
     );
 
     const procedures = (schema as any).procedures as Record<string, { mutation?: boolean }> | undefined;
@@ -347,7 +375,8 @@ export function useModelQueries<
     Schema extends SchemaDef,
     Model extends GetModels<Schema>,
     Options extends QueryOptions<Schema>,
->(schema: Schema, model: Model, rootOptions?: Accessor<QueryContext>): ModelQueryHooks<Schema, Model, Options> {
+    ExtResult extends ExtResultBase<Schema> = {},
+>(schema: Schema, model: Model, rootOptions?: Accessor<QueryContext>): ModelQueryHooks<Schema, Model, Options, ExtResult> {
     const modelDef = Object.values(schema.models).find((m) => m.name.toLowerCase() === model.toLowerCase());
     if (!modelDef) {
         throw new Error(`Model "${model}" not found in schema`);
@@ -423,7 +452,7 @@ export function useModelQueries<
         useGroupBy: (args: any, options?: any) => {
             return useInternalQuery(schema, modelName, 'groupBy', args, options);
         },
-    } as unknown as ModelQueryHooks<Schema, Model, Options>;
+    } as unknown as ModelQueryHooks<Schema, Model, Options, ExtResult>;
 }
 
 export function useInternalQuery<TQueryFnData, TData>(
diff --git a/packages/clients/tanstack-query/src/vue.ts b/packages/clients/tanstack-query/src/vue.ts
index b45a28333..6fb64aa3c 100644
--- a/packages/clients/tanstack-query/src/vue.ts
+++ b/packages/clients/tanstack-query/src/vue.ts
@@ -17,6 +17,9 @@ import {
     createInvalidator,
     createOptimisticUpdater,
     DEFAULT_QUERY_ENDPOINT,
+    type InferExtResult,
+    type InferOptions,
+    type InferSchema,
     type InvalidationPredicate,
 } from '@zenstackhq/client-helpers';
 import { fetcher, makeUrl, marshal } from '@zenstackhq/client-helpers/fetch';
@@ -25,6 +28,7 @@ import type {
     AggregateArgs,
     AggregateResult,
     BatchResult,
+    ClientContract,
     CountArgs,
     CountResult,
     CreateArgs,
@@ -33,6 +37,7 @@ import type {
     DeleteArgs,
     DeleteManyArgs,
     ExistsArgs,
+    ExtResultBase,
     FindFirstArgs,
     FindManyArgs,
     FindUniqueArgs,
@@ -67,6 +72,9 @@ import type {
     WithOptimistic,
 } from './common/types.js';
 export type { FetchFn } from '@zenstackhq/client-helpers/fetch';
+export type { InferExtResult, InferOptions, InferSchema } from '@zenstackhq/client-helpers';
+export type { SchemaDef } from '@zenstackhq/schema';
+
 export const VueQueryContextKey = 'zenstack-vue-query-context';
 
 type ProcedureHookFn<
@@ -129,18 +137,23 @@ export type ModelMutationModelResult<
     TArgs,
     Array extends boolean = false,
     Options extends QueryOptions<Schema> = QueryOptions<Schema>,
+    ExtResult extends ExtResultBase<Schema> = {},
 > = Omit<
-    ModelMutationResult<SimplifiedResult<Schema, Model, TArgs, QueryOptions<Schema>, false, Array>, TArgs>,
+    ModelMutationResult<SimplifiedResult<Schema, Model, TArgs, QueryOptions<Schema>, false, Array, ExtResult>, TArgs>,
     'mutateAsync'
 > & {
     mutateAsync<T extends TArgs>(
         args: T,
-        options?: ModelMutationOptions<SimplifiedResult<Schema, Model, T, Options, false, Array>, T>,
-    ): Promise<SimplifiedResult<Schema, Model, T, Options, false, Array>>;
+        options?: ModelMutationOptions<SimplifiedResult<Schema, Model, T, Options, false, Array, ExtResult>, T>,
+    ): Promise<SimplifiedResult<Schema, Model, T, Options, false, Array, ExtResult>>;
 };
 
-export type ClientHooks<Schema extends SchemaDef, Options extends QueryOptions<Schema> = QueryOptions<Schema>> = {
-    [Model in GetSlicedModels<Schema, Options> as `${Uncapitalize<Model>}`]: ModelQueryHooks<Schema, Model, Options>;
+export type ClientHooks<
+    Schema extends SchemaDef,
+    Options extends QueryOptions<Schema> = QueryOptions<Schema>,
+    ExtResult extends ExtResultBase<Schema> = {},
+> = {
+    [Model in GetSlicedModels<Schema, Options> as `${Uncapitalize<Model>}`]: ModelQueryHooks<Schema, Model, Options, ExtResult>;
 } & ProcedureHooks<Schema, Options>;
 
 type ProcedureHookGroup<Schema extends SchemaDef, Options extends QueryOptions<Schema>> = {
@@ -202,67 +215,68 @@ export type ModelQueryHooks<
     Schema extends SchemaDef,
     Model extends GetModels<Schema>,
     Options extends QueryOptions<Schema> = QueryOptions<Schema>,
+    ExtResult extends ExtResultBase<Schema> = {},
 > = TrimSlicedOperations<
     Schema,
     Model,
     Options,
     {
-        useFindUnique<T extends FindUniqueArgs<Schema, Model, Options>>(
-            args: MaybeRefOrGetter<SelectSubset<T, FindUniqueArgs<Schema, Model, Options>>>,
-            options?: MaybeRefOrGetter<ModelQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options> | null>>,
-        ): ModelQueryResult<SimplifiedPlainResult<Schema, Model, T, Options> | null>;
+        useFindUnique<T extends FindUniqueArgs<Schema, Model, Options, {}, ExtResult>>(
+            args: MaybeRefOrGetter<SelectSubset<T, FindUniqueArgs<Schema, Model, Options, {}, ExtResult>>>,
+            options?: MaybeRefOrGetter<ModelQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult> | null>>,
+        ): ModelQueryResult<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult> | null>;
 
-        useFindFirst<T extends FindFirstArgs<Schema, Model, Options>>(
-            args?: MaybeRefOrGetter<SelectSubset<T, FindFirstArgs<Schema, Model, Options>>>,
-            options?: MaybeRefOrGetter<ModelQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options> | null>>,
-        ): ModelQueryResult<SimplifiedPlainResult<Schema, Model, T, Options> | null>;
+        useFindFirst<T extends FindFirstArgs<Schema, Model, Options, {}, ExtResult>>(
+            args?: MaybeRefOrGetter<SelectSubset<T, FindFirstArgs<Schema, Model, Options, {}, ExtResult>>>,
+            options?: MaybeRefOrGetter<ModelQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult> | null>>,
+        ): ModelQueryResult<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult> | null>;
 
         useExists<T extends ExistsArgs<Schema, Model, Options>>(
             args?: MaybeRefOrGetter<Subset<T, ExistsArgs<Schema, Model, Options>>>,
             options?: MaybeRefOrGetter<ModelQueryOptions<boolean>>,
         ): ModelQueryResult<boolean>;
 
-        useFindMany<T extends FindManyArgs<Schema, Model, Options>>(
-            args?: MaybeRefOrGetter<SelectSubset<T, FindManyArgs<Schema, Model, Options>>>,
-            options?: MaybeRefOrGetter<ModelQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options>[]>>,
-        ): ModelQueryResult<SimplifiedPlainResult<Schema, Model, T, Options>[]>;
+        useFindMany<T extends FindManyArgs<Schema, Model, Options, {}, ExtResult>>(
+            args?: MaybeRefOrGetter<SelectSubset<T, FindManyArgs<Schema, Model, Options, {}, ExtResult>>>,
+            options?: MaybeRefOrGetter<ModelQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[]>>,
+        ): ModelQueryResult<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[]>;
 
-        useInfiniteFindMany<T extends FindManyArgs<Schema, Model, Options>>(
-            args?: MaybeRefOrGetter<SelectSubset<T, FindManyArgs<Schema, Model, Options>>>,
-            options?: MaybeRefOrGetter<ModelInfiniteQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options>[]>>,
-        ): ModelInfiniteQueryResult<InfiniteData<SimplifiedPlainResult<Schema, Model, T, Options>[]>>;
+        useInfiniteFindMany<T extends FindManyArgs<Schema, Model, Options, {}, ExtResult>>(
+            args?: MaybeRefOrGetter<SelectSubset<T, FindManyArgs<Schema, Model, Options, {}, ExtResult>>>,
+            options?: MaybeRefOrGetter<ModelInfiniteQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[]>>,
+        ): ModelInfiniteQueryResult<InfiniteData<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[]>>;
 
-        useCreate<T extends CreateArgs<Schema, Model, Options>>(
-            options?: MaybeRefOrGetter<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options>, T>>,
-        ): ModelMutationModelResult<Schema, Model, T, false, Options>;
+        useCreate<T extends CreateArgs<Schema, Model, Options, {}, ExtResult>>(
+            options?: MaybeRefOrGetter<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>, T>>,
+        ): ModelMutationModelResult<Schema, Model, T, false, Options, ExtResult>;
 
         useCreateMany<T extends CreateManyArgs<Schema, Model>>(
             options?: MaybeRefOrGetter<ModelMutationOptions<BatchResult, T>>,
         ): ModelMutationResult<BatchResult, T>;
 
-        useCreateManyAndReturn<T extends CreateManyAndReturnArgs<Schema, Model, Options>>(
-            options?: MaybeRefOrGetter<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options>[], T>>,
-        ): ModelMutationModelResult<Schema, Model, T, true, Options>;
+        useCreateManyAndReturn<T extends CreateManyAndReturnArgs<Schema, Model, Options, {}, ExtResult>>(
+            options?: MaybeRefOrGetter<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[], T>>,
+        ): ModelMutationModelResult<Schema, Model, T, true, Options, ExtResult>;
 
-        useUpdate<T extends UpdateArgs<Schema, Model, Options>>(
-            options?: MaybeRefOrGetter<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options>, T>>,
-        ): ModelMutationModelResult<Schema, Model, T, false, Options>;
+        useUpdate<T extends UpdateArgs<Schema, Model, Options, {}, ExtResult>>(
+            options?: MaybeRefOrGetter<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>, T>>,
+        ): ModelMutationModelResult<Schema, Model, T, false, Options, ExtResult>;
 
         useUpdateMany<T extends UpdateManyArgs<Schema, Model, Options>>(
             options?: MaybeRefOrGetter<ModelMutationOptions<BatchResult, T>>,
         ): ModelMutationResult<BatchResult, T>;
 
-        useUpdateManyAndReturn<T extends UpdateManyAndReturnArgs<Schema, Model, Options>>(
-            options?: MaybeRefOrGetter<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options>[], T>>,
-        ): ModelMutationModelResult<Schema, Model, T, true, Options>;
+        useUpdateManyAndReturn<T extends UpdateManyAndReturnArgs<Schema, Model, Options, {}, ExtResult>>(
+            options?: MaybeRefOrGetter<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[], T>>,
+        ): ModelMutationModelResult<Schema, Model, T, true, Options, ExtResult>;
 
-        useUpsert<T extends UpsertArgs<Schema, Model, Options>>(
-            options?: MaybeRefOrGetter<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options>, T>>,
-        ): ModelMutationModelResult<Schema, Model, T, false, Options>;
+        useUpsert<T extends UpsertArgs<Schema, Model, Options, {}, ExtResult>>(
+            options?: MaybeRefOrGetter<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>, T>>,
+        ): ModelMutationModelResult<Schema, Model, T, false, Options, ExtResult>;
 
-        useDelete<T extends DeleteArgs<Schema, Model, Options>>(
-            options?: MaybeRefOrGetter<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options>, T>>,
-        ): ModelMutationModelResult<Schema, Model, T, false, Options>;
+        useDelete<T extends DeleteArgs<Schema, Model, Options, {}, ExtResult>>(
+            options?: MaybeRefOrGetter<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>, T>>,
+        ): ModelMutationModelResult<Schema, Model, T, false, Options, ExtResult>;
 
         useDeleteMany<T extends DeleteManyArgs<Schema, Model, Options>>(
             options?: MaybeRefOrGetter<ModelMutationOptions<BatchResult, T>>,
@@ -287,11 +301,26 @@ export type ModelQueryHooks<
 
 /**
  * Gets data query hooks for all models in the schema.
+ *
+ * Accepts either a raw `SchemaDef` or a `ClientContract` type (e.g. `typeof db`) as the generic parameter.
+ * When a `ClientContract` type is provided, computed fields from plugins are reflected in the result types.
+ *
+ * @example
+ * ```typescript
+ * // Basic usage with schema
+ * const client = useClientQueries(schema)
+ *
+ * // With server client type for computed field support
+ * import type { DbType } from '~/server/db'
+ * const client = useClientQueries<DbType>(schema)
+ * ```
  */
-export function useClientQueries<Schema extends SchemaDef, Options extends QueryOptions<Schema> = QueryOptions<Schema>>(
-    schema: Schema,
+export function useClientQueries<
+    Client extends SchemaDef | ClientContract<any, any, any, any, any>,
+>(
+    schema: InferSchema<Client>,
     options?: MaybeRefOrGetter<QueryContext>,
-): ClientHooks<Schema, Options> {
+): ClientHooks<InferSchema<Client>, InferOptions<Client, InferSchema<Client>>, InferExtResult<Client> extends ExtResultBase<InferSchema<Client>> ? InferExtResult<Client> : {}> {
     const merge = (rootOpt: MaybeRefOrGetter<unknown> | undefined, opt: MaybeRefOrGetter<unknown> | undefined): any => {
         return computed(() => {
             const rootVal = toValue(rootOpt) ?? {};
@@ -302,14 +331,14 @@ export function useClientQueries<Schema extends SchemaDef, Options extends Query
 
     const result = Object.keys(schema.models).reduce(
         (acc, model) => {
-            (acc as any)[lowerCaseFirst(model)] = useModelQueries<Schema, GetModels<Schema>, Options>(
-                schema,
-                model as GetModels<Schema>,
+            (acc as any)[lowerCaseFirst(model)] = useModelQueries(
+                schema as any,
+                model as any,
                 options,
             );
             return acc;
         },
-        {} as ClientHooks<Schema, Options>,
+        {} as any,
     );
 
     const procedures = (schema as any).procedures as Record<string, { mutation?: boolean }> | undefined;
@@ -359,7 +388,8 @@ export function useModelQueries<
     Schema extends SchemaDef,
     Model extends GetModels<Schema>,
     Options extends QueryOptions<Schema>,
->(schema: Schema, model: Model, rootOptions?: MaybeRefOrGetter<QueryContext>): ModelQueryHooks<Schema, Model, Options> {
+    ExtResult extends ExtResultBase<Schema> = {},
+>(schema: Schema, model: Model, rootOptions?: MaybeRefOrGetter<QueryContext>): ModelQueryHooks<Schema, Model, Options, ExtResult> {
     const modelDef = Object.values(schema.models).find((m) => m.name.toLowerCase() === model.toLowerCase());
     if (!modelDef) {
         throw new Error(`Model "${model}" not found in schema`);
@@ -441,7 +471,7 @@ export function useModelQueries<
         useGroupBy: (args: any, options?: any) => {
             return useInternalQuery(schema, modelName, 'groupBy', args, merge(rootOptions, options));
         },
-    } as ModelQueryHooks<Schema, Model, Options>;
+    } as ModelQueryHooks<Schema, Model, Options, ExtResult>;
 }
 
 export function useInternalQuery<TQueryFnData, TData>(
diff --git a/packages/clients/tanstack-query/test/react-sliced-client.test-d.ts b/packages/clients/tanstack-query/test/react-sliced-client.test-d.ts
index 8b31551d7..78b2eca0a 100644
--- a/packages/clients/tanstack-query/test/react-sliced-client.test-d.ts
+++ b/packages/clients/tanstack-query/test/react-sliced-client.test-d.ts
@@ -1,4 +1,4 @@
-import { ZenStackClient, type GetQueryOptions } from '@zenstackhq/orm';
+import { ZenStackClient } from '@zenstackhq/orm';
 import { describe, expectTypeOf, it } from 'vitest';
 import { useClientQueries } from '../src/react';
 import { schema } from './schemas/basic/schema-lite';
@@ -20,7 +20,7 @@ describe('React client sliced client test', () => {
     });
 
     it('works with sliced models', () => {
-        const client = useClientQueries<typeof schema, GetQueryOptions<typeof _db>>(schema);
+        const client = useClientQueries<typeof _db>(schema);
 
         expectTypeOf(client).toHaveProperty('user');
         expectTypeOf(client).toHaveProperty('post');
@@ -28,18 +28,17 @@ describe('React client sliced client test', () => {
     });
 
     it('works with sliced operations', () => {
-        const client = useClientQueries<
-            typeof schema,
-            {
-                slicing: {
-                    models: {
-                        user: {
-                            includedOperations: ['findUnique', 'findMany', 'update'];
-                        };
-                    };
-                };
-            }
-        >(schema);
+        const _slicedOps = new ZenStackClient(schema, {
+            dialect: {} as any,
+            slicing: {
+                models: {
+                    user: {
+                        includedOperations: ['findUnique', 'findMany', 'update'],
+                    },
+                },
+            },
+        });
+        const client = useClientQueries<typeof _slicedOps>(schema);
 
         expectTypeOf(client.user).toHaveProperty('useFindUnique');
         expectTypeOf(client.user).toHaveProperty('useFindMany');
@@ -48,22 +47,21 @@ describe('React client sliced client test', () => {
     });
 
     it('works with sliced filters', () => {
-        const client = useClientQueries<
-            typeof schema,
-            {
-                slicing: {
-                    models: {
-                        user: {
-                            fields: {
-                                $all: {
-                                    includedFilterKinds: ['Equality'];
-                                };
-                            };
-                        };
-                    };
-                };
-            }
-        >(schema);
+        const _slicedFilters = new ZenStackClient(schema, {
+            dialect: {} as any,
+            slicing: {
+                models: {
+                    user: {
+                        fields: {
+                            $all: {
+                                includedFilterKinds: ['Equality'],
+                            },
+                        },
+                    },
+                },
+            },
+        });
+        const client = useClientQueries<typeof _slicedFilters>(schema);
 
         // Equality filter should be allowed
         client.user.useFindMany({
@@ -76,15 +74,15 @@ describe('React client sliced client test', () => {
     });
 
     it('works with sliced procedures', () => {
-        const client = useClientQueries<
-            typeof procSchema,
-            {
-                slicing: {
-                    includedProcedures: ['greet', 'sum'];
-                    excludedProcedures: ['sum'];
-                };
-            }
-        >(procSchema);
+        const _slicedProcs = new ZenStackClient(procSchema, {
+            dialect: {} as any,
+            procedures: {} as any,
+            slicing: {
+                includedProcedures: ['greet', 'sum'],
+                excludedProcedures: ['sum'],
+            },
+        });
+        const client = useClientQueries<typeof _slicedProcs>(procSchema);
 
         expectTypeOf(client.$procs).toHaveProperty('greet');
         expectTypeOf(client.$procs).not.toHaveProperty('sum');
diff --git a/packages/clients/tanstack-query/test/svelte-sliced-client.test-d.ts b/packages/clients/tanstack-query/test/svelte-sliced-client.test-d.ts
index 5b83f6ff4..2290536a8 100644
--- a/packages/clients/tanstack-query/test/svelte-sliced-client.test-d.ts
+++ b/packages/clients/tanstack-query/test/svelte-sliced-client.test-d.ts
@@ -1,4 +1,4 @@
-import { ZenStackClient, type GetQueryOptions } from '@zenstackhq/orm';
+import { ZenStackClient } from '@zenstackhq/orm';
 import { describe, expectTypeOf, it } from 'vitest';
 import { useClientQueries } from '../src/svelte/index.svelte';
 import { schema } from './schemas/basic/schema-lite';
@@ -20,7 +20,7 @@ describe('Svelte client sliced client test', () => {
     });
 
     it('works with sliced models', () => {
-        const client = useClientQueries<typeof schema, GetQueryOptions<typeof _db>>(schema);
+        const client = useClientQueries<typeof _db>(schema);
 
         expectTypeOf(client).toHaveProperty('user');
         expectTypeOf(client).toHaveProperty('post');
@@ -28,18 +28,17 @@ describe('Svelte client sliced client test', () => {
     });
 
     it('works with sliced operations', () => {
-        const client = useClientQueries<
-            typeof schema,
-            {
-                slicing: {
-                    models: {
-                        user: {
-                            includedOperations: ['findUnique', 'findMany', 'update'];
-                        };
-                    };
-                };
-            }
-        >(schema);
+        const _slicedOps = new ZenStackClient(schema, {
+            dialect: {} as any,
+            slicing: {
+                models: {
+                    user: {
+                        includedOperations: ['findUnique', 'findMany', 'update'],
+                    },
+                },
+            },
+        });
+        const client = useClientQueries<typeof _slicedOps>(schema);
 
         expectTypeOf(client.user).toHaveProperty('useFindUnique');
         expectTypeOf(client.user).toHaveProperty('useFindMany');
@@ -48,22 +47,21 @@ describe('Svelte client sliced client test', () => {
     });
 
     it('works with sliced filters', () => {
-        const client = useClientQueries<
-            typeof schema,
-            {
-                slicing: {
-                    models: {
-                        user: {
-                            fields: {
-                                $all: {
-                                    includedFilterKinds: ['Equality'];
-                                };
-                            };
-                        };
-                    };
-                };
-            }
-        >(schema);
+        const _slicedFilters = new ZenStackClient(schema, {
+            dialect: {} as any,
+            slicing: {
+                models: {
+                    user: {
+                        fields: {
+                            $all: {
+                                includedFilterKinds: ['Equality'],
+                            },
+                        },
+                    },
+                },
+            },
+        });
+        const client = useClientQueries<typeof _slicedFilters>(schema);
 
         // Equality filter should be allowed
         client.user.useFindMany(() => ({
@@ -76,15 +74,15 @@ describe('Svelte client sliced client test', () => {
     });
 
     it('works with sliced procedures', () => {
-        const client = useClientQueries<
-            typeof procSchema,
-            {
-                slicing: {
-                    includedProcedures: ['greet', 'sum'];
-                    excludedProcedures: ['sum'];
-                };
-            }
-        >(procSchema);
+        const _slicedProcs = new ZenStackClient(procSchema, {
+            dialect: {} as any,
+            procedures: {} as any,
+            slicing: {
+                includedProcedures: ['greet', 'sum'],
+                excludedProcedures: ['sum'],
+            },
+        });
+        const client = useClientQueries<typeof _slicedProcs>(procSchema);
 
         expectTypeOf(client.$procs).toHaveProperty('greet');
         expectTypeOf(client.$procs).not.toHaveProperty('sum');
diff --git a/packages/clients/tanstack-query/test/vue-sliced-client.test-d.ts b/packages/clients/tanstack-query/test/vue-sliced-client.test-d.ts
index 5fdd11d6a..51637c955 100644
--- a/packages/clients/tanstack-query/test/vue-sliced-client.test-d.ts
+++ b/packages/clients/tanstack-query/test/vue-sliced-client.test-d.ts
@@ -1,4 +1,4 @@
-import { ZenStackClient, type GetQueryOptions } from '@zenstackhq/orm';
+import { ZenStackClient } from '@zenstackhq/orm';
 import { describe, expectTypeOf, it } from 'vitest';
 import { useClientQueries } from '../src/vue';
 import { schema } from './schemas/basic/schema-lite';
@@ -20,7 +20,7 @@ describe('Vue client sliced client test', () => {
     });
 
     it('works with sliced models', () => {
-        const client = useClientQueries<typeof schema, GetQueryOptions<typeof _db>>(schema);
+        const client = useClientQueries<typeof _db>(schema);
 
         expectTypeOf(client).toHaveProperty('user');
         expectTypeOf(client).toHaveProperty('post');
@@ -28,18 +28,17 @@ describe('Vue client sliced client test', () => {
     });
 
     it('works with sliced operations', () => {
-        const client = useClientQueries<
-            typeof schema,
-            {
-                slicing: {
-                    models: {
-                        user: {
-                            includedOperations: ['findUnique', 'findMany', 'update'];
-                        };
-                    };
-                };
-            }
-        >(schema);
+        const _slicedOps = new ZenStackClient(schema, {
+            dialect: {} as any,
+            slicing: {
+                models: {
+                    user: {
+                        includedOperations: ['findUnique', 'findMany', 'update'],
+                    },
+                },
+            },
+        });
+        const client = useClientQueries<typeof _slicedOps>(schema);
 
         expectTypeOf(client.user).toHaveProperty('useFindUnique');
         expectTypeOf(client.user).toHaveProperty('useFindMany');
@@ -48,22 +47,21 @@ describe('Vue client sliced client test', () => {
     });
 
     it('works with sliced filters', () => {
-        const client = useClientQueries<
-            typeof schema,
-            {
-                slicing: {
-                    models: {
-                        user: {
-                            fields: {
-                                $all: {
-                                    includedFilterKinds: ['Equality'];
-                                };
-                            };
-                        };
-                    };
-                };
-            }
-        >(schema);
+        const _slicedFilters = new ZenStackClient(schema, {
+            dialect: {} as any,
+            slicing: {
+                models: {
+                    user: {
+                        fields: {
+                            $all: {
+                                includedFilterKinds: ['Equality'],
+                            },
+                        },
+                    },
+                },
+            },
+        });
+        const client = useClientQueries<typeof _slicedFilters>(schema);
 
         // Equality filter should be allowed
         client.user.useFindMany({
@@ -76,15 +74,15 @@ describe('Vue client sliced client test', () => {
     });
 
     it('works with sliced procedures', () => {
-        const client = useClientQueries<
-            typeof procSchema,
-            {
-                slicing: {
-                    includedProcedures: ['greet', 'sum'];
-                    excludedProcedures: ['sum'];
-                };
-            }
-        >(procSchema);
+        const _slicedProcs = new ZenStackClient(procSchema, {
+            dialect: {} as any,
+            procedures: {} as any,
+            slicing: {
+                includedProcedures: ['greet', 'sum'],
+                excludedProcedures: ['sum'],
+            },
+        });
+        const client = useClientQueries<typeof _slicedProcs>(procSchema);
 
         expectTypeOf(client.$procs).toHaveProperty('greet');
         expectTypeOf(client.$procs).not.toHaveProperty('sum');

From d6a7bc5fa5e81a55ffff835ba74d22f7bb19d3ca Mon Sep 17 00:00:00 2001
From: Eugen Istoc <eugenistoc@gmail.com>
Date: Tue, 17 Mar 2026 18:30:57 -0400
Subject: [PATCH 2/4] refactor(clients): address review feedback for TanStack
 Query hooks

- Rename `Client` type parameter to `SchemaOrClient` in useClientQueries
- Remove `ExtResult` type parameter from hooks types (ClientHooks,
  ModelQueryHooks, ModelMutationModelResult, useModelQueries) since
  hooks are not subject to result extension; pass `{}` directly instead
- Clean up unused ExtResultBase and InferExtResult imports
---
 packages/clients/tanstack-query/src/react.ts  | 133 +++++++++---------
 .../tanstack-query/src/svelte/index.svelte.ts |  94 ++++++-------
 packages/clients/tanstack-query/src/vue.ts    |  94 ++++++-------
 3 files changed, 152 insertions(+), 169 deletions(-)

diff --git a/packages/clients/tanstack-query/src/react.ts b/packages/clients/tanstack-query/src/react.ts
index ddfa49037..60afc8ec1 100644
--- a/packages/clients/tanstack-query/src/react.ts
+++ b/packages/clients/tanstack-query/src/react.ts
@@ -19,7 +19,7 @@ import {
     type UseSuspenseQueryOptions,
     type UseSuspenseQueryResult,
 } from '@tanstack/react-query';
-import { createInvalidator, createOptimisticUpdater, DEFAULT_QUERY_ENDPOINT, type InferExtResult, type InferOptions, type InferSchema } from '@zenstackhq/client-helpers';
+import { createInvalidator, createOptimisticUpdater, DEFAULT_QUERY_ENDPOINT, type InferOptions, type InferSchema } from '@zenstackhq/client-helpers';
 import { fetcher, makeUrl, marshal } from '@zenstackhq/client-helpers/fetch';
 import { lowerCaseFirst } from '@zenstackhq/common-helpers';
 import type {
@@ -35,7 +35,6 @@ import type {
     DeleteArgs,
     DeleteManyArgs,
     ExistsArgs,
-    ExtResultBase,
     FindFirstArgs,
     FindManyArgs,
     FindUniqueArgs,
@@ -70,7 +69,7 @@ import type {
     WithOptimistic,
 } from './common/types.js';
 export type { FetchFn } from '@zenstackhq/client-helpers/fetch';
-export type { InferExtResult, InferOptions, InferSchema } from '@zenstackhq/client-helpers';
+export type { InferOptions, InferSchema } from '@zenstackhq/client-helpers';
 export type { SchemaDef } from '@zenstackhq/schema';
 
 type ProcedureHookFn<
@@ -146,20 +145,18 @@ export type ModelMutationModelResult<
     TArgs,
     Array extends boolean = false,
     Options extends QueryOptions<Schema> = QueryOptions<Schema>,
-    ExtResult extends ExtResultBase<Schema> = {},
-> = Omit<ModelMutationResult<SimplifiedResult<Schema, Model, TArgs, Options, false, Array, ExtResult>, TArgs>, 'mutateAsync'> & {
+> = Omit<ModelMutationResult<SimplifiedResult<Schema, Model, TArgs, Options, false, Array, {}>, TArgs>, 'mutateAsync'> & {
     mutateAsync<T extends TArgs>(
         args: T,
-        options?: ModelMutationOptions<SimplifiedResult<Schema, Model, T, Options, false, Array, ExtResult>, T>,
-    ): Promise<SimplifiedResult<Schema, Model, T, Options, false, Array, ExtResult>>;
+        options?: ModelMutationOptions<SimplifiedResult<Schema, Model, T, Options, false, Array, {}>, T>,
+    ): Promise<SimplifiedResult<Schema, Model, T, Options, false, Array, {}>>;
 };
 
 export type ClientHooks<
     Schema extends SchemaDef,
     Options extends QueryOptions<Schema> = QueryOptions<Schema>,
-    ExtResult extends ExtResultBase<Schema> = {},
 > = {
-    [Model in GetSlicedModels<Schema, Options> as `${Uncapitalize<Model>}`]: ModelQueryHooks<Schema, Model, Options, ExtResult>;
+    [Model in GetSlicedModels<Schema, Options> as `${Uncapitalize<Model>}`]: ModelQueryHooks<Schema, Model, Options>;
 } & ProcedureHooks<Schema, Options>;
 
 type ProcedureHookGroup<Schema extends SchemaDef, Options extends QueryOptions<Schema>> = {
@@ -222,88 +219,87 @@ export type ModelQueryHooks<
     Schema extends SchemaDef,
     Model extends GetModels<Schema>,
     Options extends QueryOptions<Schema> = QueryOptions<Schema>,
-    ExtResult extends ExtResultBase<Schema> = {},
 > = TrimSlicedOperations<
     Schema,
     Model,
     Options,
     {
-        useFindUnique<T extends FindUniqueArgs<Schema, Model, Options, {}, ExtResult>>(
-            args: SelectSubset<T, FindUniqueArgs<Schema, Model, Options, {}, ExtResult>>,
-            options?: ModelQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult> | null>,
-        ): ModelQueryResult<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult> | null>;
-
-        useSuspenseFindUnique<T extends FindUniqueArgs<Schema, Model, Options, {}, ExtResult>>(
-            args: SelectSubset<T, FindUniqueArgs<Schema, Model, Options, {}, ExtResult>>,
-            options?: ModelSuspenseQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult> | null>,
-        ): ModelSuspenseQueryResult<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult> | null>;
-
-        useFindFirst<T extends FindFirstArgs<Schema, Model, Options, {}, ExtResult>>(
-            args?: SelectSubset<T, FindFirstArgs<Schema, Model, Options, {}, ExtResult>>,
-            options?: ModelQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult> | null>,
-        ): ModelQueryResult<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult> | null>;
-
-        useSuspenseFindFirst<T extends FindFirstArgs<Schema, Model, Options, {}, ExtResult>>(
-            args?: SelectSubset<T, FindFirstArgs<Schema, Model, Options, {}, ExtResult>>,
-            options?: ModelSuspenseQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult> | null>,
-        ): ModelSuspenseQueryResult<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult> | null>;
+        useFindUnique<T extends FindUniqueArgs<Schema, Model, Options, {}, {}>>(
+            args: SelectSubset<T, FindUniqueArgs<Schema, Model, Options, {}, {}>>,
+            options?: ModelQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, {}> | null>,
+        ): ModelQueryResult<SimplifiedPlainResult<Schema, Model, T, Options, {}> | null>;
+
+        useSuspenseFindUnique<T extends FindUniqueArgs<Schema, Model, Options, {}, {}>>(
+            args: SelectSubset<T, FindUniqueArgs<Schema, Model, Options, {}, {}>>,
+            options?: ModelSuspenseQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, {}> | null>,
+        ): ModelSuspenseQueryResult<SimplifiedPlainResult<Schema, Model, T, Options, {}> | null>;
+
+        useFindFirst<T extends FindFirstArgs<Schema, Model, Options, {}, {}>>(
+            args?: SelectSubset<T, FindFirstArgs<Schema, Model, Options, {}, {}>>,
+            options?: ModelQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, {}> | null>,
+        ): ModelQueryResult<SimplifiedPlainResult<Schema, Model, T, Options, {}> | null>;
+
+        useSuspenseFindFirst<T extends FindFirstArgs<Schema, Model, Options, {}, {}>>(
+            args?: SelectSubset<T, FindFirstArgs<Schema, Model, Options, {}, {}>>,
+            options?: ModelSuspenseQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, {}> | null>,
+        ): ModelSuspenseQueryResult<SimplifiedPlainResult<Schema, Model, T, Options, {}> | null>;
 
         useExists<T extends ExistsArgs<Schema, Model, Options>>(
             args?: Subset<T, ExistsArgs<Schema, Model, Options>>,
             options?: ModelQueryOptions<boolean>,
         ): ModelQueryResult<boolean>;
 
-        useFindMany<T extends FindManyArgs<Schema, Model, Options, {}, ExtResult>>(
-            args?: SelectSubset<T, FindManyArgs<Schema, Model, Options, {}, ExtResult>>,
-            options?: ModelQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[]>,
-        ): ModelQueryResult<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[]>;
+        useFindMany<T extends FindManyArgs<Schema, Model, Options, {}, {}>>(
+            args?: SelectSubset<T, FindManyArgs<Schema, Model, Options, {}, {}>>,
+            options?: ModelQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, {}>[]>,
+        ): ModelQueryResult<SimplifiedPlainResult<Schema, Model, T, Options, {}>[]>;
 
-        useSuspenseFindMany<T extends FindManyArgs<Schema, Model, Options, {}, ExtResult>>(
-            args?: SelectSubset<T, FindManyArgs<Schema, Model, Options, {}, ExtResult>>,
-            options?: ModelSuspenseQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[]>,
-        ): ModelSuspenseQueryResult<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[]>;
+        useSuspenseFindMany<T extends FindManyArgs<Schema, Model, Options, {}, {}>>(
+            args?: SelectSubset<T, FindManyArgs<Schema, Model, Options, {}, {}>>,
+            options?: ModelSuspenseQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, {}>[]>,
+        ): ModelSuspenseQueryResult<SimplifiedPlainResult<Schema, Model, T, Options, {}>[]>;
 
-        useInfiniteFindMany<T extends FindManyArgs<Schema, Model, Options, {}, ExtResult>>(
-            args?: SelectSubset<T, FindManyArgs<Schema, Model, Options, {}, ExtResult>>,
-            options?: ModelInfiniteQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[]>,
-        ): ModelInfiniteQueryResult<InfiniteData<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[]>>;
+        useInfiniteFindMany<T extends FindManyArgs<Schema, Model, Options, {}, {}>>(
+            args?: SelectSubset<T, FindManyArgs<Schema, Model, Options, {}, {}>>,
+            options?: ModelInfiniteQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, {}>[]>,
+        ): ModelInfiniteQueryResult<InfiniteData<SimplifiedPlainResult<Schema, Model, T, Options, {}>[]>>;
 
-        useSuspenseInfiniteFindMany<T extends FindManyArgs<Schema, Model, Options, {}, ExtResult>>(
-            args?: SelectSubset<T, FindManyArgs<Schema, Model, Options, {}, ExtResult>>,
-            options?: ModelSuspenseInfiniteQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[]>,
-        ): ModelSuspenseInfiniteQueryResult<InfiniteData<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[]>>;
+        useSuspenseInfiniteFindMany<T extends FindManyArgs<Schema, Model, Options, {}, {}>>(
+            args?: SelectSubset<T, FindManyArgs<Schema, Model, Options, {}, {}>>,
+            options?: ModelSuspenseInfiniteQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, {}>[]>,
+        ): ModelSuspenseInfiniteQueryResult<InfiniteData<SimplifiedPlainResult<Schema, Model, T, Options, {}>[]>>;
 
-        useCreate<T extends CreateArgs<Schema, Model, Options, {}, ExtResult>>(
-            options?: ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>, T>,
-        ): ModelMutationModelResult<Schema, Model, T, false, Options, ExtResult>;
+        useCreate<T extends CreateArgs<Schema, Model, Options, {}, {}>>(
+            options?: ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, {}>, T>,
+        ): ModelMutationModelResult<Schema, Model, T, false, Options>;
 
         useCreateMany<T extends CreateManyArgs<Schema, Model>>(
             options?: ModelMutationOptions<BatchResult, T>,
         ): ModelMutationResult<BatchResult, T>;
 
-        useCreateManyAndReturn<T extends CreateManyAndReturnArgs<Schema, Model, Options, {}, ExtResult>>(
-            options?: ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[], T>,
-        ): ModelMutationModelResult<Schema, Model, T, true, Options, ExtResult>;
+        useCreateManyAndReturn<T extends CreateManyAndReturnArgs<Schema, Model, Options, {}, {}>>(
+            options?: ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, {}>[], T>,
+        ): ModelMutationModelResult<Schema, Model, T, true, Options>;
 
-        useUpdate<T extends UpdateArgs<Schema, Model, Options, {}, ExtResult>>(
-            options?: ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>, T>,
-        ): ModelMutationModelResult<Schema, Model, T, false, Options, ExtResult>;
+        useUpdate<T extends UpdateArgs<Schema, Model, Options, {}, {}>>(
+            options?: ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, {}>, T>,
+        ): ModelMutationModelResult<Schema, Model, T, false, Options>;
 
         useUpdateMany<T extends UpdateManyArgs<Schema, Model, Options>>(
             options?: ModelMutationOptions<BatchResult, T>,
         ): ModelMutationResult<BatchResult, T>;
 
-        useUpdateManyAndReturn<T extends UpdateManyAndReturnArgs<Schema, Model, Options, {}, ExtResult>>(
-            options?: ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[], T>,
-        ): ModelMutationModelResult<Schema, Model, T, true, Options, ExtResult>;
+        useUpdateManyAndReturn<T extends UpdateManyAndReturnArgs<Schema, Model, Options, {}, {}>>(
+            options?: ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, {}>[], T>,
+        ): ModelMutationModelResult<Schema, Model, T, true, Options>;
 
-        useUpsert<T extends UpsertArgs<Schema, Model, Options, {}, ExtResult>>(
-            options?: ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>, T>,
-        ): ModelMutationModelResult<Schema, Model, T, false, Options, ExtResult>;
+        useUpsert<T extends UpsertArgs<Schema, Model, Options, {}, {}>>(
+            options?: ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, {}>, T>,
+        ): ModelMutationModelResult<Schema, Model, T, false, Options>;
 
-        useDelete<T extends DeleteArgs<Schema, Model, Options, {}, ExtResult>>(
-            options?: ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>, T>,
-        ): ModelMutationModelResult<Schema, Model, T, false, Options, ExtResult>;
+        useDelete<T extends DeleteArgs<Schema, Model, Options, {}, {}>>(
+            options?: ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, {}>, T>,
+        ): ModelMutationModelResult<Schema, Model, T, false, Options>;
 
         useDeleteMany<T extends DeleteManyArgs<Schema, Model, Options>>(
             options?: ModelMutationOptions<BatchResult, T>,
@@ -361,11 +357,11 @@ export type ModelQueryHooks<
  * @param options Options for all queries originated from this hook.
  */
 export function useClientQueries<
-    Client extends SchemaDef | ClientContract<any, any, any, any, any>,
+    SchemaOrClient extends SchemaDef | ClientContract<any, any, any, any, any>,
 >(
-    schema: InferSchema<Client>,
+    schema: InferSchema<SchemaOrClient>,
     options?: QueryContext,
-): ClientHooks<InferSchema<Client>, InferOptions<Client, InferSchema<Client>>, InferExtResult<Client> extends ExtResultBase<InferSchema<Client>> ? InferExtResult<Client> : {}> {
+): ClientHooks<InferSchema<SchemaOrClient>, InferOptions<SchemaOrClient, InferSchema<SchemaOrClient>>> {
     const result = Object.keys(schema.models).reduce(
         (acc, model) => {
             (acc as any)[lowerCaseFirst(model)] = useModelQueries(
@@ -432,8 +428,7 @@ export function useModelQueries<
     Schema extends SchemaDef,
     Model extends GetModels<Schema>,
     Options extends QueryOptions<Schema>,
-    ExtResult extends ExtResultBase<Schema> = {},
->(schema: Schema, model: Model, rootOptions?: QueryContext): ModelQueryHooks<Schema, Model, Options, ExtResult> {
+>(schema: Schema, model: Model, rootOptions?: QueryContext): ModelQueryHooks<Schema, Model, Options> {
     const modelDef = Object.values(schema.models).find((m) => m.name.toLowerCase() === model.toLowerCase());
     if (!modelDef) {
         throw new Error(`Model "${model}" not found in schema`);
@@ -543,7 +538,7 @@ export function useModelQueries<
         useSuspenseGroupBy: (args: any, options?: any) => {
             return useInternalSuspenseQuery(schema, modelName, 'groupBy', args, { ...rootOptions, ...options });
         },
-    } as ModelQueryHooks<Schema, Model, Options, ExtResult>;
+    } as ModelQueryHooks<Schema, Model, Options>;
 }
 
 export function useInternalQuery<TQueryFnData, TData>(
diff --git a/packages/clients/tanstack-query/src/svelte/index.svelte.ts b/packages/clients/tanstack-query/src/svelte/index.svelte.ts
index e690fcfc9..c0cb00033 100644
--- a/packages/clients/tanstack-query/src/svelte/index.svelte.ts
+++ b/packages/clients/tanstack-query/src/svelte/index.svelte.ts
@@ -19,7 +19,6 @@ import {
     createInvalidator,
     createOptimisticUpdater,
     DEFAULT_QUERY_ENDPOINT,
-    type InferExtResult,
     type InferOptions,
     type InferSchema,
     type InvalidationPredicate,
@@ -39,7 +38,6 @@ import type {
     DeleteArgs,
     DeleteManyArgs,
     ExistsArgs,
-    ExtResultBase,
     FindFirstArgs,
     FindManyArgs,
     FindUniqueArgs,
@@ -74,7 +72,7 @@ import type {
     WithOptimistic,
 } from '../common/types.js';
 export type { FetchFn } from '@zenstackhq/client-helpers/fetch';
-export type { InferExtResult, InferOptions, InferSchema } from '@zenstackhq/client-helpers';
+export type { InferOptions, InferSchema } from '@zenstackhq/client-helpers';
 export type { SchemaDef } from '@zenstackhq/schema';
 
 type ProcedureHookFn<
@@ -146,20 +144,18 @@ export type ModelMutationModelResult<
     TArgs,
     Array extends boolean = false,
     Options extends QueryOptions<Schema> = QueryOptions<Schema>,
-    ExtResult extends ExtResultBase<Schema> = {},
-> = Omit<ModelMutationResult<SimplifiedResult<Schema, Model, TArgs, Options, false, Array, ExtResult>, TArgs>, 'mutateAsync'> & {
+> = Omit<ModelMutationResult<SimplifiedResult<Schema, Model, TArgs, Options, false, Array, {}>, TArgs>, 'mutateAsync'> & {
     mutateAsync<T extends TArgs>(
         args: T,
-        options?: ModelMutationOptions<SimplifiedResult<Schema, Model, T, Options, false, Array, ExtResult>, T>,
-    ): Promise<SimplifiedResult<Schema, Model, T, Options, false, Array, ExtResult>>;
+        options?: ModelMutationOptions<SimplifiedResult<Schema, Model, T, Options, false, Array, {}>, T>,
+    ): Promise<SimplifiedResult<Schema, Model, T, Options, false, Array, {}>>;
 };
 
 export type ClientHooks<
     Schema extends SchemaDef,
     Options extends QueryOptions<Schema> = QueryOptions<Schema>,
-    ExtResult extends ExtResultBase<Schema> = {},
 > = {
-    [Model in GetSlicedModels<Schema, Options> as `${Uncapitalize<Model>}`]: ModelQueryHooks<Schema, Model, Options, ExtResult>;
+    [Model in GetSlicedModels<Schema, Options> as `${Uncapitalize<Model>}`]: ModelQueryHooks<Schema, Model, Options>;
 } & ProcedureHooks<Schema, Options>;
 
 type ProcedureHookGroup<Schema extends SchemaDef, Options extends QueryOptions<Schema>> = {
@@ -212,66 +208,65 @@ export type ModelQueryHooks<
     Schema extends SchemaDef,
     Model extends GetModels<Schema>,
     Options extends QueryOptions<Schema> = QueryOptions<Schema>,
-    ExtResult extends ExtResultBase<Schema> = {},
 > = TrimSlicedOperations<
     Schema,
     Model,
     Options,
     {
-        useFindUnique<T extends FindUniqueArgs<Schema, Model, Options, {}, ExtResult>>(
-            args: Accessor<SelectSubset<T, FindUniqueArgs<Schema, Model, Options, {}, ExtResult>>>,
-            options?: Accessor<ModelQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult> | null>>,
-        ): ModelQueryResult<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult> | null>;
+        useFindUnique<T extends FindUniqueArgs<Schema, Model, Options, {}, {}>>(
+            args: Accessor<SelectSubset<T, FindUniqueArgs<Schema, Model, Options, {}, {}>>>,
+            options?: Accessor<ModelQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, {}> | null>>,
+        ): ModelQueryResult<SimplifiedPlainResult<Schema, Model, T, Options, {}> | null>;
 
-        useFindFirst<T extends FindFirstArgs<Schema, Model, Options, {}, ExtResult>>(
-            args?: Accessor<SelectSubset<T, FindFirstArgs<Schema, Model, Options, {}, ExtResult>>>,
-            options?: Accessor<ModelQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult> | null>>,
-        ): ModelQueryResult<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult> | null>;
+        useFindFirst<T extends FindFirstArgs<Schema, Model, Options, {}, {}>>(
+            args?: Accessor<SelectSubset<T, FindFirstArgs<Schema, Model, Options, {}, {}>>>,
+            options?: Accessor<ModelQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, {}> | null>>,
+        ): ModelQueryResult<SimplifiedPlainResult<Schema, Model, T, Options, {}> | null>;
 
         useExists<T extends ExistsArgs<Schema, Model, Options>>(
             args?: Accessor<Subset<T, ExistsArgs<Schema, Model, Options>>>,
             options?: Accessor<ModelQueryOptions<boolean>>,
         ): ModelQueryResult<boolean>;
 
-        useFindMany<T extends FindManyArgs<Schema, Model, Options, {}, ExtResult>>(
-            args?: Accessor<SelectSubset<T, FindManyArgs<Schema, Model, Options, {}, ExtResult>>>,
-            options?: Accessor<ModelQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[]>>,
-        ): ModelQueryResult<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[]>;
+        useFindMany<T extends FindManyArgs<Schema, Model, Options, {}, {}>>(
+            args?: Accessor<SelectSubset<T, FindManyArgs<Schema, Model, Options, {}, {}>>>,
+            options?: Accessor<ModelQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, {}>[]>>,
+        ): ModelQueryResult<SimplifiedPlainResult<Schema, Model, T, Options, {}>[]>;
 
-        useInfiniteFindMany<T extends FindManyArgs<Schema, Model, Options, {}, ExtResult>>(
-            args?: Accessor<SelectSubset<T, FindManyArgs<Schema, Model, Options, {}, ExtResult>>>,
-            options?: Accessor<ModelInfiniteQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[]>>,
-        ): ModelInfiniteQueryResult<InfiniteData<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[]>>;
+        useInfiniteFindMany<T extends FindManyArgs<Schema, Model, Options, {}, {}>>(
+            args?: Accessor<SelectSubset<T, FindManyArgs<Schema, Model, Options, {}, {}>>>,
+            options?: Accessor<ModelInfiniteQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, {}>[]>>,
+        ): ModelInfiniteQueryResult<InfiniteData<SimplifiedPlainResult<Schema, Model, T, Options, {}>[]>>;
 
-        useCreate<T extends CreateArgs<Schema, Model, Options, {}, ExtResult>>(
-            options?: Accessor<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>, T>>,
-        ): ModelMutationModelResult<Schema, Model, T, false, Options, ExtResult>;
+        useCreate<T extends CreateArgs<Schema, Model, Options, {}, {}>>(
+            options?: Accessor<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, {}>, T>>,
+        ): ModelMutationModelResult<Schema, Model, T, false, Options>;
 
         useCreateMany<T extends CreateManyArgs<Schema, Model>>(
             options?: Accessor<ModelMutationOptions<BatchResult, T>>,
         ): ModelMutationResult<BatchResult, T>;
 
-        useCreateManyAndReturn<T extends CreateManyAndReturnArgs<Schema, Model, Options, {}, ExtResult>>(
-            options?: Accessor<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[], T>>,
-        ): ModelMutationModelResult<Schema, Model, T, true, Options, ExtResult>;
+        useCreateManyAndReturn<T extends CreateManyAndReturnArgs<Schema, Model, Options, {}, {}>>(
+            options?: Accessor<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, {}>[], T>>,
+        ): ModelMutationModelResult<Schema, Model, T, true, Options>;
 
-        useUpdate<T extends UpdateArgs<Schema, Model, Options, {}, ExtResult>>(
-            options?: Accessor<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>, T>>,
-        ): ModelMutationModelResult<Schema, Model, T, false, Options, ExtResult>;
+        useUpdate<T extends UpdateArgs<Schema, Model, Options, {}, {}>>(
+            options?: Accessor<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, {}>, T>>,
+        ): ModelMutationModelResult<Schema, Model, T, false, Options>;
         useUpdateMany<T extends UpdateManyArgs<Schema, Model, Options>>(
             options?: Accessor<ModelMutationOptions<BatchResult, T>>,
         ): ModelMutationResult<BatchResult, T>;
 
-        useUpdateManyAndReturn<T extends UpdateManyAndReturnArgs<Schema, Model, Options, {}, ExtResult>>(
-            options?: Accessor<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[], T>>,
-        ): ModelMutationModelResult<Schema, Model, T, true, Options, ExtResult>;
+        useUpdateManyAndReturn<T extends UpdateManyAndReturnArgs<Schema, Model, Options, {}, {}>>(
+            options?: Accessor<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, {}>[], T>>,
+        ): ModelMutationModelResult<Schema, Model, T, true, Options>;
 
-        useUpsert<T extends UpsertArgs<Schema, Model, Options, {}, ExtResult>>(
-            options?: Accessor<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>, T>>,
-        ): ModelMutationModelResult<Schema, Model, T, false, Options, ExtResult>;
-        useDelete<T extends DeleteArgs<Schema, Model, Options, {}, ExtResult>>(
-            options?: Accessor<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>, T>>,
-        ): ModelMutationModelResult<Schema, Model, T, false, Options, ExtResult>;
+        useUpsert<T extends UpsertArgs<Schema, Model, Options, {}, {}>>(
+            options?: Accessor<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, {}>, T>>,
+        ): ModelMutationModelResult<Schema, Model, T, false, Options>;
+        useDelete<T extends DeleteArgs<Schema, Model, Options, {}, {}>>(
+            options?: Accessor<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, {}>, T>>,
+        ): ModelMutationModelResult<Schema, Model, T, false, Options>;
 
         useDeleteMany<T extends DeleteManyArgs<Schema, Model, Options>>(
             options?: Accessor<ModelMutationOptions<BatchResult, T>>,
@@ -311,11 +306,11 @@ export type ModelQueryHooks<
  * ```
  */
 export function useClientQueries<
-    Client extends SchemaDef | ClientContract<any, any, any, any, any>,
+    SchemaOrClient extends SchemaDef | ClientContract<any, any, any, any, any>,
 >(
-    schema: InferSchema<Client>,
+    schema: InferSchema<SchemaOrClient>,
     options?: Accessor<QueryContext>,
-): ClientHooks<InferSchema<Client>, InferOptions<Client, InferSchema<Client>>, InferExtResult<Client> extends ExtResultBase<InferSchema<Client>> ? InferExtResult<Client> : {}> {
+): ClientHooks<InferSchema<SchemaOrClient>, InferOptions<SchemaOrClient, InferSchema<SchemaOrClient>>> {
     const result = Object.keys(schema.models).reduce(
         (acc, model) => {
             (acc as any)[lowerCaseFirst(model)] = useModelQueries(
@@ -375,8 +370,7 @@ export function useModelQueries<
     Schema extends SchemaDef,
     Model extends GetModels<Schema>,
     Options extends QueryOptions<Schema>,
-    ExtResult extends ExtResultBase<Schema> = {},
->(schema: Schema, model: Model, rootOptions?: Accessor<QueryContext>): ModelQueryHooks<Schema, Model, Options, ExtResult> {
+>(schema: Schema, model: Model, rootOptions?: Accessor<QueryContext>): ModelQueryHooks<Schema, Model, Options> {
     const modelDef = Object.values(schema.models).find((m) => m.name.toLowerCase() === model.toLowerCase());
     if (!modelDef) {
         throw new Error(`Model "${model}" not found in schema`);
@@ -452,7 +446,7 @@ export function useModelQueries<
         useGroupBy: (args: any, options?: any) => {
             return useInternalQuery(schema, modelName, 'groupBy', args, options);
         },
-    } as unknown as ModelQueryHooks<Schema, Model, Options, ExtResult>;
+    } as unknown as ModelQueryHooks<Schema, Model, Options>;
 }
 
 export function useInternalQuery<TQueryFnData, TData>(
diff --git a/packages/clients/tanstack-query/src/vue.ts b/packages/clients/tanstack-query/src/vue.ts
index 6fb64aa3c..ab7a34238 100644
--- a/packages/clients/tanstack-query/src/vue.ts
+++ b/packages/clients/tanstack-query/src/vue.ts
@@ -17,7 +17,6 @@ import {
     createInvalidator,
     createOptimisticUpdater,
     DEFAULT_QUERY_ENDPOINT,
-    type InferExtResult,
     type InferOptions,
     type InferSchema,
     type InvalidationPredicate,
@@ -37,7 +36,6 @@ import type {
     DeleteArgs,
     DeleteManyArgs,
     ExistsArgs,
-    ExtResultBase,
     FindFirstArgs,
     FindManyArgs,
     FindUniqueArgs,
@@ -72,7 +70,7 @@ import type {
     WithOptimistic,
 } from './common/types.js';
 export type { FetchFn } from '@zenstackhq/client-helpers/fetch';
-export type { InferExtResult, InferOptions, InferSchema } from '@zenstackhq/client-helpers';
+export type { InferOptions, InferSchema } from '@zenstackhq/client-helpers';
 export type { SchemaDef } from '@zenstackhq/schema';
 
 export const VueQueryContextKey = 'zenstack-vue-query-context';
@@ -137,23 +135,21 @@ export type ModelMutationModelResult<
     TArgs,
     Array extends boolean = false,
     Options extends QueryOptions<Schema> = QueryOptions<Schema>,
-    ExtResult extends ExtResultBase<Schema> = {},
 > = Omit<
-    ModelMutationResult<SimplifiedResult<Schema, Model, TArgs, QueryOptions<Schema>, false, Array, ExtResult>, TArgs>,
+    ModelMutationResult<SimplifiedResult<Schema, Model, TArgs, QueryOptions<Schema>, false, Array, {}>, TArgs>,
     'mutateAsync'
 > & {
     mutateAsync<T extends TArgs>(
         args: T,
-        options?: ModelMutationOptions<SimplifiedResult<Schema, Model, T, Options, false, Array, ExtResult>, T>,
-    ): Promise<SimplifiedResult<Schema, Model, T, Options, false, Array, ExtResult>>;
+        options?: ModelMutationOptions<SimplifiedResult<Schema, Model, T, Options, false, Array, {}>, T>,
+    ): Promise<SimplifiedResult<Schema, Model, T, Options, false, Array, {}>>;
 };
 
 export type ClientHooks<
     Schema extends SchemaDef,
     Options extends QueryOptions<Schema> = QueryOptions<Schema>,
-    ExtResult extends ExtResultBase<Schema> = {},
 > = {
-    [Model in GetSlicedModels<Schema, Options> as `${Uncapitalize<Model>}`]: ModelQueryHooks<Schema, Model, Options, ExtResult>;
+    [Model in GetSlicedModels<Schema, Options> as `${Uncapitalize<Model>}`]: ModelQueryHooks<Schema, Model, Options>;
 } & ProcedureHooks<Schema, Options>;
 
 type ProcedureHookGroup<Schema extends SchemaDef, Options extends QueryOptions<Schema>> = {
@@ -215,68 +211,67 @@ export type ModelQueryHooks<
     Schema extends SchemaDef,
     Model extends GetModels<Schema>,
     Options extends QueryOptions<Schema> = QueryOptions<Schema>,
-    ExtResult extends ExtResultBase<Schema> = {},
 > = TrimSlicedOperations<
     Schema,
     Model,
     Options,
     {
-        useFindUnique<T extends FindUniqueArgs<Schema, Model, Options, {}, ExtResult>>(
-            args: MaybeRefOrGetter<SelectSubset<T, FindUniqueArgs<Schema, Model, Options, {}, ExtResult>>>,
-            options?: MaybeRefOrGetter<ModelQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult> | null>>,
-        ): ModelQueryResult<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult> | null>;
+        useFindUnique<T extends FindUniqueArgs<Schema, Model, Options, {}, {}>>(
+            args: MaybeRefOrGetter<SelectSubset<T, FindUniqueArgs<Schema, Model, Options, {}, {}>>>,
+            options?: MaybeRefOrGetter<ModelQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, {}> | null>>,
+        ): ModelQueryResult<SimplifiedPlainResult<Schema, Model, T, Options, {}> | null>;
 
-        useFindFirst<T extends FindFirstArgs<Schema, Model, Options, {}, ExtResult>>(
-            args?: MaybeRefOrGetter<SelectSubset<T, FindFirstArgs<Schema, Model, Options, {}, ExtResult>>>,
-            options?: MaybeRefOrGetter<ModelQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult> | null>>,
-        ): ModelQueryResult<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult> | null>;
+        useFindFirst<T extends FindFirstArgs<Schema, Model, Options, {}, {}>>(
+            args?: MaybeRefOrGetter<SelectSubset<T, FindFirstArgs<Schema, Model, Options, {}, {}>>>,
+            options?: MaybeRefOrGetter<ModelQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, {}> | null>>,
+        ): ModelQueryResult<SimplifiedPlainResult<Schema, Model, T, Options, {}> | null>;
 
         useExists<T extends ExistsArgs<Schema, Model, Options>>(
             args?: MaybeRefOrGetter<Subset<T, ExistsArgs<Schema, Model, Options>>>,
             options?: MaybeRefOrGetter<ModelQueryOptions<boolean>>,
         ): ModelQueryResult<boolean>;
 
-        useFindMany<T extends FindManyArgs<Schema, Model, Options, {}, ExtResult>>(
-            args?: MaybeRefOrGetter<SelectSubset<T, FindManyArgs<Schema, Model, Options, {}, ExtResult>>>,
-            options?: MaybeRefOrGetter<ModelQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[]>>,
-        ): ModelQueryResult<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[]>;
+        useFindMany<T extends FindManyArgs<Schema, Model, Options, {}, {}>>(
+            args?: MaybeRefOrGetter<SelectSubset<T, FindManyArgs<Schema, Model, Options, {}, {}>>>,
+            options?: MaybeRefOrGetter<ModelQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, {}>[]>>,
+        ): ModelQueryResult<SimplifiedPlainResult<Schema, Model, T, Options, {}>[]>;
 
-        useInfiniteFindMany<T extends FindManyArgs<Schema, Model, Options, {}, ExtResult>>(
-            args?: MaybeRefOrGetter<SelectSubset<T, FindManyArgs<Schema, Model, Options, {}, ExtResult>>>,
-            options?: MaybeRefOrGetter<ModelInfiniteQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[]>>,
-        ): ModelInfiniteQueryResult<InfiniteData<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[]>>;
+        useInfiniteFindMany<T extends FindManyArgs<Schema, Model, Options, {}, {}>>(
+            args?: MaybeRefOrGetter<SelectSubset<T, FindManyArgs<Schema, Model, Options, {}, {}>>>,
+            options?: MaybeRefOrGetter<ModelInfiniteQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, {}>[]>>,
+        ): ModelInfiniteQueryResult<InfiniteData<SimplifiedPlainResult<Schema, Model, T, Options, {}>[]>>;
 
-        useCreate<T extends CreateArgs<Schema, Model, Options, {}, ExtResult>>(
-            options?: MaybeRefOrGetter<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>, T>>,
-        ): ModelMutationModelResult<Schema, Model, T, false, Options, ExtResult>;
+        useCreate<T extends CreateArgs<Schema, Model, Options, {}, {}>>(
+            options?: MaybeRefOrGetter<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, {}>, T>>,
+        ): ModelMutationModelResult<Schema, Model, T, false, Options>;
 
         useCreateMany<T extends CreateManyArgs<Schema, Model>>(
             options?: MaybeRefOrGetter<ModelMutationOptions<BatchResult, T>>,
         ): ModelMutationResult<BatchResult, T>;
 
-        useCreateManyAndReturn<T extends CreateManyAndReturnArgs<Schema, Model, Options, {}, ExtResult>>(
-            options?: MaybeRefOrGetter<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[], T>>,
-        ): ModelMutationModelResult<Schema, Model, T, true, Options, ExtResult>;
+        useCreateManyAndReturn<T extends CreateManyAndReturnArgs<Schema, Model, Options, {}, {}>>(
+            options?: MaybeRefOrGetter<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, {}>[], T>>,
+        ): ModelMutationModelResult<Schema, Model, T, true, Options>;
 
-        useUpdate<T extends UpdateArgs<Schema, Model, Options, {}, ExtResult>>(
-            options?: MaybeRefOrGetter<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>, T>>,
-        ): ModelMutationModelResult<Schema, Model, T, false, Options, ExtResult>;
+        useUpdate<T extends UpdateArgs<Schema, Model, Options, {}, {}>>(
+            options?: MaybeRefOrGetter<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, {}>, T>>,
+        ): ModelMutationModelResult<Schema, Model, T, false, Options>;
 
         useUpdateMany<T extends UpdateManyArgs<Schema, Model, Options>>(
             options?: MaybeRefOrGetter<ModelMutationOptions<BatchResult, T>>,
         ): ModelMutationResult<BatchResult, T>;
 
-        useUpdateManyAndReturn<T extends UpdateManyAndReturnArgs<Schema, Model, Options, {}, ExtResult>>(
-            options?: MaybeRefOrGetter<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[], T>>,
-        ): ModelMutationModelResult<Schema, Model, T, true, Options, ExtResult>;
+        useUpdateManyAndReturn<T extends UpdateManyAndReturnArgs<Schema, Model, Options, {}, {}>>(
+            options?: MaybeRefOrGetter<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, {}>[], T>>,
+        ): ModelMutationModelResult<Schema, Model, T, true, Options>;
 
-        useUpsert<T extends UpsertArgs<Schema, Model, Options, {}, ExtResult>>(
-            options?: MaybeRefOrGetter<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>, T>>,
-        ): ModelMutationModelResult<Schema, Model, T, false, Options, ExtResult>;
+        useUpsert<T extends UpsertArgs<Schema, Model, Options, {}, {}>>(
+            options?: MaybeRefOrGetter<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, {}>, T>>,
+        ): ModelMutationModelResult<Schema, Model, T, false, Options>;
 
-        useDelete<T extends DeleteArgs<Schema, Model, Options, {}, ExtResult>>(
-            options?: MaybeRefOrGetter<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>, T>>,
-        ): ModelMutationModelResult<Schema, Model, T, false, Options, ExtResult>;
+        useDelete<T extends DeleteArgs<Schema, Model, Options, {}, {}>>(
+            options?: MaybeRefOrGetter<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, {}>, T>>,
+        ): ModelMutationModelResult<Schema, Model, T, false, Options>;
 
         useDeleteMany<T extends DeleteManyArgs<Schema, Model, Options>>(
             options?: MaybeRefOrGetter<ModelMutationOptions<BatchResult, T>>,
@@ -316,11 +311,11 @@ export type ModelQueryHooks<
  * ```
  */
 export function useClientQueries<
-    Client extends SchemaDef | ClientContract<any, any, any, any, any>,
+    SchemaOrClient extends SchemaDef | ClientContract<any, any, any, any, any>,
 >(
-    schema: InferSchema<Client>,
+    schema: InferSchema<SchemaOrClient>,
     options?: MaybeRefOrGetter<QueryContext>,
-): ClientHooks<InferSchema<Client>, InferOptions<Client, InferSchema<Client>>, InferExtResult<Client> extends ExtResultBase<InferSchema<Client>> ? InferExtResult<Client> : {}> {
+): ClientHooks<InferSchema<SchemaOrClient>, InferOptions<SchemaOrClient, InferSchema<SchemaOrClient>>> {
     const merge = (rootOpt: MaybeRefOrGetter<unknown> | undefined, opt: MaybeRefOrGetter<unknown> | undefined): any => {
         return computed(() => {
             const rootVal = toValue(rootOpt) ?? {};
@@ -388,8 +383,7 @@ export function useModelQueries<
     Schema extends SchemaDef,
     Model extends GetModels<Schema>,
     Options extends QueryOptions<Schema>,
-    ExtResult extends ExtResultBase<Schema> = {},
->(schema: Schema, model: Model, rootOptions?: MaybeRefOrGetter<QueryContext>): ModelQueryHooks<Schema, Model, Options, ExtResult> {
+>(schema: Schema, model: Model, rootOptions?: MaybeRefOrGetter<QueryContext>): ModelQueryHooks<Schema, Model, Options> {
     const modelDef = Object.values(schema.models).find((m) => m.name.toLowerCase() === model.toLowerCase());
     if (!modelDef) {
         throw new Error(`Model "${model}" not found in schema`);
@@ -471,7 +465,7 @@ export function useModelQueries<
         useGroupBy: (args: any, options?: any) => {
             return useInternalQuery(schema, modelName, 'groupBy', args, merge(rootOptions, options));
         },
-    } as ModelQueryHooks<Schema, Model, Options, ExtResult>;
+    } as ModelQueryHooks<Schema, Model, Options>;
 }
 
 export function useInternalQuery<TQueryFnData, TData>(

From 346799a6911b7d30800fc296f51ae119826e4857 Mon Sep 17 00:00:00 2001
From: Eugen Istoc <eugenistoc@gmail.com>
Date: Tue, 17 Mar 2026 18:38:27 -0400
Subject: [PATCH 3/4] fix(clients): use Options generic consistently in Vue
 ModelMutationModelResult

The base mutation result type was hardcoding QueryOptions<Schema> instead
of using the Options generic parameter, breaking consistency with React
and Svelte adapters.
---
 packages/clients/tanstack-query/src/vue.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/clients/tanstack-query/src/vue.ts b/packages/clients/tanstack-query/src/vue.ts
index ab7a34238..dd8cc0418 100644
--- a/packages/clients/tanstack-query/src/vue.ts
+++ b/packages/clients/tanstack-query/src/vue.ts
@@ -136,7 +136,7 @@ export type ModelMutationModelResult<
     Array extends boolean = false,
     Options extends QueryOptions<Schema> = QueryOptions<Schema>,
 > = Omit<
-    ModelMutationResult<SimplifiedResult<Schema, Model, TArgs, QueryOptions<Schema>, false, Array, {}>, TArgs>,
+    ModelMutationResult<SimplifiedResult<Schema, Model, TArgs, Options, false, Array, {}>, TArgs>,
     'mutateAsync'
 > & {
     mutateAsync<T extends TArgs>(

From d5aead0ebff1fa355427a6dbe44d798b91a726a5 Mon Sep 17 00:00:00 2001
From: Eugen Istoc <eugenistoc@gmail.com>
Date: Wed, 18 Mar 2026 07:33:23 -0400
Subject: [PATCH 4/4] fix(clients): restore ExtResult for model hooks, keep
 removed for procedures
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The previous commit over-applied the review feedback — ExtResult was
removed from all hooks, but the reviewer intended it only for custom
procedure hooks. Regular model hooks should carry ExtResult typing for
plugin-computed field support.
---
 packages/clients/tanstack-query/src/react.ts  | 129 +++++++++---------
 .../tanstack-query/src/svelte/index.svelte.ts |  90 ++++++------
 packages/clients/tanstack-query/src/vue.ts    |  90 ++++++------
 3 files changed, 163 insertions(+), 146 deletions(-)

diff --git a/packages/clients/tanstack-query/src/react.ts b/packages/clients/tanstack-query/src/react.ts
index 60afc8ec1..e84aa7e09 100644
--- a/packages/clients/tanstack-query/src/react.ts
+++ b/packages/clients/tanstack-query/src/react.ts
@@ -19,7 +19,7 @@ import {
     type UseSuspenseQueryOptions,
     type UseSuspenseQueryResult,
 } from '@tanstack/react-query';
-import { createInvalidator, createOptimisticUpdater, DEFAULT_QUERY_ENDPOINT, type InferOptions, type InferSchema } from '@zenstackhq/client-helpers';
+import { createInvalidator, createOptimisticUpdater, DEFAULT_QUERY_ENDPOINT, type InferExtResult, type InferOptions, type InferSchema } from '@zenstackhq/client-helpers';
 import { fetcher, makeUrl, marshal } from '@zenstackhq/client-helpers/fetch';
 import { lowerCaseFirst } from '@zenstackhq/common-helpers';
 import type {
@@ -35,6 +35,7 @@ import type {
     DeleteArgs,
     DeleteManyArgs,
     ExistsArgs,
+    ExtResultBase,
     FindFirstArgs,
     FindManyArgs,
     FindUniqueArgs,
@@ -69,7 +70,7 @@ import type {
     WithOptimistic,
 } from './common/types.js';
 export type { FetchFn } from '@zenstackhq/client-helpers/fetch';
-export type { InferOptions, InferSchema } from '@zenstackhq/client-helpers';
+export type { InferExtResult, InferOptions, InferSchema } from '@zenstackhq/client-helpers';
 export type { SchemaDef } from '@zenstackhq/schema';
 
 type ProcedureHookFn<
@@ -145,18 +146,20 @@ export type ModelMutationModelResult<
     TArgs,
     Array extends boolean = false,
     Options extends QueryOptions<Schema> = QueryOptions<Schema>,
-> = Omit<ModelMutationResult<SimplifiedResult<Schema, Model, TArgs, Options, false, Array, {}>, TArgs>, 'mutateAsync'> & {
+    ExtResult extends ExtResultBase<Schema> = {},
+> = Omit<ModelMutationResult<SimplifiedResult<Schema, Model, TArgs, Options, false, Array, ExtResult>, TArgs>, 'mutateAsync'> & {
     mutateAsync<T extends TArgs>(
         args: T,
-        options?: ModelMutationOptions<SimplifiedResult<Schema, Model, T, Options, false, Array, {}>, T>,
-    ): Promise<SimplifiedResult<Schema, Model, T, Options, false, Array, {}>>;
+        options?: ModelMutationOptions<SimplifiedResult<Schema, Model, T, Options, false, Array, ExtResult>, T>,
+    ): Promise<SimplifiedResult<Schema, Model, T, Options, false, Array, ExtResult>>;
 };
 
 export type ClientHooks<
     Schema extends SchemaDef,
     Options extends QueryOptions<Schema> = QueryOptions<Schema>,
+    ExtResult extends ExtResultBase<Schema> = {},
 > = {
-    [Model in GetSlicedModels<Schema, Options> as `${Uncapitalize<Model>}`]: ModelQueryHooks<Schema, Model, Options>;
+    [Model in GetSlicedModels<Schema, Options> as `${Uncapitalize<Model>}`]: ModelQueryHooks<Schema, Model, Options, ExtResult>;
 } & ProcedureHooks<Schema, Options>;
 
 type ProcedureHookGroup<Schema extends SchemaDef, Options extends QueryOptions<Schema>> = {
@@ -219,87 +222,88 @@ export type ModelQueryHooks<
     Schema extends SchemaDef,
     Model extends GetModels<Schema>,
     Options extends QueryOptions<Schema> = QueryOptions<Schema>,
+    ExtResult extends ExtResultBase<Schema> = {},
 > = TrimSlicedOperations<
     Schema,
     Model,
     Options,
     {
-        useFindUnique<T extends FindUniqueArgs<Schema, Model, Options, {}, {}>>(
-            args: SelectSubset<T, FindUniqueArgs<Schema, Model, Options, {}, {}>>,
-            options?: ModelQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, {}> | null>,
-        ): ModelQueryResult<SimplifiedPlainResult<Schema, Model, T, Options, {}> | null>;
-
-        useSuspenseFindUnique<T extends FindUniqueArgs<Schema, Model, Options, {}, {}>>(
-            args: SelectSubset<T, FindUniqueArgs<Schema, Model, Options, {}, {}>>,
-            options?: ModelSuspenseQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, {}> | null>,
-        ): ModelSuspenseQueryResult<SimplifiedPlainResult<Schema, Model, T, Options, {}> | null>;
-
-        useFindFirst<T extends FindFirstArgs<Schema, Model, Options, {}, {}>>(
-            args?: SelectSubset<T, FindFirstArgs<Schema, Model, Options, {}, {}>>,
-            options?: ModelQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, {}> | null>,
-        ): ModelQueryResult<SimplifiedPlainResult<Schema, Model, T, Options, {}> | null>;
-
-        useSuspenseFindFirst<T extends FindFirstArgs<Schema, Model, Options, {}, {}>>(
-            args?: SelectSubset<T, FindFirstArgs<Schema, Model, Options, {}, {}>>,
-            options?: ModelSuspenseQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, {}> | null>,
-        ): ModelSuspenseQueryResult<SimplifiedPlainResult<Schema, Model, T, Options, {}> | null>;
+        useFindUnique<T extends FindUniqueArgs<Schema, Model, Options, {}, ExtResult>>(
+            args: SelectSubset<T, FindUniqueArgs<Schema, Model, Options, {}, ExtResult>>,
+            options?: ModelQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult> | null>,
+        ): ModelQueryResult<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult> | null>;
+
+        useSuspenseFindUnique<T extends FindUniqueArgs<Schema, Model, Options, {}, ExtResult>>(
+            args: SelectSubset<T, FindUniqueArgs<Schema, Model, Options, {}, ExtResult>>,
+            options?: ModelSuspenseQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult> | null>,
+        ): ModelSuspenseQueryResult<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult> | null>;
+
+        useFindFirst<T extends FindFirstArgs<Schema, Model, Options, {}, ExtResult>>(
+            args?: SelectSubset<T, FindFirstArgs<Schema, Model, Options, {}, ExtResult>>,
+            options?: ModelQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult> | null>,
+        ): ModelQueryResult<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult> | null>;
+
+        useSuspenseFindFirst<T extends FindFirstArgs<Schema, Model, Options, {}, ExtResult>>(
+            args?: SelectSubset<T, FindFirstArgs<Schema, Model, Options, {}, ExtResult>>,
+            options?: ModelSuspenseQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult> | null>,
+        ): ModelSuspenseQueryResult<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult> | null>;
 
         useExists<T extends ExistsArgs<Schema, Model, Options>>(
             args?: Subset<T, ExistsArgs<Schema, Model, Options>>,
             options?: ModelQueryOptions<boolean>,
         ): ModelQueryResult<boolean>;
 
-        useFindMany<T extends FindManyArgs<Schema, Model, Options, {}, {}>>(
-            args?: SelectSubset<T, FindManyArgs<Schema, Model, Options, {}, {}>>,
-            options?: ModelQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, {}>[]>,
-        ): ModelQueryResult<SimplifiedPlainResult<Schema, Model, T, Options, {}>[]>;
+        useFindMany<T extends FindManyArgs<Schema, Model, Options, {}, ExtResult>>(
+            args?: SelectSubset<T, FindManyArgs<Schema, Model, Options, {}, ExtResult>>,
+            options?: ModelQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[]>,
+        ): ModelQueryResult<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[]>;
 
-        useSuspenseFindMany<T extends FindManyArgs<Schema, Model, Options, {}, {}>>(
-            args?: SelectSubset<T, FindManyArgs<Schema, Model, Options, {}, {}>>,
-            options?: ModelSuspenseQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, {}>[]>,
-        ): ModelSuspenseQueryResult<SimplifiedPlainResult<Schema, Model, T, Options, {}>[]>;
+        useSuspenseFindMany<T extends FindManyArgs<Schema, Model, Options, {}, ExtResult>>(
+            args?: SelectSubset<T, FindManyArgs<Schema, Model, Options, {}, ExtResult>>,
+            options?: ModelSuspenseQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[]>,
+        ): ModelSuspenseQueryResult<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[]>;
 
-        useInfiniteFindMany<T extends FindManyArgs<Schema, Model, Options, {}, {}>>(
-            args?: SelectSubset<T, FindManyArgs<Schema, Model, Options, {}, {}>>,
-            options?: ModelInfiniteQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, {}>[]>,
-        ): ModelInfiniteQueryResult<InfiniteData<SimplifiedPlainResult<Schema, Model, T, Options, {}>[]>>;
+        useInfiniteFindMany<T extends FindManyArgs<Schema, Model, Options, {}, ExtResult>>(
+            args?: SelectSubset<T, FindManyArgs<Schema, Model, Options, {}, ExtResult>>,
+            options?: ModelInfiniteQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[]>,
+        ): ModelInfiniteQueryResult<InfiniteData<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[]>>;
 
-        useSuspenseInfiniteFindMany<T extends FindManyArgs<Schema, Model, Options, {}, {}>>(
-            args?: SelectSubset<T, FindManyArgs<Schema, Model, Options, {}, {}>>,
-            options?: ModelSuspenseInfiniteQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, {}>[]>,
-        ): ModelSuspenseInfiniteQueryResult<InfiniteData<SimplifiedPlainResult<Schema, Model, T, Options, {}>[]>>;
+        useSuspenseInfiniteFindMany<T extends FindManyArgs<Schema, Model, Options, {}, ExtResult>>(
+            args?: SelectSubset<T, FindManyArgs<Schema, Model, Options, {}, ExtResult>>,
+            options?: ModelSuspenseInfiniteQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[]>,
+        ): ModelSuspenseInfiniteQueryResult<InfiniteData<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[]>>;
 
-        useCreate<T extends CreateArgs<Schema, Model, Options, {}, {}>>(
-            options?: ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, {}>, T>,
-        ): ModelMutationModelResult<Schema, Model, T, false, Options>;
+        useCreate<T extends CreateArgs<Schema, Model, Options, {}, ExtResult>>(
+            options?: ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>, T>,
+        ): ModelMutationModelResult<Schema, Model, T, false, Options, ExtResult>;
 
         useCreateMany<T extends CreateManyArgs<Schema, Model>>(
             options?: ModelMutationOptions<BatchResult, T>,
         ): ModelMutationResult<BatchResult, T>;
 
-        useCreateManyAndReturn<T extends CreateManyAndReturnArgs<Schema, Model, Options, {}, {}>>(
-            options?: ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, {}>[], T>,
-        ): ModelMutationModelResult<Schema, Model, T, true, Options>;
+        useCreateManyAndReturn<T extends CreateManyAndReturnArgs<Schema, Model, Options, {}, ExtResult>>(
+            options?: ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[], T>,
+        ): ModelMutationModelResult<Schema, Model, T, true, Options, ExtResult>;
 
-        useUpdate<T extends UpdateArgs<Schema, Model, Options, {}, {}>>(
-            options?: ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, {}>, T>,
-        ): ModelMutationModelResult<Schema, Model, T, false, Options>;
+        useUpdate<T extends UpdateArgs<Schema, Model, Options, {}, ExtResult>>(
+            options?: ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>, T>,
+        ): ModelMutationModelResult<Schema, Model, T, false, Options, ExtResult>;
 
         useUpdateMany<T extends UpdateManyArgs<Schema, Model, Options>>(
             options?: ModelMutationOptions<BatchResult, T>,
         ): ModelMutationResult<BatchResult, T>;
 
-        useUpdateManyAndReturn<T extends UpdateManyAndReturnArgs<Schema, Model, Options, {}, {}>>(
-            options?: ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, {}>[], T>,
-        ): ModelMutationModelResult<Schema, Model, T, true, Options>;
+        useUpdateManyAndReturn<T extends UpdateManyAndReturnArgs<Schema, Model, Options, {}, ExtResult>>(
+            options?: ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[], T>,
+        ): ModelMutationModelResult<Schema, Model, T, true, Options, ExtResult>;
 
-        useUpsert<T extends UpsertArgs<Schema, Model, Options, {}, {}>>(
-            options?: ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, {}>, T>,
-        ): ModelMutationModelResult<Schema, Model, T, false, Options>;
+        useUpsert<T extends UpsertArgs<Schema, Model, Options, {}, ExtResult>>(
+            options?: ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>, T>,
+        ): ModelMutationModelResult<Schema, Model, T, false, Options, ExtResult>;
 
-        useDelete<T extends DeleteArgs<Schema, Model, Options, {}, {}>>(
-            options?: ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, {}>, T>,
-        ): ModelMutationModelResult<Schema, Model, T, false, Options>;
+        useDelete<T extends DeleteArgs<Schema, Model, Options, {}, ExtResult>>(
+            options?: ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>, T>,
+        ): ModelMutationModelResult<Schema, Model, T, false, Options, ExtResult>;
 
         useDeleteMany<T extends DeleteManyArgs<Schema, Model, Options>>(
             options?: ModelMutationOptions<BatchResult, T>,
@@ -361,7 +365,7 @@ export function useClientQueries<
 >(
     schema: InferSchema<SchemaOrClient>,
     options?: QueryContext,
-): ClientHooks<InferSchema<SchemaOrClient>, InferOptions<SchemaOrClient, InferSchema<SchemaOrClient>>> {
+): ClientHooks<InferSchema<SchemaOrClient>, InferOptions<SchemaOrClient, InferSchema<SchemaOrClient>>, InferExtResult<SchemaOrClient> extends ExtResultBase<InferSchema<SchemaOrClient>> ? InferExtResult<SchemaOrClient> : {}> {
     const result = Object.keys(schema.models).reduce(
         (acc, model) => {
             (acc as any)[lowerCaseFirst(model)] = useModelQueries(
@@ -428,7 +432,8 @@ export function useModelQueries<
     Schema extends SchemaDef,
     Model extends GetModels<Schema>,
     Options extends QueryOptions<Schema>,
->(schema: Schema, model: Model, rootOptions?: QueryContext): ModelQueryHooks<Schema, Model, Options> {
+    ExtResult extends ExtResultBase<Schema> = {},
+>(schema: Schema, model: Model, rootOptions?: QueryContext): ModelQueryHooks<Schema, Model, Options, ExtResult> {
     const modelDef = Object.values(schema.models).find((m) => m.name.toLowerCase() === model.toLowerCase());
     if (!modelDef) {
         throw new Error(`Model "${model}" not found in schema`);
@@ -538,7 +543,7 @@ export function useModelQueries<
         useSuspenseGroupBy: (args: any, options?: any) => {
             return useInternalSuspenseQuery(schema, modelName, 'groupBy', args, { ...rootOptions, ...options });
         },
-    } as ModelQueryHooks<Schema, Model, Options>;
+    } as ModelQueryHooks<Schema, Model, Options, ExtResult>;
 }
 
 export function useInternalQuery<TQueryFnData, TData>(
diff --git a/packages/clients/tanstack-query/src/svelte/index.svelte.ts b/packages/clients/tanstack-query/src/svelte/index.svelte.ts
index c0cb00033..9ddfe40e2 100644
--- a/packages/clients/tanstack-query/src/svelte/index.svelte.ts
+++ b/packages/clients/tanstack-query/src/svelte/index.svelte.ts
@@ -19,6 +19,7 @@ import {
     createInvalidator,
     createOptimisticUpdater,
     DEFAULT_QUERY_ENDPOINT,
+    type InferExtResult,
     type InferOptions,
     type InferSchema,
     type InvalidationPredicate,
@@ -38,6 +39,7 @@ import type {
     DeleteArgs,
     DeleteManyArgs,
     ExistsArgs,
+    ExtResultBase,
     FindFirstArgs,
     FindManyArgs,
     FindUniqueArgs,
@@ -72,7 +74,7 @@ import type {
     WithOptimistic,
 } from '../common/types.js';
 export type { FetchFn } from '@zenstackhq/client-helpers/fetch';
-export type { InferOptions, InferSchema } from '@zenstackhq/client-helpers';
+export type { InferExtResult, InferOptions, InferSchema } from '@zenstackhq/client-helpers';
 export type { SchemaDef } from '@zenstackhq/schema';
 
 type ProcedureHookFn<
@@ -144,18 +146,20 @@ export type ModelMutationModelResult<
     TArgs,
     Array extends boolean = false,
     Options extends QueryOptions<Schema> = QueryOptions<Schema>,
-> = Omit<ModelMutationResult<SimplifiedResult<Schema, Model, TArgs, Options, false, Array, {}>, TArgs>, 'mutateAsync'> & {
+    ExtResult extends ExtResultBase<Schema> = {},
+> = Omit<ModelMutationResult<SimplifiedResult<Schema, Model, TArgs, Options, false, Array, ExtResult>, TArgs>, 'mutateAsync'> & {
     mutateAsync<T extends TArgs>(
         args: T,
-        options?: ModelMutationOptions<SimplifiedResult<Schema, Model, T, Options, false, Array, {}>, T>,
-    ): Promise<SimplifiedResult<Schema, Model, T, Options, false, Array, {}>>;
+        options?: ModelMutationOptions<SimplifiedResult<Schema, Model, T, Options, false, Array, ExtResult>, T>,
+    ): Promise<SimplifiedResult<Schema, Model, T, Options, false, Array, ExtResult>>;
 };
 
 export type ClientHooks<
     Schema extends SchemaDef,
     Options extends QueryOptions<Schema> = QueryOptions<Schema>,
+    ExtResult extends ExtResultBase<Schema> = {},
 > = {
-    [Model in GetSlicedModels<Schema, Options> as `${Uncapitalize<Model>}`]: ModelQueryHooks<Schema, Model, Options>;
+    [Model in GetSlicedModels<Schema, Options> as `${Uncapitalize<Model>}`]: ModelQueryHooks<Schema, Model, Options, ExtResult>;
 } & ProcedureHooks<Schema, Options>;
 
 type ProcedureHookGroup<Schema extends SchemaDef, Options extends QueryOptions<Schema>> = {
@@ -208,65 +212,66 @@ export type ModelQueryHooks<
     Schema extends SchemaDef,
     Model extends GetModels<Schema>,
     Options extends QueryOptions<Schema> = QueryOptions<Schema>,
+    ExtResult extends ExtResultBase<Schema> = {},
 > = TrimSlicedOperations<
     Schema,
     Model,
     Options,
     {
-        useFindUnique<T extends FindUniqueArgs<Schema, Model, Options, {}, {}>>(
-            args: Accessor<SelectSubset<T, FindUniqueArgs<Schema, Model, Options, {}, {}>>>,
-            options?: Accessor<ModelQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, {}> | null>>,
-        ): ModelQueryResult<SimplifiedPlainResult<Schema, Model, T, Options, {}> | null>;
+        useFindUnique<T extends FindUniqueArgs<Schema, Model, Options, {}, ExtResult>>(
+            args: Accessor<SelectSubset<T, FindUniqueArgs<Schema, Model, Options, {}, ExtResult>>>,
+            options?: Accessor<ModelQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult> | null>>,
+        ): ModelQueryResult<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult> | null>;
 
-        useFindFirst<T extends FindFirstArgs<Schema, Model, Options, {}, {}>>(
-            args?: Accessor<SelectSubset<T, FindFirstArgs<Schema, Model, Options, {}, {}>>>,
-            options?: Accessor<ModelQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, {}> | null>>,
-        ): ModelQueryResult<SimplifiedPlainResult<Schema, Model, T, Options, {}> | null>;
+        useFindFirst<T extends FindFirstArgs<Schema, Model, Options, {}, ExtResult>>(
+            args?: Accessor<SelectSubset<T, FindFirstArgs<Schema, Model, Options, {}, ExtResult>>>,
+            options?: Accessor<ModelQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult> | null>>,
+        ): ModelQueryResult<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult> | null>;
 
         useExists<T extends ExistsArgs<Schema, Model, Options>>(
             args?: Accessor<Subset<T, ExistsArgs<Schema, Model, Options>>>,
             options?: Accessor<ModelQueryOptions<boolean>>,
         ): ModelQueryResult<boolean>;
 
-        useFindMany<T extends FindManyArgs<Schema, Model, Options, {}, {}>>(
-            args?: Accessor<SelectSubset<T, FindManyArgs<Schema, Model, Options, {}, {}>>>,
-            options?: Accessor<ModelQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, {}>[]>>,
-        ): ModelQueryResult<SimplifiedPlainResult<Schema, Model, T, Options, {}>[]>;
+        useFindMany<T extends FindManyArgs<Schema, Model, Options, {}, ExtResult>>(
+            args?: Accessor<SelectSubset<T, FindManyArgs<Schema, Model, Options, {}, ExtResult>>>,
+            options?: Accessor<ModelQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[]>>,
+        ): ModelQueryResult<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[]>;
 
-        useInfiniteFindMany<T extends FindManyArgs<Schema, Model, Options, {}, {}>>(
-            args?: Accessor<SelectSubset<T, FindManyArgs<Schema, Model, Options, {}, {}>>>,
-            options?: Accessor<ModelInfiniteQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, {}>[]>>,
-        ): ModelInfiniteQueryResult<InfiniteData<SimplifiedPlainResult<Schema, Model, T, Options, {}>[]>>;
+        useInfiniteFindMany<T extends FindManyArgs<Schema, Model, Options, {}, ExtResult>>(
+            args?: Accessor<SelectSubset<T, FindManyArgs<Schema, Model, Options, {}, ExtResult>>>,
+            options?: Accessor<ModelInfiniteQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[]>>,
+        ): ModelInfiniteQueryResult<InfiniteData<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[]>>;
 
-        useCreate<T extends CreateArgs<Schema, Model, Options, {}, {}>>(
-            options?: Accessor<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, {}>, T>>,
-        ): ModelMutationModelResult<Schema, Model, T, false, Options>;
+        useCreate<T extends CreateArgs<Schema, Model, Options, {}, ExtResult>>(
+            options?: Accessor<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>, T>>,
+        ): ModelMutationModelResult<Schema, Model, T, false, Options, ExtResult>;
 
         useCreateMany<T extends CreateManyArgs<Schema, Model>>(
             options?: Accessor<ModelMutationOptions<BatchResult, T>>,
         ): ModelMutationResult<BatchResult, T>;
 
-        useCreateManyAndReturn<T extends CreateManyAndReturnArgs<Schema, Model, Options, {}, {}>>(
-            options?: Accessor<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, {}>[], T>>,
-        ): ModelMutationModelResult<Schema, Model, T, true, Options>;
+        useCreateManyAndReturn<T extends CreateManyAndReturnArgs<Schema, Model, Options, {}, ExtResult>>(
+            options?: Accessor<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[], T>>,
+        ): ModelMutationModelResult<Schema, Model, T, true, Options, ExtResult>;
 
-        useUpdate<T extends UpdateArgs<Schema, Model, Options, {}, {}>>(
-            options?: Accessor<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, {}>, T>>,
-        ): ModelMutationModelResult<Schema, Model, T, false, Options>;
+        useUpdate<T extends UpdateArgs<Schema, Model, Options, {}, ExtResult>>(
+            options?: Accessor<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>, T>>,
+        ): ModelMutationModelResult<Schema, Model, T, false, Options, ExtResult>;
         useUpdateMany<T extends UpdateManyArgs<Schema, Model, Options>>(
             options?: Accessor<ModelMutationOptions<BatchResult, T>>,
         ): ModelMutationResult<BatchResult, T>;
 
-        useUpdateManyAndReturn<T extends UpdateManyAndReturnArgs<Schema, Model, Options, {}, {}>>(
-            options?: Accessor<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, {}>[], T>>,
-        ): ModelMutationModelResult<Schema, Model, T, true, Options>;
+        useUpdateManyAndReturn<T extends UpdateManyAndReturnArgs<Schema, Model, Options, {}, ExtResult>>(
+            options?: Accessor<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[], T>>,
+        ): ModelMutationModelResult<Schema, Model, T, true, Options, ExtResult>;
 
-        useUpsert<T extends UpsertArgs<Schema, Model, Options, {}, {}>>(
-            options?: Accessor<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, {}>, T>>,
-        ): ModelMutationModelResult<Schema, Model, T, false, Options>;
-        useDelete<T extends DeleteArgs<Schema, Model, Options, {}, {}>>(
-            options?: Accessor<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, {}>, T>>,
-        ): ModelMutationModelResult<Schema, Model, T, false, Options>;
+        useUpsert<T extends UpsertArgs<Schema, Model, Options, {}, ExtResult>>(
+            options?: Accessor<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>, T>>,
+        ): ModelMutationModelResult<Schema, Model, T, false, Options, ExtResult>;
+        useDelete<T extends DeleteArgs<Schema, Model, Options, {}, ExtResult>>(
+            options?: Accessor<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>, T>>,
+        ): ModelMutationModelResult<Schema, Model, T, false, Options, ExtResult>;
 
         useDeleteMany<T extends DeleteManyArgs<Schema, Model, Options>>(
             options?: Accessor<ModelMutationOptions<BatchResult, T>>,
@@ -310,7 +315,7 @@ export function useClientQueries<
 >(
     schema: InferSchema<SchemaOrClient>,
     options?: Accessor<QueryContext>,
-): ClientHooks<InferSchema<SchemaOrClient>, InferOptions<SchemaOrClient, InferSchema<SchemaOrClient>>> {
+): ClientHooks<InferSchema<SchemaOrClient>, InferOptions<SchemaOrClient, InferSchema<SchemaOrClient>>, InferExtResult<SchemaOrClient> extends ExtResultBase<InferSchema<SchemaOrClient>> ? InferExtResult<SchemaOrClient> : {}> {
     const result = Object.keys(schema.models).reduce(
         (acc, model) => {
             (acc as any)[lowerCaseFirst(model)] = useModelQueries(
@@ -370,7 +375,8 @@ export function useModelQueries<
     Schema extends SchemaDef,
     Model extends GetModels<Schema>,
     Options extends QueryOptions<Schema>,
->(schema: Schema, model: Model, rootOptions?: Accessor<QueryContext>): ModelQueryHooks<Schema, Model, Options> {
+    ExtResult extends ExtResultBase<Schema> = {},
+>(schema: Schema, model: Model, rootOptions?: Accessor<QueryContext>): ModelQueryHooks<Schema, Model, Options, ExtResult> {
     const modelDef = Object.values(schema.models).find((m) => m.name.toLowerCase() === model.toLowerCase());
     if (!modelDef) {
         throw new Error(`Model "${model}" not found in schema`);
@@ -446,7 +452,7 @@ export function useModelQueries<
         useGroupBy: (args: any, options?: any) => {
             return useInternalQuery(schema, modelName, 'groupBy', args, options);
         },
-    } as unknown as ModelQueryHooks<Schema, Model, Options>;
+    } as unknown as ModelQueryHooks<Schema, Model, Options, ExtResult>;
 }
 
 export function useInternalQuery<TQueryFnData, TData>(
diff --git a/packages/clients/tanstack-query/src/vue.ts b/packages/clients/tanstack-query/src/vue.ts
index dd8cc0418..4b0e8a682 100644
--- a/packages/clients/tanstack-query/src/vue.ts
+++ b/packages/clients/tanstack-query/src/vue.ts
@@ -17,6 +17,7 @@ import {
     createInvalidator,
     createOptimisticUpdater,
     DEFAULT_QUERY_ENDPOINT,
+    type InferExtResult,
     type InferOptions,
     type InferSchema,
     type InvalidationPredicate,
@@ -36,6 +37,7 @@ import type {
     DeleteArgs,
     DeleteManyArgs,
     ExistsArgs,
+    ExtResultBase,
     FindFirstArgs,
     FindManyArgs,
     FindUniqueArgs,
@@ -70,7 +72,7 @@ import type {
     WithOptimistic,
 } from './common/types.js';
 export type { FetchFn } from '@zenstackhq/client-helpers/fetch';
-export type { InferOptions, InferSchema } from '@zenstackhq/client-helpers';
+export type { InferExtResult, InferOptions, InferSchema } from '@zenstackhq/client-helpers';
 export type { SchemaDef } from '@zenstackhq/schema';
 
 export const VueQueryContextKey = 'zenstack-vue-query-context';
@@ -135,21 +137,23 @@ export type ModelMutationModelResult<
     TArgs,
     Array extends boolean = false,
     Options extends QueryOptions<Schema> = QueryOptions<Schema>,
+    ExtResult extends ExtResultBase<Schema> = {},
 > = Omit<
-    ModelMutationResult<SimplifiedResult<Schema, Model, TArgs, Options, false, Array, {}>, TArgs>,
+    ModelMutationResult<SimplifiedResult<Schema, Model, TArgs, Options, false, Array, ExtResult>, TArgs>,
     'mutateAsync'
 > & {
     mutateAsync<T extends TArgs>(
         args: T,
-        options?: ModelMutationOptions<SimplifiedResult<Schema, Model, T, Options, false, Array, {}>, T>,
-    ): Promise<SimplifiedResult<Schema, Model, T, Options, false, Array, {}>>;
+        options?: ModelMutationOptions<SimplifiedResult<Schema, Model, T, Options, false, Array, ExtResult>, T>,
+    ): Promise<SimplifiedResult<Schema, Model, T, Options, false, Array, ExtResult>>;
 };
 
 export type ClientHooks<
     Schema extends SchemaDef,
     Options extends QueryOptions<Schema> = QueryOptions<Schema>,
+    ExtResult extends ExtResultBase<Schema> = {},
 > = {
-    [Model in GetSlicedModels<Schema, Options> as `${Uncapitalize<Model>}`]: ModelQueryHooks<Schema, Model, Options>;
+    [Model in GetSlicedModels<Schema, Options> as `${Uncapitalize<Model>}`]: ModelQueryHooks<Schema, Model, Options, ExtResult>;
 } & ProcedureHooks<Schema, Options>;
 
 type ProcedureHookGroup<Schema extends SchemaDef, Options extends QueryOptions<Schema>> = {
@@ -211,67 +215,68 @@ export type ModelQueryHooks<
     Schema extends SchemaDef,
     Model extends GetModels<Schema>,
     Options extends QueryOptions<Schema> = QueryOptions<Schema>,
+    ExtResult extends ExtResultBase<Schema> = {},
 > = TrimSlicedOperations<
     Schema,
     Model,
     Options,
     {
-        useFindUnique<T extends FindUniqueArgs<Schema, Model, Options, {}, {}>>(
-            args: MaybeRefOrGetter<SelectSubset<T, FindUniqueArgs<Schema, Model, Options, {}, {}>>>,
-            options?: MaybeRefOrGetter<ModelQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, {}> | null>>,
-        ): ModelQueryResult<SimplifiedPlainResult<Schema, Model, T, Options, {}> | null>;
+        useFindUnique<T extends FindUniqueArgs<Schema, Model, Options, {}, ExtResult>>(
+            args: MaybeRefOrGetter<SelectSubset<T, FindUniqueArgs<Schema, Model, Options, {}, ExtResult>>>,
+            options?: MaybeRefOrGetter<ModelQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult> | null>>,
+        ): ModelQueryResult<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult> | null>;
 
-        useFindFirst<T extends FindFirstArgs<Schema, Model, Options, {}, {}>>(
-            args?: MaybeRefOrGetter<SelectSubset<T, FindFirstArgs<Schema, Model, Options, {}, {}>>>,
-            options?: MaybeRefOrGetter<ModelQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, {}> | null>>,
-        ): ModelQueryResult<SimplifiedPlainResult<Schema, Model, T, Options, {}> | null>;
+        useFindFirst<T extends FindFirstArgs<Schema, Model, Options, {}, ExtResult>>(
+            args?: MaybeRefOrGetter<SelectSubset<T, FindFirstArgs<Schema, Model, Options, {}, ExtResult>>>,
+            options?: MaybeRefOrGetter<ModelQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult> | null>>,
+        ): ModelQueryResult<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult> | null>;
 
         useExists<T extends ExistsArgs<Schema, Model, Options>>(
             args?: MaybeRefOrGetter<Subset<T, ExistsArgs<Schema, Model, Options>>>,
             options?: MaybeRefOrGetter<ModelQueryOptions<boolean>>,
         ): ModelQueryResult<boolean>;
 
-        useFindMany<T extends FindManyArgs<Schema, Model, Options, {}, {}>>(
-            args?: MaybeRefOrGetter<SelectSubset<T, FindManyArgs<Schema, Model, Options, {}, {}>>>,
-            options?: MaybeRefOrGetter<ModelQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, {}>[]>>,
-        ): ModelQueryResult<SimplifiedPlainResult<Schema, Model, T, Options, {}>[]>;
+        useFindMany<T extends FindManyArgs<Schema, Model, Options, {}, ExtResult>>(
+            args?: MaybeRefOrGetter<SelectSubset<T, FindManyArgs<Schema, Model, Options, {}, ExtResult>>>,
+            options?: MaybeRefOrGetter<ModelQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[]>>,
+        ): ModelQueryResult<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[]>;
 
-        useInfiniteFindMany<T extends FindManyArgs<Schema, Model, Options, {}, {}>>(
-            args?: MaybeRefOrGetter<SelectSubset<T, FindManyArgs<Schema, Model, Options, {}, {}>>>,
-            options?: MaybeRefOrGetter<ModelInfiniteQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, {}>[]>>,
-        ): ModelInfiniteQueryResult<InfiniteData<SimplifiedPlainResult<Schema, Model, T, Options, {}>[]>>;
+        useInfiniteFindMany<T extends FindManyArgs<Schema, Model, Options, {}, ExtResult>>(
+            args?: MaybeRefOrGetter<SelectSubset<T, FindManyArgs<Schema, Model, Options, {}, ExtResult>>>,
+            options?: MaybeRefOrGetter<ModelInfiniteQueryOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[]>>,
+        ): ModelInfiniteQueryResult<InfiniteData<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[]>>;
 
-        useCreate<T extends CreateArgs<Schema, Model, Options, {}, {}>>(
-            options?: MaybeRefOrGetter<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, {}>, T>>,
-        ): ModelMutationModelResult<Schema, Model, T, false, Options>;
+        useCreate<T extends CreateArgs<Schema, Model, Options, {}, ExtResult>>(
+            options?: MaybeRefOrGetter<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>, T>>,
+        ): ModelMutationModelResult<Schema, Model, T, false, Options, ExtResult>;
 
         useCreateMany<T extends CreateManyArgs<Schema, Model>>(
             options?: MaybeRefOrGetter<ModelMutationOptions<BatchResult, T>>,
         ): ModelMutationResult<BatchResult, T>;
 
-        useCreateManyAndReturn<T extends CreateManyAndReturnArgs<Schema, Model, Options, {}, {}>>(
-            options?: MaybeRefOrGetter<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, {}>[], T>>,
-        ): ModelMutationModelResult<Schema, Model, T, true, Options>;
+        useCreateManyAndReturn<T extends CreateManyAndReturnArgs<Schema, Model, Options, {}, ExtResult>>(
+            options?: MaybeRefOrGetter<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[], T>>,
+        ): ModelMutationModelResult<Schema, Model, T, true, Options, ExtResult>;
 
-        useUpdate<T extends UpdateArgs<Schema, Model, Options, {}, {}>>(
-            options?: MaybeRefOrGetter<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, {}>, T>>,
-        ): ModelMutationModelResult<Schema, Model, T, false, Options>;
+        useUpdate<T extends UpdateArgs<Schema, Model, Options, {}, ExtResult>>(
+            options?: MaybeRefOrGetter<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>, T>>,
+        ): ModelMutationModelResult<Schema, Model, T, false, Options, ExtResult>;
 
         useUpdateMany<T extends UpdateManyArgs<Schema, Model, Options>>(
             options?: MaybeRefOrGetter<ModelMutationOptions<BatchResult, T>>,
         ): ModelMutationResult<BatchResult, T>;
 
-        useUpdateManyAndReturn<T extends UpdateManyAndReturnArgs<Schema, Model, Options, {}, {}>>(
-            options?: MaybeRefOrGetter<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, {}>[], T>>,
-        ): ModelMutationModelResult<Schema, Model, T, true, Options>;
+        useUpdateManyAndReturn<T extends UpdateManyAndReturnArgs<Schema, Model, Options, {}, ExtResult>>(
+            options?: MaybeRefOrGetter<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[], T>>,
+        ): ModelMutationModelResult<Schema, Model, T, true, Options, ExtResult>;
 
-        useUpsert<T extends UpsertArgs<Schema, Model, Options, {}, {}>>(
-            options?: MaybeRefOrGetter<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, {}>, T>>,
-        ): ModelMutationModelResult<Schema, Model, T, false, Options>;
+        useUpsert<T extends UpsertArgs<Schema, Model, Options, {}, ExtResult>>(
+            options?: MaybeRefOrGetter<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>, T>>,
+        ): ModelMutationModelResult<Schema, Model, T, false, Options, ExtResult>;
 
-        useDelete<T extends DeleteArgs<Schema, Model, Options, {}, {}>>(
-            options?: MaybeRefOrGetter<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, {}>, T>>,
-        ): ModelMutationModelResult<Schema, Model, T, false, Options>;
+        useDelete<T extends DeleteArgs<Schema, Model, Options, {}, ExtResult>>(
+            options?: MaybeRefOrGetter<ModelMutationOptions<SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>, T>>,
+        ): ModelMutationModelResult<Schema, Model, T, false, Options, ExtResult>;
 
         useDeleteMany<T extends DeleteManyArgs<Schema, Model, Options>>(
             options?: MaybeRefOrGetter<ModelMutationOptions<BatchResult, T>>,
@@ -315,7 +320,7 @@ export function useClientQueries<
 >(
     schema: InferSchema<SchemaOrClient>,
     options?: MaybeRefOrGetter<QueryContext>,
-): ClientHooks<InferSchema<SchemaOrClient>, InferOptions<SchemaOrClient, InferSchema<SchemaOrClient>>> {
+): ClientHooks<InferSchema<SchemaOrClient>, InferOptions<SchemaOrClient, InferSchema<SchemaOrClient>>, InferExtResult<SchemaOrClient> extends ExtResultBase<InferSchema<SchemaOrClient>> ? InferExtResult<SchemaOrClient> : {}> {
     const merge = (rootOpt: MaybeRefOrGetter<unknown> | undefined, opt: MaybeRefOrGetter<unknown> | undefined): any => {
         return computed(() => {
             const rootVal = toValue(rootOpt) ?? {};
@@ -383,7 +388,8 @@ export function useModelQueries<
     Schema extends SchemaDef,
     Model extends GetModels<Schema>,
     Options extends QueryOptions<Schema>,
->(schema: Schema, model: Model, rootOptions?: MaybeRefOrGetter<QueryContext>): ModelQueryHooks<Schema, Model, Options> {
+    ExtResult extends ExtResultBase<Schema> = {},
+>(schema: Schema, model: Model, rootOptions?: MaybeRefOrGetter<QueryContext>): ModelQueryHooks<Schema, Model, Options, ExtResult> {
     const modelDef = Object.values(schema.models).find((m) => m.name.toLowerCase() === model.toLowerCase());
     if (!modelDef) {
         throw new Error(`Model "${model}" not found in schema`);
@@ -465,7 +471,7 @@ export function useModelQueries<
         useGroupBy: (args: any, options?: any) => {
             return useInternalQuery(schema, modelName, 'groupBy', args, merge(rootOptions, options));
         },
-    } as ModelQueryHooks<Schema, Model, Options>;
+    } as ModelQueryHooks<Schema, Model, Options, ExtResult>;
 }
 
 export function useInternalQuery<TQueryFnData, TData>(