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..e84aa7e09 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<
+    SchemaOrClient extends SchemaDef | ClientContract<any, any, any, any, any>,
+>(
+    schema: InferSchema<SchemaOrClient>,
     options?: QueryContext,
-): ClientHooks<Schema, Options> {
+): 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<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..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,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<
+    SchemaOrClient extends SchemaDef | ClientContract<any, any, any, any, any>,
+>(
+    schema: InferSchema<SchemaOrClient>,
     options?: Accessor<QueryContext>,
-): ClientHooks<Schema, Options> {
+): 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<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..4b0e8a682 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, 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>> = {
@@ -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<
+    SchemaOrClient extends SchemaDef | ClientContract<any, any, any, any, any>,
+>(
+    schema: InferSchema<SchemaOrClient>,
     options?: MaybeRefOrGetter<QueryContext>,
-): ClientHooks<Schema, Options> {
+): 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) ?? {};
@@ -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');