diff --git a/packages/clients/tanstack-query/package.json b/packages/clients/tanstack-query/package.json
index cf52cafa..60810ad0 100644
--- a/packages/clients/tanstack-query/package.json
+++ b/packages/clients/tanstack-query/package.json
@@ -67,8 +67,8 @@
     },
     "devDependencies": {
         "@tanstack/react-query": "catalog:",
-        "@tanstack/svelte-query": "5.90.2",
         "@tanstack/vue-query": "5.90.6",
+        "@tanstack/svelte-query": "5.90.2",
         "@testing-library/dom": "^10.4.1",
         "@testing-library/react": "^16.3.0",
         "@types/react": "catalog:",
diff --git a/packages/clients/tanstack-query/src/react.ts b/packages/clients/tanstack-query/src/react.ts
index 05962d87..d9e0ca6d 100644
--- a/packages/clients/tanstack-query/src/react.ts
+++ b/packages/clients/tanstack-query/src/react.ts
@@ -36,6 +36,7 @@ import type {
     GroupByArgs,
     GroupByResult,
     ModelResult,
+    SelectIncludeOmit,
     SelectSubset,
     Subset,
     UpdateArgs,
@@ -56,6 +57,7 @@ import {
     type ExtraMutationOptions,
     type ExtraQueryOptions,
 } from './utils/common';
+import type { TrimDelegateModelOperations } from './utils/types';
 
 export type { FetchFn } from './utils/common';
 
@@ -119,126 +121,144 @@ export type ModelMutationOptions<T, TArgs> = Omit<UseMutationOptions<T, DefaultE
 
 export type ModelMutationResult<T, TArgs> = UseMutationResult<T, DefaultError, TArgs>;
 
-export type SchemaHooks<Schema extends SchemaDef> = {
-    [Model in GetModels<Schema> as `${Uncapitalize<Model>}`]: ModelQueryHooks<Schema, Model>;
-};
-
-export type ModelQueryHooks<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
-    useFindUnique<T extends FindUniqueArgs<Schema, Model>>(
-        args: SelectSubset<T, FindUniqueArgs<Schema, Model>>,
-        options?: ModelQueryOptions<ModelResult<Schema, Model, T> | null>,
-    ): ModelQueryResult<ModelResult<Schema, Model, T> | null>;
-
-    useSuspenseFindUnique<T extends FindUniqueArgs<Schema, Model>>(
-        args: SelectSubset<T, FindUniqueArgs<Schema, Model>>,
-        options?: ModelSuspenseQueryOptions<ModelResult<Schema, Model, T> | null>,
-    ): ModelSuspenseQueryResult<ModelResult<Schema, Model, T> | null>;
-
-    useFindFirst<T extends FindArgs<Schema, Model, false>>(
-        args?: SelectSubset<T, FindArgs<Schema, Model, false>>,
-        options?: ModelQueryOptions<ModelResult<Schema, Model, T> | null>,
-    ): ModelQueryResult<ModelResult<Schema, Model, T> | null>;
-
-    useSuspenseFindFirst<T extends FindArgs<Schema, Model, false>>(
-        args?: SelectSubset<T, FindArgs<Schema, Model, false>>,
-        options?: ModelSuspenseQueryOptions<ModelResult<Schema, Model, T> | null>,
-    ): ModelSuspenseQueryResult<ModelResult<Schema, Model, T> | null>;
-
-    useFindMany<T extends FindArgs<Schema, Model, true>>(
-        args?: SelectSubset<T, FindArgs<Schema, Model, true>>,
-        options?: ModelQueryOptions<ModelResult<Schema, Model, T>[]>,
-    ): ModelQueryResult<ModelResult<Schema, Model, T>[]>;
-
-    useSuspenseFindMany<T extends FindArgs<Schema, Model, true>>(
-        args?: SelectSubset<T, FindArgs<Schema, Model, true>>,
-        options?: ModelSuspenseQueryOptions<ModelResult<Schema, Model, T>[]>,
-    ): ModelSuspenseQueryResult<ModelResult<Schema, Model, T>[]>;
-
-    useInfiniteFindMany<T extends FindArgs<Schema, Model, true>>(
-        args?: SelectSubset<T, FindArgs<Schema, Model, true>>,
-        options?: ModelInfiniteQueryOptions<ModelResult<Schema, Model, T>[]>,
-    ): ModelInfiniteQueryResult<InfiniteData<ModelResult<Schema, Model, T>[]>>;
-
-    useSuspenseInfiniteFindMany<T extends FindArgs<Schema, Model, true>>(
-        args?: SelectSubset<T, FindArgs<Schema, Model, true>>,
-        options?: ModelSuspenseInfiniteQueryOptions<ModelResult<Schema, Model, T>[]>,
-    ): ModelSuspenseInfiniteQueryResult<InfiniteData<ModelResult<Schema, Model, T>[]>>;
-
-    useCreate<T extends CreateArgs<Schema, Model>>(
-        options?: ModelMutationOptions<ModelResult<Schema, Model, T>, T>,
-    ): ModelMutationResult<ModelResult<Schema, Model, T>, T>;
-
-    useCreateMany<T extends CreateManyArgs<Schema, Model>>(
-        options?: ModelMutationOptions<BatchResult, T>,
-    ): ModelMutationResult<BatchResult, T>;
-
-    useCreateManyAndReturn<T extends CreateManyAndReturnArgs<Schema, Model>>(
-        options?: ModelMutationOptions<ModelResult<Schema, Model, T>[], T>,
-    ): ModelMutationResult<ModelResult<Schema, Model, T>[], T>;
-
-    useUpdate<T extends UpdateArgs<Schema, Model>>(
-        options?: ModelMutationOptions<ModelResult<Schema, Model, T>, T>,
-    ): ModelMutationResult<ModelResult<Schema, Model, T>, T>;
-
-    useUpdateMany<T extends UpdateManyArgs<Schema, Model>>(
-        options?: ModelMutationOptions<BatchResult, T>,
-    ): ModelMutationResult<BatchResult, T>;
-
-    useUpdateManyAndReturn<T extends UpdateManyAndReturnArgs<Schema, Model>>(
-        options?: ModelMutationOptions<ModelResult<Schema, Model, T>[], T>,
-    ): ModelMutationResult<ModelResult<Schema, Model, T>[], T>;
-
-    useUpsert<T extends UpsertArgs<Schema, Model>>(
+export type ModelMutationModelResult<
+    Schema extends SchemaDef,
+    Model extends GetModels<Schema>,
+    TArgs extends SelectIncludeOmit<Schema, Model, boolean>,
+    Array extends boolean = false,
+> = Omit<ModelMutationResult<ModelResult<Schema, Model, TArgs>, TArgs>, 'mutateAsync'> & {
+    mutateAsync<T extends TArgs>(
+        args: T,
         options?: ModelMutationOptions<ModelResult<Schema, Model, T>, T>,
-    ): ModelMutationResult<ModelResult<Schema, Model, T>, T>;
+    ): Promise<Array extends true ? ModelResult<Schema, Model, T>[] : ModelResult<Schema, Model, T>>;
+};
 
-    useDelete<T extends DeleteArgs<Schema, Model>>(
-        options?: ModelMutationOptions<ModelResult<Schema, Model, T>, T>,
-    ): ModelMutationResult<ModelResult<Schema, Model, T>, T>;
-
-    useDeleteMany<T extends DeleteManyArgs<Schema, Model>>(
-        options?: ModelMutationOptions<BatchResult, T>,
-    ): ModelMutationResult<BatchResult, T>;
-
-    useCount<T extends CountArgs<Schema, Model>>(
-        args?: Subset<T, CountArgs<Schema, Model>>,
-        options?: ModelQueryOptions<CountResult<Schema, Model, T>>,
-    ): ModelQueryResult<CountResult<Schema, Model, T>>;
-
-    useSuspenseCount<T extends CountArgs<Schema, Model>>(
-        args?: Subset<T, CountArgs<Schema, Model>>,
-        options?: ModelSuspenseQueryOptions<CountResult<Schema, Model, T>>,
-    ): ModelSuspenseQueryResult<CountResult<Schema, Model, T>>;
-
-    useAggregate<T extends AggregateArgs<Schema, Model>>(
-        args: Subset<T, AggregateArgs<Schema, Model>>,
-        options?: ModelQueryOptions<AggregateResult<Schema, Model, T>>,
-    ): ModelQueryResult<AggregateResult<Schema, Model, T>>;
-
-    useSuspenseAggregate<T extends AggregateArgs<Schema, Model>>(
-        args: Subset<T, AggregateArgs<Schema, Model>>,
-        options?: ModelSuspenseQueryOptions<AggregateResult<Schema, Model, T>>,
-    ): ModelSuspenseQueryResult<AggregateResult<Schema, Model, T>>;
-
-    useGroupBy<T extends GroupByArgs<Schema, Model>>(
-        args: Subset<T, GroupByArgs<Schema, Model>>,
-        options?: ModelQueryOptions<GroupByResult<Schema, Model, T>>,
-    ): ModelQueryResult<GroupByResult<Schema, Model, T>>;
-
-    useSuspenseGroupBy<T extends GroupByArgs<Schema, Model>>(
-        args: Subset<T, GroupByArgs<Schema, Model>>,
-        options?: ModelSuspenseQueryOptions<GroupByResult<Schema, Model, T>>,
-    ): ModelSuspenseQueryResult<GroupByResult<Schema, Model, T>>;
+export type ClientHooks<Schema extends SchemaDef> = {
+    [Model in GetModels<Schema> as `${Uncapitalize<Model>}`]: ModelQueryHooks<Schema, Model>;
 };
 
+// Note that we can potentially use TypeScript's mapped type to directly map from ORM contract, but that seems
+// to significantly slow down tsc performance ...
+export type ModelQueryHooks<Schema extends SchemaDef, Model extends GetModels<Schema>> = TrimDelegateModelOperations<
+    Schema,
+    Model,
+    {
+        useFindUnique<T extends FindUniqueArgs<Schema, Model>>(
+            args: SelectSubset<T, FindUniqueArgs<Schema, Model>>,
+            options?: ModelQueryOptions<ModelResult<Schema, Model, T> | null>,
+        ): ModelQueryResult<ModelResult<Schema, Model, T> | null>;
+
+        useSuspenseFindUnique<T extends FindUniqueArgs<Schema, Model>>(
+            args: SelectSubset<T, FindUniqueArgs<Schema, Model>>,
+            options?: ModelSuspenseQueryOptions<ModelResult<Schema, Model, T> | null>,
+        ): ModelSuspenseQueryResult<ModelResult<Schema, Model, T> | null>;
+
+        useFindFirst<T extends FindArgs<Schema, Model, false>>(
+            args?: SelectSubset<T, FindArgs<Schema, Model, false>>,
+            options?: ModelQueryOptions<ModelResult<Schema, Model, T> | null>,
+        ): ModelQueryResult<ModelResult<Schema, Model, T> | null>;
+
+        useSuspenseFindFirst<T extends FindArgs<Schema, Model, false>>(
+            args?: SelectSubset<T, FindArgs<Schema, Model, false>>,
+            options?: ModelSuspenseQueryOptions<ModelResult<Schema, Model, T> | null>,
+        ): ModelSuspenseQueryResult<ModelResult<Schema, Model, T> | null>;
+
+        useFindMany<T extends FindArgs<Schema, Model, true>>(
+            args?: SelectSubset<T, FindArgs<Schema, Model, true>>,
+            options?: ModelQueryOptions<ModelResult<Schema, Model, T>[]>,
+        ): ModelQueryResult<ModelResult<Schema, Model, T>[]>;
+
+        useSuspenseFindMany<T extends FindArgs<Schema, Model, true>>(
+            args?: SelectSubset<T, FindArgs<Schema, Model, true>>,
+            options?: ModelSuspenseQueryOptions<ModelResult<Schema, Model, T>[]>,
+        ): ModelSuspenseQueryResult<ModelResult<Schema, Model, T>[]>;
+
+        useInfiniteFindMany<T extends FindArgs<Schema, Model, true>>(
+            args?: SelectSubset<T, FindArgs<Schema, Model, true>>,
+            options?: ModelInfiniteQueryOptions<ModelResult<Schema, Model, T>[]>,
+        ): ModelInfiniteQueryResult<InfiniteData<ModelResult<Schema, Model, T>[]>>;
+
+        useSuspenseInfiniteFindMany<T extends FindArgs<Schema, Model, true>>(
+            args?: SelectSubset<T, FindArgs<Schema, Model, true>>,
+            options?: ModelSuspenseInfiniteQueryOptions<ModelResult<Schema, Model, T>[]>,
+        ): ModelSuspenseInfiniteQueryResult<InfiniteData<ModelResult<Schema, Model, T>[]>>;
+
+        useCreate<T extends CreateArgs<Schema, Model>>(
+            options?: ModelMutationOptions<ModelResult<Schema, Model, T>, T>,
+        ): ModelMutationModelResult<Schema, Model, T>;
+
+        useCreateMany<T extends CreateManyArgs<Schema, Model>>(
+            options?: ModelMutationOptions<BatchResult, T>,
+        ): ModelMutationResult<BatchResult, T>;
+
+        useCreateManyAndReturn<T extends CreateManyAndReturnArgs<Schema, Model>>(
+            options?: ModelMutationOptions<ModelResult<Schema, Model, T>[], T>,
+        ): ModelMutationModelResult<Schema, Model, T, true>;
+
+        useUpdate<T extends UpdateArgs<Schema, Model>>(
+            options?: ModelMutationOptions<ModelResult<Schema, Model, T>, T>,
+        ): ModelMutationModelResult<Schema, Model, T>;
+
+        useUpdateMany<T extends UpdateManyArgs<Schema, Model>>(
+            options?: ModelMutationOptions<BatchResult, T>,
+        ): ModelMutationResult<BatchResult, T>;
+
+        useUpdateManyAndReturn<T extends UpdateManyAndReturnArgs<Schema, Model>>(
+            options?: ModelMutationOptions<ModelResult<Schema, Model, T>[], T>,
+        ): ModelMutationModelResult<Schema, Model, T, true>;
+
+        useUpsert<T extends UpsertArgs<Schema, Model>>(
+            options?: ModelMutationOptions<ModelResult<Schema, Model, T>, T>,
+        ): ModelMutationModelResult<Schema, Model, T>;
+
+        useDelete<T extends DeleteArgs<Schema, Model>>(
+            options?: ModelMutationOptions<ModelResult<Schema, Model, T>, T>,
+        ): ModelMutationModelResult<Schema, Model, T>;
+
+        useDeleteMany<T extends DeleteManyArgs<Schema, Model>>(
+            options?: ModelMutationOptions<BatchResult, T>,
+        ): ModelMutationResult<BatchResult, T>;
+
+        useCount<T extends CountArgs<Schema, Model>>(
+            args?: Subset<T, CountArgs<Schema, Model>>,
+            options?: ModelQueryOptions<CountResult<Schema, Model, T>>,
+        ): ModelQueryResult<CountResult<Schema, Model, T>>;
+
+        useSuspenseCount<T extends CountArgs<Schema, Model>>(
+            args?: Subset<T, CountArgs<Schema, Model>>,
+            options?: ModelSuspenseQueryOptions<CountResult<Schema, Model, T>>,
+        ): ModelSuspenseQueryResult<CountResult<Schema, Model, T>>;
+
+        useAggregate<T extends AggregateArgs<Schema, Model>>(
+            args: Subset<T, AggregateArgs<Schema, Model>>,
+            options?: ModelQueryOptions<AggregateResult<Schema, Model, T>>,
+        ): ModelQueryResult<AggregateResult<Schema, Model, T>>;
+
+        useSuspenseAggregate<T extends AggregateArgs<Schema, Model>>(
+            args: Subset<T, AggregateArgs<Schema, Model>>,
+            options?: ModelSuspenseQueryOptions<AggregateResult<Schema, Model, T>>,
+        ): ModelSuspenseQueryResult<AggregateResult<Schema, Model, T>>;
+
+        useGroupBy<T extends GroupByArgs<Schema, Model>>(
+            args: Subset<T, GroupByArgs<Schema, Model>>,
+            options?: ModelQueryOptions<GroupByResult<Schema, Model, T>>,
+        ): ModelQueryResult<GroupByResult<Schema, Model, T>>;
+
+        useSuspenseGroupBy<T extends GroupByArgs<Schema, Model>>(
+            args: Subset<T, GroupByArgs<Schema, Model>>,
+            options?: ModelSuspenseQueryOptions<GroupByResult<Schema, Model, T>>,
+        ): ModelSuspenseQueryResult<GroupByResult<Schema, Model, T>>;
+    }
+>;
+
 /**
  * Gets data query hooks for all models in the schema.
  */
-export function useClientQueries<Schema extends SchemaDef>(schema: Schema): SchemaHooks<Schema> {
+export function useClientQueries<Schema extends SchemaDef>(schema: Schema): ClientHooks<Schema> {
     return Object.keys(schema.models).reduce((acc, model) => {
         (acc as any)[lowerCaseFirst(model)] = useModelQueries(schema, model as GetModels<Schema>);
         return acc;
-    }, {} as SchemaHooks<Schema>);
+    }, {} as ClientHooks<Schema>);
 }
 
 /**
@@ -289,39 +309,39 @@ export function useModelQueries<Schema extends SchemaDef, Model extends GetModel
         },
 
         useCreate: (options?: any) => {
-            return useInternalMutation(schema, modelName, 'POST', 'create', options, true);
+            return useInternalMutation(schema, modelName, 'POST', 'create', options);
         },
 
         useCreateMany: (options?: any) => {
-            return useInternalMutation(schema, modelName, 'POST', 'createMany', options, false);
+            return useInternalMutation(schema, modelName, 'POST', 'createMany', options);
         },
 
         useCreateManyAndReturn: (options?: any) => {
-            return useInternalMutation(schema, modelName, 'POST', 'createManyAndReturn', options, true);
+            return useInternalMutation(schema, modelName, 'POST', 'createManyAndReturn', options);
         },
 
         useUpdate: (options?: any) => {
-            return useInternalMutation(schema, modelName, 'PUT', 'update', options, true);
+            return useInternalMutation(schema, modelName, 'PUT', 'update', options);
         },
 
         useUpdateMany: (options?: any) => {
-            return useInternalMutation(schema, modelName, 'PUT', 'updateMany', options, false);
+            return useInternalMutation(schema, modelName, 'PUT', 'updateMany', options);
         },
 
         useUpdateManyAndReturn: (options?: any) => {
-            return useInternalMutation(schema, modelName, 'PUT', 'updateManyAndReturn', options, true);
+            return useInternalMutation(schema, modelName, 'PUT', 'updateManyAndReturn', options);
         },
 
         useUpsert: (options?: any) => {
-            return useInternalMutation(schema, modelName, 'POST', 'upsert', options, true);
+            return useInternalMutation(schema, modelName, 'POST', 'upsert', options);
         },
 
         useDelete: (options?: any) => {
-            return useInternalMutation(schema, modelName, 'DELETE', 'delete', options, true);
+            return useInternalMutation(schema, modelName, 'DELETE', 'delete', options);
         },
 
         useDeleteMany: (options?: any) => {
-            return useInternalMutation(schema, modelName, 'DELETE', 'deleteMany', options, false);
+            return useInternalMutation(schema, modelName, 'DELETE', 'deleteMany', options);
         },
 
         useCount: (options?: any) => {
@@ -367,7 +387,7 @@ export function useInternalQuery<TQueryFnData, TData>(
         queryKey,
         ...useQuery({
             queryKey,
-            queryFn: ({ signal }) => fetcher<TQueryFnData, false>(reqUrl, { signal }, fetch, false),
+            queryFn: ({ signal }) => fetcher<TQueryFnData>(reqUrl, { signal }, fetch),
             ...options,
         }),
     };
@@ -390,7 +410,7 @@ export function useInternalSuspenseQuery<TQueryFnData, TData>(
         queryKey,
         ...useSuspenseQuery({
             queryKey,
-            queryFn: ({ signal }) => fetcher<TQueryFnData, false>(reqUrl, { signal }, fetch, false),
+            queryFn: ({ signal }) => fetcher<TQueryFnData>(reqUrl, { signal }, fetch),
             ...options,
         }),
     };
@@ -401,11 +421,14 @@ export function useInternalInfiniteQuery<TQueryFnData, TData>(
     model: string,
     operation: string,
     args: unknown,
-    options: Omit<
-        UseInfiniteQueryOptions<TQueryFnData, DefaultError, InfiniteData<TData>>,
-        'queryKey' | 'initialPageParam'
-    >,
+    options:
+        | Omit<
+              UseInfiniteQueryOptions<TQueryFnData, DefaultError, InfiniteData<TData>>,
+              'queryKey' | 'initialPageParam'
+          >
+        | undefined,
 ) {
+    options = options ?? { getNextPageParam: () => undefined };
     const { endpoint, fetch } = useHooksContext();
     const queryKey = getQueryKey(model, operation, args, { infinite: true, optimisticUpdate: false });
     return {
@@ -413,12 +436,7 @@ export function useInternalInfiniteQuery<TQueryFnData, TData>(
         ...useInfiniteQuery({
             queryKey,
             queryFn: ({ pageParam, signal }) => {
-                return fetcher<TQueryFnData, false>(
-                    makeUrl(endpoint, model, operation, pageParam ?? args),
-                    { signal },
-                    fetch,
-                    false,
-                );
+                return fetcher<TQueryFnData>(makeUrl(endpoint, model, operation, pageParam ?? args), { signal }, fetch);
             },
             initialPageParam: args,
             ...options,
@@ -443,12 +461,7 @@ export function useInternalSuspenseInfiniteQuery<TQueryFnData, TData>(
         ...useSuspenseInfiniteQuery({
             queryKey,
             queryFn: ({ pageParam, signal }) => {
-                return fetcher<TQueryFnData, false>(
-                    makeUrl(endpoint, model, operation, pageParam ?? args),
-                    { signal },
-                    fetch,
-                    false,
-                );
+                return fetcher<TQueryFnData>(makeUrl(endpoint, model, operation, pageParam ?? args), { signal }, fetch);
             },
             initialPageParam: args,
             ...options,
@@ -467,18 +480,12 @@ export function useInternalSuspenseInfiniteQuery<TQueryFnData, TData>(
  * @param options The react-query options.
  * @param checkReadBack Whether to check for read back errors and return undefined if found.
  */
-export function useInternalMutation<
-    TArgs,
-    R = any,
-    C extends boolean = boolean,
-    Result = C extends true ? R | undefined : R,
->(
+export function useInternalMutation<TArgs, R = any>(
     schema: SchemaDef,
     model: string,
     method: 'POST' | 'PUT' | 'DELETE',
     operation: string,
-    options?: Omit<UseMutationOptions<Result, DefaultError, TArgs>, 'mutationFn'> & ExtraMutationOptions,
-    checkReadBack?: C,
+    options?: Omit<UseMutationOptions<R, DefaultError, TArgs>, 'mutationFn'> & ExtraMutationOptions,
 ) {
     const { endpoint, fetch, logging } = useHooksContext();
     const queryClient = useQueryClient();
@@ -494,7 +501,7 @@ export function useInternalMutation<
                 body: marshal(data),
             }),
         };
-        return fetcher<R, C>(reqUrl, fetchInit, fetch, checkReadBack) as Promise<Result>;
+        return fetcher<R>(reqUrl, fetchInit, fetch) as Promise<R>;
     };
 
     const finalOptions = { ...options, mutationFn };
diff --git a/packages/clients/tanstack-query/src/svelte.ts b/packages/clients/tanstack-query/src/svelte.ts
index b2b5961e..29004aee 100644
--- a/packages/clients/tanstack-query/src/svelte.ts
+++ b/packages/clients/tanstack-query/src/svelte.ts
@@ -32,6 +32,7 @@ import type {
     GroupByArgs,
     GroupByResult,
     ModelResult,
+    SelectIncludeOmit,
     SelectSubset,
     Subset,
     UpdateArgs,
@@ -53,6 +54,7 @@ import {
     type ExtraMutationOptions,
     type ExtraQueryOptions,
 } from './utils/common';
+import type { TrimDelegateModelOperations } from './utils/types';
 
 export type { FetchFn } from './utils/common';
 
@@ -107,91 +109,111 @@ export type ModelMutationOptions<T, TArgs> = Omit<CreateMutationOptions<T, Defau
 
 export type ModelMutationResult<T, TArgs> = CreateMutationResult<T, DefaultError, TArgs>;
 
-export type SchemaHooks<Schema extends SchemaDef> = {
+export type ModelMutationModelResult<
+    Schema extends SchemaDef,
+    Model extends GetModels<Schema>,
+    TArgs extends SelectIncludeOmit<Schema, Model, boolean>,
+    Array extends boolean = false,
+> = Readable<
+    Omit<UnwrapStore<ModelMutationResult<ModelResult<Schema, Model, TArgs>, TArgs>>, 'mutateAsync'> & {
+        mutateAsync<T extends TArgs>(
+            args: T,
+            options?: ModelMutationOptions<ModelResult<Schema, Model, T>, T>,
+        ): Promise<Array extends true ? ModelResult<Schema, Model, T>[] : ModelResult<Schema, Model, T>>;
+    }
+>;
+
+export type ClientHooks<Schema extends SchemaDef> = {
     [Model in GetModels<Schema> as `${Uncapitalize<Model>}`]: ModelQueryHooks<Schema, Model>;
 };
 
-export type ModelQueryHooks<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
-    useFindUnique<T extends FindUniqueArgs<Schema, Model>>(
-        args: SelectSubset<T, FindUniqueArgs<Schema, Model>>,
-        options?: ModelQueryOptions<ModelResult<Schema, Model, T> | null>,
-    ): ModelQueryResult<ModelResult<Schema, Model, T> | null>;
-
-    useFindFirst<T extends FindArgs<Schema, Model, false>>(
-        args?: SelectSubset<T, FindArgs<Schema, Model, false>>,
-        options?: ModelQueryOptions<ModelResult<Schema, Model, T> | null>,
-    ): ModelQueryResult<ModelResult<Schema, Model, T> | null>;
-
-    useFindMany<T extends FindArgs<Schema, Model, true>>(
-        args?: SelectSubset<T, FindArgs<Schema, Model, true>>,
-        options?: ModelQueryOptions<ModelResult<Schema, Model, T>[]>,
-    ): ModelQueryResult<ModelResult<Schema, Model, T>[]>;
-
-    useInfiniteFindMany<T extends FindArgs<Schema, Model, true>>(
-        args?: SelectSubset<T, FindArgs<Schema, Model, true>>,
-        options?: ModelInfiniteQueryOptions<ModelResult<Schema, Model, T>[]>,
-    ): ModelInfiniteQueryResult<InfiniteData<ModelResult<Schema, Model, T>[]>>;
-
-    useCreate<T extends CreateArgs<Schema, Model>>(
-        options?: ModelMutationOptions<ModelResult<Schema, Model, T>, T>,
-    ): ModelMutationResult<ModelResult<Schema, Model, T>, T>;
-
-    useCreateMany<T extends CreateManyArgs<Schema, Model>>(
-        options?: ModelMutationOptions<BatchResult, T>,
-    ): ModelMutationResult<BatchResult, T>;
-
-    useCreateManyAndReturn<T extends CreateManyAndReturnArgs<Schema, Model>>(
-        options?: ModelMutationOptions<ModelResult<Schema, Model, T>[], T>,
-    ): ModelMutationResult<ModelResult<Schema, Model, T>[], T>;
-
-    useUpdate<T extends UpdateArgs<Schema, Model>>(
-        options?: ModelMutationOptions<ModelResult<Schema, Model, T>, T>,
-    ): ModelMutationResult<ModelResult<Schema, Model, T>, T>;
-
-    useUpdateMany<T extends UpdateManyArgs<Schema, Model>>(
-        options?: ModelMutationOptions<BatchResult, T>,
-    ): ModelMutationResult<BatchResult, T>;
-
-    useUpdateManyAndReturn<T extends UpdateManyAndReturnArgs<Schema, Model>>(
-        options?: ModelMutationOptions<ModelResult<Schema, Model, T>[], T>,
-    ): ModelMutationResult<ModelResult<Schema, Model, T>[], T>;
-
-    useUpsert<T extends UpsertArgs<Schema, Model>>(
-        options?: ModelMutationOptions<ModelResult<Schema, Model, T>, T>,
-    ): ModelMutationResult<ModelResult<Schema, Model, T>, T>;
-
-    useDelete<T extends DeleteArgs<Schema, Model>>(
-        options?: ModelMutationOptions<ModelResult<Schema, Model, T>, T>,
-    ): ModelMutationResult<ModelResult<Schema, Model, T>, T>;
-
-    useDeleteMany<T extends DeleteManyArgs<Schema, Model>>(
-        options?: ModelMutationOptions<BatchResult, T>,
-    ): ModelMutationResult<BatchResult, T>;
-
-    useCount<T extends CountArgs<Schema, Model>>(
-        args?: Subset<T, CountArgs<Schema, Model>>,
-        options?: ModelQueryOptions<CountResult<Schema, Model, T>>,
-    ): ModelQueryResult<CountResult<Schema, Model, T>>;
-
-    useAggregate<T extends AggregateArgs<Schema, Model>>(
-        args: Subset<T, AggregateArgs<Schema, Model>>,
-        options?: ModelQueryOptions<AggregateResult<Schema, Model, T>>,
-    ): ModelQueryResult<AggregateResult<Schema, Model, T>>;
-
-    useGroupBy<T extends GroupByArgs<Schema, Model>>(
-        args: Subset<T, GroupByArgs<Schema, Model>>,
-        options?: ModelQueryOptions<GroupByResult<Schema, Model, T>>,
-    ): ModelQueryResult<GroupByResult<Schema, Model, T>>;
-};
+// Note that we can potentially use TypeScript's mapped type to directly map from ORM contract, but that seems
+// to significantly slow down tsc performance ...
+export type ModelQueryHooks<Schema extends SchemaDef, Model extends GetModels<Schema>> = TrimDelegateModelOperations<
+    Schema,
+    Model,
+    {
+        useFindUnique<T extends FindUniqueArgs<Schema, Model>>(
+            args: SelectSubset<T, FindUniqueArgs<Schema, Model>>,
+            options?: ModelQueryOptions<ModelResult<Schema, Model, T> | null>,
+        ): ModelQueryResult<ModelResult<Schema, Model, T> | null>;
+
+        useFindFirst<T extends FindArgs<Schema, Model, false>>(
+            args?: SelectSubset<T, FindArgs<Schema, Model, false>>,
+            options?: ModelQueryOptions<ModelResult<Schema, Model, T> | null>,
+        ): ModelQueryResult<ModelResult<Schema, Model, T> | null>;
+
+        useFindMany<T extends FindArgs<Schema, Model, true>>(
+            args?: SelectSubset<T, FindArgs<Schema, Model, true>>,
+            options?: ModelQueryOptions<ModelResult<Schema, Model, T>[]>,
+        ): ModelQueryResult<ModelResult<Schema, Model, T>[]>;
+
+        useInfiniteFindMany<T extends FindArgs<Schema, Model, true>>(
+            args?: SelectSubset<T, FindArgs<Schema, Model, true>>,
+            options?: ModelInfiniteQueryOptions<ModelResult<Schema, Model, T>[]>,
+        ): ModelInfiniteQueryResult<InfiniteData<ModelResult<Schema, Model, T>[]>>;
+
+        useCreate<T extends CreateArgs<Schema, Model>>(
+            options?: ModelMutationOptions<ModelResult<Schema, Model, T>, T>,
+        ): ModelMutationModelResult<Schema, Model, T>;
+
+        useCreateMany<T extends CreateManyArgs<Schema, Model>>(
+            options?: ModelMutationOptions<BatchResult, T>,
+        ): ModelMutationResult<BatchResult, T>;
+
+        useCreateManyAndReturn<T extends CreateManyAndReturnArgs<Schema, Model>>(
+            options?: ModelMutationOptions<ModelResult<Schema, Model, T>[], T>,
+        ): ModelMutationModelResult<Schema, Model, T, true>;
+
+        useUpdate<T extends UpdateArgs<Schema, Model>>(
+            options?: ModelMutationOptions<ModelResult<Schema, Model, T>, T>,
+        ): ModelMutationModelResult<Schema, Model, T>;
+
+        useUpdateMany<T extends UpdateManyArgs<Schema, Model>>(
+            options?: ModelMutationOptions<BatchResult, T>,
+        ): ModelMutationResult<BatchResult, T>;
+
+        useUpdateManyAndReturn<T extends UpdateManyAndReturnArgs<Schema, Model>>(
+            options?: ModelMutationOptions<ModelResult<Schema, Model, T>[], T>,
+        ): ModelMutationModelResult<Schema, Model, T, true>;
+
+        useUpsert<T extends UpsertArgs<Schema, Model>>(
+            options?: ModelMutationOptions<ModelResult<Schema, Model, T>, T>,
+        ): ModelMutationModelResult<Schema, Model, T>;
+
+        useDelete<T extends DeleteArgs<Schema, Model>>(
+            options?: ModelMutationOptions<ModelResult<Schema, Model, T>, T>,
+        ): ModelMutationModelResult<Schema, Model, T>;
+
+        useDeleteMany<T extends DeleteManyArgs<Schema, Model>>(
+            options?: ModelMutationOptions<BatchResult, T>,
+        ): ModelMutationResult<BatchResult, T>;
+
+        useCount<T extends CountArgs<Schema, Model>>(
+            args?: Subset<T, CountArgs<Schema, Model>>,
+            options?: ModelQueryOptions<CountResult<Schema, Model, T>>,
+        ): ModelQueryResult<CountResult<Schema, Model, T>>;
+
+        useAggregate<T extends AggregateArgs<Schema, Model>>(
+            args: Subset<T, AggregateArgs<Schema, Model>>,
+            options?: ModelQueryOptions<AggregateResult<Schema, Model, T>>,
+        ): ModelQueryResult<AggregateResult<Schema, Model, T>>;
+
+        useGroupBy<T extends GroupByArgs<Schema, Model>>(
+            args: Subset<T, GroupByArgs<Schema, Model>>,
+            options?: ModelQueryOptions<GroupByResult<Schema, Model, T>>,
+        ): ModelQueryResult<GroupByResult<Schema, Model, T>>;
+    }
+>;
 
 /**
  * Gets data query hooks for all models in the schema.
  */
-export function useClientQueries<Schema extends SchemaDef>(schema: Schema): SchemaHooks<Schema> {
+export function useClientQueries<Schema extends SchemaDef>(schema: Schema): ClientHooks<Schema> {
     return Object.keys(schema.models).reduce((acc, model) => {
         (acc as any)[lowerCaseFirst(model)] = useModelQueries(schema, model as GetModels<Schema>);
         return acc;
-    }, {} as SchemaHooks<Schema>);
+    }, {} as ClientHooks<Schema>);
 }
 
 /**
@@ -226,39 +248,39 @@ export function useModelQueries<Schema extends SchemaDef, Model extends GetModel
         },
 
         useCreate: (options?: any) => {
-            return useInternalMutation(schema, modelName, 'POST', 'create', options, true);
+            return useInternalMutation(schema, modelName, 'POST', 'create', options);
         },
 
         useCreateMany: (options?: any) => {
-            return useInternalMutation(schema, modelName, 'POST', 'createMany', options, false);
+            return useInternalMutation(schema, modelName, 'POST', 'createMany', options);
         },
 
         useCreateManyAndReturn: (options?: any) => {
-            return useInternalMutation(schema, modelName, 'POST', 'createManyAndReturn', options, true);
+            return useInternalMutation(schema, modelName, 'POST', 'createManyAndReturn', options);
         },
 
         useUpdate: (options?: any) => {
-            return useInternalMutation(schema, modelName, 'PUT', 'update', options, true);
+            return useInternalMutation(schema, modelName, 'PUT', 'update', options);
         },
 
         useUpdateMany: (options?: any) => {
-            return useInternalMutation(schema, modelName, 'PUT', 'updateMany', options, false);
+            return useInternalMutation(schema, modelName, 'PUT', 'updateMany', options);
         },
 
         useUpdateManyAndReturn: (options?: any) => {
-            return useInternalMutation(schema, modelName, 'PUT', 'updateManyAndReturn', options, true);
+            return useInternalMutation(schema, modelName, 'PUT', 'updateManyAndReturn', options);
         },
 
         useUpsert: (options?: any) => {
-            return useInternalMutation(schema, modelName, 'POST', 'upsert', options, true);
+            return useInternalMutation(schema, modelName, 'POST', 'upsert', options);
         },
 
         useDelete: (options?: any) => {
-            return useInternalMutation(schema, modelName, 'DELETE', 'delete', options, true);
+            return useInternalMutation(schema, modelName, 'DELETE', 'delete', options);
         },
 
         useDeleteMany: (options?: any) => {
-            return useInternalMutation(schema, modelName, 'DELETE', 'deleteMany', options, false);
+            return useInternalMutation(schema, modelName, 'DELETE', 'deleteMany', options);
         },
 
         useCount: (options?: any) => {
@@ -291,7 +313,7 @@ export function useInternalQuery<TQueryFnData, TData>(
         optimisticUpdate: optionsValue?.optimisticUpdate !== false,
     });
     const queryFn: QueryFunction<TQueryFnData, QueryKey, unknown> = ({ signal }) =>
-        fetcher<TQueryFnData, false>(reqUrl, { signal }, fetch, false);
+        fetcher<TQueryFnData>(reqUrl, { signal }, fetch);
 
     let mergedOpt: any;
     if (isStore(options)) {
@@ -324,23 +346,21 @@ export function useInternalInfiniteQuery<TQueryFnData, TData>(
     model: string,
     operation: string,
     args: StoreOrVal<unknown>,
-    options: StoreOrVal<
-        Omit<
-            CreateInfiniteQueryOptions<TQueryFnData, DefaultError, InfiniteData<TData>>,
-            'queryKey' | 'initialPageParam'
-        >
-    >,
+    options:
+        | StoreOrVal<
+              Omit<
+                  CreateInfiniteQueryOptions<TQueryFnData, DefaultError, InfiniteData<TData>>,
+                  'queryKey' | 'initialPageParam'
+              >
+          >
+        | undefined,
 ) {
+    options = options ?? { getNextPageParam: () => undefined };
     const { endpoint, fetch } = getQuerySettings();
     const argsValue = unwrapStore(args);
     const queryKey = getQueryKey(model, operation, argsValue, { infinite: true, optimisticUpdate: false });
     const queryFn: QueryFunction<TQueryFnData, QueryKey, unknown> = ({ pageParam, signal }) =>
-        fetcher<TQueryFnData, false>(
-            makeUrl(endpoint, model, operation, pageParam ?? argsValue),
-            { signal },
-            fetch,
-            false,
-        );
+        fetcher<TQueryFnData>(makeUrl(endpoint, model, operation, pageParam ?? argsValue), { signal }, fetch);
 
     let mergedOpt: StoreOrVal<CreateInfiniteQueryOptions<TQueryFnData, DefaultError, InfiniteData<TData>>>;
     if (isStore(options)) {
@@ -381,18 +401,12 @@ export function useInternalInfiniteQuery<TQueryFnData, TData>(
  * @param options The svelte-query options.
  * @param checkReadBack Whether to check for read back errors and return undefined if found.
  */
-export function useInternalMutation<
-    TArgs,
-    R = any,
-    C extends boolean = boolean,
-    Result = C extends true ? R | undefined : R,
->(
+export function useInternalMutation<TArgs, R = any>(
     schema: SchemaDef,
     model: string,
     method: 'POST' | 'PUT' | 'DELETE',
     operation: string,
-    options?: StoreOrVal<Omit<CreateMutationOptions<Result, DefaultError, TArgs>, 'mutationFn'> & ExtraMutationOptions>,
-    checkReadBack?: C,
+    options?: StoreOrVal<Omit<CreateMutationOptions<R, DefaultError, TArgs>, 'mutationFn'> & ExtraMutationOptions>,
 ) {
     const { endpoint, fetch, logging } = getQuerySettings();
     const queryClient = useQueryClient();
@@ -409,10 +423,10 @@ export function useInternalMutation<
                 body: marshal(data),
             }),
         };
-        return fetcher<R, C>(reqUrl, fetchInit, fetch, checkReadBack) as Promise<Result>;
+        return fetcher<R>(reqUrl, fetchInit, fetch) as Promise<R>;
     };
 
-    let mergedOpt: StoreOrVal<CreateMutationOptions<Result, DefaultError, TArgs>>;
+    let mergedOpt: StoreOrVal<CreateMutationOptions<R, DefaultError, TArgs>>;
 
     if (isStore(options)) {
         mergedOpt = derived([options], ([$opt]) => ({
diff --git a/packages/clients/tanstack-query/src/utils/common.ts b/packages/clients/tanstack-query/src/utils/common.ts
index 87fc8fe6..28710d25 100644
--- a/packages/clients/tanstack-query/src/utils/common.ts
+++ b/packages/clients/tanstack-query/src/utils/common.ts
@@ -125,21 +125,12 @@ export type APIContext = {
     logging?: boolean;
 };
 
-export async function fetcher<R, C extends boolean>(
-    url: string,
-    options?: RequestInit,
-    customFetch?: FetchFn,
-    checkReadBack?: C,
-): Promise<C extends true ? R | undefined : R> {
+export async function fetcher<R>(url: string, options?: RequestInit, customFetch?: FetchFn): Promise<R> {
     const _fetch = customFetch ?? fetch;
     const res = await _fetch(url, options);
     if (!res.ok) {
         const errData = unmarshal(await res.text());
-        if (
-            checkReadBack !== false &&
-            errData.error?.rejectedByPolicy &&
-            errData.error?.rejectReason === 'cannot-read-back'
-        ) {
+        if (errData.error?.rejectedByPolicy && errData.error?.rejectReason === 'cannot-read-back') {
             // policy doesn't allow mutation result to be read back, just return undefined
             return undefined as any;
         }
diff --git a/packages/clients/tanstack-query/src/utils/types.ts b/packages/clients/tanstack-query/src/utils/types.ts
index 1ebd2d25..3c7fdc1d 100644
--- a/packages/clients/tanstack-query/src/utils/types.ts
+++ b/packages/clients/tanstack-query/src/utils/types.ts
@@ -1,3 +1,6 @@
+import type { OperationsIneligibleForDelegateModels } from '@zenstackhq/orm';
+import type { GetModels, IsDelegateModel, SchemaDef } from '@zenstackhq/schema';
+
 export type MaybePromise<T> = T | Promise<T> | PromiseLike<T>;
 
 export const ORMWriteActions = [
@@ -17,3 +20,9 @@ export const ORMWriteActions = [
 ] as const;
 
 export type ORMWriteActionType = (typeof ORMWriteActions)[number];
+
+export type TrimDelegateModelOperations<
+    Schema extends SchemaDef,
+    Model extends GetModels<Schema>,
+    T extends Record<string, unknown>,
+> = IsDelegateModel<Schema, Model> extends true ? Omit<T, OperationsIneligibleForDelegateModels> : T;
diff --git a/packages/clients/tanstack-query/src/vue.ts b/packages/clients/tanstack-query/src/vue.ts
index 990f1bc4..77d3ab34 100644
--- a/packages/clients/tanstack-query/src/vue.ts
+++ b/packages/clients/tanstack-query/src/vue.ts
@@ -30,6 +30,7 @@ import type {
     GroupByArgs,
     GroupByResult,
     ModelResult,
+    SelectIncludeOmit,
     SelectSubset,
     Subset,
     UpdateArgs,
@@ -51,6 +52,7 @@ import {
     type ExtraMutationOptions,
     type ExtraQueryOptions,
 } from './utils/common';
+import type { TrimDelegateModelOperations } from './utils/types';
 
 export type { FetchFn } from './utils/common';
 export const VueQueryContextKey = 'zenstack-vue-query-context';
@@ -80,107 +82,127 @@ function getQuerySettings() {
     return { endpoint: endpoint ?? DEFAULT_QUERY_ENDPOINT, ...rest };
 }
 
-export type ModelQueryOptions<T> = Omit<UseQueryOptions<T, DefaultError>, 'queryKey'> & ExtraQueryOptions;
+export type ModelQueryOptions<T> = MaybeRefOrGetter<
+    Omit<UnwrapRef<UseQueryOptions<T, DefaultError>>, 'queryKey'> & ExtraQueryOptions
+>;
 
 export type ModelQueryResult<T> = UseQueryReturnType<T, DefaultError> & { queryKey: QueryKey };
 
-export type ModelInfiniteQueryOptions<T> = Omit<
-    UseInfiniteQueryOptions<T, DefaultError, InfiniteData<T>>,
-    'queryKey' | 'initialPageParam'
+export type ModelInfiniteQueryOptions<T> = MaybeRefOrGetter<
+    Omit<UnwrapRef<UseInfiniteQueryOptions<T, DefaultError, InfiniteData<T>>>, 'queryKey' | 'initialPageParam'>
 >;
 
 export type ModelInfiniteQueryResult<T> = UseInfiniteQueryReturnType<T, DefaultError> & { queryKey: QueryKey };
 
-export type ModelMutationOptions<T, TArgs> = Omit<UseMutationOptions<T, DefaultError, TArgs>, 'mutationFn'> &
-    ExtraMutationOptions;
+export type ModelMutationOptions<T, TArgs> = MaybeRefOrGetter<
+    Omit<UnwrapRef<UseMutationOptions<T, DefaultError, TArgs>>, 'mutationFn'> & ExtraMutationOptions
+>;
 
 export type ModelMutationResult<T, TArgs> = UseMutationReturnType<T, DefaultError, TArgs, unknown>;
 
-export type SchemaHooks<Schema extends SchemaDef> = {
-    [Model in GetModels<Schema> as `${Uncapitalize<Model>}`]: ModelQueryHooks<Schema, Model>;
-};
-
-export type ModelQueryHooks<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
-    useFindUnique<T extends FindUniqueArgs<Schema, Model>>(
-        args: SelectSubset<T, FindUniqueArgs<Schema, Model>>,
-        options?: ModelQueryOptions<ModelResult<Schema, Model, T> | null>,
-    ): ModelQueryResult<ModelResult<Schema, Model, T> | null>;
-
-    useFindFirst<T extends FindArgs<Schema, Model, false>>(
-        args?: SelectSubset<T, FindArgs<Schema, Model, false>>,
-        options?: ModelQueryOptions<ModelResult<Schema, Model, T> | null>,
-    ): ModelQueryResult<ModelResult<Schema, Model, T> | null>;
-
-    useFindMany<T extends FindArgs<Schema, Model, true>>(
-        args?: SelectSubset<T, FindArgs<Schema, Model, true>>,
-        options?: ModelQueryOptions<ModelResult<Schema, Model, T>[]>,
-    ): ModelQueryResult<ModelResult<Schema, Model, T>[]>;
-
-    useInfiniteFindMany<T extends FindArgs<Schema, Model, true>>(
-        args?: SelectSubset<T, FindArgs<Schema, Model, true>>,
-        options?: ModelInfiniteQueryOptions<ModelResult<Schema, Model, T>[]>,
-    ): ModelInfiniteQueryResult<InfiniteData<ModelResult<Schema, Model, T>[]>>;
-
-    useCreate<T extends CreateArgs<Schema, Model>>(
-        options?: ModelMutationOptions<ModelResult<Schema, Model, T>, T>,
-    ): ModelMutationResult<ModelResult<Schema, Model, T>, T>;
-
-    useCreateMany<T extends CreateManyArgs<Schema, Model>>(
-        options?: ModelMutationOptions<BatchResult, T>,
-    ): ModelMutationResult<BatchResult, T>;
-
-    useCreateManyAndReturn<T extends CreateManyAndReturnArgs<Schema, Model>>(
-        options?: ModelMutationOptions<ModelResult<Schema, Model, T>[], T>,
-    ): ModelMutationResult<ModelResult<Schema, Model, T>[], T>;
-
-    useUpdate<T extends UpdateArgs<Schema, Model>>(
-        options?: ModelMutationOptions<ModelResult<Schema, Model, T>, T>,
-    ): ModelMutationResult<ModelResult<Schema, Model, T>, T>;
-
-    useUpdateMany<T extends UpdateManyArgs<Schema, Model>>(
-        options?: ModelMutationOptions<BatchResult, T>,
-    ): ModelMutationResult<BatchResult, T>;
-
-    useUpdateManyAndReturn<T extends UpdateManyAndReturnArgs<Schema, Model>>(
-        options?: ModelMutationOptions<ModelResult<Schema, Model, T>[], T>,
-    ): ModelMutationResult<ModelResult<Schema, Model, T>[], T>;
-
-    useUpsert<T extends UpsertArgs<Schema, Model>>(
+export type ModelMutationModelResult<
+    Schema extends SchemaDef,
+    Model extends GetModels<Schema>,
+    TArgs extends SelectIncludeOmit<Schema, Model, boolean>,
+    Array extends boolean = false,
+> = Omit<ModelMutationResult<ModelResult<Schema, Model, TArgs>, TArgs>, 'mutateAsync'> & {
+    mutateAsync<T extends TArgs>(
+        args: T,
         options?: ModelMutationOptions<ModelResult<Schema, Model, T>, T>,
-    ): ModelMutationResult<ModelResult<Schema, Model, T>, T>;
+    ): Promise<Array extends true ? ModelResult<Schema, Model, T>[] : ModelResult<Schema, Model, T>>;
+};
 
-    useDelete<T extends DeleteArgs<Schema, Model>>(
-        options?: ModelMutationOptions<ModelResult<Schema, Model, T>, T>,
-    ): ModelMutationResult<ModelResult<Schema, Model, T>, T>;
-
-    useDeleteMany<T extends DeleteManyArgs<Schema, Model>>(
-        options?: ModelMutationOptions<BatchResult, T>,
-    ): ModelMutationResult<BatchResult, T>;
-
-    useCount<T extends CountArgs<Schema, Model>>(
-        args?: Subset<T, CountArgs<Schema, Model>>,
-        options?: ModelQueryOptions<CountResult<Schema, Model, T>>,
-    ): ModelQueryResult<CountResult<Schema, Model, T>>;
-
-    useAggregate<T extends AggregateArgs<Schema, Model>>(
-        args: Subset<T, AggregateArgs<Schema, Model>>,
-        options?: ModelQueryOptions<AggregateResult<Schema, Model, T>>,
-    ): ModelQueryResult<AggregateResult<Schema, Model, T>>;
-
-    useGroupBy<T extends GroupByArgs<Schema, Model>>(
-        args: Subset<T, GroupByArgs<Schema, Model>>,
-        options?: ModelQueryOptions<GroupByResult<Schema, Model, T>>,
-    ): ModelQueryResult<GroupByResult<Schema, Model, T>>;
+export type ClientHooks<Schema extends SchemaDef> = {
+    [Model in GetModels<Schema> as `${Uncapitalize<Model>}`]: ModelQueryHooks<Schema, Model>;
 };
 
+// Note that we can potentially use TypeScript's mapped type to directly map from ORM contract, but that seems
+// to significantly slow down tsc performance ...
+export type ModelQueryHooks<Schema extends SchemaDef, Model extends GetModels<Schema>> = TrimDelegateModelOperations<
+    Schema,
+    Model,
+    {
+        useFindUnique<T extends FindUniqueArgs<Schema, Model>>(
+            args: SelectSubset<T, FindUniqueArgs<Schema, Model>>,
+            options?: ModelQueryOptions<ModelResult<Schema, Model, T> | null>,
+        ): ModelQueryResult<ModelResult<Schema, Model, T> | null>;
+
+        useFindFirst<T extends FindArgs<Schema, Model, false>>(
+            args?: SelectSubset<T, FindArgs<Schema, Model, false>>,
+            options?: ModelQueryOptions<ModelResult<Schema, Model, T> | null>,
+        ): ModelQueryResult<ModelResult<Schema, Model, T> | null>;
+
+        useFindMany<T extends FindArgs<Schema, Model, true>>(
+            args?: SelectSubset<T, FindArgs<Schema, Model, true>>,
+            options?: ModelQueryOptions<ModelResult<Schema, Model, T>[]>,
+        ): ModelQueryResult<ModelResult<Schema, Model, T>[]>;
+
+        useInfiniteFindMany<T extends FindArgs<Schema, Model, true>>(
+            args?: SelectSubset<T, FindArgs<Schema, Model, true>>,
+            options?: ModelInfiniteQueryOptions<ModelResult<Schema, Model, T>[]>,
+        ): ModelInfiniteQueryResult<InfiniteData<ModelResult<Schema, Model, T>[]>>;
+
+        useCreate<T extends CreateArgs<Schema, Model>>(
+            options?: ModelMutationOptions<ModelResult<Schema, Model, T>, T>,
+        ): ModelMutationModelResult<Schema, Model, T>;
+
+        useCreateMany<T extends CreateManyArgs<Schema, Model>>(
+            options?: ModelMutationOptions<BatchResult, T>,
+        ): ModelMutationResult<BatchResult, T>;
+
+        useCreateManyAndReturn<T extends CreateManyAndReturnArgs<Schema, Model>>(
+            options?: ModelMutationOptions<ModelResult<Schema, Model, T>[], T>,
+        ): ModelMutationModelResult<Schema, Model, T, true>;
+
+        useUpdate<T extends UpdateArgs<Schema, Model>>(
+            options?: ModelMutationOptions<ModelResult<Schema, Model, T>, T>,
+        ): ModelMutationModelResult<Schema, Model, T>;
+
+        useUpdateMany<T extends UpdateManyArgs<Schema, Model>>(
+            options?: ModelMutationOptions<BatchResult, T>,
+        ): ModelMutationResult<BatchResult, T>;
+
+        useUpdateManyAndReturn<T extends UpdateManyAndReturnArgs<Schema, Model>>(
+            options?: ModelMutationOptions<ModelResult<Schema, Model, T>[], T>,
+        ): ModelMutationModelResult<Schema, Model, T, true>;
+
+        useUpsert<T extends UpsertArgs<Schema, Model>>(
+            options?: ModelMutationOptions<ModelResult<Schema, Model, T>, T>,
+        ): ModelMutationModelResult<Schema, Model, T>;
+
+        useDelete<T extends DeleteArgs<Schema, Model>>(
+            options?: ModelMutationOptions<ModelResult<Schema, Model, T>, T>,
+        ): ModelMutationModelResult<Schema, Model, T>;
+
+        useDeleteMany<T extends DeleteManyArgs<Schema, Model>>(
+            options?: ModelMutationOptions<BatchResult, T>,
+        ): ModelMutationResult<BatchResult, T>;
+
+        useCount<T extends CountArgs<Schema, Model>>(
+            args?: Subset<T, CountArgs<Schema, Model>>,
+            options?: ModelQueryOptions<CountResult<Schema, Model, T>>,
+        ): ModelQueryResult<CountResult<Schema, Model, T>>;
+
+        useAggregate<T extends AggregateArgs<Schema, Model>>(
+            args: Subset<T, AggregateArgs<Schema, Model>>,
+            options?: ModelQueryOptions<AggregateResult<Schema, Model, T>>,
+        ): ModelQueryResult<AggregateResult<Schema, Model, T>>;
+
+        useGroupBy<T extends GroupByArgs<Schema, Model>>(
+            args: Subset<T, GroupByArgs<Schema, Model>>,
+            options?: ModelQueryOptions<GroupByResult<Schema, Model, T>>,
+        ): ModelQueryResult<GroupByResult<Schema, Model, T>>;
+    }
+>;
+
 /**
  * Gets data query hooks for all models in the schema.
  */
-export function useClientQueries<Schema extends SchemaDef>(schema: Schema): SchemaHooks<Schema> {
+export function useClientQueries<Schema extends SchemaDef>(schema: Schema): ClientHooks<Schema> {
     return Object.keys(schema.models).reduce((acc, model) => {
         (acc as any)[lowerCaseFirst(model)] = useModelQueries(schema, model as GetModels<Schema>);
         return acc;
-    }, {} as SchemaHooks<Schema>);
+    }, {} as ClientHooks<Schema>);
 }
 
 /**
@@ -215,39 +237,39 @@ export function useModelQueries<Schema extends SchemaDef, Model extends GetModel
         },
 
         useCreate: (options?: any) => {
-            return useInternalMutation(schema, modelName, 'POST', 'create', options, true);
+            return useInternalMutation(schema, modelName, 'POST', 'create', options);
         },
 
         useCreateMany: (options?: any) => {
-            return useInternalMutation(schema, modelName, 'POST', 'createMany', options, false);
+            return useInternalMutation(schema, modelName, 'POST', 'createMany', options);
         },
 
         useCreateManyAndReturn: (options?: any) => {
-            return useInternalMutation(schema, modelName, 'POST', 'createManyAndReturn', options, true);
+            return useInternalMutation(schema, modelName, 'POST', 'createManyAndReturn', options);
         },
 
         useUpdate: (options?: any) => {
-            return useInternalMutation(schema, modelName, 'PUT', 'update', options, true);
+            return useInternalMutation(schema, modelName, 'PUT', 'update', options);
         },
 
         useUpdateMany: (options?: any) => {
-            return useInternalMutation(schema, modelName, 'PUT', 'updateMany', options, false);
+            return useInternalMutation(schema, modelName, 'PUT', 'updateMany', options);
         },
 
         useUpdateManyAndReturn: (options?: any) => {
-            return useInternalMutation(schema, modelName, 'PUT', 'updateManyAndReturn', options, true);
+            return useInternalMutation(schema, modelName, 'PUT', 'updateManyAndReturn', options);
         },
 
         useUpsert: (options?: any) => {
-            return useInternalMutation(schema, modelName, 'POST', 'upsert', options, true);
+            return useInternalMutation(schema, modelName, 'POST', 'upsert', options);
         },
 
         useDelete: (options?: any) => {
-            return useInternalMutation(schema, modelName, 'DELETE', 'delete', options, true);
+            return useInternalMutation(schema, modelName, 'DELETE', 'delete', options);
         },
 
         useDeleteMany: (options?: any) => {
-            return useInternalMutation(schema, modelName, 'DELETE', 'deleteMany', options, false);
+            return useInternalMutation(schema, modelName, 'DELETE', 'deleteMany', options);
         },
 
         useCount: (options?: any) => {
@@ -286,7 +308,7 @@ export function useInternalQuery<TQueryFnData, TData>(
         queryFn: ({ queryKey, signal }: any) => {
             const [_prefix, _model, _op, args] = queryKey;
             const reqUrl = makeUrl(endpoint, model, operation, args);
-            return fetcher<TQueryFnData, false>(reqUrl, { signal }, fetch, false);
+            return fetcher<TQueryFnData>(reqUrl, { signal }, fetch);
         },
         ...restOptions,
     };
@@ -298,13 +320,16 @@ export function useInternalInfiniteQuery<TQueryFnData, TData>(
     model: string,
     operation: string,
     args: MaybeRefOrGetter<unknown>,
-    options: MaybeRefOrGetter<
-        Omit<
-            UnwrapRef<UseInfiniteQueryOptions<TQueryFnData, DefaultError, InfiniteData<TData>>>,
-            'queryKey' | 'initialPageParam'
-        >
-    >,
+    options:
+        | MaybeRefOrGetter<
+              Omit<
+                  UnwrapRef<UseInfiniteQueryOptions<TQueryFnData, DefaultError, InfiniteData<TData>>>,
+                  'queryKey' | 'initialPageParam'
+              >
+          >
+        | undefined,
 ) {
+    options = options ?? { getNextPageParam: () => undefined };
     const { endpoint, fetch } = getQuerySettings();
     const argsValue = toValue(args);
     const optionsValue = toValue(options);
@@ -315,7 +340,7 @@ export function useInternalInfiniteQuery<TQueryFnData, TData>(
         queryFn: ({ queryKey, signal }: any) => {
             const [_prefix, _model, _op, args] = queryKey;
             const reqUrl = makeUrl(endpoint, model, operation, args);
-            return fetcher<TQueryFnData, false>(reqUrl, { signal }, fetch, false);
+            return fetcher<TQueryFnData>(reqUrl, { signal }, fetch);
         },
         initialPageParam: argsValue,
         ...optionsValue,
@@ -337,20 +362,14 @@ export function useInternalInfiniteQuery<TQueryFnData, TData>(
  * @param options The vue-query options.
  * @param checkReadBack Whether to check for read back errors and return undefined if found.
  */
-export function useInternalMutation<
-    TArgs,
-    R = any,
-    C extends boolean = boolean,
-    Result = C extends true ? R | undefined : R,
->(
+export function useInternalMutation<TArgs, R = any>(
     schema: SchemaDef,
     model: string,
     method: 'POST' | 'PUT' | 'DELETE',
     operation: string,
     options?: MaybeRefOrGetter<
-        Omit<UnwrapRef<UseMutationOptions<Result, DefaultError, TArgs>>, 'mutationFn'> & ExtraMutationOptions
+        Omit<UnwrapRef<UseMutationOptions<R, DefaultError, TArgs>>, 'mutationFn'> & ExtraMutationOptions
     >,
-    checkReadBack?: C,
 ) {
     const { endpoint, fetch, logging } = getQuerySettings();
     const queryClient = useQueryClient();
@@ -366,7 +385,7 @@ export function useInternalMutation<
                 body: marshal(data),
             }),
         };
-        return fetcher<R, C>(reqUrl, fetchInit, fetch, checkReadBack) as Promise<Result>;
+        return fetcher<R>(reqUrl, fetchInit, fetch) as Promise<R>;
     };
 
     const optionsValue = toValue(options);
diff --git a/packages/clients/tanstack-query/test/react-typing-test.ts b/packages/clients/tanstack-query/test/react-typing-test.ts
new file mode 100644
index 00000000..b5814dbd
--- /dev/null
+++ b/packages/clients/tanstack-query/test/react-typing-test.ts
@@ -0,0 +1,103 @@
+import { useClientQueries } from '../src/react';
+import { schema } from './schemas/basic/schema-lite';
+
+const client = useClientQueries(schema);
+
+// @ts-expect-error missing args
+client.user.useFindUnique();
+
+check(client.user.useFindUnique({ where: { id: '1' } }).data?.email);
+check(client.user.useFindUnique({ where: { id: '1' } }).queryKey);
+check(client.user.useFindUnique({ where: { id: '1' } }, { optimisticUpdate: true, enabled: false }));
+
+// @ts-expect-error unselected field
+check(client.user.useFindUnique({ select: { email: true } }).data.name);
+
+check(client.user.useFindUnique({ where: { id: '1' }, include: { posts: true } }).data?.posts[0]?.title);
+
+check(client.user.useFindFirst().data?.email);
+
+check(client.user.useFindMany().data?.[0]?.email);
+
+check(client.user.useInfiniteFindMany().data?.pages[0]?.[0]?.email);
+check(
+    client.user.useInfiniteFindMany(
+        {},
+        {
+            getNextPageParam: () => ({ id: '2' }),
+        },
+    ).data?.pages[1]?.[0]?.email,
+);
+
+check(client.user.useSuspenseFindMany().data[0]?.email);
+check(client.user.useSuspenseInfiniteFindMany().data.pages[0]?.[0]?.email);
+check(client.user.useCount().data?.toFixed(2));
+check(client.user.useCount({ select: { email: true } }).data?.email.toFixed(2));
+
+check(client.user.useAggregate({ _max: { email: true } }).data?._max.email);
+
+check(client.user.useGroupBy({ by: ['email'], _max: { name: true } }).data?.[0]?._max.name);
+
+// @ts-expect-error missing args
+client.user.useCreate().mutate();
+client.user.useCreate().mutate({ data: { email: 'test@example.com' } });
+client.user
+    .useCreate({ optimisticUpdate: true, invalidateQueries: false, retry: 3 })
+    .mutate({ data: { email: 'test@example.com' } });
+
+client.user
+    .useCreate()
+    .mutateAsync({ data: { email: 'test@example.com' }, include: { posts: true } })
+    .then((d) => check(d.posts[0]?.title));
+
+client.user
+    .useCreateMany()
+    .mutateAsync({
+        data: [{ email: 'test@example.com' }, { email: 'test2@example.com' }],
+        skipDuplicates: true,
+    })
+    .then((d) => d.count);
+
+client.user
+    .useCreateManyAndReturn()
+    .mutateAsync({
+        data: [{ email: 'test@example.com' }],
+    })
+    .then((d) => check(d[0]?.name));
+
+client.user
+    .useCreateManyAndReturn()
+    .mutateAsync({
+        data: [{ email: 'test@example.com' }],
+        select: { email: true },
+    })
+    // @ts-expect-error unselected field
+    .then((d) => check(d[0].name));
+
+client.user.useUpdate().mutate(
+    { data: { email: 'updated@example.com' }, where: { id: '1' } },
+    {
+        onSuccess: (d) => {
+            check(d.email);
+        },
+    },
+);
+
+client.user.useUpdateMany().mutate({ data: { email: 'updated@example.com' } });
+
+client.user
+    .useUpdateManyAndReturn()
+    .mutateAsync({ data: { email: 'updated@example.com' } })
+    .then((d) => check(d[0]?.email));
+
+client.user
+    .useUpsert()
+    .mutate({ where: { id: '1' }, create: { email: 'new@example.com' }, update: { email: 'updated@example.com' } });
+
+client.user.useDelete().mutate({ where: { id: '1' }, include: { posts: true } });
+
+client.user.useDeleteMany().mutate({ where: { email: 'test@example.com' } });
+
+function check(_value: unknown) {
+    // noop
+}
diff --git a/packages/clients/tanstack-query/test/svelte-typing-test.ts b/packages/clients/tanstack-query/test/svelte-typing-test.ts
new file mode 100644
index 00000000..b39c1566
--- /dev/null
+++ b/packages/clients/tanstack-query/test/svelte-typing-test.ts
@@ -0,0 +1,100 @@
+import { get } from 'svelte/store';
+import { useClientQueries } from '../src/svelte';
+import { schema } from './schemas/basic/schema-lite';
+
+const client = useClientQueries(schema);
+
+// @ts-expect-error missing args
+client.user.useFindUnique();
+
+check(get(client.user.useFindUnique({ where: { id: '1' } })).data?.email);
+check(get(client.user.useFindUnique({ where: { id: '1' } })).queryKey);
+check(get(client.user.useFindUnique({ where: { id: '1' } }, { optimisticUpdate: true, enabled: false })));
+
+// @ts-expect-error unselected field
+check(get(client.user.useFindUnique({ select: { email: true } })).data.name);
+
+check(get(client.user.useFindUnique({ where: { id: '1' }, include: { posts: true } })).data?.posts[0]?.title);
+
+check(get(client.user.useFindFirst()).data?.email);
+
+check(get(client.user.useFindMany()).data?.[0]?.email);
+check(get(client.user.useInfiniteFindMany()).data?.pages[0]?.[0]?.email);
+check(
+    get(
+        client.user.useInfiniteFindMany(
+            {},
+            {
+                getNextPageParam: () => ({ id: '2' }),
+            },
+        ),
+    ).data?.pages[1]?.[0]?.email,
+);
+
+check(get(client.user.useCount()).data?.toFixed(2));
+check(get(client.user.useCount({ select: { email: true } })).data?.email.toFixed(2));
+
+check(get(client.user.useAggregate({ _max: { email: true } })).data?._max.email);
+
+check(get(client.user.useGroupBy({ by: ['email'], _max: { name: true } })).data?.[0]?._max.name);
+
+// @ts-expect-error missing args
+client.user.useCreate().mutate();
+get(client.user.useCreate()).mutate({ data: { email: 'test@example.com' } });
+get(client.user.useCreate({ optimisticUpdate: true, invalidateQueries: false, retry: 3 })).mutate({
+    data: { email: 'test@example.com' },
+});
+
+get(client.user.useCreate())
+    .mutateAsync({ data: { email: 'test@example.com' }, include: { posts: true } })
+    .then((d) => check(d.posts[0]?.title));
+
+get(client.user.useCreateMany())
+    .mutateAsync({
+        data: [{ email: 'test@example.com' }, { email: 'test2@example.com' }],
+        skipDuplicates: true,
+    })
+    .then((d) => d.count);
+
+get(client.user.useCreateManyAndReturn())
+    .mutateAsync({
+        data: [{ email: 'test@example.com' }],
+    })
+    .then((d) => check(d[0]?.name));
+
+get(client.user.useCreateManyAndReturn())
+    .mutateAsync({
+        data: [{ email: 'test@example.com' }],
+        select: { email: true },
+    })
+    // @ts-expect-error unselected field
+    .then((d) => check(d[0].name));
+
+get(client.user.useUpdate()).mutate(
+    { data: { email: 'updated@example.com' }, where: { id: '1' } },
+    {
+        onSuccess: (d) => {
+            check(d.email);
+        },
+    },
+);
+
+get(client.user.useUpdateMany()).mutate({ data: { email: 'updated@example.com' } });
+
+get(client.user.useUpdateManyAndReturn())
+    .mutateAsync({ data: { email: 'updated@example.com' } })
+    .then((d) => check(d[0]?.email));
+
+get(client.user.useUpsert()).mutate({
+    where: { id: '1' },
+    create: { email: 'new@example.com' },
+    update: { email: 'updated@example.com' },
+});
+
+get(client.user.useDelete()).mutate({ where: { id: '1' }, include: { posts: true } });
+
+get(client.user.useDeleteMany()).mutate({ where: { email: 'test@example.com' } });
+
+function check(_value: unknown) {
+    // noop
+}
diff --git a/packages/clients/tanstack-query/test/vue-typing-test.ts b/packages/clients/tanstack-query/test/vue-typing-test.ts
new file mode 100644
index 00000000..5d99e318
--- /dev/null
+++ b/packages/clients/tanstack-query/test/vue-typing-test.ts
@@ -0,0 +1,101 @@
+import { useClientQueries } from '../src/vue';
+import { schema } from './schemas/basic/schema-lite';
+
+const client = useClientQueries(schema);
+
+// @ts-expect-error missing args
+client.user.useFindUnique();
+
+check(client.user.useFindUnique({ where: { id: '1' } }).data.value?.email);
+check(client.user.useFindUnique({ where: { id: '1' } }).queryKey);
+check(client.user.useFindUnique({ where: { id: '1' } }, { optimisticUpdate: true, enabled: false }));
+
+// @ts-expect-error unselected field
+check(client.user.useFindUnique({ select: { email: true } }).data.name);
+
+check(client.user.useFindUnique({ where: { id: '1' }, include: { posts: true } }).data.value?.posts[0]?.title);
+
+check(client.user.useFindFirst().data.value?.email);
+
+check(client.user.useFindMany().data.value?.[0]?.email);
+
+check(client.user.useInfiniteFindMany().data.value?.pages[0]?.[0]?.email);
+check(
+    client.user.useInfiniteFindMany(
+        {},
+        {
+            getNextPageParam: () => ({ id: '2' }),
+        },
+    ).data.value?.pages[1]?.[0]?.email,
+);
+
+check(client.user.useCount().data.value?.toFixed(2));
+check(client.user.useCount({ select: { email: true } }).data.value?.email.toFixed(2));
+
+check(client.user.useAggregate({ _max: { email: true } }).data.value?._max.email);
+
+check(client.user.useGroupBy({ by: ['email'], _max: { name: true } }).data.value?.[0]?._max.name);
+
+// @ts-expect-error missing args
+client.user.useCreate().mutate();
+client.user.useCreate().mutate({ data: { email: 'test@example.com' } });
+client.user
+    .useCreate({ optimisticUpdate: true, invalidateQueries: false, retry: 3 })
+    .mutate({ data: { email: 'test@example.com' } });
+
+client.user
+    .useCreate()
+    .mutateAsync({ data: { email: 'test@example.com' }, include: { posts: true } })
+    .then((d) => check(d.posts[0]?.title));
+
+client.user
+    .useCreateMany()
+    .mutateAsync({
+        data: [{ email: 'test@example.com' }, { email: 'test2@example.com' }],
+        skipDuplicates: true,
+    })
+    .then((d) => d.count);
+
+client.user
+    .useCreateManyAndReturn()
+    .mutateAsync({
+        data: [{ email: 'test@example.com' }],
+    })
+    .then((d) => check(d[0]?.name));
+
+client.user
+    .useCreateManyAndReturn()
+    .mutateAsync({
+        data: [{ email: 'test@example.com' }],
+        select: { email: true },
+    })
+    // @ts-expect-error unselected field
+    .then((d) => check(d[0].name));
+
+client.user.useUpdate().mutate(
+    { data: { email: 'updated@example.com' }, where: { id: '1' } },
+    {
+        onSuccess: (d) => {
+            check(d.email);
+        },
+    },
+);
+
+client.user.useUpdateMany().mutate({ data: { email: 'updated@example.com' } });
+
+client.user
+    .useUpdateManyAndReturn()
+    .mutateAsync({ data: { email: 'updated@example.com' } })
+    .then((d) => check(d[0]?.email));
+
+client.user
+    .useUpsert()
+    .mutate({ where: { id: '1' }, create: { email: 'new@example.com' }, update: { email: 'updated@example.com' } });
+
+client.user.useDelete().mutate({ where: { id: '1' }, include: { posts: true } });
+
+client.user.useDeleteMany().mutate({ where: { email: 'test@example.com' } });
+
+function check(_value: unknown) {
+    // noop
+}
diff --git a/packages/orm/src/client/contract.ts b/packages/orm/src/client/contract.ts
index 81d7c016..8e30795a 100644
--- a/packages/orm/src/client/contract.ts
+++ b/packages/orm/src/client/contract.ts
@@ -795,10 +795,12 @@ export type AllModelOperations<Schema extends SchemaDef, Model extends GetModels
     ): ZenStackPromise<Schema, Simplify<GroupByResult<Schema, Model, T>>>;
 };
 
+export type OperationsIneligibleForDelegateModels = 'create' | 'createMany' | 'createManyAndReturn' | 'upsert';
+
 export type ModelOperations<Schema extends SchemaDef, Model extends GetModels<Schema>> = Omit<
     AllModelOperations<Schema, Model>,
     // exclude operations not applicable to delegate models
-    IsDelegateModel<Schema, Model> extends true ? 'create' | 'createMany' | 'createManyAndReturn' | 'upsert' : never
+    IsDelegateModel<Schema, Model> extends true ? OperationsIneligibleForDelegateModels : never
 >;
 
 //#endregion