diff --git a/packages/clients/tanstack-query/src/common/types.ts b/packages/clients/tanstack-query/src/common/types.ts
index f745ceeb4..a967869ed 100644
--- a/packages/clients/tanstack-query/src/common/types.ts
+++ b/packages/clients/tanstack-query/src/common/types.ts
@@ -3,11 +3,12 @@ import type { FetchFn } from '@zenstackhq/client-helpers/fetch';
 import type {
     GetProcedureNames,
     GetSlicedOperations,
-    OperationsIneligibleForDelegateModels,
+    ModelAllowsCreate,
+    OperationsRequiringCreate,
     ProcedureFunc,
     QueryOptions,
 } from '@zenstackhq/orm';
-import type { GetModels, IsDelegateModel, SchemaDef } from '@zenstackhq/schema';
+import type { GetModels, SchemaDef } from '@zenstackhq/schema';
 
 /**
  * Context type for configuring the hooks.
@@ -59,8 +60,8 @@ export type ExtraMutationOptions = {
     optimisticDataProvider?: OptimisticDataProvider;
 } & QueryContext;
 
-type HooksOperationsIneligibleForDelegateModels = OperationsIneligibleForDelegateModels extends any
-    ? `use${Capitalize<OperationsIneligibleForDelegateModels>}`
+type HooksOperationsRequiringCreate = OperationsRequiringCreate extends any
+    ? `use${Capitalize<OperationsRequiringCreate>}`
     : never;
 
 type Modifiers = '' | 'Suspense' | 'Infinite' | 'SuspenseInfinite';
@@ -76,12 +77,12 @@ export type TrimSlicedOperations<
 > = {
     // trim operations based on slicing options
     [Key in keyof T as Key extends `use${Modifiers}${Capitalize<GetSlicedOperations<Schema, Model, Options>>}`
-        ? IsDelegateModel<Schema, Model> extends true
-            ? // trim operations ineligible for delegate models
-              Key extends HooksOperationsIneligibleForDelegateModels
-                ? never
-                : Key
-            : Key
+        ? ModelAllowsCreate<Schema, Model> extends true
+            ? Key
+            : // trim create operations for models that don't allow create
+              Key extends HooksOperationsRequiringCreate
+              ? never
+              : Key
         : never]: T[Key];
 };
 
diff --git a/packages/orm/src/client/client-impl.ts b/packages/orm/src/client/client-impl.ts
index 1046d0ca8..92dddebb8 100644
--- a/packages/orm/src/client/client-impl.ts
+++ b/packages/orm/src/client/client-impl.ts
@@ -39,6 +39,7 @@ import { SchemaDbPusher } from './helpers/schema-db-pusher';
 import type { ClientOptions, ProceduresOptions } from './options';
 import type { AnyPlugin } from './plugin';
 import { createZenStackPromise, type ZenStackPromise } from './promise';
+import { fieldHasDefaultValue, isUnsupportedField, requireModel } from './query-utils';
 import { ResultProcessor } from './result-processor';
 
 /**
@@ -821,5 +822,13 @@ function createModelCrudHandler(
         }
     }
 
+    // Remove create/upsert operations for models with required Unsupported fields
+    const modelDef = requireModel(client.$schema, model);
+    if (Object.values(modelDef.fields).some((f) => isUnsupportedField(f) && !f.optional && !fieldHasDefaultValue(f))) {
+        for (const op of ['create', 'createMany', 'createManyAndReturn', 'upsert'] as const) {
+            delete (operations as any)[op];
+        }
+    }
+
     return operations as ModelOperations<any, any>;
 }
diff --git a/packages/orm/src/client/contract.ts b/packages/orm/src/client/contract.ts
index c6b772aa4..23c2367fd 100644
--- a/packages/orm/src/client/contract.ts
+++ b/packages/orm/src/client/contract.ts
@@ -2,7 +2,6 @@ import {
     type FieldIsArray,
     type GetModels,
     type GetTypeDefs,
-    type IsDelegateModel,
     type ProcedureDef,
     type RelationFields,
     type RelationFieldType,
@@ -43,7 +42,12 @@ import type { ClientOptions, QueryOptions } from './options';
 import type { ExtClientMembersBase, ExtQueryArgsBase, RuntimePlugin } from './plugin';
 import type { ZenStackPromise } from './promise';
 import type { ToKysely } from './query-builder';
-import type { GetSlicedModels, GetSlicedOperations, GetSlicedProcedures } from './type-utils';
+import type {
+    GetSlicedModels,
+    GetSlicedOperations,
+    GetSlicedProcedures,
+    ModelAllowsCreate,
+} from './type-utils';
 import type { ZodSchemaFactory } from './zod/factory';
 
 type TransactionUnsupportedMethods = (typeof TRANSACTION_UNSUPPORTED_METHODS)[number];
@@ -284,8 +288,8 @@ type SliceOperations<
         // keep only operations included by slicing options
         [Key in keyof T as Key extends GetSlicedOperations<Schema, Model, Options> ? Key : never]: T[Key];
     },
-    // exclude operations not applicable to delegate models
-    IsDelegateModel<Schema, Model> extends true ? OperationsIneligibleForDelegateModels : never
+    // exclude create operations for models that don't allow create (delegate models, required Unsupported fields)
+    | (ModelAllowsCreate<Schema, Model> extends true ? never : OperationsRequiringCreate)
 >;
 
 export type AllModelOperations<
@@ -880,7 +884,7 @@ type CommonModelOperations<
     ): ZenStackPromise<Schema, boolean>;
 };
 
-export type OperationsIneligibleForDelegateModels = 'create' | 'createMany' | 'createManyAndReturn' | 'upsert';
+export type OperationsRequiringCreate = 'create' | 'createMany' | 'createManyAndReturn' | 'upsert';
 
 export type ModelOperations<
     Schema extends SchemaDef,
diff --git a/packages/orm/src/client/crud-types.ts b/packages/orm/src/client/crud-types.ts
index 6c335cf93..d5d6e8c27 100644
--- a/packages/orm/src/client/crud-types.ts
+++ b/packages/orm/src/client/crud-types.ts
@@ -6,7 +6,6 @@ import type {
     FieldHasDefault,
     FieldIsArray,
     FieldIsDelegateDiscriminator,
-    FieldIsDelegateRelation,
     FieldIsRelation,
     FieldType,
     ForeignKeyFields,
@@ -60,7 +59,7 @@ import type {
 import type { FilterKind, QueryOptions } from './options';
 import type { ExtQueryArgsBase } from './plugin';
 import type { ToKyselySchema } from './query-builder';
-import type { GetSlicedFilterKindsForField, GetSlicedModels } from './type-utils';
+import type { GetSlicedFilterKindsForField, GetSlicedModels, ModelAllowsCreate } from './type-utils';
 
 //#region Query results
 
@@ -1331,6 +1330,15 @@ type CreateFKPayload<Schema extends SchemaDef, Model extends GetModels<Schema>>
     }
 >;
 
+type RelationModelAllowsCreate<
+    Schema extends SchemaDef,
+    Model extends GetModels<Schema>,
+    Field extends RelationFields<Schema, Model>,
+> =
+    GetModelFieldType<Schema, Model, Field> extends GetModels<Schema>
+        ? ModelAllowsCreate<Schema, GetModelFieldType<Schema, Model, Field>>
+        : false;
+
 type CreateRelationFieldPayload<
     Schema extends SchemaDef,
     Model extends GetModels<Schema>,
@@ -1360,8 +1368,8 @@ type CreateRelationFieldPayload<
     },
     // no "createMany" for non-array fields
     | (FieldIsArray<Schema, Model, Field> extends true ? never : 'createMany')
-    // exclude operations not applicable to delegate models
-    | (FieldIsDelegateRelation<Schema, Model, Field> extends true ? 'create' | 'createMany' | 'connectOrCreate' : never)
+    // exclude create operations for models that don't allow create
+    | (RelationModelAllowsCreate<Schema, Model, Field> extends true ? never : 'create' | 'createMany' | 'connectOrCreate')
 >;
 
 type CreateRelationPayload<
@@ -1715,10 +1723,8 @@ type ToManyRelationUpdateInput<
          */
         set?: SetRelationInput<Schema, Model, Field, Options>;
     },
-    // exclude
-    FieldIsDelegateRelation<Schema, Model, Field> extends true
-        ? 'create' | 'createMany' | 'connectOrCreate' | 'upsert'
-        : never
+    // exclude create operations for models that don't allow create
+    | (RelationModelAllowsCreate<Schema, Model, Field> extends true ? never : 'create' | 'createMany' | 'connectOrCreate' | 'upsert')
 >;
 
 type ToOneRelationUpdateInput<
@@ -1765,7 +1771,8 @@ type ToOneRelationUpdateInput<
               delete?: NestedDeleteInput<Schema, Model, Field, Options>;
           }
         : {}),
-    FieldIsDelegateRelation<Schema, Model, Field> extends true ? 'create' | 'connectOrCreate' | 'upsert' : never
+    // exclude create operations for models that don't allow create
+    | (RelationModelAllowsCreate<Schema, Model, Field> extends true ? never : 'create' | 'connectOrCreate' | 'upsert')
 >;
 
 // #endregion
diff --git a/packages/orm/src/client/crud/dialects/base-dialect.ts b/packages/orm/src/client/crud/dialects/base-dialect.ts
index 1f5102121..24081069b 100644
--- a/packages/orm/src/client/crud/dialects/base-dialect.ts
+++ b/packages/orm/src/client/crud/dialects/base-dialect.ts
@@ -29,6 +29,7 @@ import {
     isInheritedField,
     isRelationField,
     isTypeDef,
+    getModelFields,
     makeDefaultOrderBy,
     requireField,
     requireIdFields,
@@ -1117,17 +1118,13 @@ export abstract class BaseCrudDialect<Schema extends SchemaDef> {
         omit: Record<string, boolean | undefined> | undefined | null,
         modelAlias: string,
     ) {
-        const modelDef = requireModel(this.schema, model);
         let result = query;
 
-        for (const field of Object.keys(modelDef.fields)) {
-            if (isRelationField(this.schema, model, field)) {
-                continue;
-            }
-            if (this.shouldOmitField(omit, model, field)) {
+        for (const fieldDef of getModelFields(this.schema, model, { inherited: true, computed: true })) {
+            if (this.shouldOmitField(omit, model, fieldDef.name)) {
                 continue;
             }
-            result = this.buildSelectField(result, model, modelAlias, field);
+            result = this.buildSelectField(result, model, modelAlias, fieldDef.name);
         }
 
         // select all fields from delegate descendants and pack into a JSON field `$delegate$Model`
diff --git a/packages/orm/src/client/crud/operations/base.ts b/packages/orm/src/client/crud/operations/base.ts
index a12f0fe2a..d05485d5d 100644
--- a/packages/orm/src/client/crud/operations/base.ts
+++ b/packages/orm/src/client/crud/operations/base.ts
@@ -1148,7 +1148,7 @@ export abstract class BaseOperationHandler<Schema extends SchemaDef> {
 
         const parentWhere = await this.buildUpdateParentRelationFilter(kysely, fromRelation);
 
-        let combinedWhere: WhereInput<Schema, GetModels<Schema>, any, false> = where ?? {};
+        let combinedWhere: Record<string, any> = where ?? {};
         if (Object.keys(parentWhere).length > 0) {
             combinedWhere = Object.keys(combinedWhere).length > 0 ? { AND: [parentWhere, combinedWhere] } : parentWhere;
         }
@@ -1210,7 +1210,7 @@ export abstract class BaseOperationHandler<Schema extends SchemaDef> {
 
         if (needIdRead) {
             const readResult = await this.readUnique(kysely, model, {
-                where: combinedWhere,
+                where: combinedWhere as WhereInput<Schema, GetModels<Schema>>,
                 select: this.makeIdSelect(model),
             });
             if (!readResult && throwIfNotFound) {
@@ -2507,6 +2507,7 @@ export abstract class BaseOperationHandler<Schema extends SchemaDef> {
         return newArgs;
     }
 
+
     private doNormalizeArgs(args: unknown) {
         if (args && typeof args === 'object') {
             for (const [key, value] of Object.entries(args)) {
diff --git a/packages/orm/src/client/executor/name-mapper.ts b/packages/orm/src/client/executor/name-mapper.ts
index 6a7535fe0..369526cd6 100644
--- a/packages/orm/src/client/executor/name-mapper.ts
+++ b/packages/orm/src/client/executor/name-mapper.ts
@@ -37,8 +37,8 @@ import {
     getEnum,
     getField,
     getModel,
+    getModelFields,
     isEnum,
-    requireModel,
     stripAlias,
 } from '../query-utils';
 
@@ -66,7 +66,7 @@ export class QueryNameMapper extends OperationNodeTransformer {
                 this.modelToTableMap.set(modelName, mappedName);
             }
 
-            for (const fieldDef of this.getModelFields(modelDef)) {
+            for (const fieldDef of getModelFields(this.schema, modelName)) {
                 const mappedName = this.getMappedName(fieldDef);
                 if (mappedName) {
                     this.fieldToColumnMap.set(`${modelName}.${fieldDef.name}`, mappedName);
@@ -431,7 +431,7 @@ export class QueryNameMapper extends OperationNodeTransformer {
                     if (!modelDef) {
                         continue;
                     }
-                    if (this.getModelFields(modelDef).some((f) => f.name === name)) {
+                    if (getModelFields(this.schema, scope.model).some((f) => f.name === name)) {
                         return scope;
                     }
                 }
@@ -560,8 +560,7 @@ export class QueryNameMapper extends OperationNodeTransformer {
     }
 
     private createSelectAllFields(model: string, alias: OperationNode | undefined) {
-        const modelDef = requireModel(this.schema, model);
-        return this.getModelFields(modelDef).map((fieldDef) => {
+        return getModelFields(this.schema, model).map((fieldDef) => {
             const columnName = this.mapFieldName(model, fieldDef.name);
             const columnRef = ReferenceNode.create(
                 ColumnNode.create(columnName),
@@ -576,9 +575,6 @@ export class QueryNameMapper extends OperationNodeTransformer {
         });
     }
 
-    private getModelFields(modelDef: ModelDef) {
-        return Object.values(modelDef.fields).filter((f) => !f.relation && !f.computed && !f.originModel);
-    }
 
     private processSelections(selections: readonly SelectionNode[]) {
         const result: SelectionNode[] = [];
@@ -627,9 +623,8 @@ export class QueryNameMapper extends OperationNodeTransformer {
         }
 
         // expand select all to a list of selections with name mapping
-        const modelDef = requireModel(this.schema, scope.model);
-        return this.getModelFields(modelDef).map((fieldDef) => {
-            const columnName = this.mapFieldName(modelDef.name, fieldDef.name);
+        return getModelFields(this.schema, scope.model).map((fieldDef) => {
+            const columnName = this.mapFieldName(scope.model!, fieldDef.name);
             const columnRef = ReferenceNode.create(ColumnNode.create(columnName));
 
             // process enum value mapping
@@ -660,7 +655,7 @@ export class QueryNameMapper extends OperationNodeTransformer {
         if (!modelDef) {
             return false;
         }
-        return this.getModelFields(modelDef).some((fieldDef) => {
+        return getModelFields(this.schema, model).some((fieldDef) => {
             const enumDef = getEnum(this.schema, fieldDef.type);
             if (!enumDef) {
                 return false;
diff --git a/packages/orm/src/client/helpers/schema-db-pusher.ts b/packages/orm/src/client/helpers/schema-db-pusher.ts
index 4886687ef..f84a29004 100644
--- a/packages/orm/src/client/helpers/schema-db-pusher.ts
+++ b/packages/orm/src/client/helpers/schema-db-pusher.ts
@@ -12,7 +12,7 @@ import {
     type SchemaDef,
 } from '../../schema';
 import type { ToKysely } from '../query-builder';
-import { requireModel } from '../query-utils';
+import { isUnsupportedField, requireModel } from '../query-utils';
 
 /**
  * This class is for testing purposes only. It should never be used in production.
@@ -117,6 +117,11 @@ export class SchemaDbPusher<Schema extends SchemaDef> {
                 continue;
             }
 
+            if (isUnsupportedField(fieldDef)) {
+                // Unsupported fields cannot be represented in the ORM's schema pusher
+                continue;
+            }
+
             if (fieldDef.relation) {
                 table = this.addForeignKeyConstraint(table, modelDef.name, fieldName, fieldDef);
             } else if (!this.isComputedField(fieldDef)) {
diff --git a/packages/orm/src/client/query-utils.ts b/packages/orm/src/client/query-utils.ts
index 0ea7ea58a..2e8b134b3 100644
--- a/packages/orm/src/client/query-utils.ts
+++ b/packages/orm/src/client/query-utils.ts
@@ -70,12 +70,12 @@ export function requireField(schema: SchemaDef, modelOrType: string, field: stri
 }
 
 /**
- * Gets all model fields, by default non-relation, non-computed, non-inherited fields only.
+ * Gets all model fields, by default non-relation, non-computed, non-inherited, non-unsupported fields only.
  */
 export function getModelFields(
     schema: SchemaDef,
     model: string,
-    options?: { relations?: boolean; computed?: boolean; inherited?: boolean },
+    options?: { relations?: boolean; computed?: boolean; inherited?: boolean; unsupported?: boolean },
 ) {
     const modelDef = requireModel(schema, model);
     return Object.values(modelDef.fields).filter((f) => {
@@ -88,10 +88,20 @@ export function getModelFields(
         if (f.originModel && !options?.inherited) {
             return false;
         }
+        if (f.type === 'Unsupported' && !options?.unsupported) {
+            return false;
+        }
         return true;
     });
 }
 
+/**
+ * Checks if a field is of `Unsupported` type.
+ */
+export function isUnsupportedField(fieldDef: FieldDef) {
+    return fieldDef.type === 'Unsupported';
+}
+
 export function getIdFields<Schema extends SchemaDef>(schema: SchemaDef, model: GetModels<Schema>) {
     const modelDef = getModel(schema, model);
     return modelDef?.idFields;
diff --git a/packages/orm/src/client/type-utils.ts b/packages/orm/src/client/type-utils.ts
index 3a4589f71..68e79a6c0 100644
--- a/packages/orm/src/client/type-utils.ts
+++ b/packages/orm/src/client/type-utils.ts
@@ -1,8 +1,39 @@
-import type { GetModels, SchemaDef } from '@zenstackhq/schema';
+import type { FieldDef, GetModel, GetModels, IsDelegateModel, SchemaDef } from '@zenstackhq/schema';
 import type { GetProcedureNames } from './crud-types';
 import type { AllCrudOperations } from './crud/operations/base';
 import type { FilterKind, QueryOptions, SlicingOptions } from './options';
 
+/**
+ * Checks if a model has any required Unsupported fields (non-optional, no default).
+ * Uses raw field access since `GetModelFields` excludes Unsupported fields.
+ */
+export type ModelHasRequiredUnsupportedField<Schema extends SchemaDef, Model extends GetModels<Schema>> = true extends {
+    [Key in Extract<keyof GetModel<Schema, Model>['fields'], string>]: GetModel<
+        Schema,
+        Model
+    >['fields'][Key] extends infer F extends FieldDef
+        ? F['type'] extends 'Unsupported'
+            ? F['optional'] extends true
+                ? false
+                : 'default' extends keyof F
+                  ? false
+                  : true
+            : false
+        : false;
+}[Extract<keyof GetModel<Schema, Model>['fields'], string>]
+    ? true
+    : false;
+
+/**
+ * Checks if a model allows create operations (not a delegate model and has no required Unsupported fields).
+ */
+export type ModelAllowsCreate<Schema extends SchemaDef, Model extends GetModels<Schema>> =
+    IsDelegateModel<Schema, Model> extends true
+        ? false
+        : ModelHasRequiredUnsupportedField<Schema, Model> extends true
+          ? false
+          : true;
+
 type IsNever<T> = [T] extends [never] ? true : false;
 
 // #region Model slicing
diff --git a/packages/orm/src/client/zod/factory.ts b/packages/orm/src/client/zod/factory.ts
index 0f0eb61e8..6e1c5db2c 100644
--- a/packages/orm/src/client/zod/factory.ts
+++ b/packages/orm/src/client/zod/factory.ts
@@ -129,6 +129,14 @@ export class ZodSchemaFactory<
         return this.options.validateInput !== false;
     }
 
+    /**
+     * Returns model field entries, excluding Unsupported fields.
+     */
+    private getModelFields(model: string): [string, FieldDef][] {
+        const modelDef = requireModel(this.schema, model);
+        return Object.entries(modelDef.fields).filter(([, def]) => def.type !== 'Unsupported');
+    }
+
     private shouldIncludeRelations(options?: CreateSchemaOptions): boolean {
         return options?.relationDepth === undefined || options.relationDepth > 0;
     }
@@ -337,8 +345,6 @@ export class ZodSchemaFactory<
         withAggregations = false,
         options?: CreateSchemaOptions,
     ): ZodType {
-        const modelDef = requireModel(this.schema, model);
-
         // unique field used in unique filters bypass filter slicing
         const uniqueFieldNames = unique
             ? getUniqueFields(this.schema, model)
@@ -353,8 +359,7 @@ export class ZodSchemaFactory<
         const nextOpts = this.nextOptions(options);
 
         const fields: Record<string, any> = {};
-        for (const field of Object.keys(modelDef.fields)) {
-            const fieldDef = requireField(this.schema, model, field);
+        for (const [field, fieldDef] of this.getModelFields(model)) {
             let fieldSchema: ZodType | undefined;
 
             if (fieldDef.relation) {
@@ -877,10 +882,8 @@ export class ZodSchemaFactory<
 
     @cache()
     private makeSelectSchema(model: string, options?: CreateSchemaOptions) {
-        const modelDef = requireModel(this.schema, model);
         const fields: Record<string, ZodType> = {};
-        for (const field of Object.keys(modelDef.fields)) {
-            const fieldDef = requireField(this.schema, model, field);
+        for (const [field, fieldDef] of this.getModelFields(model)) {
             if (fieldDef.relation) {
                 if (!this.shouldIncludeRelations(options)) {
                     continue;
@@ -992,10 +995,8 @@ export class ZodSchemaFactory<
 
     @cache()
     private makeOmitSchema(model: string) {
-        const modelDef = requireModel(this.schema, model);
         const fields: Record<string, ZodType> = {};
-        for (const field of Object.keys(modelDef.fields)) {
-            const fieldDef = requireField(this.schema, model, field);
+        for (const [field, fieldDef] of this.getModelFields(model)) {
             if (!fieldDef.relation) {
                 if (this.options.allowQueryTimeOmitOverride !== false) {
                     // if override is allowed, use boolean
@@ -1043,12 +1044,10 @@ export class ZodSchemaFactory<
         WithAggregation: boolean,
         options?: CreateSchemaOptions,
     ) {
-        const modelDef = requireModel(this.schema, model);
         const fields: Record<string, ZodType> = {};
         const sort = z.union([z.literal('asc'), z.literal('desc')]);
         const nextOpts = this.nextOptions(options);
-        for (const field of Object.keys(modelDef.fields)) {
-            const fieldDef = requireField(this.schema, model, field);
+        for (const [field, fieldDef] of this.getModelFields(model)) {
             if (fieldDef.relation) {
                 // relations
                 if (withRelation && this.shouldIncludeRelations(options)) {
@@ -1098,8 +1097,9 @@ export class ZodSchemaFactory<
 
     @cache()
     private makeDistinctSchema(model: string) {
-        const modelDef = requireModel(this.schema, model);
-        const nonRelationFields = Object.keys(modelDef.fields).filter((field) => !modelDef.fields[field]?.relation);
+        const nonRelationFields = this.getModelFields(model)
+            .filter(([, def]) => !def.relation)
+            .map(([name]) => name);
         return nonRelationFields.length > 0 ? this.orArray(z.enum(nonRelationFields as any), true) : z.never();
     }
 
@@ -1170,20 +1170,19 @@ export class ZodSchemaFactory<
         const uncheckedVariantFields: Record<string, ZodType> = {};
         const checkedVariantFields: Record<string, ZodType> = {};
         const modelDef = requireModel(this.schema, model);
+        const modelFields = this.getModelFields(model);
         const hasRelation =
             !skipRelations &&
-            Object.entries(modelDef.fields).some(([f, def]) => !withoutFields.includes(f) && def.relation);
+            modelFields.some(([f, def]) => !withoutFields.includes(f) && def.relation);
 
         const nextOpts = this.nextOptions(options);
 
-        Object.keys(modelDef.fields).forEach((field) => {
+        modelFields.forEach(([field, fieldDef]) => {
             if (withoutFields.includes(field)) {
                 return;
             }
 
-            const fieldDef = requireField(this.schema, model, field);
-
-            // skip computed fields and discriminator fields, they cannot be set on create
+            // skip computed fields and discriminator fields
             if (fieldDef.computed || fieldDef.isDiscriminator) {
                 return;
             }
@@ -1302,21 +1301,28 @@ export class ZodSchemaFactory<
         const fieldDef = requireField(this.schema, model, field);
         const fieldType = fieldDef.type;
         const array = !!fieldDef.array;
+        const canCreateModel = this.canCreateModel(fieldType);
         const fields: Record<string, ZodType> = {
-            create: this.makeCreateDataSchema(
+            connect: this.makeConnectDataSchema(fieldType, array, options).optional(),
+        };
+
+        if (canCreateModel) {
+            fields['create'] = this.makeCreateDataSchema(
                 fieldDef.type,
                 !!fieldDef.array,
                 withoutFields,
                 false,
                 options,
-            ).optional(),
-
-            connect: this.makeConnectDataSchema(fieldType, array, options).optional(),
-
-            connectOrCreate: this.makeConnectOrCreateDataSchema(fieldType, array, withoutFields, options).optional(),
-        };
+            ).optional();
+            fields['connectOrCreate'] = this.makeConnectOrCreateDataSchema(
+                fieldType,
+                array,
+                withoutFields,
+                options,
+            ).optional();
+        }
 
-        if (array) {
+        if (array && canCreateModel) {
             fields['createMany'] = this.makeCreateManyPayloadSchema(fieldType, withoutFields, options).optional();
         }
 
@@ -1346,19 +1352,21 @@ export class ZodSchemaFactory<
                       ])
                       .optional();
 
-            let upsertWhere = this.makeWhereSchema(fieldType, true, false, false, options);
-            if (!fieldDef.array) {
-                // to-one relation, can upsert without where clause
-                upsertWhere = upsertWhere.optional();
+            if (canCreateModel) {
+                let upsertWhere = this.makeWhereSchema(fieldType, true, false, false, options);
+                if (!fieldDef.array) {
+                    // to-one relation, can upsert without where clause
+                    upsertWhere = upsertWhere.optional();
+                }
+                fields['upsert'] = this.orArray(
+                    z.strictObject({
+                        where: upsertWhere,
+                        create: this.makeCreateDataSchema(fieldType, false, withoutFields, false, options),
+                        update: this.makeUpdateDataSchema(fieldType, withoutFields, false, options),
+                    }),
+                    true,
+                ).optional();
             }
-            fields['upsert'] = this.orArray(
-                z.strictObject({
-                    where: upsertWhere,
-                    create: this.makeCreateDataSchema(fieldType, false, withoutFields, false, options),
-                    update: this.makeUpdateDataSchema(fieldType, withoutFields, false, options),
-                }),
-                true,
-            ).optional();
 
             if (array) {
                 // to-many relation specifics
@@ -1524,21 +1532,20 @@ export class ZodSchemaFactory<
         const uncheckedVariantFields: Record<string, ZodType> = {};
         const checkedVariantFields: Record<string, ZodType> = {};
         const modelDef = requireModel(this.schema, model);
+        const modelFields = this.getModelFields(model);
         const hasRelation =
             !skipRelations &&
-            Object.entries(modelDef.fields).some(([key, value]) => value.relation && !withoutFields.includes(key));
+            modelFields.some(([key, value]) => value.relation && !withoutFields.includes(key));
 
         const nextOpts = this.nextOptions(options);
 
-        Object.keys(modelDef.fields).forEach((field) => {
+        modelFields.forEach(([field, fieldDef]) => {
             if (withoutFields.includes(field)) {
                 return;
             }
 
-            const fieldDef = requireField(this.schema, model, field);
-
+            // skip computed fields and discriminator fields
             if (fieldDef.computed || fieldDef.isDiscriminator) {
-                // skip computed fields and discriminator fields, they cannot be updated
                 return;
             }
 
@@ -1698,13 +1705,12 @@ export class ZodSchemaFactory<
 
     @cache()
     private makeCountAggregateInputSchema(model: string) {
-        const modelDef = requireModel(this.schema, model);
         return z.union([
             z.literal(true),
             z.strictObject({
                 _all: z.literal(true).optional(),
-                ...Object.keys(modelDef.fields).reduce(
-                    (acc, field) => {
+                ...this.getModelFields(model).reduce(
+                    (acc, [field]) => {
                         acc[field] = z.literal(true).optional();
                         return acc;
                     },
@@ -1741,11 +1747,9 @@ export class ZodSchemaFactory<
 
     @cache()
     private makeSumAvgInputSchema(model: string) {
-        const modelDef = requireModel(this.schema, model);
         return z.strictObject(
-            Object.keys(modelDef.fields).reduce(
-                (acc, field) => {
-                    const fieldDef = requireField(this.schema, model, field);
+            this.getModelFields(model).reduce(
+                (acc, [field, fieldDef]) => {
                     if (this.isNumericField(fieldDef)) {
                         acc[field] = z.literal(true).optional();
                     }
@@ -1758,11 +1762,9 @@ export class ZodSchemaFactory<
 
     @cache()
     private makeMinMaxInputSchema(model: string) {
-        const modelDef = requireModel(this.schema, model);
         return z.strictObject(
-            Object.keys(modelDef.fields).reduce(
-                (acc, field) => {
-                    const fieldDef = requireField(this.schema, model, field);
+            this.getModelFields(model).reduce(
+                (acc, [field, fieldDef]) => {
                     if (!fieldDef.relation && !fieldDef.array) {
                         acc[field] = z.literal(true).optional();
                     }
@@ -1782,8 +1784,9 @@ export class ZodSchemaFactory<
         model: Model,
         options?: CreateSchemaOptions,
     ): ZodType<GroupByArgs<Schema, Model, Options, ExtQueryArgs>> {
-        const modelDef = requireModel(this.schema, model);
-        const nonRelationFields = Object.keys(modelDef.fields).filter((field) => !modelDef.fields[field]?.relation);
+        const nonRelationFields = this.getModelFields(model)
+            .filter(([, def]) => !def.relation)
+            .map(([name]) => name);
         const bySchema =
             nonRelationFields.length > 0
                 ? this.orArray(z.enum(nonRelationFields as [string, ...string[]]), true)
@@ -2185,10 +2188,14 @@ export class ZodSchemaFactory<
         }
     }
 
-    /**
-     * Checks if a model is included in the slicing configuration.
-     * Returns true if the model is allowed, false if it's excluded.
-     */
+    private canCreateModel(model: string) {
+        const modelDef = requireModel(this.schema, model);
+        const hasRequiredUnsupportedFields = Object.values(modelDef.fields).some(
+            (fieldDef) => fieldDef.type === 'Unsupported' && !fieldDef.optional && !fieldHasDefaultValue(fieldDef),
+        );
+        return !hasRequiredUnsupportedFields;
+    }
+
     private isModelAllowed(targetModel: string): boolean {
         const slicing = this.options.slicing;
         if (!slicing) {
diff --git a/packages/schema/src/schema.ts b/packages/schema/src/schema.ts
index e21b5e30e..b93ea9355 100644
--- a/packages/schema/src/schema.ts
+++ b/packages/schema/src/schema.ts
@@ -150,10 +150,15 @@ export type GetTypeDefs<Schema extends SchemaDef> = Extract<keyof Schema['typeDe
 export type GetTypeDef<Schema extends SchemaDef, TypeDef extends GetTypeDefs<Schema>> =
     Schema['typeDefs'] extends Record<string, unknown> ? Schema['typeDefs'][TypeDef] : never;
 
-export type GetModelFields<Schema extends SchemaDef, Model extends GetModels<Schema>> = Extract<
-    keyof GetModel<Schema, Model>['fields'],
-    string
->;
+export type GetModelFields<Schema extends SchemaDef, Model extends GetModels<Schema>> = keyof {
+    [Key in Extract<keyof GetModel<Schema, Model>['fields'], string> as FieldIsUnsupported<
+        Schema,
+        Model,
+        Key
+    > extends true
+        ? never
+        : Key]: never;
+};
 
 export type GetModelField<
     Schema extends SchemaDef,
@@ -281,6 +286,16 @@ export type FieldIsComputed<
     Field extends GetModelFields<Schema, Model>,
 > = GetModelField<Schema, Model, Field>['computed'] extends true ? true : false;
 
+export type FieldIsUnsupported<
+    Schema extends SchemaDef,
+    Model extends GetModels<Schema>,
+    Field extends string,
+> = Field extends keyof GetModel<Schema, Model>['fields']
+    ? GetModel<Schema, Model>['fields'][Field]['type'] extends 'Unsupported'
+        ? true
+        : false
+    : never;
+
 export type FieldHasDefault<
     Schema extends SchemaDef,
     Model extends GetModels<Schema>,
diff --git a/tests/e2e/orm/client-api/unsupported.test-d.ts b/tests/e2e/orm/client-api/unsupported.test-d.ts
new file mode 100644
index 000000000..a9797cc90
--- /dev/null
+++ b/tests/e2e/orm/client-api/unsupported.test-d.ts
@@ -0,0 +1,134 @@
+import type { ClientContract, CreateArgs, FindManyArgs, ModelResult, UpdateArgs } from '@zenstackhq/orm';
+import { describe, expectTypeOf, it } from 'vitest';
+import z from 'zod';
+import { schema } from '../schemas/unsupported/schema';
+
+type Schema = typeof schema;
+
+declare const client: ClientContract<Schema>;
+
+describe('Unsupported field exclusion - typing', () => {
+    // #region Result types
+
+    it('excludes Unsupported fields from result type (optional Unsupported)', () => {
+        type ItemResult = ModelResult<Schema, 'Item'>;
+        expectTypeOf<ItemResult>().toHaveProperty('id');
+        expectTypeOf<ItemResult>().toHaveProperty('name');
+        // Unsupported field should be excluded
+        expectTypeOf<ItemResult>().not.toHaveProperty('data');
+    });
+
+    it('excludes Unsupported fields from result type (required Unsupported)', () => {
+        type GeoResult = ModelResult<Schema, 'GeoRecord'>;
+        expectTypeOf<GeoResult>().toHaveProperty('id');
+        expectTypeOf<GeoResult>().toHaveProperty('title');
+        // Unsupported field should be excluded
+        expectTypeOf<GeoResult>().not.toHaveProperty('extra');
+    });
+
+    // #endregion
+
+    // #region Find/Where types
+
+    it('excludes Unsupported fields from where filter', () => {
+        type FindArgs = FindManyArgs<Schema, 'Item'>;
+        type Where = NonNullable<FindArgs['where']>;
+        expectTypeOf<Where>().toHaveProperty('id');
+        expectTypeOf<Where>().toHaveProperty('name');
+        // Unsupported field should not be filterable
+        expectTypeOf<Where>().not.toHaveProperty('data');
+    });
+
+    // #endregion
+
+    // #region Select/Omit types
+
+    it('excludes Unsupported fields from select', () => {
+        type FindArgs = FindManyArgs<Schema, 'Item'>;
+        type Select = NonNullable<FindArgs['select']>;
+        expectTypeOf<Select>().toHaveProperty('id');
+        expectTypeOf<Select>().toHaveProperty('name');
+        // Unsupported field should not be selectable
+        expectTypeOf<Select>().not.toHaveProperty('data');
+    });
+
+    it('excludes Unsupported fields from omit', () => {
+        type FindArgs = FindManyArgs<Schema, 'Item'>;
+        type Omit = NonNullable<FindArgs['omit']>;
+        expectTypeOf<Omit>().toHaveProperty('id');
+        expectTypeOf<Omit>().toHaveProperty('name');
+        // Unsupported field should not appear in omit
+        expectTypeOf<Omit>().not.toHaveProperty('data');
+    });
+
+    // #endregion
+
+    // #region Create types
+
+    it('excludes Unsupported fields from create data', () => {
+        type Args = CreateArgs<Schema, 'Item'>;
+        type Data = Args['data'];
+        expectTypeOf<Data>().toHaveProperty('name');
+        // Unsupported field should not be in create data
+        expectTypeOf<Data>().not.toHaveProperty('data');
+    });
+
+    // #endregion
+
+    // #region Update types
+
+    it('excludes Unsupported fields from update data', () => {
+        type Args = UpdateArgs<Schema, 'Item'>;
+        type Data = Args['data'];
+        expectTypeOf<Data>().toHaveProperty('name');
+        // Unsupported field should not be in update data
+        expectTypeOf<Data>().not.toHaveProperty('data');
+    });
+
+    // #endregion
+
+    // #region OrderBy types
+
+    it('excludes Unsupported fields from orderBy', () => {
+        // Test orderBy via the Zod schema factory since the OrderBy type is wrapped in OrArray
+        const s = client.$zod.makeFindManySchema('Item');
+        type Args = NonNullable<z.infer<typeof s>>;
+        type OrderBy = NonNullable<Args['orderBy']>;
+        // Use assignment test: valid field should work, Unsupported should not
+        const _valid: OrderBy = { name: 'asc' };
+        void _valid;
+        // @ts-expect-error 'data' (Unsupported) should not be in orderBy
+        const _invalid: OrderBy = { data: 'asc' };
+        void _invalid;
+    });
+
+    // #endregion
+
+    // #region Operation disabling for models with required Unsupported fields
+
+    it('disables create operations for models with required Unsupported fields', () => {
+        // Item has only optional Unsupported - create should be available
+        expectTypeOf(client.item).toHaveProperty('create');
+        expectTypeOf(client.item).toHaveProperty('createMany');
+        expectTypeOf(client.item).toHaveProperty('upsert');
+
+        // GeoRecord has required Unsupported without default - create operations should be disabled
+        expectTypeOf(client.geoRecord).not.toHaveProperty('create');
+        expectTypeOf(client.geoRecord).not.toHaveProperty('createMany');
+        expectTypeOf(client.geoRecord).not.toHaveProperty('createManyAndReturn');
+        expectTypeOf(client.geoRecord).not.toHaveProperty('upsert');
+
+        // GeoRecord should still have read/update/delete operations
+        expectTypeOf(client.geoRecord).toHaveProperty('findMany');
+        expectTypeOf(client.geoRecord).toHaveProperty('findUnique');
+        expectTypeOf(client.geoRecord).toHaveProperty('update');
+        expectTypeOf(client.geoRecord).toHaveProperty('delete');
+
+        // GeoRecordWithDefault has required Unsupported WITH default - create should be available
+        expectTypeOf(client.geoRecordWithDefault).toHaveProperty('create');
+        expectTypeOf(client.geoRecordWithDefault).toHaveProperty('createMany');
+        expectTypeOf(client.geoRecordWithDefault).toHaveProperty('upsert');
+    });
+
+    // #endregion
+});
diff --git a/tests/e2e/orm/client-api/unsupported.test.ts b/tests/e2e/orm/client-api/unsupported.test.ts
new file mode 100644
index 000000000..8e03b2dd8
--- /dev/null
+++ b/tests/e2e/orm/client-api/unsupported.test.ts
@@ -0,0 +1,286 @@
+import path from 'node:path';
+import { createQuerySchemaFactory } from '@zenstackhq/orm';
+import { createTestClient } from '@zenstackhq/testtools';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { schema } from '../schemas/unsupported/schema';
+
+describe('Unsupported field exclusion - Zod runtime validation', () => {
+    const factory = createQuerySchemaFactory(schema);
+
+    describe('Zod schemas', () => {
+        // #region Where schemas
+
+        describe('where schema', () => {
+            it('rejects Unsupported fields in where filter', () => {
+                const s = factory.makeFindManySchema('Item');
+
+                // valid filter on regular field
+                expect(s.safeParse({ where: { name: 'test' } }).success).toBe(true);
+
+                // Unsupported field should be rejected
+                expect(s.safeParse({ where: { data: 'some_value' } }).success).toBe(false);
+            });
+
+            it('rejects Unsupported fields in where filter (required Unsupported)', () => {
+                const s = factory.makeFindManySchema('GeoRecord');
+                expect(s.safeParse({ where: { title: 'test' } }).success).toBe(true);
+                expect(s.safeParse({ where: { extra: 'some_value' } }).success).toBe(false);
+            });
+        });
+
+        // #endregion
+
+        // #region Select schemas
+
+        describe('select schema', () => {
+            it('rejects Unsupported fields in select', () => {
+                const s = factory.makeFindManySchema('Item');
+
+                // valid select
+                expect(s.safeParse({ select: { id: true, name: true } }).success).toBe(true);
+
+                // Unsupported field in select should be rejected
+                expect(s.safeParse({ select: { data: true } }).success).toBe(false);
+            });
+        });
+
+        // #endregion
+
+        // #region Omit schemas
+
+        describe('omit schema', () => {
+            it('rejects Unsupported fields in omit', () => {
+                const s = factory.makeFindManySchema('Item');
+
+                // valid omit
+                expect(s.safeParse({ omit: { name: true } }).success).toBe(true);
+
+                // Unsupported field in omit should be rejected
+                expect(s.safeParse({ omit: { data: true } }).success).toBe(false);
+            });
+        });
+
+        // #endregion
+
+        // #region OrderBy schemas
+
+        describe('orderBy schema', () => {
+            it('rejects Unsupported fields in orderBy', () => {
+                const s = factory.makeFindManySchema('Item');
+
+                // valid orderBy
+                expect(s.safeParse({ orderBy: { name: 'asc' } }).success).toBe(true);
+
+                // Unsupported field in orderBy should be rejected
+                expect(s.safeParse({ orderBy: { data: 'asc' } }).success).toBe(false);
+            });
+        });
+
+        // #endregion
+
+        // #region Create schemas
+
+        describe('create schema', () => {
+            it('rejects Unsupported fields in create data (optional Unsupported)', () => {
+                const s = factory.makeCreateSchema('Item');
+
+                // valid create
+                expect(s.safeParse({ data: { name: 'test' } }).success).toBe(true);
+
+                // Unsupported field in create data should be rejected
+                expect(s.safeParse({ data: { name: 'test', data: 'some_value' } }).success).toBe(false);
+            });
+
+            it('rejects Unsupported fields in create data (required Unsupported with default)', () => {
+                const s = factory.makeCreateSchema('GeoRecordWithDefault');
+
+                // valid create (required Unsupported has default, so it's not required in input)
+                expect(s.safeParse({ data: { label: 'test' } }).success).toBe(true);
+
+                // Unsupported field in create data should still be rejected
+                expect(s.safeParse({ data: { label: 'test', area: 'some_value' } }).success).toBe(false);
+            });
+        });
+
+        // #endregion
+
+        // #region Update schemas
+
+        describe('update schema', () => {
+            it('rejects Unsupported fields in update data', () => {
+                const s = factory.makeUpdateSchema('Item');
+
+                // valid update
+                expect(s.safeParse({ where: { id: 1 }, data: { name: 'updated' } }).success).toBe(true);
+
+                // Unsupported field in update data should be rejected
+                expect(s.safeParse({ where: { id: 1 }, data: { data: 'some_value' } }).success).toBe(false);
+            });
+        });
+
+        // #endregion
+
+        // #region Distinct schema
+
+        describe('distinct schema', () => {
+            it('rejects Unsupported fields in distinct', () => {
+                const s = factory.makeFindManySchema('Item');
+
+                // valid distinct
+                expect(s.safeParse({ distinct: 'name' }).success).toBe(true);
+
+                // Unsupported field in distinct should be rejected
+                expect(s.safeParse({ distinct: 'data' }).success).toBe(false);
+            });
+        });
+
+        // #endregion
+
+        // #region Aggregate schemas
+
+        describe('aggregate schema', () => {
+            it('rejects Unsupported fields in aggregate min/max', () => {
+                const s = factory.makeAggregateSchema('Item');
+
+                // valid min/max on regular field
+                expect(s.safeParse({ _min: { name: true } }).success).toBe(true);
+                expect(s.safeParse({ _max: { name: true } }).success).toBe(true);
+
+                // Unsupported field in aggregate should be rejected
+                expect(s.safeParse({ _min: { data: true } }).success).toBe(false);
+                expect(s.safeParse({ _max: { data: true } }).success).toBe(false);
+            });
+
+            it('rejects Unsupported fields in aggregate count', () => {
+                const s = factory.makeAggregateSchema('Item');
+
+                // valid count
+                expect(s.safeParse({ _count: { name: true } }).success).toBe(true);
+
+                // Unsupported field in count should be rejected
+                expect(s.safeParse({ _count: { data: true } }).success).toBe(false);
+            });
+        });
+
+        // #endregion
+
+        // #region GroupBy schemas
+
+        describe('groupBy schema', () => {
+            it('rejects Unsupported fields in groupBy by', () => {
+                const s = factory.makeGroupBySchema('Item');
+
+                // valid groupBy
+                expect(s.safeParse({ by: 'name' }).success).toBe(true);
+
+                // Unsupported field in groupBy should be rejected
+                expect(s.safeParse({ by: 'data' }).success).toBe(false);
+            });
+        });
+
+        // #endregion
+    });
+
+    const schemaFile = path.join(__dirname, '../schemas/unsupported/schema.zmodel');
+    const clientOptions = { provider: 'postgresql' as const, usePrismaPush: true, schemaFile };
+
+    describe('ORM calls', () => {
+        let db: Awaited<ReturnType<typeof createTestClient<typeof schema, any>>>;
+
+        beforeEach(async () => {
+            db = await createTestClient(schema, clientOptions);
+        });
+
+        afterEach(async () => {
+            await db?.$disconnect();
+        });
+
+        it('rejects Unsupported fields in findMany where', async () => {
+            // valid call
+            await db.item.findMany({ where: { name: 'test' } });
+            // @ts-expect-error data (Unsupported) should not be in where
+            await expect(db.item.findMany({ where: { data: 'val' } })).toBeRejectedByValidation();
+        });
+
+        it('rejects Unsupported fields in select', async () => {
+            // valid call
+            await db.item.findMany({ select: { id: true, name: true } });
+            // @ts-expect-error data (Unsupported) should not be in select
+            await expect(db.item.findMany({ select: { data: true } })).toBeRejectedByValidation();
+        });
+
+        it('rejects Unsupported fields in omit', async () => {
+            // valid call
+            await db.item.findMany({ omit: { name: true } });
+            // @ts-expect-error data (Unsupported) should not be in omit
+            await expect(db.item.findMany({ omit: { data: true } })).toBeRejectedByValidation();
+        });
+
+        it('rejects Unsupported fields in orderBy', async () => {
+            // valid call
+            await db.item.findMany({ orderBy: { name: 'asc' } });
+            // @ts-expect-error data (Unsupported) should not be in orderBy
+            await expect(db.item.findMany({ orderBy: { data: 'asc' } })).toBeRejectedByValidation();
+        });
+
+        it('rejects Unsupported fields in create data', async () => {
+            // valid call
+            await db.item.create({ data: { name: 'test' } });
+            // @ts-expect-error data (Unsupported) should not be in create data
+            await expect(db.item.create({ data: { name: 'test', data: 'val' } })).toBeRejectedByValidation();
+        });
+
+        it('rejects Unsupported fields in update data', async () => {
+            const item = await db.item.create({ data: { name: 'test' } });
+            // valid call
+            await db.item.update({ where: { id: item.id }, data: { name: 'updated' } });
+            await expect(
+                // @ts-expect-error data (Unsupported) should not be in update data
+                db.item.update({ where: { id: item.id }, data: { data: 'val' } }),
+            ).toBeRejectedByValidation();
+        });
+
+        it('blocks create on model with required Unsupported field', () => {
+            // create should not exist on geoRecord (required Unsupported without default)
+            // @ts-expect-error create should not be defined
+            expect(db.geoRecord.create).toBeUndefined();
+        });
+
+        it('blocks upsert on model with required Unsupported field', () => {
+            // upsert should not exist on geoRecord (required Unsupported without default)
+            // @ts-expect-error upsert should not be defined
+            expect(db.geoRecord.upsert).toBeUndefined();
+        });
+
+        it('rejects nested create for model with required Unsupported field', async () => {
+            await expect(
+                db.geoParent.create({
+                    data: {
+                        name: 'parent',
+                        // @ts-expect-error create should not be allowed for GeoRecord (required Unsupported)
+                        records: { create: { title: 'test' } },
+                    },
+                }),
+            ).toBeRejectedByValidation();
+        });
+
+        it('rejects nested connectOrCreate for model with required Unsupported field', async () => {
+            await expect(
+                db.geoParent.create({
+                    data: {
+                        name: 'parent',
+                        // @ts-expect-error connectOrCreate should not be allowed for GeoRecord (required Unsupported)
+                        records: { connectOrCreate: { where: { id: 1 }, create: { title: 'test' } } },
+                    },
+                }),
+            ).toBeRejectedByValidation();
+        });
+
+        it('allows create on model with required Unsupported field that has default', async () => {
+            // GeoRecordWithDefault has a required Unsupported with @default(dbgenerated(...)),
+            // so create should be allowed at type level and runtime
+            const record = await db.geoRecordWithDefault.create({ data: { label: 'test' } });
+            expect(record.label).toBe('test');
+        });
+    });
+});
diff --git a/tests/e2e/orm/schemas/unsupported/input.ts b/tests/e2e/orm/schemas/unsupported/input.ts
new file mode 100644
index 000000000..12f5b9800
--- /dev/null
+++ b/tests/e2e/orm/schemas/unsupported/input.ts
@@ -0,0 +1,94 @@
+//////////////////////////////////////////////////////////////////////////////////////////////
+// DO NOT MODIFY THIS FILE                                                                  //
+// This file is automatically generated by ZenStack CLI and should not be manually updated. //
+//////////////////////////////////////////////////////////////////////////////////////////////
+
+/* eslint-disable */
+
+import { type SchemaType as $Schema } from "./schema";
+import type { FindManyArgs as $FindManyArgs, FindUniqueArgs as $FindUniqueArgs, FindFirstArgs as $FindFirstArgs, ExistsArgs as $ExistsArgs, CreateArgs as $CreateArgs, CreateManyArgs as $CreateManyArgs, CreateManyAndReturnArgs as $CreateManyAndReturnArgs, UpdateArgs as $UpdateArgs, UpdateManyArgs as $UpdateManyArgs, UpdateManyAndReturnArgs as $UpdateManyAndReturnArgs, UpsertArgs as $UpsertArgs, DeleteArgs as $DeleteArgs, DeleteManyArgs as $DeleteManyArgs, CountArgs as $CountArgs, AggregateArgs as $AggregateArgs, GroupByArgs as $GroupByArgs, WhereInput as $WhereInput, SelectInput as $SelectInput, IncludeInput as $IncludeInput, OmitInput as $OmitInput, QueryOptions as $QueryOptions } from "@zenstackhq/orm";
+import type { SimplifiedPlainResult as $Result, SelectIncludeOmit as $SelectIncludeOmit } from "@zenstackhq/orm";
+export type ItemFindManyArgs = $FindManyArgs<$Schema, "Item">;
+export type ItemFindUniqueArgs = $FindUniqueArgs<$Schema, "Item">;
+export type ItemFindFirstArgs = $FindFirstArgs<$Schema, "Item">;
+export type ItemExistsArgs = $ExistsArgs<$Schema, "Item">;
+export type ItemCreateArgs = $CreateArgs<$Schema, "Item">;
+export type ItemCreateManyArgs = $CreateManyArgs<$Schema, "Item">;
+export type ItemCreateManyAndReturnArgs = $CreateManyAndReturnArgs<$Schema, "Item">;
+export type ItemUpdateArgs = $UpdateArgs<$Schema, "Item">;
+export type ItemUpdateManyArgs = $UpdateManyArgs<$Schema, "Item">;
+export type ItemUpdateManyAndReturnArgs = $UpdateManyAndReturnArgs<$Schema, "Item">;
+export type ItemUpsertArgs = $UpsertArgs<$Schema, "Item">;
+export type ItemDeleteArgs = $DeleteArgs<$Schema, "Item">;
+export type ItemDeleteManyArgs = $DeleteManyArgs<$Schema, "Item">;
+export type ItemCountArgs = $CountArgs<$Schema, "Item">;
+export type ItemAggregateArgs = $AggregateArgs<$Schema, "Item">;
+export type ItemGroupByArgs = $GroupByArgs<$Schema, "Item">;
+export type ItemWhereInput = $WhereInput<$Schema, "Item">;
+export type ItemSelect = $SelectInput<$Schema, "Item">;
+export type ItemInclude = $IncludeInput<$Schema, "Item">;
+export type ItemOmit = $OmitInput<$Schema, "Item">;
+export type ItemGetPayload<Args extends $SelectIncludeOmit<$Schema, "Item", true>, Options extends $QueryOptions<$Schema> = $QueryOptions<$Schema>> = $Result<$Schema, "Item", Args, Options>;
+export type GeoRecordFindManyArgs = $FindManyArgs<$Schema, "GeoRecord">;
+export type GeoRecordFindUniqueArgs = $FindUniqueArgs<$Schema, "GeoRecord">;
+export type GeoRecordFindFirstArgs = $FindFirstArgs<$Schema, "GeoRecord">;
+export type GeoRecordExistsArgs = $ExistsArgs<$Schema, "GeoRecord">;
+export type GeoRecordCreateArgs = $CreateArgs<$Schema, "GeoRecord">;
+export type GeoRecordCreateManyArgs = $CreateManyArgs<$Schema, "GeoRecord">;
+export type GeoRecordCreateManyAndReturnArgs = $CreateManyAndReturnArgs<$Schema, "GeoRecord">;
+export type GeoRecordUpdateArgs = $UpdateArgs<$Schema, "GeoRecord">;
+export type GeoRecordUpdateManyArgs = $UpdateManyArgs<$Schema, "GeoRecord">;
+export type GeoRecordUpdateManyAndReturnArgs = $UpdateManyAndReturnArgs<$Schema, "GeoRecord">;
+export type GeoRecordUpsertArgs = $UpsertArgs<$Schema, "GeoRecord">;
+export type GeoRecordDeleteArgs = $DeleteArgs<$Schema, "GeoRecord">;
+export type GeoRecordDeleteManyArgs = $DeleteManyArgs<$Schema, "GeoRecord">;
+export type GeoRecordCountArgs = $CountArgs<$Schema, "GeoRecord">;
+export type GeoRecordAggregateArgs = $AggregateArgs<$Schema, "GeoRecord">;
+export type GeoRecordGroupByArgs = $GroupByArgs<$Schema, "GeoRecord">;
+export type GeoRecordWhereInput = $WhereInput<$Schema, "GeoRecord">;
+export type GeoRecordSelect = $SelectInput<$Schema, "GeoRecord">;
+export type GeoRecordInclude = $IncludeInput<$Schema, "GeoRecord">;
+export type GeoRecordOmit = $OmitInput<$Schema, "GeoRecord">;
+export type GeoRecordGetPayload<Args extends $SelectIncludeOmit<$Schema, "GeoRecord", true>, Options extends $QueryOptions<$Schema> = $QueryOptions<$Schema>> = $Result<$Schema, "GeoRecord", Args, Options>;
+export type GeoParentFindManyArgs = $FindManyArgs<$Schema, "GeoParent">;
+export type GeoParentFindUniqueArgs = $FindUniqueArgs<$Schema, "GeoParent">;
+export type GeoParentFindFirstArgs = $FindFirstArgs<$Schema, "GeoParent">;
+export type GeoParentExistsArgs = $ExistsArgs<$Schema, "GeoParent">;
+export type GeoParentCreateArgs = $CreateArgs<$Schema, "GeoParent">;
+export type GeoParentCreateManyArgs = $CreateManyArgs<$Schema, "GeoParent">;
+export type GeoParentCreateManyAndReturnArgs = $CreateManyAndReturnArgs<$Schema, "GeoParent">;
+export type GeoParentUpdateArgs = $UpdateArgs<$Schema, "GeoParent">;
+export type GeoParentUpdateManyArgs = $UpdateManyArgs<$Schema, "GeoParent">;
+export type GeoParentUpdateManyAndReturnArgs = $UpdateManyAndReturnArgs<$Schema, "GeoParent">;
+export type GeoParentUpsertArgs = $UpsertArgs<$Schema, "GeoParent">;
+export type GeoParentDeleteArgs = $DeleteArgs<$Schema, "GeoParent">;
+export type GeoParentDeleteManyArgs = $DeleteManyArgs<$Schema, "GeoParent">;
+export type GeoParentCountArgs = $CountArgs<$Schema, "GeoParent">;
+export type GeoParentAggregateArgs = $AggregateArgs<$Schema, "GeoParent">;
+export type GeoParentGroupByArgs = $GroupByArgs<$Schema, "GeoParent">;
+export type GeoParentWhereInput = $WhereInput<$Schema, "GeoParent">;
+export type GeoParentSelect = $SelectInput<$Schema, "GeoParent">;
+export type GeoParentInclude = $IncludeInput<$Schema, "GeoParent">;
+export type GeoParentOmit = $OmitInput<$Schema, "GeoParent">;
+export type GeoParentGetPayload<Args extends $SelectIncludeOmit<$Schema, "GeoParent", true>, Options extends $QueryOptions<$Schema> = $QueryOptions<$Schema>> = $Result<$Schema, "GeoParent", Args, Options>;
+export type GeoRecordWithDefaultFindManyArgs = $FindManyArgs<$Schema, "GeoRecordWithDefault">;
+export type GeoRecordWithDefaultFindUniqueArgs = $FindUniqueArgs<$Schema, "GeoRecordWithDefault">;
+export type GeoRecordWithDefaultFindFirstArgs = $FindFirstArgs<$Schema, "GeoRecordWithDefault">;
+export type GeoRecordWithDefaultExistsArgs = $ExistsArgs<$Schema, "GeoRecordWithDefault">;
+export type GeoRecordWithDefaultCreateArgs = $CreateArgs<$Schema, "GeoRecordWithDefault">;
+export type GeoRecordWithDefaultCreateManyArgs = $CreateManyArgs<$Schema, "GeoRecordWithDefault">;
+export type GeoRecordWithDefaultCreateManyAndReturnArgs = $CreateManyAndReturnArgs<$Schema, "GeoRecordWithDefault">;
+export type GeoRecordWithDefaultUpdateArgs = $UpdateArgs<$Schema, "GeoRecordWithDefault">;
+export type GeoRecordWithDefaultUpdateManyArgs = $UpdateManyArgs<$Schema, "GeoRecordWithDefault">;
+export type GeoRecordWithDefaultUpdateManyAndReturnArgs = $UpdateManyAndReturnArgs<$Schema, "GeoRecordWithDefault">;
+export type GeoRecordWithDefaultUpsertArgs = $UpsertArgs<$Schema, "GeoRecordWithDefault">;
+export type GeoRecordWithDefaultDeleteArgs = $DeleteArgs<$Schema, "GeoRecordWithDefault">;
+export type GeoRecordWithDefaultDeleteManyArgs = $DeleteManyArgs<$Schema, "GeoRecordWithDefault">;
+export type GeoRecordWithDefaultCountArgs = $CountArgs<$Schema, "GeoRecordWithDefault">;
+export type GeoRecordWithDefaultAggregateArgs = $AggregateArgs<$Schema, "GeoRecordWithDefault">;
+export type GeoRecordWithDefaultGroupByArgs = $GroupByArgs<$Schema, "GeoRecordWithDefault">;
+export type GeoRecordWithDefaultWhereInput = $WhereInput<$Schema, "GeoRecordWithDefault">;
+export type GeoRecordWithDefaultSelect = $SelectInput<$Schema, "GeoRecordWithDefault">;
+export type GeoRecordWithDefaultInclude = $IncludeInput<$Schema, "GeoRecordWithDefault">;
+export type GeoRecordWithDefaultOmit = $OmitInput<$Schema, "GeoRecordWithDefault">;
+export type GeoRecordWithDefaultGetPayload<Args extends $SelectIncludeOmit<$Schema, "GeoRecordWithDefault", true>, Options extends $QueryOptions<$Schema> = $QueryOptions<$Schema>> = $Result<$Schema, "GeoRecordWithDefault", Args, Options>;
diff --git a/tests/e2e/orm/schemas/unsupported/models.ts b/tests/e2e/orm/schemas/unsupported/models.ts
new file mode 100644
index 000000000..239bf0806
--- /dev/null
+++ b/tests/e2e/orm/schemas/unsupported/models.ts
@@ -0,0 +1,13 @@
+//////////////////////////////////////////////////////////////////////////////////////////////
+// DO NOT MODIFY THIS FILE                                                                  //
+// This file is automatically generated by ZenStack CLI and should not be manually updated. //
+//////////////////////////////////////////////////////////////////////////////////////////////
+
+/* eslint-disable */
+
+import { type SchemaType as $Schema } from "./schema";
+import type { ModelResult as $ModelResult } from "@zenstackhq/orm";
+export type Item = $ModelResult<$Schema, "Item">;
+export type GeoRecord = $ModelResult<$Schema, "GeoRecord">;
+export type GeoParent = $ModelResult<$Schema, "GeoParent">;
+export type GeoRecordWithDefault = $ModelResult<$Schema, "GeoRecordWithDefault">;
diff --git a/tests/e2e/orm/schemas/unsupported/schema.ts b/tests/e2e/orm/schemas/unsupported/schema.ts
new file mode 100644
index 000000000..b691406ce
--- /dev/null
+++ b/tests/e2e/orm/schemas/unsupported/schema.ts
@@ -0,0 +1,133 @@
+//////////////////////////////////////////////////////////////////////////////////////////////
+// DO NOT MODIFY THIS FILE                                                                  //
+// This file is automatically generated by ZenStack CLI and should not be manually updated. //
+//////////////////////////////////////////////////////////////////////////////////////////////
+
+/* eslint-disable */
+
+import { type SchemaDef, ExpressionUtils } from "@zenstackhq/schema";
+export class SchemaType implements SchemaDef {
+    provider = {
+        type: "postgresql"
+    } as const;
+    models = {
+        Item: {
+            name: "Item",
+            fields: {
+                id: {
+                    name: "id",
+                    type: "Int",
+                    id: true,
+                    attributes: [{ name: "@id" }, { name: "@default", args: [{ name: "value", value: ExpressionUtils.call("autoincrement") }] }],
+                    default: ExpressionUtils.call("autoincrement")
+                },
+                name: {
+                    name: "name",
+                    type: "String"
+                },
+                data: {
+                    name: "data",
+                    type: "Unsupported",
+                    optional: true
+                }
+            },
+            idFields: ["id"],
+            uniqueFields: {
+                id: { type: "Int" }
+            }
+        },
+        GeoRecord: {
+            name: "GeoRecord",
+            fields: {
+                id: {
+                    name: "id",
+                    type: "Int",
+                    id: true,
+                    attributes: [{ name: "@id" }, { name: "@default", args: [{ name: "value", value: ExpressionUtils.call("autoincrement") }] }],
+                    default: ExpressionUtils.call("autoincrement")
+                },
+                title: {
+                    name: "title",
+                    type: "String"
+                },
+                extra: {
+                    name: "extra",
+                    type: "Unsupported"
+                },
+                parent: {
+                    name: "parent",
+                    type: "GeoParent",
+                    optional: true,
+                    attributes: [{ name: "@relation", args: [{ name: "fields", value: ExpressionUtils.array("Int", [ExpressionUtils.field("parentId")]) }, { name: "references", value: ExpressionUtils.array("Int", [ExpressionUtils.field("id")]) }] }],
+                    relation: { opposite: "records", fields: ["parentId"], references: ["id"] }
+                },
+                parentId: {
+                    name: "parentId",
+                    type: "Int",
+                    optional: true,
+                    foreignKeyFor: [
+                        "parent"
+                    ]
+                }
+            },
+            idFields: ["id"],
+            uniqueFields: {
+                id: { type: "Int" }
+            }
+        },
+        GeoParent: {
+            name: "GeoParent",
+            fields: {
+                id: {
+                    name: "id",
+                    type: "Int",
+                    id: true,
+                    attributes: [{ name: "@id" }, { name: "@default", args: [{ name: "value", value: ExpressionUtils.call("autoincrement") }] }],
+                    default: ExpressionUtils.call("autoincrement")
+                },
+                name: {
+                    name: "name",
+                    type: "String"
+                },
+                records: {
+                    name: "records",
+                    type: "GeoRecord",
+                    array: true,
+                    relation: { opposite: "parent" }
+                }
+            },
+            idFields: ["id"],
+            uniqueFields: {
+                id: { type: "Int" }
+            }
+        },
+        GeoRecordWithDefault: {
+            name: "GeoRecordWithDefault",
+            fields: {
+                id: {
+                    name: "id",
+                    type: "Int",
+                    id: true,
+                    attributes: [{ name: "@id" }, { name: "@default", args: [{ name: "value", value: ExpressionUtils.call("autoincrement") }] }],
+                    default: ExpressionUtils.call("autoincrement")
+                },
+                label: {
+                    name: "label",
+                    type: "String"
+                },
+                area: {
+                    name: "area",
+                    type: "Unsupported",
+                    attributes: [{ name: "@default", args: [{ name: "value", value: ExpressionUtils.call("dbgenerated", [ExpressionUtils.literal("'<root/>'::xml")]) }] }],
+                    default: ExpressionUtils.call("dbgenerated", [ExpressionUtils.literal("'<root/>'::xml")])
+                }
+            },
+            idFields: ["id"],
+            uniqueFields: {
+                id: { type: "Int" }
+            }
+        }
+    } as const;
+    plugins = {};
+}
+export const schema = new SchemaType();
diff --git a/tests/e2e/orm/schemas/unsupported/schema.zmodel b/tests/e2e/orm/schemas/unsupported/schema.zmodel
new file mode 100644
index 000000000..8f447a6e2
--- /dev/null
+++ b/tests/e2e/orm/schemas/unsupported/schema.zmodel
@@ -0,0 +1,34 @@
+datasource db {
+    provider = "postgresql"
+    url = env('DATABASE_URL')
+}
+
+// Model with an optional Unsupported field (create should work)
+model Item {
+    id   Int                @id @default(autoincrement())
+    name String
+    data Unsupported("xml")?
+}
+
+// Model with a required Unsupported field (create should be blocked)
+model GeoRecord {
+    id       Int                @id @default(autoincrement())
+    title    String
+    extra    Unsupported("xml")
+    parent   GeoParent?         @relation(fields: [parentId], references: [id])
+    parentId Int?
+}
+
+// Parent model that has a relation to GeoRecord
+model GeoParent {
+    id      Int         @id @default(autoincrement())
+    name    String
+    records GeoRecord[]
+}
+
+// Model with a required Unsupported field that has a default (create should work)
+model GeoRecordWithDefault {
+    id    Int                @id @default(autoincrement())
+    label String
+    area  Unsupported("xml") @default(dbgenerated("'<root/>'::xml"))
+}