diff --git a/packages/clients/tanstack-query/src/react.ts b/packages/clients/tanstack-query/src/react.ts
index a8f55b9c..b5763ce3 100644
--- a/packages/clients/tanstack-query/src/react.ts
+++ b/packages/clients/tanstack-query/src/react.ts
@@ -31,13 +31,13 @@ import type {
     CreateManyArgs,
     DeleteArgs,
     DeleteManyArgs,
-    FindArgs,
+    FindFirstArgs,
+    FindManyArgs,
     FindUniqueArgs,
     GroupByArgs,
     GroupByResult,
-    ModelResult,
-    SelectIncludeOmit,
     SelectSubset,
+    SimplifiedModelResult,
     Subset,
     UpdateArgs,
     UpdateManyAndReturnArgs,
@@ -126,13 +126,13 @@ export type ModelMutationResult<T, TArgs> = UseMutationResult<T, DefaultError, T
 export type ModelMutationModelResult<
     Schema extends SchemaDef,
     Model extends GetModels<Schema>,
-    TArgs extends SelectIncludeOmit<Schema, Model, boolean>,
+    TArgs,
     Array extends boolean = false,
-> = Omit<ModelMutationResult<ModelResult<Schema, Model, TArgs>, TArgs>, 'mutateAsync'> & {
+> = Omit<ModelMutationResult<SimplifiedModelResult<Schema, Model, TArgs, false, Array>, 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>>;
+        options?: ModelMutationOptions<SimplifiedModelResult<Schema, Model, T, false, Array>, T>,
+    ): Promise<SimplifiedModelResult<Schema, Model, T, false, Array>>;
 };
 
 export type ClientHooks<Schema extends SchemaDef> = {
@@ -145,108 +145,108 @@ export type ModelQueryHooks<Schema extends SchemaDef, Model extends GetModels<Sc
     Schema,
     Model,
     {
-        useFindUnique<T extends FindUniqueArgs<Schema, Model>>(
+        useFindUnique<T extends FindUniqueArgs<Schema, Model, true>>(
             args: SelectSubset<T, FindUniqueArgs<Schema, Model>>,
-            options?: ModelQueryOptions<ModelResult<Schema, Model, T> | null>,
-        ): ModelQueryResult<ModelResult<Schema, Model, T> | null>;
+            options?: ModelQueryOptions<SimplifiedModelResult<Schema, Model, T> | null>,
+        ): ModelQueryResult<SimplifiedModelResult<Schema, Model, T> | null>;
 
-        useSuspenseFindUnique<T extends FindUniqueArgs<Schema, Model>>(
+        useSuspenseFindUnique<T extends FindUniqueArgs<Schema, Model, true>>(
             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>,
+            options?: ModelSuspenseQueryOptions<SimplifiedModelResult<Schema, Model, T> | null>,
+        ): ModelSuspenseQueryResult<SimplifiedModelResult<Schema, Model, T> | null>;
+
+        useFindFirst<T extends FindFirstArgs<Schema, Model, true>>(
+            args?: SelectSubset<T, FindFirstArgs<Schema, Model>>,
+            options?: ModelQueryOptions<SimplifiedModelResult<Schema, Model, T> | null>,
+        ): ModelQueryResult<SimplifiedModelResult<Schema, Model, T> | null>;
+
+        useSuspenseFindFirst<T extends FindFirstArgs<Schema, Model, true>>(
+            args?: SelectSubset<T, FindFirstArgs<Schema, Model>>,
+            options?: ModelSuspenseQueryOptions<SimplifiedModelResult<Schema, Model, T> | null>,
+        ): ModelSuspenseQueryResult<SimplifiedModelResult<Schema, Model, T> | null>;
+
+        useFindMany<T extends FindManyArgs<Schema, Model, true>>(
+            args?: SelectSubset<T, FindManyArgs<Schema, Model>>,
+            options?: ModelQueryOptions<SimplifiedModelResult<Schema, Model, T>[]>,
+        ): ModelQueryResult<SimplifiedModelResult<Schema, Model, T>[]>;
+
+        useSuspenseFindMany<T extends FindManyArgs<Schema, Model, true>>(
+            args?: SelectSubset<T, FindManyArgs<Schema, Model>>,
+            options?: ModelSuspenseQueryOptions<SimplifiedModelResult<Schema, Model, T>[]>,
+        ): ModelSuspenseQueryResult<SimplifiedModelResult<Schema, Model, T>[]>;
+
+        useInfiniteFindMany<T extends FindManyArgs<Schema, Model, true>>(
+            args?: SelectSubset<T, FindManyArgs<Schema, Model>>,
+            options?: ModelInfiniteQueryOptions<SimplifiedModelResult<Schema, Model, T>[]>,
+        ): ModelInfiniteQueryResult<InfiniteData<SimplifiedModelResult<Schema, Model, T>[]>>;
+
+        useSuspenseInfiniteFindMany<T extends FindManyArgs<Schema, Model, true>>(
+            args?: SelectSubset<T, FindManyArgs<Schema, Model>>,
+            options?: ModelSuspenseInfiniteQueryOptions<SimplifiedModelResult<Schema, Model, T>[]>,
+        ): ModelSuspenseInfiniteQueryResult<InfiniteData<SimplifiedModelResult<Schema, Model, T>[]>>;
+
+        useCreate<T extends CreateArgs<Schema, Model, true>>(
+            options?: ModelMutationOptions<SimplifiedModelResult<Schema, Model, T>, T>,
         ): ModelMutationModelResult<Schema, Model, T>;
 
-        useCreateMany<T extends CreateManyArgs<Schema, Model>>(
+        useCreateMany<T extends CreateManyArgs<Schema, Model, true>>(
             options?: ModelMutationOptions<BatchResult, T>,
         ): ModelMutationResult<BatchResult, T>;
 
-        useCreateManyAndReturn<T extends CreateManyAndReturnArgs<Schema, Model>>(
-            options?: ModelMutationOptions<ModelResult<Schema, Model, T>[], T>,
+        useCreateManyAndReturn<T extends CreateManyAndReturnArgs<Schema, Model, true>>(
+            options?: ModelMutationOptions<SimplifiedModelResult<Schema, Model, T>[], T>,
         ): ModelMutationModelResult<Schema, Model, T, true>;
 
-        useUpdate<T extends UpdateArgs<Schema, Model>>(
-            options?: ModelMutationOptions<ModelResult<Schema, Model, T>, T>,
+        useUpdate<T extends UpdateArgs<Schema, Model, true>>(
+            options?: ModelMutationOptions<SimplifiedModelResult<Schema, Model, T>, T>,
         ): ModelMutationModelResult<Schema, Model, T>;
 
-        useUpdateMany<T extends UpdateManyArgs<Schema, Model>>(
+        useUpdateMany<T extends UpdateManyArgs<Schema, Model, true>>(
             options?: ModelMutationOptions<BatchResult, T>,
         ): ModelMutationResult<BatchResult, T>;
 
-        useUpdateManyAndReturn<T extends UpdateManyAndReturnArgs<Schema, Model>>(
-            options?: ModelMutationOptions<ModelResult<Schema, Model, T>[], T>,
+        useUpdateManyAndReturn<T extends UpdateManyAndReturnArgs<Schema, Model, true>>(
+            options?: ModelMutationOptions<SimplifiedModelResult<Schema, Model, T>[], T>,
         ): ModelMutationModelResult<Schema, Model, T, true>;
 
-        useUpsert<T extends UpsertArgs<Schema, Model>>(
-            options?: ModelMutationOptions<ModelResult<Schema, Model, T>, T>,
+        useUpsert<T extends UpsertArgs<Schema, Model, true>>(
+            options?: ModelMutationOptions<SimplifiedModelResult<Schema, Model, T>, T>,
         ): ModelMutationModelResult<Schema, Model, T>;
 
-        useDelete<T extends DeleteArgs<Schema, Model>>(
-            options?: ModelMutationOptions<ModelResult<Schema, Model, T>, T>,
+        useDelete<T extends DeleteArgs<Schema, Model, true>>(
+            options?: ModelMutationOptions<SimplifiedModelResult<Schema, Model, T>, T>,
         ): ModelMutationModelResult<Schema, Model, T>;
 
-        useDeleteMany<T extends DeleteManyArgs<Schema, Model>>(
+        useDeleteMany<T extends DeleteManyArgs<Schema, Model, true>>(
             options?: ModelMutationOptions<BatchResult, T>,
         ): ModelMutationResult<BatchResult, T>;
 
-        useCount<T extends CountArgs<Schema, Model>>(
+        useCount<T extends CountArgs<Schema, Model, true>>(
             args?: Subset<T, CountArgs<Schema, Model>>,
             options?: ModelQueryOptions<CountResult<Schema, Model, T>>,
         ): ModelQueryResult<CountResult<Schema, Model, T>>;
 
-        useSuspenseCount<T extends CountArgs<Schema, Model>>(
+        useSuspenseCount<T extends CountArgs<Schema, Model, true>>(
             args?: Subset<T, CountArgs<Schema, Model>>,
             options?: ModelSuspenseQueryOptions<CountResult<Schema, Model, T>>,
         ): ModelSuspenseQueryResult<CountResult<Schema, Model, T>>;
 
-        useAggregate<T extends AggregateArgs<Schema, Model>>(
+        useAggregate<T extends AggregateArgs<Schema, Model, true>>(
             args: Subset<T, AggregateArgs<Schema, Model>>,
             options?: ModelQueryOptions<AggregateResult<Schema, Model, T>>,
         ): ModelQueryResult<AggregateResult<Schema, Model, T>>;
 
-        useSuspenseAggregate<T extends AggregateArgs<Schema, Model>>(
+        useSuspenseAggregate<T extends AggregateArgs<Schema, Model, true>>(
             args: Subset<T, AggregateArgs<Schema, Model>>,
             options?: ModelSuspenseQueryOptions<AggregateResult<Schema, Model, T>>,
         ): ModelSuspenseQueryResult<AggregateResult<Schema, Model, T>>;
 
-        useGroupBy<T extends GroupByArgs<Schema, Model>>(
+        useGroupBy<T extends GroupByArgs<Schema, Model, true>>(
             args: Subset<T, GroupByArgs<Schema, Model>>,
             options?: ModelQueryOptions<GroupByResult<Schema, Model, T>>,
         ): ModelQueryResult<GroupByResult<Schema, Model, T>>;
 
-        useSuspenseGroupBy<T extends GroupByArgs<Schema, Model>>(
+        useSuspenseGroupBy<T extends GroupByArgs<Schema, Model, true>>(
             args: Subset<T, GroupByArgs<Schema, Model>>,
             options?: ModelSuspenseQueryOptions<GroupByResult<Schema, Model, T>>,
         ): ModelSuspenseQueryResult<GroupByResult<Schema, Model, T>>;
diff --git a/packages/clients/tanstack-query/src/svelte.ts b/packages/clients/tanstack-query/src/svelte.ts
index 3cd81476..e05840a2 100644
--- a/packages/clients/tanstack-query/src/svelte.ts
+++ b/packages/clients/tanstack-query/src/svelte.ts
@@ -27,13 +27,13 @@ import type {
     CreateManyArgs,
     DeleteArgs,
     DeleteManyArgs,
-    FindArgs,
+    FindFirstArgs,
+    FindManyArgs,
     FindUniqueArgs,
     GroupByArgs,
     GroupByResult,
-    ModelResult,
-    SelectIncludeOmit,
     SelectSubset,
+    SimplifiedModelResult,
     Subset,
     UpdateArgs,
     UpdateManyAndReturnArgs,
@@ -114,14 +114,17 @@ export type ModelMutationResult<T, TArgs> = CreateMutationResult<T, DefaultError
 export type ModelMutationModelResult<
     Schema extends SchemaDef,
     Model extends GetModels<Schema>,
-    TArgs extends SelectIncludeOmit<Schema, Model, boolean>,
+    TArgs,
     Array extends boolean = false,
 > = Readable<
-    Omit<UnwrapStore<ModelMutationResult<ModelResult<Schema, Model, TArgs>, TArgs>>, 'mutateAsync'> & {
+    Omit<
+        UnwrapStore<ModelMutationResult<SimplifiedModelResult<Schema, Model, TArgs, false, Array>, 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>>;
+            options?: ModelMutationOptions<SimplifiedModelResult<Schema, Model, T, false, Array>, T>,
+        ): Promise<SimplifiedModelResult<Schema, Model, T, false, Array>>;
     }
 >;
 
@@ -135,73 +138,73 @@ export type ModelQueryHooks<Schema extends SchemaDef, Model extends GetModels<Sc
     Schema,
     Model,
     {
-        useFindUnique<T extends FindUniqueArgs<Schema, Model>>(
+        useFindUnique<T extends FindUniqueArgs<Schema, Model, true>>(
             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>,
+            options?: ModelQueryOptions<SimplifiedModelResult<Schema, Model, T> | null>,
+        ): ModelQueryResult<SimplifiedModelResult<Schema, Model, T> | null>;
+
+        useFindFirst<T extends FindFirstArgs<Schema, Model, true>>(
+            args?: SelectSubset<T, FindFirstArgs<Schema, Model>>,
+            options?: ModelQueryOptions<SimplifiedModelResult<Schema, Model, T> | null>,
+        ): ModelQueryResult<SimplifiedModelResult<Schema, Model, T> | null>;
+
+        useFindMany<T extends FindManyArgs<Schema, Model, true>>(
+            args?: SelectSubset<T, FindManyArgs<Schema, Model>>,
+            options?: ModelQueryOptions<SimplifiedModelResult<Schema, Model, T>[]>,
+        ): ModelQueryResult<SimplifiedModelResult<Schema, Model, T>[]>;
+
+        useInfiniteFindMany<T extends FindManyArgs<Schema, Model, true>>(
+            args?: SelectSubset<T, FindManyArgs<Schema, Model>>,
+            options?: ModelInfiniteQueryOptions<SimplifiedModelResult<Schema, Model, T>[]>,
+        ): ModelInfiniteQueryResult<InfiniteData<SimplifiedModelResult<Schema, Model, T>[]>>;
+
+        useCreate<T extends CreateArgs<Schema, Model, true>>(
+            options?: ModelMutationOptions<SimplifiedModelResult<Schema, Model, T>, T>,
         ): ModelMutationModelResult<Schema, Model, T>;
 
-        useCreateMany<T extends CreateManyArgs<Schema, Model>>(
+        useCreateMany<T extends CreateManyArgs<Schema, Model, true>>(
             options?: ModelMutationOptions<BatchResult, T>,
         ): ModelMutationResult<BatchResult, T>;
 
-        useCreateManyAndReturn<T extends CreateManyAndReturnArgs<Schema, Model>>(
-            options?: ModelMutationOptions<ModelResult<Schema, Model, T>[], T>,
+        useCreateManyAndReturn<T extends CreateManyAndReturnArgs<Schema, Model, true>>(
+            options?: ModelMutationOptions<SimplifiedModelResult<Schema, Model, T>[], T>,
         ): ModelMutationModelResult<Schema, Model, T, true>;
 
-        useUpdate<T extends UpdateArgs<Schema, Model>>(
-            options?: ModelMutationOptions<ModelResult<Schema, Model, T>, T>,
+        useUpdate<T extends UpdateArgs<Schema, Model, true>>(
+            options?: ModelMutationOptions<SimplifiedModelResult<Schema, Model, T>, T>,
         ): ModelMutationModelResult<Schema, Model, T>;
 
-        useUpdateMany<T extends UpdateManyArgs<Schema, Model>>(
+        useUpdateMany<T extends UpdateManyArgs<Schema, Model, true>>(
             options?: ModelMutationOptions<BatchResult, T>,
         ): ModelMutationResult<BatchResult, T>;
 
-        useUpdateManyAndReturn<T extends UpdateManyAndReturnArgs<Schema, Model>>(
-            options?: ModelMutationOptions<ModelResult<Schema, Model, T>[], T>,
+        useUpdateManyAndReturn<T extends UpdateManyAndReturnArgs<Schema, Model, true>>(
+            options?: ModelMutationOptions<SimplifiedModelResult<Schema, Model, T>[], T>,
         ): ModelMutationModelResult<Schema, Model, T, true>;
 
-        useUpsert<T extends UpsertArgs<Schema, Model>>(
-            options?: ModelMutationOptions<ModelResult<Schema, Model, T>, T>,
+        useUpsert<T extends UpsertArgs<Schema, Model, true>>(
+            options?: ModelMutationOptions<SimplifiedModelResult<Schema, Model, T>, T>,
         ): ModelMutationModelResult<Schema, Model, T>;
 
-        useDelete<T extends DeleteArgs<Schema, Model>>(
-            options?: ModelMutationOptions<ModelResult<Schema, Model, T>, T>,
+        useDelete<T extends DeleteArgs<Schema, Model, true>>(
+            options?: ModelMutationOptions<SimplifiedModelResult<Schema, Model, T>, T>,
         ): ModelMutationModelResult<Schema, Model, T>;
 
-        useDeleteMany<T extends DeleteManyArgs<Schema, Model>>(
+        useDeleteMany<T extends DeleteManyArgs<Schema, Model, true>>(
             options?: ModelMutationOptions<BatchResult, T>,
         ): ModelMutationResult<BatchResult, T>;
 
-        useCount<T extends CountArgs<Schema, Model>>(
+        useCount<T extends CountArgs<Schema, Model, true>>(
             args?: Subset<T, CountArgs<Schema, Model>>,
             options?: ModelQueryOptions<CountResult<Schema, Model, T>>,
         ): ModelQueryResult<CountResult<Schema, Model, T>>;
 
-        useAggregate<T extends AggregateArgs<Schema, Model>>(
+        useAggregate<T extends AggregateArgs<Schema, Model, true>>(
             args: Subset<T, AggregateArgs<Schema, Model>>,
             options?: ModelQueryOptions<AggregateResult<Schema, Model, T>>,
         ): ModelQueryResult<AggregateResult<Schema, Model, T>>;
 
-        useGroupBy<T extends GroupByArgs<Schema, Model>>(
+        useGroupBy<T extends GroupByArgs<Schema, Model, true>>(
             args: Subset<T, GroupByArgs<Schema, Model>>,
             options?: ModelQueryOptions<GroupByResult<Schema, Model, T>>,
         ): ModelQueryResult<GroupByResult<Schema, Model, T>>;
diff --git a/packages/clients/tanstack-query/src/vue.ts b/packages/clients/tanstack-query/src/vue.ts
index 2623f014..5c71f319 100644
--- a/packages/clients/tanstack-query/src/vue.ts
+++ b/packages/clients/tanstack-query/src/vue.ts
@@ -25,13 +25,13 @@ import type {
     CreateManyArgs,
     DeleteArgs,
     DeleteManyArgs,
-    FindArgs,
+    FindFirstArgs,
+    FindManyArgs,
     FindUniqueArgs,
     GroupByArgs,
     GroupByResult,
-    ModelResult,
-    SelectIncludeOmit,
     SelectSubset,
+    SimplifiedModelResult,
     Subset,
     UpdateArgs,
     UpdateManyAndReturnArgs,
@@ -103,13 +103,13 @@ export type ModelMutationResult<T, TArgs> = UseMutationReturnType<T, DefaultErro
 export type ModelMutationModelResult<
     Schema extends SchemaDef,
     Model extends GetModels<Schema>,
-    TArgs extends SelectIncludeOmit<Schema, Model, boolean>,
+    TArgs,
     Array extends boolean = false,
-> = Omit<ModelMutationResult<ModelResult<Schema, Model, TArgs>, TArgs>, 'mutateAsync'> & {
+> = Omit<ModelMutationResult<SimplifiedModelResult<Schema, Model, TArgs, false, Array>, 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>>;
+        options?: ModelMutationOptions<SimplifiedModelResult<Schema, Model, T, false, Array>, T>,
+    ): Promise<SimplifiedModelResult<Schema, Model, T, false, Array>>;
 };
 
 export type ClientHooks<Schema extends SchemaDef> = {
@@ -122,73 +122,73 @@ export type ModelQueryHooks<Schema extends SchemaDef, Model extends GetModels<Sc
     Schema,
     Model,
     {
-        useFindUnique<T extends FindUniqueArgs<Schema, Model>>(
+        useFindUnique<T extends FindUniqueArgs<Schema, Model, true>>(
             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>,
+            options?: ModelQueryOptions<SimplifiedModelResult<Schema, Model, T> | null>,
+        ): ModelQueryResult<SimplifiedModelResult<Schema, Model, T> | null>;
+
+        useFindFirst<T extends FindFirstArgs<Schema, Model, true>>(
+            args?: SelectSubset<T, FindFirstArgs<Schema, Model>>,
+            options?: ModelQueryOptions<SimplifiedModelResult<Schema, Model, T> | null>,
+        ): ModelQueryResult<SimplifiedModelResult<Schema, Model, T> | null>;
+
+        useFindMany<T extends FindManyArgs<Schema, Model, true>>(
+            args?: SelectSubset<T, FindManyArgs<Schema, Model>>,
+            options?: ModelQueryOptions<SimplifiedModelResult<Schema, Model, T>[]>,
+        ): ModelQueryResult<SimplifiedModelResult<Schema, Model, T>[]>;
+
+        useInfiniteFindMany<T extends FindManyArgs<Schema, Model, true>>(
+            args?: SelectSubset<T, FindManyArgs<Schema, Model>>,
+            options?: ModelInfiniteQueryOptions<SimplifiedModelResult<Schema, Model, T>[]>,
+        ): ModelInfiniteQueryResult<InfiniteData<SimplifiedModelResult<Schema, Model, T>[]>>;
+
+        useCreate<T extends CreateArgs<Schema, Model, true>>(
+            options?: ModelMutationOptions<SimplifiedModelResult<Schema, Model, T>, T>,
         ): ModelMutationModelResult<Schema, Model, T>;
 
-        useCreateMany<T extends CreateManyArgs<Schema, Model>>(
+        useCreateMany<T extends CreateManyArgs<Schema, Model, true>>(
             options?: ModelMutationOptions<BatchResult, T>,
         ): ModelMutationResult<BatchResult, T>;
 
-        useCreateManyAndReturn<T extends CreateManyAndReturnArgs<Schema, Model>>(
-            options?: ModelMutationOptions<ModelResult<Schema, Model, T>[], T>,
+        useCreateManyAndReturn<T extends CreateManyAndReturnArgs<Schema, Model, true>>(
+            options?: ModelMutationOptions<SimplifiedModelResult<Schema, Model, T>[], T>,
         ): ModelMutationModelResult<Schema, Model, T, true>;
 
-        useUpdate<T extends UpdateArgs<Schema, Model>>(
-            options?: ModelMutationOptions<ModelResult<Schema, Model, T>, T>,
+        useUpdate<T extends UpdateArgs<Schema, Model, true>>(
+            options?: ModelMutationOptions<SimplifiedModelResult<Schema, Model, T>, T>,
         ): ModelMutationModelResult<Schema, Model, T>;
 
-        useUpdateMany<T extends UpdateManyArgs<Schema, Model>>(
+        useUpdateMany<T extends UpdateManyArgs<Schema, Model, true>>(
             options?: ModelMutationOptions<BatchResult, T>,
         ): ModelMutationResult<BatchResult, T>;
 
-        useUpdateManyAndReturn<T extends UpdateManyAndReturnArgs<Schema, Model>>(
-            options?: ModelMutationOptions<ModelResult<Schema, Model, T>[], T>,
+        useUpdateManyAndReturn<T extends UpdateManyAndReturnArgs<Schema, Model, true>>(
+            options?: ModelMutationOptions<SimplifiedModelResult<Schema, Model, T>[], T>,
         ): ModelMutationModelResult<Schema, Model, T, true>;
 
-        useUpsert<T extends UpsertArgs<Schema, Model>>(
-            options?: ModelMutationOptions<ModelResult<Schema, Model, T>, T>,
+        useUpsert<T extends UpsertArgs<Schema, Model, true>>(
+            options?: ModelMutationOptions<SimplifiedModelResult<Schema, Model, T>, T>,
         ): ModelMutationModelResult<Schema, Model, T>;
 
-        useDelete<T extends DeleteArgs<Schema, Model>>(
-            options?: ModelMutationOptions<ModelResult<Schema, Model, T>, T>,
+        useDelete<T extends DeleteArgs<Schema, Model, true>>(
+            options?: ModelMutationOptions<SimplifiedModelResult<Schema, Model, T>, T>,
         ): ModelMutationModelResult<Schema, Model, T>;
 
-        useDeleteMany<T extends DeleteManyArgs<Schema, Model>>(
+        useDeleteMany<T extends DeleteManyArgs<Schema, Model, true>>(
             options?: ModelMutationOptions<BatchResult, T>,
         ): ModelMutationResult<BatchResult, T>;
 
-        useCount<T extends CountArgs<Schema, Model>>(
+        useCount<T extends CountArgs<Schema, Model, true>>(
             args?: Subset<T, CountArgs<Schema, Model>>,
             options?: ModelQueryOptions<CountResult<Schema, Model, T>>,
         ): ModelQueryResult<CountResult<Schema, Model, T>>;
 
-        useAggregate<T extends AggregateArgs<Schema, Model>>(
+        useAggregate<T extends AggregateArgs<Schema, Model, true>>(
             args: Subset<T, AggregateArgs<Schema, Model>>,
             options?: ModelQueryOptions<AggregateResult<Schema, Model, T>>,
         ): ModelQueryResult<AggregateResult<Schema, Model, T>>;
 
-        useGroupBy<T extends GroupByArgs<Schema, Model>>(
+        useGroupBy<T extends GroupByArgs<Schema, Model, true>>(
             args: Subset<T, GroupByArgs<Schema, Model>>,
             options?: ModelQueryOptions<GroupByResult<Schema, Model, T>>,
         ): ModelQueryResult<GroupByResult<Schema, Model, T>>;
diff --git a/packages/clients/tanstack-query/test/react-query.test.tsx b/packages/clients/tanstack-query/test/react-query.test.tsx
index e9ea8295..9a178f48 100644
--- a/packages/clients/tanstack-query/test/react-query.test.tsx
+++ b/packages/clients/tanstack-query/test/react-query.test.tsx
@@ -25,7 +25,7 @@ describe('React Query Test', () => {
         const Provider = QuerySettingsProvider;
         const wrapper = ({ children }: { children: React.ReactNode }) => (
             <QueryClientProvider client={queryClient}>
-                <Provider value={{ endpoint: `${BASE_URL}/api/model`, logging: true }}>{children}</Provider>
+                <Provider value={{ endpoint: `${BASE_URL}/api/model` }}>{children}</Provider>
             </QueryClientProvider>
         );
         return { queryClient, wrapper };
diff --git a/packages/orm/src/client/contract.ts b/packages/orm/src/client/contract.ts
index e9383162..7f1fd48c 100644
--- a/packages/orm/src/client/contract.ts
+++ b/packages/orm/src/client/contract.ts
@@ -14,12 +14,14 @@ import type {
     CreateManyArgs,
     DeleteArgs,
     DeleteManyArgs,
-    FindArgs,
+    FindFirstArgs,
+    FindManyArgs,
     FindUniqueArgs,
     GroupByArgs,
     GroupByResult,
     ModelResult,
     SelectSubset,
+    SimplifiedModelResult,
     Subset,
     UpdateArgs,
     UpdateManyAndReturnArgs,
@@ -323,9 +325,9 @@ export type AllModelOperations<Schema extends SchemaDef, Model extends GetModels
      * }); // result: `{ _count: { posts: number } }`
      * ```
      */
-    findMany<T extends FindArgs<Schema, Model, true>>(
-        args?: SelectSubset<T, FindArgs<Schema, Model, true>>,
-    ): ZenStackPromise<Schema, Simplify<ModelResult<Schema, Model, T>>[]>;
+    findMany<T extends FindManyArgs<Schema, Model, true>>(
+        args?: SelectSubset<T, FindManyArgs<Schema, Model>>,
+    ): ZenStackPromise<Schema, SimplifiedModelResult<Schema, Model, T>[]>;
 
     /**
      * Returns a uniquely identified entity.
@@ -333,9 +335,9 @@ export type AllModelOperations<Schema extends SchemaDef, Model extends GetModels
      * @returns a single entity or null if not found
      * @see {@link findMany}
      */
-    findUnique<T extends FindUniqueArgs<Schema, Model>>(
+    findUnique<T extends FindUniqueArgs<Schema, Model, true>>(
         args: SelectSubset<T, FindUniqueArgs<Schema, Model>>,
-    ): ZenStackPromise<Schema, Simplify<ModelResult<Schema, Model, T>> | null>;
+    ): ZenStackPromise<Schema, SimplifiedModelResult<Schema, Model, T> | null>;
 
     /**
      * Returns a uniquely identified entity or throws `NotFoundError` if not found.
@@ -343,9 +345,9 @@ export type AllModelOperations<Schema extends SchemaDef, Model extends GetModels
      * @returns a single entity
      * @see {@link findMany}
      */
-    findUniqueOrThrow<T extends FindUniqueArgs<Schema, Model>>(
+    findUniqueOrThrow<T extends FindUniqueArgs<Schema, Model, true>>(
         args: SelectSubset<T, FindUniqueArgs<Schema, Model>>,
-    ): ZenStackPromise<Schema, Simplify<ModelResult<Schema, Model, T>>>;
+    ): ZenStackPromise<Schema, SimplifiedModelResult<Schema, Model, T>>;
 
     /**
      * Returns the first entity.
@@ -353,9 +355,9 @@ export type AllModelOperations<Schema extends SchemaDef, Model extends GetModels
      * @returns a single entity or null if not found
      * @see {@link findMany}
      */
-    findFirst<T extends FindArgs<Schema, Model, true>>(
-        args?: SelectSubset<T, FindArgs<Schema, Model, true>>,
-    ): ZenStackPromise<Schema, Simplify<ModelResult<Schema, Model, T>> | null>;
+    findFirst<T extends FindFirstArgs<Schema, Model, true>>(
+        args?: SelectSubset<T, FindFirstArgs<Schema, Model>>,
+    ): ZenStackPromise<Schema, SimplifiedModelResult<Schema, Model, T> | null>;
 
     /**
      * Returns the first entity or throws `NotFoundError` if not found.
@@ -363,9 +365,9 @@ export type AllModelOperations<Schema extends SchemaDef, Model extends GetModels
      * @returns a single entity
      * @see {@link findMany}
      */
-    findFirstOrThrow<T extends FindArgs<Schema, Model, true>>(
-        args?: SelectSubset<T, FindArgs<Schema, Model, true>>,
-    ): ZenStackPromise<Schema, Simplify<ModelResult<Schema, Model, T>>>;
+    findFirstOrThrow<T extends FindFirstArgs<Schema, Model, true>>(
+        args?: SelectSubset<T, FindFirstArgs<Schema, Model>>,
+    ): ZenStackPromise<Schema, SimplifiedModelResult<Schema, Model, T>>;
 
     /**
      * Creates a new entity.
@@ -419,9 +421,9 @@ export type AllModelOperations<Schema extends SchemaDef, Model extends GetModels
      * });
      * ```
      */
-    create<T extends CreateArgs<Schema, Model>>(
+    create<T extends CreateArgs<Schema, Model, true>>(
         args: SelectSubset<T, CreateArgs<Schema, Model>>,
-    ): ZenStackPromise<Schema, Simplify<ModelResult<Schema, Model, T>>>;
+    ): ZenStackPromise<Schema, SimplifiedModelResult<Schema, Model, T>>;
 
     /**
      * Creates multiple entities. Only scalar fields are allowed.
@@ -448,7 +450,7 @@ export type AllModelOperations<Schema extends SchemaDef, Model extends GetModels
      * });
      * ```
      */
-    createMany<T extends CreateManyArgs<Schema, Model>>(
+    createMany<T extends CreateManyArgs<Schema, Model, true>>(
         args?: SelectSubset<T, CreateManyArgs<Schema, Model>>,
     ): ZenStackPromise<Schema, BatchResult>;
 
@@ -470,9 +472,9 @@ export type AllModelOperations<Schema extends SchemaDef, Model extends GetModels
      * });
      * ```
      */
-    createManyAndReturn<T extends CreateManyAndReturnArgs<Schema, Model>>(
+    createManyAndReturn<T extends CreateManyAndReturnArgs<Schema, Model, true>>(
         args?: SelectSubset<T, CreateManyAndReturnArgs<Schema, Model>>,
-    ): ZenStackPromise<Schema, Simplify<ModelResult<Schema, Model, T>>[]>;
+    ): ZenStackPromise<Schema, SimplifiedModelResult<Schema, Model, T>[]>;
 
     /**
      * Updates a uniquely identified entity.
@@ -591,9 +593,9 @@ export type AllModelOperations<Schema extends SchemaDef, Model extends GetModels
      * });
      * ```
      */
-    update<T extends UpdateArgs<Schema, Model>>(
+    update<T extends UpdateArgs<Schema, Model, true>>(
         args: SelectSubset<T, UpdateArgs<Schema, Model>>,
-    ): ZenStackPromise<Schema, Simplify<ModelResult<Schema, Model, T>>>;
+    ): ZenStackPromise<Schema, SimplifiedModelResult<Schema, Model, T>>;
 
     /**
      * Updates multiple entities.
@@ -615,7 +617,7 @@ export type AllModelOperations<Schema extends SchemaDef, Model extends GetModels
      *     limit: 10
      * });
      */
-    updateMany<T extends UpdateManyArgs<Schema, Model>>(
+    updateMany<T extends UpdateManyArgs<Schema, Model, true>>(
         args: Subset<T, UpdateManyArgs<Schema, Model>>,
     ): ZenStackPromise<Schema, BatchResult>;
 
@@ -641,9 +643,9 @@ export type AllModelOperations<Schema extends SchemaDef, Model extends GetModels
      * });
      * ```
      */
-    updateManyAndReturn<T extends UpdateManyAndReturnArgs<Schema, Model>>(
+    updateManyAndReturn<T extends UpdateManyAndReturnArgs<Schema, Model, true>>(
         args: Subset<T, UpdateManyAndReturnArgs<Schema, Model>>,
-    ): ZenStackPromise<Schema, Simplify<ModelResult<Schema, Model, T>>[]>;
+    ): ZenStackPromise<Schema, SimplifiedModelResult<Schema, Model, T>[]>;
 
     /**
      * Creates or updates an entity.
@@ -665,9 +667,9 @@ export type AllModelOperations<Schema extends SchemaDef, Model extends GetModels
      * });
      * ```
      */
-    upsert<T extends UpsertArgs<Schema, Model>>(
+    upsert<T extends UpsertArgs<Schema, Model, true>>(
         args: SelectSubset<T, UpsertArgs<Schema, Model>>,
-    ): ZenStackPromise<Schema, Simplify<ModelResult<Schema, Model, T>>>;
+    ): ZenStackPromise<Schema, SimplifiedModelResult<Schema, Model, T>>;
 
     /**
      * Deletes a uniquely identifiable entity.
@@ -688,9 +690,9 @@ export type AllModelOperations<Schema extends SchemaDef, Model extends GetModels
      * }); // result: `{ id: string; email: string }`
      * ```
      */
-    delete<T extends DeleteArgs<Schema, Model>>(
+    delete<T extends DeleteArgs<Schema, Model, true>>(
         args: SelectSubset<T, DeleteArgs<Schema, Model>>,
-    ): ZenStackPromise<Schema, Simplify<ModelResult<Schema, Model, T>>>;
+    ): ZenStackPromise<Schema, SimplifiedModelResult<Schema, Model, T>>;
 
     /**
      * Deletes multiple entities.
@@ -711,7 +713,7 @@ export type AllModelOperations<Schema extends SchemaDef, Model extends GetModels
      * });
      * ```
      */
-    deleteMany<T extends DeleteManyArgs<Schema, Model>>(
+    deleteMany<T extends DeleteManyArgs<Schema, Model, true>>(
         args?: Subset<T, DeleteManyArgs<Schema, Model>>,
     ): ZenStackPromise<Schema, BatchResult>;
 
@@ -733,7 +735,7 @@ export type AllModelOperations<Schema extends SchemaDef, Model extends GetModels
      *     select: { _all: true, email: true }
      * }); // result: `{ _all: number, email: number }`
      */
-    count<T extends CountArgs<Schema, Model>>(
+    count<T extends CountArgs<Schema, Model, true>>(
         args?: Subset<T, CountArgs<Schema, Model>>,
     ): ZenStackPromise<Schema, Simplify<CountResult<Schema, Model, T>>>;
 
@@ -754,7 +756,7 @@ export type AllModelOperations<Schema extends SchemaDef, Model extends GetModels
      *     _max: { age: true }
      * }); // result: `{ _count: number, _avg: { age: number }, ... }`
      */
-    aggregate<T extends AggregateArgs<Schema, Model>>(
+    aggregate<T extends AggregateArgs<Schema, Model, true>>(
         args: Subset<T, AggregateArgs<Schema, Model>>,
     ): ZenStackPromise<Schema, Simplify<AggregateResult<Schema, Model, T>>>;
 
@@ -791,7 +793,7 @@ export type AllModelOperations<Schema extends SchemaDef, Model extends GetModels
      *     having: { country: 'US', age: { _avg: { gte: 18 } } }
      * });
      */
-    groupBy<T extends GroupByArgs<Schema, Model>>(
+    groupBy<T extends GroupByArgs<Schema, Model, true>>(
         args: Subset<T, GroupByArgs<Schema, Model>>,
     ): ZenStackPromise<Schema, Simplify<GroupByResult<Schema, Model, T>>>;
 };
diff --git a/packages/orm/src/client/crud-types.ts b/packages/orm/src/client/crud-types.ts
index fd9714ed..e1af448f 100644
--- a/packages/orm/src/client/crud-types.ts
+++ b/packages/orm/src/client/crud-types.ts
@@ -39,6 +39,7 @@ import type {
     Optional,
     OrArray,
     Simplify,
+    SimplifyIf,
     ValueOfPotentialTuple,
     WrapType,
     XOR,
@@ -135,7 +136,7 @@ type SelectCountResult<Schema extends SchemaDef, Model extends GetModels<Schema>
 export type ModelResult<
     Schema extends SchemaDef,
     Model extends GetModels<Schema>,
-    Args extends SelectIncludeOmit<Schema, Model, boolean> = {},
+    Args = {},
     Optional = false,
     Array = false,
 > = WrapType<
@@ -181,7 +182,7 @@ export type ModelResult<
 export type SimplifiedModelResult<
     Schema extends SchemaDef,
     Model extends GetModels<Schema>,
-    Args extends SelectIncludeOmit<Schema, Model, boolean> = {},
+    Args = {},
     Optional = false,
     Array = false,
 > = Simplify<ModelResult<Schema, Model, Args, Optional, Array>>;
@@ -663,33 +664,64 @@ export type FindArgs<
               (AllowFilter extends true ? FilterArgs<Schema, Model> : {}) &
               SelectIncludeOmit<Schema, Model, Collection>;
 
-export type FindManyArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = FindArgs<Schema, Model, true>;
-export type FindFirstArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = FindArgs<Schema, Model, false>;
+export type FindManyArgs<
+    Schema extends SchemaDef,
+    Model extends GetModels<Schema>,
+    Simplify extends boolean = false,
+> = SimplifyIf<FindArgs<Schema, Model, true>, Simplify>;
 
-export type FindUniqueArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
-    where?: WhereUniqueInput<Schema, Model>;
-} & SelectIncludeOmit<Schema, Model, true>;
+export type FindFirstArgs<
+    Schema extends SchemaDef,
+    Model extends GetModels<Schema>,
+    Simplify extends boolean = false,
+> = SimplifyIf<FindArgs<Schema, Model, true>, Simplify>;
+
+export type FindUniqueArgs<
+    Schema extends SchemaDef,
+    Model extends GetModels<Schema>,
+    Simplify extends boolean = false,
+> = SimplifyIf<
+    {
+        where?: WhereUniqueInput<Schema, Model>;
+    } & SelectIncludeOmit<Schema, Model, true>,
+    Simplify
+>;
 
 //#endregion
 
 //#region Create args
 
-export type CreateArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
-    data: CreateInput<Schema, Model>;
-    select?: SelectInput<Schema, Model>;
-    include?: IncludeInput<Schema, Model>;
-    omit?: OmitInput<Schema, Model>;
-};
+export type CreateArgs<
+    Schema extends SchemaDef,
+    Model extends GetModels<Schema>,
+    Simplify extends boolean = false,
+> = SimplifyIf<
+    {
+        data: CreateInput<Schema, Model>;
+        select?: SelectInput<Schema, Model>;
+        include?: IncludeInput<Schema, Model>;
+        omit?: OmitInput<Schema, Model>;
+    },
+    Simplify
+>;
 
-export type CreateManyArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = CreateManyInput<Schema, Model>;
+export type CreateManyArgs<
+    Schema extends SchemaDef,
+    Model extends GetModels<Schema>,
+    Simplify extends boolean = false,
+> = SimplifyIf<CreateManyInput<Schema, Model>, Simplify>;
 
-export type CreateManyAndReturnArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = CreateManyInput<
-    Schema,
-    Model
-> & {
-    select?: SelectInput<Schema, Model, false, false>;
-    omit?: OmitInput<Schema, Model>;
-};
+export type CreateManyAndReturnArgs<
+    Schema extends SchemaDef,
+    Model extends GetModels<Schema>,
+    Simplify extends boolean = false,
+> = SimplifyIf<
+    CreateManyInput<Schema, Model> & {
+        select?: SelectInput<Schema, Model, false, false>;
+        omit?: OmitInput<Schema, Model>;
+    },
+    Simplify
+>;
 
 type OptionalWrap<Schema extends SchemaDef, Model extends GetModels<Schema>, T extends object> = Optional<
     T,
@@ -707,17 +739,20 @@ type CreateScalarPayload<Schema extends SchemaDef, Model extends GetModels<Schem
     }
 >;
 
+// For unknown reason toplevel `Simplify` can't simplify this type, so we added an extra layer
+// to make it work
 type ScalarCreatePayload<
     Schema extends SchemaDef,
     Model extends GetModels<Schema>,
     Field extends ScalarFields<Schema, Model, false>,
-> =
+> = Simplify<
     | MapModelFieldType<Schema, Model, Field>
     | (FieldIsArray<Schema, Model, Field> extends true
           ? {
                 set?: MapModelFieldType<Schema, Model, Field>;
             }
-          : never);
+          : never)
+>;
 
 type CreateFKPayload<Schema extends SchemaDef, Model extends GetModels<Schema>> = OptionalWrap<
     Schema,
@@ -812,26 +847,38 @@ type NestedCreateManyInput<
 
 // #region Update args
 
-export type UpdateArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
-    data: UpdateInput<Schema, Model>;
-    where: WhereUniqueInput<Schema, Model>;
-    select?: SelectInput<Schema, Model>;
-    include?: IncludeInput<Schema, Model>;
-    omit?: OmitInput<Schema, Model>;
-};
-
-export type UpdateManyArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = UpdateManyPayload<
-    Schema,
-    Model
+export type UpdateArgs<
+    Schema extends SchemaDef,
+    Model extends GetModels<Schema>,
+    Simplify extends boolean = false,
+> = SimplifyIf<
+    {
+        data: UpdateInput<Schema, Model>;
+        where: WhereUniqueInput<Schema, Model>;
+        select?: SelectInput<Schema, Model>;
+        include?: IncludeInput<Schema, Model>;
+        omit?: OmitInput<Schema, Model>;
+    },
+    Simplify
 >;
 
-export type UpdateManyAndReturnArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = UpdateManyPayload<
-    Schema,
-    Model
-> & {
-    select?: SelectInput<Schema, Model, false, false>;
-    omit?: OmitInput<Schema, Model>;
-};
+export type UpdateManyArgs<
+    Schema extends SchemaDef,
+    Model extends GetModels<Schema>,
+    Simplify extends boolean = false,
+> = SimplifyIf<UpdateManyPayload<Schema, Model>, Simplify>;
+
+export type UpdateManyAndReturnArgs<
+    Schema extends SchemaDef,
+    Model extends GetModels<Schema>,
+    Simplify extends boolean = false,
+> = SimplifyIf<
+    UpdateManyPayload<Schema, Model> & {
+        select?: SelectInput<Schema, Model, false, false>;
+        omit?: OmitInput<Schema, Model>;
+    },
+    Simplify
+>;
 
 type UpdateManyPayload<Schema extends SchemaDef, Model extends GetModels<Schema>, Without extends string = never> = {
     data: OrArray<UpdateScalarInput<Schema, Model, Without>>;
@@ -839,14 +886,21 @@ type UpdateManyPayload<Schema extends SchemaDef, Model extends GetModels<Schema>
     limit?: number;
 };
 
-export type UpsertArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
-    create: CreateInput<Schema, Model>;
-    update: UpdateInput<Schema, Model>;
-    where: WhereUniqueInput<Schema, Model>;
-    select?: SelectInput<Schema, Model>;
-    include?: IncludeInput<Schema, Model>;
-    omit?: OmitInput<Schema, Model>;
-};
+export type UpsertArgs<
+    Schema extends SchemaDef,
+    Model extends GetModels<Schema>,
+    Simplify extends boolean = false,
+> = SimplifyIf<
+    {
+        create: CreateInput<Schema, Model>;
+        update: UpdateInput<Schema, Model>;
+        where: WhereUniqueInput<Schema, Model>;
+        select?: SelectInput<Schema, Model>;
+        include?: IncludeInput<Schema, Model>;
+        omit?: OmitInput<Schema, Model>;
+    },
+    Simplify
+>;
 
 type UpdateScalarInput<
     Schema extends SchemaDef,
@@ -958,38 +1012,54 @@ type ToOneRelationUpdateInput<
 
 // #region Delete args
 
-export type DeleteArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
-    where: WhereUniqueInput<Schema, Model>;
-    select?: SelectInput<Schema, Model>;
-    include?: IncludeInput<Schema, Model>;
-    omit?: OmitInput<Schema, Model>;
-};
+export type DeleteArgs<
+    Schema extends SchemaDef,
+    Model extends GetModels<Schema>,
+    Simplify extends boolean = false,
+> = SimplifyIf<
+    {
+        where: WhereUniqueInput<Schema, Model>;
+        select?: SelectInput<Schema, Model>;
+        include?: IncludeInput<Schema, Model>;
+        omit?: OmitInput<Schema, Model>;
+    },
+    Simplify
+>;
 
-export type DeleteManyArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
-    where?: WhereInput<Schema, Model>;
-    limit?: number;
-};
+export type DeleteManyArgs<
+    Schema extends SchemaDef,
+    Model extends GetModels<Schema>,
+    Simplify extends boolean = false,
+> = SimplifyIf<
+    {
+        where?: WhereInput<Schema, Model>;
+        limit?: number;
+    },
+    Simplify
+>;
 
 // #endregion
 
 // #region Count args
 
-export type CountArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = Omit<
-    FindArgs<Schema, Model, true>,
-    'select' | 'include' | 'distinct' | 'omit'
-> & {
-    select?: CountAggregateInput<Schema, Model> | true;
-};
+export type CountArgs<
+    Schema extends SchemaDef,
+    Model extends GetModels<Schema>,
+    Simplify extends boolean = false,
+> = SimplifyIf<
+    Omit<FindArgs<Schema, Model, true>, 'select' | 'include' | 'distinct' | 'omit'> & {
+        select?: CountAggregateInput<Schema, Model> | true;
+    },
+    Simplify
+>;
 
 type CountAggregateInput<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
     [Key in NonRelationFields<Schema, Model>]?: true;
 } & { _all?: true };
 
-export type CountResult<
-    Schema extends SchemaDef,
-    Model extends GetModels<Schema>,
-    Args extends CountArgs<Schema, Model>,
-> = Args extends { select: infer S }
+export type CountResult<Schema extends SchemaDef, _Model extends GetModels<Schema>, Args> = Args extends {
+    select: infer S;
+}
     ? S extends true
         ? number
         : {
@@ -1001,21 +1071,28 @@ export type CountResult<
 
 // #region Aggregate
 
-export type AggregateArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
-    where?: WhereInput<Schema, Model>;
-    skip?: number;
-    take?: number;
-    orderBy?: OrArray<OrderBy<Schema, Model, true, false>>;
-} & {
-    _count?: true | CountAggregateInput<Schema, Model>;
-    _min?: MinMaxInput<Schema, Model, true>;
-    _max?: MinMaxInput<Schema, Model, true>;
-} & (NumericFields<Schema, Model> extends never
-        ? {}
-        : {
-              _avg?: SumAvgInput<Schema, Model, true>;
-              _sum?: SumAvgInput<Schema, Model, true>;
-          });
+export type AggregateArgs<
+    Schema extends SchemaDef,
+    Model extends GetModels<Schema>,
+    Simplify extends boolean = false,
+> = SimplifyIf<
+    {
+        where?: WhereInput<Schema, Model>;
+        skip?: number;
+        take?: number;
+        orderBy?: OrArray<OrderBy<Schema, Model, true, false>>;
+    } & {
+        _count?: true | CountAggregateInput<Schema, Model>;
+        _min?: MinMaxInput<Schema, Model, true>;
+        _max?: MinMaxInput<Schema, Model, true>;
+    } & (NumericFields<Schema, Model> extends never
+            ? {}
+            : {
+                  _avg?: SumAvgInput<Schema, Model, true>;
+                  _sum?: SumAvgInput<Schema, Model, true>;
+              }),
+    Simplify
+>;
 
 type NumericFields<Schema extends SchemaDef, Model extends GetModels<Schema>> = keyof {
     [Key in GetModelFields<Schema, Model> as GetModelFieldType<Schema, Model, Key> extends
@@ -1041,11 +1118,9 @@ type MinMaxInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Valu
           : Key]?: ValueType;
 };
 
-export type AggregateResult<
-    Schema extends SchemaDef,
-    Model extends GetModels<Schema>,
-    Args extends AggregateArgs<Schema, Model>,
-> = (Args extends { _count: infer Count }
+export type AggregateResult<Schema extends SchemaDef, _Model extends GetModels<Schema>, Args> = (Args extends {
+    _count: infer Count;
+}
     ? {
           _count: AggCommonOutput<Count>;
       }
@@ -1088,29 +1163,36 @@ type GroupByHaving<Schema extends SchemaDef, Model extends GetModels<Schema>> =
     '$expr'
 >;
 
-export type GroupByArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
-    where?: WhereInput<Schema, Model>;
-    orderBy?: OrArray<OrderBy<Schema, Model, false, true>>;
-    by: NonRelationFields<Schema, Model> | NonEmptyArray<NonRelationFields<Schema, Model>>;
-    having?: GroupByHaving<Schema, Model>;
-    take?: number;
-    skip?: number;
-    // aggregations
-    _count?: true | CountAggregateInput<Schema, Model>;
-    _min?: MinMaxInput<Schema, Model, true>;
-    _max?: MinMaxInput<Schema, Model, true>;
-} & (NumericFields<Schema, Model> extends never
-    ? {}
-    : {
-          // aggregations specific to numeric fields
-          _avg?: SumAvgInput<Schema, Model, true>;
-          _sum?: SumAvgInput<Schema, Model, true>;
-      });
+export type GroupByArgs<
+    Schema extends SchemaDef,
+    Model extends GetModels<Schema>,
+    Simplify extends boolean = false,
+> = SimplifyIf<
+    {
+        where?: WhereInput<Schema, Model>;
+        orderBy?: OrArray<OrderBy<Schema, Model, false, true>>;
+        by: NonRelationFields<Schema, Model> | NonEmptyArray<NonRelationFields<Schema, Model>>;
+        having?: GroupByHaving<Schema, Model>;
+        take?: number;
+        skip?: number;
+        // aggregations
+        _count?: true | CountAggregateInput<Schema, Model>;
+        _min?: MinMaxInput<Schema, Model, true>;
+        _max?: MinMaxInput<Schema, Model, true>;
+    } & (NumericFields<Schema, Model> extends never
+        ? {}
+        : {
+              // aggregations specific to numeric fields
+              _avg?: SumAvgInput<Schema, Model, true>;
+              _sum?: SumAvgInput<Schema, Model, true>;
+          }),
+    Simplify
+>;
 
 export type GroupByResult<
     Schema extends SchemaDef,
     Model extends GetModels<Schema>,
-    Args extends GroupByArgs<Schema, Model>,
+    Args extends { by: unknown },
 > = Array<
     {
         [Key in NonRelationFields<Schema, Model> as Key extends ValueOfPotentialTuple<Args['by']>
diff --git a/packages/orm/src/client/crud/validator/index.ts b/packages/orm/src/client/crud/validator/index.ts
index 4cd9c584..dc3e9f5f 100644
--- a/packages/orm/src/client/crud/validator/index.ts
+++ b/packages/orm/src/client/crud/validator/index.ts
@@ -65,14 +65,18 @@ export class InputValidator<Schema extends SchemaDef> {
         return this.client.$options.validateInput !== false;
     }
 
-    validateFindArgs(model: GetModels<Schema>, args: unknown, options: { unique: boolean; findOne: boolean }) {
+    validateFindArgs(
+        model: GetModels<Schema>,
+        args: unknown,
+        options: { unique: boolean; findOne: boolean },
+    ): FindArgs<Schema, GetModels<Schema>, true> | undefined {
         return this.validate<
             FindArgs<Schema, GetModels<Schema>, true> | undefined,
             Parameters<typeof this.makeFindSchema>[1]
         >(model, 'find', options, (model, options) => this.makeFindSchema(model, options), args);
     }
 
-    validateCreateArgs(model: GetModels<Schema>, args: unknown) {
+    validateCreateArgs(model: GetModels<Schema>, args: unknown): CreateArgs<Schema, GetModels<Schema>> {
         return this.validate<CreateArgs<Schema, GetModels<Schema>>>(
             model,
             'create',
@@ -82,8 +86,8 @@ export class InputValidator<Schema extends SchemaDef> {
         );
     }
 
-    validateCreateManyArgs(model: GetModels<Schema>, args: unknown) {
-        return this.validate<CreateManyArgs<Schema, GetModels<Schema>>, undefined>(
+    validateCreateManyArgs(model: GetModels<Schema>, args: unknown): CreateManyArgs<Schema, GetModels<Schema>> {
+        return this.validate<CreateManyArgs<Schema, GetModels<Schema>>>(
             model,
             'createMany',
             undefined,
@@ -92,7 +96,10 @@ export class InputValidator<Schema extends SchemaDef> {
         );
     }
 
-    validateCreateManyAndReturnArgs(model: GetModels<Schema>, args: unknown) {
+    validateCreateManyAndReturnArgs(
+        model: GetModels<Schema>,
+        args: unknown,
+    ): CreateManyAndReturnArgs<Schema, GetModels<Schema>> | undefined {
         return this.validate<CreateManyAndReturnArgs<Schema, GetModels<Schema>> | undefined>(
             model,
             'createManyAndReturn',
@@ -102,7 +109,7 @@ export class InputValidator<Schema extends SchemaDef> {
         );
     }
 
-    validateUpdateArgs(model: GetModels<Schema>, args: unknown) {
+    validateUpdateArgs(model: GetModels<Schema>, args: unknown): UpdateArgs<Schema, GetModels<Schema>> {
         return this.validate<UpdateArgs<Schema, GetModels<Schema>>>(
             model,
             'update',
@@ -112,7 +119,7 @@ export class InputValidator<Schema extends SchemaDef> {
         );
     }
 
-    validateUpdateManyArgs(model: GetModels<Schema>, args: unknown) {
+    validateUpdateManyArgs(model: GetModels<Schema>, args: unknown): UpdateManyArgs<Schema, GetModels<Schema>> {
         return this.validate<UpdateManyArgs<Schema, GetModels<Schema>>>(
             model,
             'updateMany',
@@ -122,8 +129,11 @@ export class InputValidator<Schema extends SchemaDef> {
         );
     }
 
-    validateUpdateManyAndReturnArgs(model: GetModels<Schema>, args: unknown) {
-        return this.validate<UpdateManyAndReturnArgs<Schema, GetModels<Schema>> | undefined>(
+    validateUpdateManyAndReturnArgs(
+        model: GetModels<Schema>,
+        args: unknown,
+    ): UpdateManyAndReturnArgs<Schema, GetModels<Schema>> {
+        return this.validate<UpdateManyAndReturnArgs<Schema, GetModels<Schema>>>(
             model,
             'updateManyAndReturn',
             undefined,
@@ -132,7 +142,7 @@ export class InputValidator<Schema extends SchemaDef> {
         );
     }
 
-    validateUpsertArgs(model: GetModels<Schema>, args: unknown) {
+    validateUpsertArgs(model: GetModels<Schema>, args: unknown): UpsertArgs<Schema, GetModels<Schema>> {
         return this.validate<UpsertArgs<Schema, GetModels<Schema>>>(
             model,
             'upsert',
@@ -142,7 +152,7 @@ export class InputValidator<Schema extends SchemaDef> {
         );
     }
 
-    validateDeleteArgs(model: GetModels<Schema>, args: unknown) {
+    validateDeleteArgs(model: GetModels<Schema>, args: unknown): DeleteArgs<Schema, GetModels<Schema>> {
         return this.validate<DeleteArgs<Schema, GetModels<Schema>>>(
             model,
             'delete',
@@ -152,7 +162,10 @@ export class InputValidator<Schema extends SchemaDef> {
         );
     }
 
-    validateDeleteManyArgs(model: GetModels<Schema>, args: unknown) {
+    validateDeleteManyArgs(
+        model: GetModels<Schema>,
+        args: unknown,
+    ): DeleteManyArgs<Schema, GetModels<Schema>> | undefined {
         return this.validate<DeleteManyArgs<Schema, GetModels<Schema>> | undefined>(
             model,
             'deleteMany',
@@ -162,8 +175,8 @@ export class InputValidator<Schema extends SchemaDef> {
         );
     }
 
-    validateCountArgs(model: GetModels<Schema>, args: unknown) {
-        return this.validate<CountArgs<Schema, GetModels<Schema>> | undefined, undefined>(
+    validateCountArgs(model: GetModels<Schema>, args: unknown): CountArgs<Schema, GetModels<Schema>> | undefined {
+        return this.validate<CountArgs<Schema, GetModels<Schema>> | undefined>(
             model,
             'count',
             undefined,
@@ -172,8 +185,8 @@ export class InputValidator<Schema extends SchemaDef> {
         );
     }
 
-    validateAggregateArgs(model: GetModels<Schema>, args: unknown) {
-        return this.validate<AggregateArgs<Schema, GetModels<Schema>>, undefined>(
+    validateAggregateArgs(model: GetModels<Schema>, args: unknown): AggregateArgs<Schema, GetModels<Schema>> {
+        return this.validate<AggregateArgs<Schema, GetModels<Schema>>>(
             model,
             'aggregate',
             undefined,
@@ -182,8 +195,8 @@ export class InputValidator<Schema extends SchemaDef> {
         );
     }
 
-    validateGroupByArgs(model: GetModels<Schema>, args: unknown) {
-        return this.validate<GroupByArgs<Schema, GetModels<Schema>>, undefined>(
+    validateGroupByArgs(model: GetModels<Schema>, args: unknown): GroupByArgs<Schema, GetModels<Schema>> {
+        return this.validate<GroupByArgs<Schema, GetModels<Schema>>>(
             model,
             'groupBy',
             undefined,
diff --git a/packages/orm/src/utils/type-utils.ts b/packages/orm/src/utils/type-utils.ts
index e5cd1f33..47b4e095 100644
--- a/packages/orm/src/utils/type-utils.ts
+++ b/packages/orm/src/utils/type-utils.ts
@@ -16,6 +16,8 @@ export type Simplify<T, D extends number = 6> = D extends 0
           : { [K in keyof T]: Simplify<T[K], _Depth[D]> } & {}
       : T;
 
+export type SimplifyIf<T, Condition extends boolean> = Condition extends true ? Simplify<T> : T;
+
 export type WrapType<T, Optional = false, Array = false> = Array extends true
     ? Optional extends true
         ? T[] | null