From 04dc3ca960a042a3abb772e6b6c279b62630a4ef Mon Sep 17 00:00:00 2001
From: ymc9 <104139426+ymc9@users.noreply.github.com>
Date: Fri, 14 Nov 2025 22:36:55 -0800
Subject: [PATCH 1/3] fix(orm): reimplement typescript type display
 simplification

---
 packages/clients/tanstack-query/src/react.ts  |  46 +--
 packages/clients/tanstack-query/src/svelte.ts |  32 +-
 packages/clients/tanstack-query/src/vue.ts    |  32 +-
 .../test/schemas/basic/schema-lite.ts         |   8 +-
 packages/orm/src/client/contract.ts           |  34 +-
 packages/orm/src/client/crud-types.ts         | 322 ++++++------------
 .../src/client/crud/dialects/base-dialect.ts  |  16 +-
 packages/sdk/src/ts-schema-generator.ts       |  54 ++-
 samples/next.js/zenstack/schema-lite.ts       |   8 +-
 samples/next.js/zenstack/schema.ts            |   8 +-
 samples/orm/zenstack/schema.ts                |   8 +-
 tests/e2e/apps/rally/zenstack/schema.ts       |   8 +-
 tests/e2e/orm/schemas/basic/schema.ts         |   8 +-
 tests/e2e/orm/schemas/default-auth/schema.ts  |   8 +-
 tests/e2e/orm/schemas/delegate/schema.ts      |   8 +-
 tests/e2e/orm/schemas/name-mapping/schema.ts  |   8 +-
 tests/e2e/orm/schemas/petstore/schema.ts      |   8 +-
 tests/e2e/orm/schemas/todo/schema.ts          |   8 +-
 tests/e2e/orm/schemas/typing/schema.ts        |   8 +-
 19 files changed, 311 insertions(+), 321 deletions(-)

diff --git a/packages/clients/tanstack-query/src/react.ts b/packages/clients/tanstack-query/src/react.ts
index b5763ce3..92af99b5 100644
--- a/packages/clients/tanstack-query/src/react.ts
+++ b/packages/clients/tanstack-query/src/react.ts
@@ -145,108 +145,108 @@ export type ModelQueryHooks<Schema extends SchemaDef, Model extends GetModels<Sc
     Schema,
     Model,
     {
-        useFindUnique<T extends FindUniqueArgs<Schema, Model, true>>(
+        useFindUnique<T extends FindUniqueArgs<Schema, Model>>(
             args: SelectSubset<T, FindUniqueArgs<Schema, Model>>,
             options?: ModelQueryOptions<SimplifiedModelResult<Schema, Model, T> | null>,
         ): ModelQueryResult<SimplifiedModelResult<Schema, Model, T> | null>;
 
-        useSuspenseFindUnique<T extends FindUniqueArgs<Schema, Model, true>>(
+        useSuspenseFindUnique<T extends FindUniqueArgs<Schema, Model>>(
             args: SelectSubset<T, FindUniqueArgs<Schema, Model>>,
             options?: ModelSuspenseQueryOptions<SimplifiedModelResult<Schema, Model, T> | null>,
         ): ModelSuspenseQueryResult<SimplifiedModelResult<Schema, Model, T> | null>;
 
-        useFindFirst<T extends FindFirstArgs<Schema, Model, true>>(
+        useFindFirst<T extends FindFirstArgs<Schema, Model>>(
             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>>(
+        useSuspenseFindFirst<T extends FindFirstArgs<Schema, Model>>(
             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>>(
+        useFindMany<T extends FindManyArgs<Schema, Model>>(
             args?: SelectSubset<T, FindManyArgs<Schema, Model>>,
             options?: ModelQueryOptions<SimplifiedModelResult<Schema, Model, T>[]>,
         ): ModelQueryResult<SimplifiedModelResult<Schema, Model, T>[]>;
 
-        useSuspenseFindMany<T extends FindManyArgs<Schema, Model, true>>(
+        useSuspenseFindMany<T extends FindManyArgs<Schema, Model>>(
             args?: SelectSubset<T, FindManyArgs<Schema, Model>>,
             options?: ModelSuspenseQueryOptions<SimplifiedModelResult<Schema, Model, T>[]>,
         ): ModelSuspenseQueryResult<SimplifiedModelResult<Schema, Model, T>[]>;
 
-        useInfiniteFindMany<T extends FindManyArgs<Schema, Model, true>>(
+        useInfiniteFindMany<T extends FindManyArgs<Schema, Model>>(
             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>>(
+        useSuspenseInfiniteFindMany<T extends FindManyArgs<Schema, Model>>(
             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>>(
+        useCreate<T extends CreateArgs<Schema, Model>>(
             options?: ModelMutationOptions<SimplifiedModelResult<Schema, Model, T>, T>,
         ): ModelMutationModelResult<Schema, Model, T>;
 
-        useCreateMany<T extends CreateManyArgs<Schema, Model, true>>(
+        useCreateMany<T extends CreateManyArgs<Schema, Model>>(
             options?: ModelMutationOptions<BatchResult, T>,
         ): ModelMutationResult<BatchResult, T>;
 
-        useCreateManyAndReturn<T extends CreateManyAndReturnArgs<Schema, Model, true>>(
+        useCreateManyAndReturn<T extends CreateManyAndReturnArgs<Schema, Model>>(
             options?: ModelMutationOptions<SimplifiedModelResult<Schema, Model, T>[], T>,
         ): ModelMutationModelResult<Schema, Model, T, true>;
 
-        useUpdate<T extends UpdateArgs<Schema, Model, true>>(
+        useUpdate<T extends UpdateArgs<Schema, Model>>(
             options?: ModelMutationOptions<SimplifiedModelResult<Schema, Model, T>, T>,
         ): ModelMutationModelResult<Schema, Model, T>;
 
-        useUpdateMany<T extends UpdateManyArgs<Schema, Model, true>>(
+        useUpdateMany<T extends UpdateManyArgs<Schema, Model>>(
             options?: ModelMutationOptions<BatchResult, T>,
         ): ModelMutationResult<BatchResult, T>;
 
-        useUpdateManyAndReturn<T extends UpdateManyAndReturnArgs<Schema, Model, true>>(
+        useUpdateManyAndReturn<T extends UpdateManyAndReturnArgs<Schema, Model>>(
             options?: ModelMutationOptions<SimplifiedModelResult<Schema, Model, T>[], T>,
         ): ModelMutationModelResult<Schema, Model, T, true>;
 
-        useUpsert<T extends UpsertArgs<Schema, Model, true>>(
+        useUpsert<T extends UpsertArgs<Schema, Model>>(
             options?: ModelMutationOptions<SimplifiedModelResult<Schema, Model, T>, T>,
         ): ModelMutationModelResult<Schema, Model, T>;
 
-        useDelete<T extends DeleteArgs<Schema, Model, true>>(
+        useDelete<T extends DeleteArgs<Schema, Model>>(
             options?: ModelMutationOptions<SimplifiedModelResult<Schema, Model, T>, T>,
         ): ModelMutationModelResult<Schema, Model, T>;
 
-        useDeleteMany<T extends DeleteManyArgs<Schema, Model, true>>(
+        useDeleteMany<T extends DeleteManyArgs<Schema, Model>>(
             options?: ModelMutationOptions<BatchResult, T>,
         ): ModelMutationResult<BatchResult, T>;
 
-        useCount<T extends CountArgs<Schema, Model, true>>(
+        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, true>>(
+        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, true>>(
+        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, true>>(
+        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, true>>(
+        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, true>>(
+        useSuspenseGroupBy<T extends GroupByArgs<Schema, Model>>(
             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 e05840a2..8b40750c 100644
--- a/packages/clients/tanstack-query/src/svelte.ts
+++ b/packages/clients/tanstack-query/src/svelte.ts
@@ -138,73 +138,73 @@ export type ModelQueryHooks<Schema extends SchemaDef, Model extends GetModels<Sc
     Schema,
     Model,
     {
-        useFindUnique<T extends FindUniqueArgs<Schema, Model, true>>(
+        useFindUnique<T extends FindUniqueArgs<Schema, Model>>(
             args: SelectSubset<T, FindUniqueArgs<Schema, Model>>,
             options?: ModelQueryOptions<SimplifiedModelResult<Schema, Model, T> | null>,
         ): ModelQueryResult<SimplifiedModelResult<Schema, Model, T> | null>;
 
-        useFindFirst<T extends FindFirstArgs<Schema, Model, true>>(
+        useFindFirst<T extends FindFirstArgs<Schema, Model>>(
             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>>(
+        useFindMany<T extends FindManyArgs<Schema, Model>>(
             args?: SelectSubset<T, FindManyArgs<Schema, Model>>,
             options?: ModelQueryOptions<SimplifiedModelResult<Schema, Model, T>[]>,
         ): ModelQueryResult<SimplifiedModelResult<Schema, Model, T>[]>;
 
-        useInfiniteFindMany<T extends FindManyArgs<Schema, Model, true>>(
+        useInfiniteFindMany<T extends FindManyArgs<Schema, Model>>(
             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>>(
+        useCreate<T extends CreateArgs<Schema, Model>>(
             options?: ModelMutationOptions<SimplifiedModelResult<Schema, Model, T>, T>,
         ): ModelMutationModelResult<Schema, Model, T>;
 
-        useCreateMany<T extends CreateManyArgs<Schema, Model, true>>(
+        useCreateMany<T extends CreateManyArgs<Schema, Model>>(
             options?: ModelMutationOptions<BatchResult, T>,
         ): ModelMutationResult<BatchResult, T>;
 
-        useCreateManyAndReturn<T extends CreateManyAndReturnArgs<Schema, Model, true>>(
+        useCreateManyAndReturn<T extends CreateManyAndReturnArgs<Schema, Model>>(
             options?: ModelMutationOptions<SimplifiedModelResult<Schema, Model, T>[], T>,
         ): ModelMutationModelResult<Schema, Model, T, true>;
 
-        useUpdate<T extends UpdateArgs<Schema, Model, true>>(
+        useUpdate<T extends UpdateArgs<Schema, Model>>(
             options?: ModelMutationOptions<SimplifiedModelResult<Schema, Model, T>, T>,
         ): ModelMutationModelResult<Schema, Model, T>;
 
-        useUpdateMany<T extends UpdateManyArgs<Schema, Model, true>>(
+        useUpdateMany<T extends UpdateManyArgs<Schema, Model>>(
             options?: ModelMutationOptions<BatchResult, T>,
         ): ModelMutationResult<BatchResult, T>;
 
-        useUpdateManyAndReturn<T extends UpdateManyAndReturnArgs<Schema, Model, true>>(
+        useUpdateManyAndReturn<T extends UpdateManyAndReturnArgs<Schema, Model>>(
             options?: ModelMutationOptions<SimplifiedModelResult<Schema, Model, T>[], T>,
         ): ModelMutationModelResult<Schema, Model, T, true>;
 
-        useUpsert<T extends UpsertArgs<Schema, Model, true>>(
+        useUpsert<T extends UpsertArgs<Schema, Model>>(
             options?: ModelMutationOptions<SimplifiedModelResult<Schema, Model, T>, T>,
         ): ModelMutationModelResult<Schema, Model, T>;
 
-        useDelete<T extends DeleteArgs<Schema, Model, true>>(
+        useDelete<T extends DeleteArgs<Schema, Model>>(
             options?: ModelMutationOptions<SimplifiedModelResult<Schema, Model, T>, T>,
         ): ModelMutationModelResult<Schema, Model, T>;
 
-        useDeleteMany<T extends DeleteManyArgs<Schema, Model, true>>(
+        useDeleteMany<T extends DeleteManyArgs<Schema, Model>>(
             options?: ModelMutationOptions<BatchResult, T>,
         ): ModelMutationResult<BatchResult, T>;
 
-        useCount<T extends CountArgs<Schema, Model, true>>(
+        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, true>>(
+        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, true>>(
+        useGroupBy<T extends GroupByArgs<Schema, Model>>(
             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 5c71f319..e5051426 100644
--- a/packages/clients/tanstack-query/src/vue.ts
+++ b/packages/clients/tanstack-query/src/vue.ts
@@ -122,73 +122,73 @@ export type ModelQueryHooks<Schema extends SchemaDef, Model extends GetModels<Sc
     Schema,
     Model,
     {
-        useFindUnique<T extends FindUniqueArgs<Schema, Model, true>>(
+        useFindUnique<T extends FindUniqueArgs<Schema, Model>>(
             args: SelectSubset<T, FindUniqueArgs<Schema, Model>>,
             options?: ModelQueryOptions<SimplifiedModelResult<Schema, Model, T> | null>,
         ): ModelQueryResult<SimplifiedModelResult<Schema, Model, T> | null>;
 
-        useFindFirst<T extends FindFirstArgs<Schema, Model, true>>(
+        useFindFirst<T extends FindFirstArgs<Schema, Model>>(
             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>>(
+        useFindMany<T extends FindManyArgs<Schema, Model>>(
             args?: SelectSubset<T, FindManyArgs<Schema, Model>>,
             options?: ModelQueryOptions<SimplifiedModelResult<Schema, Model, T>[]>,
         ): ModelQueryResult<SimplifiedModelResult<Schema, Model, T>[]>;
 
-        useInfiniteFindMany<T extends FindManyArgs<Schema, Model, true>>(
+        useInfiniteFindMany<T extends FindManyArgs<Schema, Model>>(
             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>>(
+        useCreate<T extends CreateArgs<Schema, Model>>(
             options?: ModelMutationOptions<SimplifiedModelResult<Schema, Model, T>, T>,
         ): ModelMutationModelResult<Schema, Model, T>;
 
-        useCreateMany<T extends CreateManyArgs<Schema, Model, true>>(
+        useCreateMany<T extends CreateManyArgs<Schema, Model>>(
             options?: ModelMutationOptions<BatchResult, T>,
         ): ModelMutationResult<BatchResult, T>;
 
-        useCreateManyAndReturn<T extends CreateManyAndReturnArgs<Schema, Model, true>>(
+        useCreateManyAndReturn<T extends CreateManyAndReturnArgs<Schema, Model>>(
             options?: ModelMutationOptions<SimplifiedModelResult<Schema, Model, T>[], T>,
         ): ModelMutationModelResult<Schema, Model, T, true>;
 
-        useUpdate<T extends UpdateArgs<Schema, Model, true>>(
+        useUpdate<T extends UpdateArgs<Schema, Model>>(
             options?: ModelMutationOptions<SimplifiedModelResult<Schema, Model, T>, T>,
         ): ModelMutationModelResult<Schema, Model, T>;
 
-        useUpdateMany<T extends UpdateManyArgs<Schema, Model, true>>(
+        useUpdateMany<T extends UpdateManyArgs<Schema, Model>>(
             options?: ModelMutationOptions<BatchResult, T>,
         ): ModelMutationResult<BatchResult, T>;
 
-        useUpdateManyAndReturn<T extends UpdateManyAndReturnArgs<Schema, Model, true>>(
+        useUpdateManyAndReturn<T extends UpdateManyAndReturnArgs<Schema, Model>>(
             options?: ModelMutationOptions<SimplifiedModelResult<Schema, Model, T>[], T>,
         ): ModelMutationModelResult<Schema, Model, T, true>;
 
-        useUpsert<T extends UpsertArgs<Schema, Model, true>>(
+        useUpsert<T extends UpsertArgs<Schema, Model>>(
             options?: ModelMutationOptions<SimplifiedModelResult<Schema, Model, T>, T>,
         ): ModelMutationModelResult<Schema, Model, T>;
 
-        useDelete<T extends DeleteArgs<Schema, Model, true>>(
+        useDelete<T extends DeleteArgs<Schema, Model>>(
             options?: ModelMutationOptions<SimplifiedModelResult<Schema, Model, T>, T>,
         ): ModelMutationModelResult<Schema, Model, T>;
 
-        useDeleteMany<T extends DeleteManyArgs<Schema, Model, true>>(
+        useDeleteMany<T extends DeleteManyArgs<Schema, Model>>(
             options?: ModelMutationOptions<BatchResult, T>,
         ): ModelMutationResult<BatchResult, T>;
 
-        useCount<T extends CountArgs<Schema, Model, true>>(
+        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, true>>(
+        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, true>>(
+        useGroupBy<T extends GroupByArgs<Schema, Model>>(
             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/schemas/basic/schema-lite.ts b/packages/clients/tanstack-query/test/schemas/basic/schema-lite.ts
index ea44666f..3d826024 100644
--- a/packages/clients/tanstack-query/test/schemas/basic/schema-lite.ts
+++ b/packages/clients/tanstack-query/test/schemas/basic/schema-lite.ts
@@ -6,7 +6,7 @@
 /* eslint-disable */
 
 import { type SchemaDef, ExpressionUtils } from "@zenstackhq/orm/schema";
-export const schema = {
+const _schema = {
     provider: {
         type: "sqlite"
     },
@@ -169,4 +169,8 @@ export const schema = {
     authType: "User",
     plugins: {}
 } as const satisfies SchemaDef;
-export type SchemaType = typeof schema;
+type Schema = typeof _schema & {
+    __brand?: "schema";
+};
+export const schema: Schema = _schema;
+export type SchemaType = Schema;
diff --git a/packages/orm/src/client/contract.ts b/packages/orm/src/client/contract.ts
index 7f1fd48c..6db19953 100644
--- a/packages/orm/src/client/contract.ts
+++ b/packages/orm/src/client/contract.ts
@@ -325,7 +325,7 @@ export type AllModelOperations<Schema extends SchemaDef, Model extends GetModels
      * }); // result: `{ _count: { posts: number } }`
      * ```
      */
-    findMany<T extends FindManyArgs<Schema, Model, true>>(
+    findMany<T extends FindManyArgs<Schema, Model>>(
         args?: SelectSubset<T, FindManyArgs<Schema, Model>>,
     ): ZenStackPromise<Schema, SimplifiedModelResult<Schema, Model, T>[]>;
 
@@ -335,7 +335,7 @@ 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, true>>(
+    findUnique<T extends FindUniqueArgs<Schema, Model>>(
         args: SelectSubset<T, FindUniqueArgs<Schema, Model>>,
     ): ZenStackPromise<Schema, SimplifiedModelResult<Schema, Model, T> | null>;
 
@@ -345,7 +345,7 @@ export type AllModelOperations<Schema extends SchemaDef, Model extends GetModels
      * @returns a single entity
      * @see {@link findMany}
      */
-    findUniqueOrThrow<T extends FindUniqueArgs<Schema, Model, true>>(
+    findUniqueOrThrow<T extends FindUniqueArgs<Schema, Model>>(
         args: SelectSubset<T, FindUniqueArgs<Schema, Model>>,
     ): ZenStackPromise<Schema, SimplifiedModelResult<Schema, Model, T>>;
 
@@ -355,7 +355,7 @@ export type AllModelOperations<Schema extends SchemaDef, Model extends GetModels
      * @returns a single entity or null if not found
      * @see {@link findMany}
      */
-    findFirst<T extends FindFirstArgs<Schema, Model, true>>(
+    findFirst<T extends FindFirstArgs<Schema, Model>>(
         args?: SelectSubset<T, FindFirstArgs<Schema, Model>>,
     ): ZenStackPromise<Schema, SimplifiedModelResult<Schema, Model, T> | null>;
 
@@ -365,7 +365,7 @@ export type AllModelOperations<Schema extends SchemaDef, Model extends GetModels
      * @returns a single entity
      * @see {@link findMany}
      */
-    findFirstOrThrow<T extends FindFirstArgs<Schema, Model, true>>(
+    findFirstOrThrow<T extends FindFirstArgs<Schema, Model>>(
         args?: SelectSubset<T, FindFirstArgs<Schema, Model>>,
     ): ZenStackPromise<Schema, SimplifiedModelResult<Schema, Model, T>>;
 
@@ -421,7 +421,7 @@ export type AllModelOperations<Schema extends SchemaDef, Model extends GetModels
      * });
      * ```
      */
-    create<T extends CreateArgs<Schema, Model, true>>(
+    create<T extends CreateArgs<Schema, Model>>(
         args: SelectSubset<T, CreateArgs<Schema, Model>>,
     ): ZenStackPromise<Schema, SimplifiedModelResult<Schema, Model, T>>;
 
@@ -450,7 +450,7 @@ export type AllModelOperations<Schema extends SchemaDef, Model extends GetModels
      * });
      * ```
      */
-    createMany<T extends CreateManyArgs<Schema, Model, true>>(
+    createMany<T extends CreateManyArgs<Schema, Model>>(
         args?: SelectSubset<T, CreateManyArgs<Schema, Model>>,
     ): ZenStackPromise<Schema, BatchResult>;
 
@@ -472,7 +472,7 @@ export type AllModelOperations<Schema extends SchemaDef, Model extends GetModels
      * });
      * ```
      */
-    createManyAndReturn<T extends CreateManyAndReturnArgs<Schema, Model, true>>(
+    createManyAndReturn<T extends CreateManyAndReturnArgs<Schema, Model>>(
         args?: SelectSubset<T, CreateManyAndReturnArgs<Schema, Model>>,
     ): ZenStackPromise<Schema, SimplifiedModelResult<Schema, Model, T>[]>;
 
@@ -593,7 +593,7 @@ export type AllModelOperations<Schema extends SchemaDef, Model extends GetModels
      * });
      * ```
      */
-    update<T extends UpdateArgs<Schema, Model, true>>(
+    update<T extends UpdateArgs<Schema, Model>>(
         args: SelectSubset<T, UpdateArgs<Schema, Model>>,
     ): ZenStackPromise<Schema, SimplifiedModelResult<Schema, Model, T>>;
 
@@ -617,7 +617,7 @@ export type AllModelOperations<Schema extends SchemaDef, Model extends GetModels
      *     limit: 10
      * });
      */
-    updateMany<T extends UpdateManyArgs<Schema, Model, true>>(
+    updateMany<T extends UpdateManyArgs<Schema, Model>>(
         args: Subset<T, UpdateManyArgs<Schema, Model>>,
     ): ZenStackPromise<Schema, BatchResult>;
 
@@ -643,7 +643,7 @@ export type AllModelOperations<Schema extends SchemaDef, Model extends GetModels
      * });
      * ```
      */
-    updateManyAndReturn<T extends UpdateManyAndReturnArgs<Schema, Model, true>>(
+    updateManyAndReturn<T extends UpdateManyAndReturnArgs<Schema, Model>>(
         args: Subset<T, UpdateManyAndReturnArgs<Schema, Model>>,
     ): ZenStackPromise<Schema, SimplifiedModelResult<Schema, Model, T>[]>;
 
@@ -667,7 +667,7 @@ export type AllModelOperations<Schema extends SchemaDef, Model extends GetModels
      * });
      * ```
      */
-    upsert<T extends UpsertArgs<Schema, Model, true>>(
+    upsert<T extends UpsertArgs<Schema, Model>>(
         args: SelectSubset<T, UpsertArgs<Schema, Model>>,
     ): ZenStackPromise<Schema, SimplifiedModelResult<Schema, Model, T>>;
 
@@ -690,7 +690,7 @@ export type AllModelOperations<Schema extends SchemaDef, Model extends GetModels
      * }); // result: `{ id: string; email: string }`
      * ```
      */
-    delete<T extends DeleteArgs<Schema, Model, true>>(
+    delete<T extends DeleteArgs<Schema, Model>>(
         args: SelectSubset<T, DeleteArgs<Schema, Model>>,
     ): ZenStackPromise<Schema, SimplifiedModelResult<Schema, Model, T>>;
 
@@ -713,7 +713,7 @@ export type AllModelOperations<Schema extends SchemaDef, Model extends GetModels
      * });
      * ```
      */
-    deleteMany<T extends DeleteManyArgs<Schema, Model, true>>(
+    deleteMany<T extends DeleteManyArgs<Schema, Model>>(
         args?: Subset<T, DeleteManyArgs<Schema, Model>>,
     ): ZenStackPromise<Schema, BatchResult>;
 
@@ -735,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, true>>(
+    count<T extends CountArgs<Schema, Model>>(
         args?: Subset<T, CountArgs<Schema, Model>>,
     ): ZenStackPromise<Schema, Simplify<CountResult<Schema, Model, T>>>;
 
@@ -756,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, true>>(
+    aggregate<T extends AggregateArgs<Schema, Model>>(
         args: Subset<T, AggregateArgs<Schema, Model>>,
     ): ZenStackPromise<Schema, Simplify<AggregateResult<Schema, Model, T>>>;
 
@@ -793,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, true>>(
+    groupBy<T extends GroupByArgs<Schema, Model>>(
         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 944d6881..f4b5cd06 100644
--- a/packages/orm/src/client/crud-types.ts
+++ b/packages/orm/src/client/crud-types.ts
@@ -39,7 +39,6 @@ import type {
     Optional,
     OrArray,
     Simplify,
-    SimplifyIf,
     ValueOfPotentialTuple,
     WrapType,
     XOR,
@@ -230,7 +229,6 @@ export type WhereInput<
               >
             : // primitive
               PrimitiveFilter<
-                  Schema,
                   GetModelFieldType<Schema, Model, Key>,
                   ModelFieldIsOptional<Schema, Model, Key>,
                   WithAggregations
@@ -257,7 +255,7 @@ type EnumFilter<
           not?: EnumFilter<Schema, T, Nullable, WithAggregations>;
       } & (WithAggregations extends true
           ? {
-                _count?: NumberFilter<Schema, 'Int', false, false>;
+                _count?: NumberFilter<'Int', false, false>;
                 _min?: EnumFilter<Schema, T, false, false>;
                 _max?: EnumFilter<Schema, T, false, false>;
             }
@@ -275,27 +273,21 @@ type ArrayFilter<Schema extends SchemaDef, T extends string> = {
 type MapScalarType<Schema extends SchemaDef, T extends string> =
     T extends GetEnums<Schema> ? keyof GetEnum<Schema, T> : MapBaseType<T>;
 
-type PrimitiveFilter<
-    Schema extends SchemaDef,
-    T extends string,
-    Nullable extends boolean,
-    WithAggregations extends boolean,
-> = T extends 'String'
-    ? StringFilter<Schema, Nullable, WithAggregations>
+type PrimitiveFilter<T extends string, Nullable extends boolean, WithAggregations extends boolean> = T extends 'String'
+    ? StringFilter<Nullable, WithAggregations>
     : T extends 'Int' | 'Float' | 'Decimal' | 'BigInt'
-      ? NumberFilter<Schema, T, Nullable, WithAggregations>
+      ? NumberFilter<T, Nullable, WithAggregations>
       : T extends 'Boolean'
-        ? BooleanFilter<Schema, Nullable, WithAggregations>
+        ? BooleanFilter<Nullable, WithAggregations>
         : T extends 'DateTime'
-          ? DateTimeFilter<Schema, Nullable, WithAggregations>
+          ? DateTimeFilter<Nullable, WithAggregations>
           : T extends 'Bytes'
-            ? BytesFilter<Schema, Nullable, WithAggregations>
+            ? BytesFilter<Nullable, WithAggregations>
             : T extends 'Json'
               ? 'Not implemented yet' // TODO: Json filter
               : never;
 
 type CommonPrimitiveFilter<
-    Schema extends SchemaDef,
     DataType,
     T extends BuiltinType,
     Nullable extends boolean,
@@ -308,82 +300,77 @@ type CommonPrimitiveFilter<
     lte?: DataType;
     gt?: DataType;
     gte?: DataType;
-    not?: PrimitiveFilter<Schema, T, Nullable, WithAggregations>;
+    not?: PrimitiveFilter<T, Nullable, WithAggregations>;
 };
 
-export type StringFilter<Schema extends SchemaDef, Nullable extends boolean, WithAggregations extends boolean> =
+export type StringFilter<Nullable extends boolean, WithAggregations extends boolean> =
     | NullableIf<string, Nullable>
-    | (CommonPrimitiveFilter<Schema, string, 'String', Nullable, WithAggregations> & {
+    | (CommonPrimitiveFilter<string, 'String', Nullable, WithAggregations> & {
           contains?: string;
           startsWith?: string;
           endsWith?: string;
+          mode?: 'default' | 'insensitive';
       } & (WithAggregations extends true
               ? {
-                    _count?: NumberFilter<Schema, 'Int', false, false>;
-                    _min?: StringFilter<Schema, false, false>;
-                    _max?: StringFilter<Schema, false, false>;
-                }
-              : {}) &
-          (ProviderSupportsCaseSensitivity<Schema> extends true
-              ? {
-                    mode?: 'default' | 'insensitive';
+                    _count?: NumberFilter<'Int', false, false>;
+                    _min?: StringFilter<false, false>;
+                    _max?: StringFilter<false, false>;
                 }
               : {}));
 
 export type NumberFilter<
-    Schema extends SchemaDef,
     T extends 'Int' | 'Float' | 'Decimal' | 'BigInt',
     Nullable extends boolean,
     WithAggregations extends boolean,
 > =
     | NullableIf<number | bigint, Nullable>
-    | (CommonPrimitiveFilter<Schema, number, T, Nullable, WithAggregations> &
+    | (CommonPrimitiveFilter<number, T, Nullable, WithAggregations> &
           (WithAggregations extends true
               ? {
-                    _count?: NumberFilter<Schema, 'Int', false, false>;
-                    _avg?: NumberFilter<Schema, T, false, false>;
-                    _sum?: NumberFilter<Schema, T, false, false>;
-                    _min?: NumberFilter<Schema, T, false, false>;
-                    _max?: NumberFilter<Schema, T, false, false>;
+                    _count?: NumberFilter<'Int', false, false>;
+                    _avg?: NumberFilter<T, false, false>;
+                    _sum?: NumberFilter<T, false, false>;
+                    _min?: NumberFilter<T, false, false>;
+                    _max?: NumberFilter<T, false, false>;
                 }
               : {}));
 
-export type DateTimeFilter<Schema extends SchemaDef, Nullable extends boolean, WithAggregations extends boolean> =
+export type DateTimeFilter<Nullable extends boolean, WithAggregations extends boolean> =
     | NullableIf<Date | string, Nullable>
-    | (CommonPrimitiveFilter<Schema, Date | string, 'DateTime', Nullable, WithAggregations> &
+    | (CommonPrimitiveFilter<Date | string, 'DateTime', Nullable, WithAggregations> &
           (WithAggregations extends true
               ? {
-                    _count?: NumberFilter<Schema, 'Int', false, false>;
-                    _min?: DateTimeFilter<Schema, false, false>;
-                    _max?: DateTimeFilter<Schema, false, false>;
+                    _count?: NumberFilter<'Int', false, false>;
+                    _min?: DateTimeFilter<false, false>;
+                    _max?: DateTimeFilter<false, false>;
                 }
               : {}));
 
-export type BytesFilter<Schema extends SchemaDef, Nullable extends boolean, WithAggregations extends boolean> =
+export type BytesFilter<Nullable extends boolean, WithAggregations extends boolean> =
     | NullableIf<Uint8Array | Buffer, Nullable>
     | ({
           equals?: NullableIf<Uint8Array, Nullable>;
           in?: Uint8Array[];
           notIn?: Uint8Array[];
-          not?: BytesFilter<Schema, Nullable, WithAggregations>;
+          not?: BytesFilter<Nullable, WithAggregations>;
       } & (WithAggregations extends true
           ? {
-                _count?: NumberFilter<Schema, 'Int', false, false>;
-                _min?: BytesFilter<Schema, false, false>;
-                _max?: BytesFilter<Schema, false, false>;
+                _count?: NumberFilter<'Int', false, false>;
+                _min?: BytesFilter<false, false>;
+                _max?: BytesFilter<false, false>;
             }
           : {}));
 
-export type BooleanFilter<Schema extends SchemaDef, Nullable extends boolean, WithAggregations extends boolean> =
+export type BooleanFilter<Nullable extends boolean, WithAggregations extends boolean> =
     | NullableIf<boolean, Nullable>
     | ({
           equals?: NullableIf<boolean, Nullable>;
-          not?: BooleanFilter<Schema, Nullable, WithAggregations>;
+          not?: BooleanFilter<Nullable, WithAggregations>;
       } & (WithAggregations extends true
           ? {
-                _count?: NumberFilter<Schema, 'Int', false, false>;
-                _min?: BooleanFilter<Schema, false, false>;
-                _max?: BooleanFilter<Schema, false, false>;
+                _count?: NumberFilter<'Int', false, false>;
+                _min?: BooleanFilter<false, false>;
+                _max?: BooleanFilter<false, false>;
             }
           : {}));
 
@@ -669,58 +656,29 @@ export type FindArgs<
               (AllowFilter extends true ? FilterArgs<Schema, Model> : {}) &
               SelectIncludeOmit<Schema, Model, Collection>;
 
-export type FindManyArgs<
-    Schema extends SchemaDef,
-    Model extends GetModels<Schema>,
-    Simplify extends boolean = false,
-> = SimplifyIf<FindArgs<Schema, Model, true>, Simplify>;
+export type FindManyArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = FindArgs<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 FindFirstArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = FindArgs<Schema, Model, true>;
 
-export type FindUniqueArgs<
-    Schema extends SchemaDef,
-    Model extends GetModels<Schema>,
-    Simplify extends boolean = false,
-> = SimplifyIf<
-    {
-        where?: WhereUniqueInput<Schema, Model>;
-    } & SelectIncludeOmit<Schema, Model, true>,
-    Simplify
->;
+export type FindUniqueArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
+    where?: WhereUniqueInput<Schema, Model>;
+} & SelectIncludeOmit<Schema, Model, true>;
 
 //#endregion
 
 //#region Create args
 
-export type CreateArgs<
-    Schema extends SchemaDef,
-    Model extends GetModels<Schema>,
-    Simplify extends boolean = false,
-> = SimplifyIf<
-    {
-        data: CreateInput<Schema, Model>;
-    } & SelectIncludeOmit<Schema, Model, true>,
-    Simplify
->;
+export type CreateArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
+    data: CreateInput<Schema, Model>;
+} & SelectIncludeOmit<Schema, Model, true>;
 
-export type CreateManyArgs<
-    Schema extends SchemaDef,
-    Model extends GetModels<Schema>,
-    Simplify extends boolean = false,
-> = SimplifyIf<CreateManyInput<Schema, Model>, Simplify>;
+export type CreateManyArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = CreateManyInput<Schema, Model>;
 
-export type CreateManyAndReturnArgs<
-    Schema extends SchemaDef,
-    Model extends GetModels<Schema>,
-    Simplify extends boolean = false,
-> = SimplifyIf<
-    CreateManyInput<Schema, Model> & Omit<SelectIncludeOmit<Schema, Model, false, false>, 'include'>,
-    Simplify
->;
+export type CreateManyAndReturnArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = CreateManyInput<
+    Schema,
+    Model
+> &
+    Omit<SelectIncludeOmit<Schema, Model, false, false>, 'include'>;
 
 type OptionalWrap<Schema extends SchemaDef, Model extends GetModels<Schema>, T extends object> = Optional<
     T,
@@ -846,51 +804,33 @@ type NestedCreateManyInput<
 
 // #region Update args
 
-export type UpdateArgs<
-    Schema extends SchemaDef,
-    Model extends GetModels<Schema>,
-    Simplify extends boolean = false,
-> = SimplifyIf<
-    {
-        data: UpdateInput<Schema, Model>;
-        where: WhereUniqueInput<Schema, Model>;
-    } & SelectIncludeOmit<Schema, Model, true>,
-    Simplify
->;
-
-export type UpdateManyArgs<
-    Schema extends SchemaDef,
-    Model extends GetModels<Schema>,
-    Simplify extends boolean = false,
-> = SimplifyIf<UpdateManyPayload<Schema, Model>, Simplify>;
+export type UpdateArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
+    data: UpdateInput<Schema, Model>;
+    where: WhereUniqueInput<Schema, Model>;
+} & SelectIncludeOmit<Schema, Model, true>;
 
-export type UpdateManyAndReturnArgs<
-    Schema extends SchemaDef,
-    Model extends GetModels<Schema>,
-    Simplify extends boolean = false,
-> = SimplifyIf<
-    UpdateManyPayload<Schema, Model> & Omit<SelectIncludeOmit<Schema, Model, false, false>, 'include'>,
-    Simplify
+export type UpdateManyArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = UpdateManyPayload<
+    Schema,
+    Model
 >;
 
+export type UpdateManyAndReturnArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = UpdateManyPayload<
+    Schema,
+    Model
+> &
+    Omit<SelectIncludeOmit<Schema, Model, false, false>, 'include'>;
+
 type UpdateManyPayload<Schema extends SchemaDef, Model extends GetModels<Schema>, Without extends string = never> = {
     data: OrArray<UpdateScalarInput<Schema, Model, Without>>;
     where?: WhereInput<Schema, Model>;
     limit?: number;
 };
 
-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>;
-    } & SelectIncludeOmit<Schema, Model, true>,
-    Simplify
->;
+export type UpsertArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
+    create: CreateInput<Schema, Model>;
+    update: UpdateInput<Schema, Model>;
+    where: WhereUniqueInput<Schema, Model>;
+} & SelectIncludeOmit<Schema, Model, true>;
 
 type UpdateScalarInput<
     Schema extends SchemaDef,
@@ -1002,43 +942,25 @@ type ToOneRelationUpdateInput<
 
 // #region Delete args
 
-export type DeleteArgs<
-    Schema extends SchemaDef,
-    Model extends GetModels<Schema>,
-    Simplify extends boolean = false,
-> = SimplifyIf<
-    {
-        where: WhereUniqueInput<Schema, Model>;
-    } & SelectIncludeOmit<Schema, Model, true>,
-    Simplify
->;
+export type DeleteArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
+    where: WhereUniqueInput<Schema, Model>;
+} & SelectIncludeOmit<Schema, Model, true>;
 
-export type DeleteManyArgs<
-    Schema extends SchemaDef,
-    Model extends GetModels<Schema>,
-    Simplify extends boolean = false,
-> = SimplifyIf<
-    {
-        where?: WhereInput<Schema, Model>;
-        limit?: number;
-    },
-    Simplify
->;
+export type DeleteManyArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
+    where?: WhereInput<Schema, Model>;
+    limit?: number;
+};
 
 // #endregion
 
 // #region Count args
 
-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
->;
+export type CountArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = Omit<
+    FindArgs<Schema, Model, true>,
+    'select' | 'include' | 'distinct' | 'omit'
+> & {
+    select?: CountAggregateInput<Schema, Model> | true;
+};
 
 type CountAggregateInput<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
     [Key in NonRelationFields<Schema, Model>]?: true;
@@ -1058,28 +980,21 @@ export type CountResult<Schema extends SchemaDef, _Model extends GetModels<Schem
 
 // #region Aggregate
 
-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
->;
+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>;
+          });
 
 type NumericFields<Schema extends SchemaDef, Model extends GetModels<Schema>> = keyof {
     [Key in GetModelFields<Schema, Model> as GetModelFieldType<Schema, Model, Key> extends
@@ -1150,31 +1065,24 @@ type GroupByHaving<Schema extends SchemaDef, Model extends GetModels<Schema>> =
     '$expr'
 >;
 
-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 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 GroupByResult<
     Schema extends SchemaDef,
@@ -1350,10 +1258,6 @@ type HasToManyRelations<Schema extends SchemaDef, Model extends GetModels<Schema
     ? false
     : true;
 
-type ProviderSupportsCaseSensitivity<Schema extends SchemaDef> = Schema['provider']['type'] extends 'postgresql'
-    ? true
-    : false;
-
 type ProviderSupportsDistinct<Schema extends SchemaDef> = Schema['provider']['type'] extends 'postgresql'
     ? true
     : false;
diff --git a/packages/orm/src/client/crud/dialects/base-dialect.ts b/packages/orm/src/client/crud/dialects/base-dialect.ts
index b9f557a7..2b96941e 100644
--- a/packages/orm/src/client/crud/dialects/base-dialect.ts
+++ b/packages/orm/src/client/crud/dialects/base-dialect.ts
@@ -604,7 +604,7 @@ export abstract class BaseCrudDialect<Schema extends SchemaDef> {
         return { conditions, consumedKeys };
     }
 
-    private buildStringFilter(fieldRef: Expression<any>, payload: StringFilter<Schema, true, boolean>) {
+    private buildStringFilter(fieldRef: Expression<any>, payload: StringFilter<true, boolean>) {
         let mode: 'default' | 'insensitive' | undefined;
         if (payload && typeof payload === 'object' && 'mode' in payload) {
             mode = payload.mode;
@@ -615,7 +615,7 @@ export abstract class BaseCrudDialect<Schema extends SchemaDef> {
             payload,
             mode === 'insensitive' ? this.eb.fn('lower', [fieldRef]) : fieldRef,
             (value) => this.prepStringCasing(this.eb, value, mode),
-            (value) => this.buildStringFilter(fieldRef, value as StringFilter<Schema, true, boolean>),
+            (value) => this.buildStringFilter(fieldRef, value as StringFilter<true, boolean>),
         );
 
         if (payload && typeof payload === 'object') {
@@ -683,38 +683,38 @@ export abstract class BaseCrudDialect<Schema extends SchemaDef> {
         return this.and(...conditions);
     }
 
-    private buildBooleanFilter(fieldRef: Expression<any>, payload: BooleanFilter<Schema, boolean, boolean>) {
+    private buildBooleanFilter(fieldRef: Expression<any>, payload: BooleanFilter<boolean, boolean>) {
         const { conditions } = this.buildStandardFilter(
             'Boolean',
             payload,
             fieldRef,
             (value) => this.transformPrimitive(value, 'Boolean', false),
-            (value) => this.buildBooleanFilter(fieldRef, value as BooleanFilter<Schema, boolean, boolean>),
+            (value) => this.buildBooleanFilter(fieldRef, value as BooleanFilter<boolean, boolean>),
             true,
             ['equals', 'not'],
         );
         return this.and(...conditions);
     }
 
-    private buildDateTimeFilter(fieldRef: Expression<any>, payload: DateTimeFilter<Schema, boolean, boolean>) {
+    private buildDateTimeFilter(fieldRef: Expression<any>, payload: DateTimeFilter<boolean, boolean>) {
         const { conditions } = this.buildStandardFilter(
             'DateTime',
             payload,
             fieldRef,
             (value) => this.transformPrimitive(value, 'DateTime', false),
-            (value) => this.buildDateTimeFilter(fieldRef, value as DateTimeFilter<Schema, boolean, boolean>),
+            (value) => this.buildDateTimeFilter(fieldRef, value as DateTimeFilter<boolean, boolean>),
             true,
         );
         return this.and(...conditions);
     }
 
-    private buildBytesFilter(fieldRef: Expression<any>, payload: BytesFilter<Schema, boolean, boolean>) {
+    private buildBytesFilter(fieldRef: Expression<any>, payload: BytesFilter<boolean, boolean>) {
         const conditions = this.buildStandardFilter(
             'Bytes',
             payload,
             fieldRef,
             (value) => this.transformPrimitive(value, 'Bytes', false),
-            (value) => this.buildBytesFilter(fieldRef, value as BytesFilter<Schema, boolean, boolean>),
+            (value) => this.buildBytesFilter(fieldRef, value as BytesFilter<boolean, boolean>),
             true,
             ['equals', 'in', 'notIn', 'not'],
         );
diff --git a/packages/sdk/src/ts-schema-generator.ts b/packages/sdk/src/ts-schema-generator.ts
index 798b6dfe..d1d19fe1 100644
--- a/packages/sdk/src/ts-schema-generator.ts
+++ b/packages/sdk/src/ts-schema-generator.ts
@@ -148,12 +148,13 @@ export class TsSchemaGenerator {
         );
         statements.push(runtimeImportDecl);
 
-        const declaration = ts.factory.createVariableStatement(
-            [ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)],
+        // const _schema = { ... } as const satisfies SchemaDef;
+        const _schemaDecl = ts.factory.createVariableStatement(
+            [],
             ts.factory.createVariableDeclarationList(
                 [
                     ts.factory.createVariableDeclaration(
-                        'schema',
+                        '_schema',
                         undefined,
                         undefined,
                         ts.factory.createSatisfiesExpression(
@@ -165,16 +166,53 @@ export class TsSchemaGenerator {
                 ts.NodeFlags.Const,
             ),
         );
-        statements.push(declaration);
+        statements.push(_schemaDecl);
+
+        // type Schema = typeof _schema & { __brand?: 'schema' };
+        // use a branded type to prevent typescript compiler from expanding the schema type
+        const brandedSchemaType = ts.factory.createTypeAliasDeclaration(
+            undefined,
+            'Schema',
+            undefined,
+            ts.factory.createIntersectionTypeNode([
+                ts.factory.createTypeQueryNode(ts.factory.createIdentifier('_schema')),
+                ts.factory.createTypeLiteralNode([
+                    ts.factory.createPropertySignature(
+                        undefined,
+                        '__brand',
+                        ts.factory.createToken(ts.SyntaxKind.QuestionToken),
+                        ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral('schema')),
+                    ),
+                ]),
+            ]),
+        );
+        statements.push(brandedSchemaType);
+
+        // export const schema: Schema = _schema;
+        const schemaExportDecl = ts.factory.createVariableStatement(
+            [ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)],
+            ts.factory.createVariableDeclarationList(
+                [
+                    ts.factory.createVariableDeclaration(
+                        'schema',
+                        undefined,
+                        ts.factory.createTypeReferenceNode('Schema'),
+                        ts.factory.createIdentifier('_schema'),
+                    ),
+                ],
+                ts.NodeFlags.Const,
+            ),
+        );
+        statements.push(schemaExportDecl);
 
-        // create statement "export type SchemaType = typeof schema;"
-        const typeDeclaration = ts.factory.createTypeAliasDeclaration(
+        // export type SchemaType = Schema;
+        const schemaTypeDeclaration = ts.factory.createTypeAliasDeclaration(
             [ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)],
             'SchemaType',
             undefined,
-            ts.factory.createTypeReferenceNode('typeof schema'),
+            ts.factory.createTypeReferenceNode('Schema'),
         );
-        statements.push(typeDeclaration);
+        statements.push(schemaTypeDeclaration);
     }
 
     private createExpressionUtilsCall(method: string, args?: ts.Expression[]): ts.CallExpression {
diff --git a/samples/next.js/zenstack/schema-lite.ts b/samples/next.js/zenstack/schema-lite.ts
index 87909373..e8b2f096 100644
--- a/samples/next.js/zenstack/schema-lite.ts
+++ b/samples/next.js/zenstack/schema-lite.ts
@@ -6,7 +6,7 @@
 /* eslint-disable */
 
 import { type SchemaDef, ExpressionUtils } from "@zenstackhq/orm/schema";
-export const schema = {
+const _schema = {
     provider: {
         type: "sqlite"
     },
@@ -103,4 +103,8 @@ export const schema = {
     authType: "User",
     plugins: {}
 } as const satisfies SchemaDef;
-export type SchemaType = typeof schema;
+type Schema = typeof _schema & {
+    __brand?: "schema";
+};
+export const schema: Schema = _schema;
+export type SchemaType = Schema;
diff --git a/samples/next.js/zenstack/schema.ts b/samples/next.js/zenstack/schema.ts
index 8a6632b0..6388c6c2 100644
--- a/samples/next.js/zenstack/schema.ts
+++ b/samples/next.js/zenstack/schema.ts
@@ -6,7 +6,7 @@
 /* eslint-disable */
 
 import { type SchemaDef, ExpressionUtils } from "@zenstackhq/orm/schema";
-export const schema = {
+const _schema = {
     provider: {
         type: "sqlite"
     },
@@ -112,4 +112,8 @@ export const schema = {
     authType: "User",
     plugins: {}
 } as const satisfies SchemaDef;
-export type SchemaType = typeof schema;
+type Schema = typeof _schema & {
+    __brand?: "schema";
+};
+export const schema: Schema = _schema;
+export type SchemaType = Schema;
diff --git a/samples/orm/zenstack/schema.ts b/samples/orm/zenstack/schema.ts
index 4c9134b9..1db7031c 100644
--- a/samples/orm/zenstack/schema.ts
+++ b/samples/orm/zenstack/schema.ts
@@ -6,7 +6,7 @@
 /* eslint-disable */
 
 import { type SchemaDef, type OperandExpression, ExpressionUtils } from "@zenstackhq/orm/schema";
-export const schema = {
+const _schema = {
     provider: {
         type: "sqlite"
     },
@@ -241,4 +241,8 @@ export const schema = {
     authType: "User",
     plugins: {}
 } as const satisfies SchemaDef;
-export type SchemaType = typeof schema;
+type Schema = typeof _schema & {
+    __brand?: "schema";
+};
+export const schema: Schema = _schema;
+export type SchemaType = Schema;
diff --git a/tests/e2e/apps/rally/zenstack/schema.ts b/tests/e2e/apps/rally/zenstack/schema.ts
index 1684a553..278bac74 100644
--- a/tests/e2e/apps/rally/zenstack/schema.ts
+++ b/tests/e2e/apps/rally/zenstack/schema.ts
@@ -6,7 +6,7 @@
 /* eslint-disable */
 
 import { type SchemaDef, ExpressionUtils } from "@zenstackhq/orm/schema";
-export const schema = {
+const _schema = {
     provider: {
         type: "postgresql"
     },
@@ -2520,4 +2520,8 @@ export const schema = {
     authType: "User",
     plugins: {}
 } as const satisfies SchemaDef;
-export type SchemaType = typeof schema;
+type Schema = typeof _schema & {
+    __brand?: "schema";
+};
+export const schema: Schema = _schema;
+export type SchemaType = Schema;
diff --git a/tests/e2e/orm/schemas/basic/schema.ts b/tests/e2e/orm/schemas/basic/schema.ts
index 6339ab0a..3774b207 100644
--- a/tests/e2e/orm/schemas/basic/schema.ts
+++ b/tests/e2e/orm/schemas/basic/schema.ts
@@ -6,7 +6,7 @@
 /* eslint-disable */
 
 import { type SchemaDef, ExpressionUtils } from "@zenstackhq/orm/schema";
-export const schema = {
+const _schema = {
     provider: {
         type: "sqlite"
     },
@@ -284,4 +284,8 @@ export const schema = {
     authType: "User",
     plugins: {}
 } as const satisfies SchemaDef;
-export type SchemaType = typeof schema;
+type Schema = typeof _schema & {
+    __brand?: "schema";
+};
+export const schema: Schema = _schema;
+export type SchemaType = Schema;
diff --git a/tests/e2e/orm/schemas/default-auth/schema.ts b/tests/e2e/orm/schemas/default-auth/schema.ts
index 42035b8b..c5610c0f 100644
--- a/tests/e2e/orm/schemas/default-auth/schema.ts
+++ b/tests/e2e/orm/schemas/default-auth/schema.ts
@@ -6,7 +6,7 @@
 /* eslint-disable */
 
 import { type SchemaDef, ExpressionUtils } from "@zenstackhq/orm/schema";
-export const schema = {
+const _schema = {
     provider: {
         type: "sqlite"
     },
@@ -119,4 +119,8 @@ export const schema = {
     authType: "User",
     plugins: {}
 } as const satisfies SchemaDef;
-export type SchemaType = typeof schema;
+type Schema = typeof _schema & {
+    __brand?: "schema";
+};
+export const schema: Schema = _schema;
+export type SchemaType = Schema;
diff --git a/tests/e2e/orm/schemas/delegate/schema.ts b/tests/e2e/orm/schemas/delegate/schema.ts
index 8767b8e1..eaf1725a 100644
--- a/tests/e2e/orm/schemas/delegate/schema.ts
+++ b/tests/e2e/orm/schemas/delegate/schema.ts
@@ -6,7 +6,7 @@
 /* eslint-disable */
 
 import { type SchemaDef, ExpressionUtils } from "@zenstackhq/orm/schema";
-export const schema = {
+const _schema = {
     provider: {
         type: "sqlite"
     },
@@ -462,4 +462,8 @@ export const schema = {
     authType: "User",
     plugins: {}
 } as const satisfies SchemaDef;
-export type SchemaType = typeof schema;
+type Schema = typeof _schema & {
+    __brand?: "schema";
+};
+export const schema: Schema = _schema;
+export type SchemaType = Schema;
diff --git a/tests/e2e/orm/schemas/name-mapping/schema.ts b/tests/e2e/orm/schemas/name-mapping/schema.ts
index b81c03ae..6b154ed7 100644
--- a/tests/e2e/orm/schemas/name-mapping/schema.ts
+++ b/tests/e2e/orm/schemas/name-mapping/schema.ts
@@ -6,7 +6,7 @@
 /* eslint-disable */
 
 import { type SchemaDef, ExpressionUtils } from "@zenstackhq/orm/schema";
-export const schema = {
+const _schema = {
     provider: {
         type: "sqlite"
     },
@@ -120,4 +120,8 @@ export const schema = {
     authType: "User",
     plugins: {}
 } as const satisfies SchemaDef;
-export type SchemaType = typeof schema;
+type Schema = typeof _schema & {
+    __brand?: "schema";
+};
+export const schema: Schema = _schema;
+export type SchemaType = Schema;
diff --git a/tests/e2e/orm/schemas/petstore/schema.ts b/tests/e2e/orm/schemas/petstore/schema.ts
index 747372a7..e3b9de6a 100644
--- a/tests/e2e/orm/schemas/petstore/schema.ts
+++ b/tests/e2e/orm/schemas/petstore/schema.ts
@@ -6,7 +6,7 @@
 /* eslint-disable */
 
 import { type SchemaDef, ExpressionUtils } from "@zenstackhq/orm/schema";
-export const schema = {
+const _schema = {
     provider: {
         type: "sqlite"
     },
@@ -154,4 +154,8 @@ export const schema = {
     authType: "User",
     plugins: {}
 } as const satisfies SchemaDef;
-export type SchemaType = typeof schema;
+type Schema = typeof _schema & {
+    __brand?: "schema";
+};
+export const schema: Schema = _schema;
+export type SchemaType = Schema;
diff --git a/tests/e2e/orm/schemas/todo/schema.ts b/tests/e2e/orm/schemas/todo/schema.ts
index 4a8f811c..458cf5c2 100644
--- a/tests/e2e/orm/schemas/todo/schema.ts
+++ b/tests/e2e/orm/schemas/todo/schema.ts
@@ -6,7 +6,7 @@
 /* eslint-disable */
 
 import { type SchemaDef, ExpressionUtils } from "@zenstackhq/orm/schema";
-export const schema = {
+const _schema = {
     provider: {
         type: "sqlite"
     },
@@ -393,4 +393,8 @@ export const schema = {
     authType: "User",
     plugins: {}
 } as const satisfies SchemaDef;
-export type SchemaType = typeof schema;
+type Schema = typeof _schema & {
+    __brand?: "schema";
+};
+export const schema: Schema = _schema;
+export type SchemaType = Schema;
diff --git a/tests/e2e/orm/schemas/typing/schema.ts b/tests/e2e/orm/schemas/typing/schema.ts
index 1a1212bd..57da73ec 100644
--- a/tests/e2e/orm/schemas/typing/schema.ts
+++ b/tests/e2e/orm/schemas/typing/schema.ts
@@ -6,7 +6,7 @@
 /* eslint-disable */
 
 import { type SchemaDef, type OperandExpression, ExpressionUtils } from "@zenstackhq/orm/schema";
-export const schema = {
+const _schema = {
     provider: {
         type: "postgresql"
     },
@@ -344,4 +344,8 @@ export const schema = {
     authType: "User",
     plugins: {}
 } as const satisfies SchemaDef;
-export type SchemaType = typeof schema;
+type Schema = typeof _schema & {
+    __brand?: "schema";
+};
+export const schema: Schema = _schema;
+export type SchemaType = Schema;

From 9f20e3b85a03b31532f52c8947db9ebfe7e1ec81 Mon Sep 17 00:00:00 2001
From: ymc9 <104139426+ymc9@users.noreply.github.com>
Date: Fri, 14 Nov 2025 22:44:18 -0800
Subject: [PATCH 2/3] update

---
 packages/orm/src/client/crud-types.ts | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/packages/orm/src/client/crud-types.ts b/packages/orm/src/client/crud-types.ts
index f4b5cd06..831af6c7 100644
--- a/packages/orm/src/client/crud-types.ts
+++ b/packages/orm/src/client/crud-types.ts
@@ -309,6 +309,9 @@ export type StringFilter<Nullable extends boolean, WithAggregations extends bool
           contains?: string;
           startsWith?: string;
           endsWith?: string;
+          /**
+           * Not effective for "sqlite" provider
+           */
           mode?: 'default' | 'insensitive';
       } & (WithAggregations extends true
               ? {

From 2885ee25d21357fd1c4075a3fc6c6199299aa534 Mon Sep 17 00:00:00 2001
From: ymc9 <104139426+ymc9@users.noreply.github.com>
Date: Fri, 14 Nov 2025 22:57:19 -0800
Subject: [PATCH 3/3] fix(orm): findUnique arg typing

---
 packages/orm/src/client/crud-types.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/orm/src/client/crud-types.ts b/packages/orm/src/client/crud-types.ts
index 831af6c7..7f5defdf 100644
--- a/packages/orm/src/client/crud-types.ts
+++ b/packages/orm/src/client/crud-types.ts
@@ -664,7 +664,7 @@ export type FindManyArgs<Schema extends SchemaDef, Model extends GetModels<Schem
 export type FindFirstArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = FindArgs<Schema, Model, true>;
 
 export type FindUniqueArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
-    where?: WhereUniqueInput<Schema, Model>;
+    where: WhereUniqueInput<Schema, Model>;
 } & SelectIncludeOmit<Schema, Model, true>;
 
 //#endregion