@zenstackhq/orm 3.5.0-beta.3 → 3.5.0-beta.4

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import * as _zenstackhq_schema from '@zenstackhq/schema';
-import { SchemaDef, GetModels, ScalarFields, ForeignKeyFields, GetModelFields, FieldHasDefault, GetModelFieldType, ModelFieldIsOptional, GetModelField, GetModel, ProcedureDef, BuiltinType, FieldDef, ModelDef, DataSourceProviderType, NonRelationFields, RelationFields, FieldIsArray, RelationFieldType, FieldIsRelation, GetEnums, GetEnum, GetTypeDefs, GetTypeDefFields, GetTypeDefField, TypeDefFieldIsOptional, GetTypeDefFieldType, TypeDefFieldIsArray, UpdatedAtInfo, FieldIsDelegateDiscriminator, FieldType, RelationInfo, FieldIsDelegateRelation, IsDelegateModel, Expression as Expression$1, LiteralExpression, ArrayExpression, FieldExpression, MemberExpression, BinaryExpression, UnaryExpression, CallExpression, BindingExpression, ThisExpression, NullExpression } from '@zenstackhq/schema';
+import { SchemaDef, GetModels, ScalarFields, ForeignKeyFields, GetModelFields, FieldHasDefault, GetModelFieldType, ModelFieldIsOptional, GetModelField, NonRelationFields, GetModel, ProcedureDef, BuiltinType, FieldDef, ModelDef, DataSourceProviderType, IsDelegateModel, RelationFields, FieldIsArray, RelationFieldType, FieldIsRelation, GetEnums, GetEnum, GetTypeDefs, GetTypeDefFields, GetTypeDefField, TypeDefFieldIsOptional, GetTypeDefFieldType, TypeDefFieldIsArray, UpdatedAtInfo, FieldIsDelegateDiscriminator, FieldType, RelationInfo, Expression as Expression$1, LiteralExpression, ArrayExpression, FieldExpression, MemberExpression, BinaryExpression, UnaryExpression, CallExpression, BindingExpression, ThisExpression, NullExpression } from '@zenstackhq/schema';
 import * as kysely from 'kysely';
 import { Kysely, OperationNodeVisitor, OperationNode, SelectQueryNode, SelectionNode, ColumnNode, AliasNode, TableNode, FromNode, ReferenceNode, AndNode, OrNode, ValueListNode, ParensNode, JoinNode, RawNode, WhereNode, InsertQueryNode, DeleteQueryNode, ReturningNode, CreateTableNode, AddColumnNode, ColumnDefinitionNode, DropTableNode, OrderByNode, OrderByItemNode, GroupByNode, GroupByItemNode, UpdateQueryNode, ColumnUpdateNode, LimitNode, OffsetNode, OnConflictNode, OnDuplicateKeyNode, CheckConstraintNode, DataTypeNode, SelectAllNode, IdentifierNode, SchemableIdentifierNode, ValueNode, PrimitiveValueListNode, OperatorNode, CreateIndexNode, DropIndexNode, ListNode, PrimaryKeyConstraintNode, UniqueConstraintNode, ReferencesNode, WithNode, CommonTableExpressionNode, CommonTableExpressionNameNode, HavingNode, CreateSchemaNode, DropSchemaNode, AlterTableNode, DropColumnNode, RenameColumnNode, AlterColumnNode, ModifyColumnNode, AddConstraintNode, DropConstraintNode, ForeignKeyConstraintNode, CreateViewNode, DropViewNode, GeneratedNode, DefaultValueNode, OnNode, ValuesNode, SelectModifierNode, CreateTypeNode, DropTypeNode, ExplainNode, DefaultInsertValueNode, AggregateFunctionNode, OverNode, PartitionByNode, PartitionByItemNode, SetOperationNode, BinaryOperationNode, UnaryOperationNode, UsingNode, FunctionNode, CaseNode, WhenNode, JSONReferenceNode, JSONPathNode, JSONPathLegNode, JSONOperatorChainNode, TupleNode, MergeQueryNode, MatchedNode, AddIndexNode, CastNode, FetchNode, TopNode, OutputNode, RenameConstraintNode, RefreshMaterializedViewNode, OrActionNode, CollateNode, Generated, QueryId, RootOperationNode, QueryResult, UnknownRow, Dialect, ExpressionBuilder, Expression, KyselyConfig, OperandExpression, SelectQueryBuilder, SqlBool, AliasableExpression, ExpressionWrapper } from 'kysely';
 import Decimal from 'decimal.js';
@@ -258,10 +258,53 @@ type ExtQueryArgsBase = {
  * Member names should start with '$' to avoid model name conflicts.
  */
 type ExtClientMembersBase = Record<string, unknown>;
+/**
+ * Base shape of plugin-extended result fields.
+ * Keyed by model name, each value maps field names to their definitions.
+ * `needs` keys are constrained to non-relation fields of the corresponding model.
+ */
+type ExtResultBase<Schema extends SchemaDef = SchemaDef> = {
+    [M in GetModels<Schema> as Uncapitalize<M>]?: Record<string, {
+        needs: Partial<Record<NonRelationFields<Schema, M>, true>>;
+        compute: (...args: any[]) => any;
+    }>;
+};
+/**
+ * Mapped type that provides per-field contextual typing for `compute` callbacks
+ * based on the `needs` declaration. Uses a separate type parameter `R_` that captures
+ * the needs shape (model → field → { neededField: true }), then links each field's
+ * `compute` parameter to exactly the keys declared in its `needs`.
+ */
+type ExtResultInferenceArgs<Schema extends SchemaDef, R_> = {
+    [K in keyof R_ & string]: {
+        [P in keyof R_[K]]?: {
+            needs?: {
+                [F in keyof R_[K][P]]: F extends NonRelationFields<Schema, ModelNameFromKey<Schema, K>> ? true : never;
+            } & Partial<Record<NonRelationFields<Schema, ModelNameFromKey<Schema, K>>, true>>;
+            compute: (data: ExtResultComputeData<Schema, ModelNameFromKey<Schema, K>, R_[K][P]>) => unknown;
+        };
+    };
+};
+/**
+ * Reverse-maps an uncapitalized key back to the original model name in the schema.
+ * E.g., for a schema with model `myModel`, the key `myModel` maps back to `myModel`
+ * (not `MyModel` as `Capitalize` would produce).
+ */
+type ModelNameFromKey<Schema extends SchemaDef, K extends string> = {
+    [M in GetModels<Schema>]: Uncapitalize<M> extends K ? M : never;
+}[GetModels<Schema>];
+/**
+ * Maps the needs shape `S` to an object with actual schema field types.
+ * For each key in `S` that is a valid non-relation field of model `M`,
+ * resolves the TypeScript type from the schema field definition.
+ */
+type ExtResultComputeData<Schema extends SchemaDef, M extends GetModels<Schema>, S> = {
+    [F in keyof S & GetModelFields<Schema, M>]: MapModelFieldType<Schema, M, F>;
+};
 /**
  * ZenStack runtime plugin.
  */
-interface RuntimePlugin<Schema extends SchemaDef, ExtQueryArgs extends ExtQueryArgsBase, ExtClientMembers extends Record<string, unknown>> {
+interface RuntimePlugin<Schema extends SchemaDef, ExtQueryArgs extends ExtQueryArgsBase, ExtClientMembers extends Record<string, unknown>, ExtResult extends ExtResultBase<Schema>> {
     /**
      * Plugin ID.
      */
@@ -305,12 +348,57 @@ interface RuntimePlugin<Schema extends SchemaDef, ExtQueryArgs extends ExtQueryA
      * Extended client members (methods and properties).
      */
     client?: ExtClientMembers;
+    /**
+     * Extended result fields on query results.
+     * Keyed by model name, each value defines computed fields with `needs` and `compute`.
+     */
+    result?: ExtResult;
 }
-type AnyPlugin = RuntimePlugin<any, any, any>;
+type AnyPlugin = RuntimePlugin<any, any, any, any>;
+/**
+ * Defines a ZenStack runtime plugin based on type of the given schema.
+ *
+ * @see {@link https://zenstack.dev/docs/orm/plugins/|Plugin Documentation}
+ *
+ * @example
+ * ```typescript
+ * definePlugin(schema, {
+ *     id: 'my-plugin',
+ *     result: {
+ *         user: {
+ *             fullName: {
+ *                 needs: { firstName: true, lastName: true },
+ *                 compute: (user) => `${user.firstName} ${user.lastName}`,
+ *             },
+ *         },
+ *     },
+ * });
+ * ```
+ */
+declare function definePlugin<Schema extends SchemaDef, const ExtQueryArgs extends ExtQueryArgsBase = {}, const ExtClientMembers extends Record<string, unknown> = {}, const ExtResult extends ExtResultBase<Schema> = {}, R_ = {}>(schema: Schema, plugin: RuntimePlugin<Schema, ExtQueryArgs, ExtClientMembers, ExtResult> & {
+    result?: ExtResultInferenceArgs<Schema, R_>;
+}): RuntimePlugin<Schema, ExtQueryArgs, ExtClientMembers, ExtResult>;
 /**
  * Defines a ZenStack runtime plugin.
- */
-declare function definePlugin<Schema extends SchemaDef, const ExtQueryArgs extends ExtQueryArgsBase = {}, const ExtClientMembers extends Record<string, unknown> = {}>(plugin: RuntimePlugin<Schema, ExtQueryArgs, ExtClientMembers>): RuntimePlugin<any, ExtQueryArgs, ExtClientMembers>;
+ *
+ * @see {@link https://zenstack.dev/docs/orm/plugins/|Plugin Documentation}
+ *
+ * @example
+ * ```typescript
+ * definePlugin(schema, {
+ *     id: 'my-plugin',
+ *     result: {
+ *         user: {
+ *             fullName: {
+ *                 needs: { firstName: true, lastName: true },
+ *                 compute: (user) => `${user.firstName} ${user.lastName}`,
+ *             },
+ *         },
+ *     },
+ * });
+ * ```
+ *  */
+declare function definePlugin<Schema extends SchemaDef, const ExtQueryArgs extends ExtQueryArgsBase = {}, const ExtClientMembers extends Record<string, unknown> = {}, const ExtResult extends ExtResultBase<Schema> = {}>(plugin: RuntimePlugin<Schema, ExtQueryArgs, ExtClientMembers, ExtResult>): RuntimePlugin<Schema, ExtQueryArgs, ExtClientMembers, ExtResult>;
 type OnProcedureCallback<Schema extends SchemaDef> = (ctx: OnProcedureHookContext<Schema>) => Promise<unknown>;
 type OnProcedureHookContext<Schema extends SchemaDef> = {
     /**
@@ -648,12 +736,12 @@ type ClientOptions<Schema extends SchemaDef> = QueryOptions<Schema> & {
  * Config for omitting fields in ORM query results.
  */
 type OmitConfig<Schema extends SchemaDef> = {
-    [Model in GetModels<Schema>]?: {
+    [Model in GetModels<Schema> as Uncapitalize<Model>]?: {
         [Field in GetModelFields<Schema, Model> as Field extends ScalarFields<Schema, Model> ? Field : never]?: boolean;
     };
 };
 type ComputedFieldsOptions<Schema extends SchemaDef> = {
-    [Model in GetModels<Schema> as 'computedFields' extends keyof GetModel<Schema, Model> ? Model : never]: {
+    [Model in GetModels<Schema> as 'computedFields' extends keyof GetModel<Schema, Model> ? Uncapitalize<Model> : never]: {
         [Field in keyof Schema['models'][Model]['computedFields']]: Schema['models'][Model]['computedFields'][Field] extends infer Func ? Func extends (...args: any[]) => infer R ? (p: ExpressionBuilder<ToKyselySchema<Schema>, Model>, ...args: Parameters<Func>) => OperandExpression<R> : never : never;
     };
 };
@@ -932,6 +1020,17 @@ declare const AllReadOperations: readonly ["findMany", "findUnique", "findFirst"
  */
 type AllReadOperations = (typeof AllReadOperations)[number];
 
+/**
+ * Checks if a model has any required Unsupported fields (non-optional, no default).
+ * Uses raw field access since `GetModelFields` excludes Unsupported fields.
+ */
+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).
+ */
+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;
 /**
  * Filters models based on slicing configuration.
@@ -1005,10 +1104,10 @@ type DefaultModelResult<Schema extends SchemaDef, Model extends GetModels<Schema
 }, Optional, Array>;
 type ShouldOmitField<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema>, Field extends GetModelFields<Schema, Model>, Omit> = QueryLevelOmit<Schema, Model, Field, Omit> extends boolean ? QueryLevelOmit<Schema, Model, Field, Omit> : OptionsLevelOmit<Schema, Model, Field, Options> extends boolean ? OptionsLevelOmit<Schema, Model, Field, Options> : SchemaLevelOmit<Schema, Model, Field>;
 type QueryLevelOmit<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends GetModelFields<Schema, Model>, Omit> = Field extends keyof Omit ? (Omit[Field] extends boolean ? Omit[Field] : undefined) : undefined;
-type OptionsLevelOmit<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends GetModelFields<Schema, Model>, Options extends QueryOptions<Schema>> = Model extends keyof Options['omit'] ? Field extends keyof Options['omit'][Model] ? Options['omit'][Model][Field] extends boolean ? Options['omit'][Model][Field] : undefined : undefined : undefined;
+type OptionsLevelOmit<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends GetModelFields<Schema, Model>, Options extends QueryOptions<Schema>> = Uncapitalize<Model> extends keyof Options['omit'] ? Field extends keyof Options['omit'][Uncapitalize<Model>] ? Options['omit'][Uncapitalize<Model>][Field] extends boolean ? Options['omit'][Uncapitalize<Model>][Field] : undefined : undefined : undefined;
 type SchemaLevelOmit<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends GetModelFields<Schema, Model>> = GetModelField<Schema, Model, Field>['omit'] extends true ? true : false;
-type ModelSelectResult<Schema extends SchemaDef, Model extends GetModels<Schema>, Select, Omit, Options extends QueryOptions<Schema>> = {
-    [Key in keyof Select as Select[Key] extends false | undefined ? never : Key extends '_count' ? Select[Key] extends SelectCount<Schema, Model, Options> ? Key : never : Key extends keyof Omit ? Omit[Key] extends true ? never : Key : Key]: Key extends '_count' ? SelectCountResult<Schema, Model, Select[Key]> : Key extends NonRelationFields<Schema, Model> ? MapModelFieldType<Schema, Model, Key> : Key extends RelationFields<Schema, Model> ? ModelResult<Schema, RelationFieldType<Schema, Model, Key>, Select[Key], Options, ModelFieldIsOptional<Schema, Model, Key>, FieldIsArray<Schema, Model, Key>> : never;
+type ModelSelectResult<Schema extends SchemaDef, Model extends GetModels<Schema>, Select, Omit, Options extends QueryOptions<Schema>, ExtResult extends ExtResultBase<Schema> = {}> = {
+    [Key in keyof Select as Select[Key] extends false | undefined ? never : Key extends keyof ExtractExtResult<ExtResult, Model & string> ? never : Key extends '_count' ? Select[Key] extends SelectCount<Schema, Model, Options> ? Key : never : Key extends keyof Omit ? Omit[Key] extends true ? never : Key : Key]: Key extends '_count' ? SelectCountResult<Schema, Model, Select[Key]> : Key extends NonRelationFields<Schema, Model> ? MapModelFieldType<Schema, Model, Key> : Key extends RelationFields<Schema, Model> ? ModelResult<Schema, RelationFieldType<Schema, Model, Key>, Select[Key], Options, ModelFieldIsOptional<Schema, Model, Key>, FieldIsArray<Schema, Model, Key>, ExtResult> : never;
 };
 type SelectCountResult<Schema extends SchemaDef, Model extends GetModels<Schema>, C> = C extends true ? {
     [Key in RelationFields<Schema, Model> as FieldIsArray<Schema, Model, Key> extends true ? Key : never]: number;
@@ -1017,22 +1116,22 @@ type SelectCountResult<Schema extends SchemaDef, Model extends GetModels<Schema>
 } ? {
     [Key in keyof S]: number;
 } : never;
-type ModelResult<Schema extends SchemaDef, Model extends GetModels<Schema>, Args = {}, Options extends QueryOptions<Schema> = QueryOptions<Schema>, Optional = false, Array = false> = WrapType<Args extends {
+type ModelResult<Schema extends SchemaDef, Model extends GetModels<Schema>, Args = {}, Options extends QueryOptions<Schema> = QueryOptions<Schema>, Optional = false, Array = false, ExtResult extends ExtResultBase<Schema> = {}> = WrapType<(Args extends {
     select: infer S extends object;
     omit?: infer O extends object;
-} & Record<string, unknown> ? ModelSelectResult<Schema, Model, S, O, Options> : Args extends {
+} & Record<string, unknown> ? ModelSelectResult<Schema, Model, S, O, Options, ExtResult> : Args extends {
     include: infer I extends object;
     omit?: infer O extends object;
 } & Record<string, unknown> ? // select all non-omitted scalar fields
 DefaultModelResult<Schema, Model, O, Options, false, false> & {
-    [Key in keyof I & RelationFields<Schema, Model> as I[Key] extends false | undefined ? never : Key]: ModelResult<Schema, RelationFieldType<Schema, Model, Key>, I[Key], Options, ModelFieldIsOptional<Schema, Model, Key>, FieldIsArray<Schema, Model, Key>>;
+    [Key in keyof I & RelationFields<Schema, Model> as I[Key] extends false | undefined ? never : Key]: ModelResult<Schema, RelationFieldType<Schema, Model, Key>, I[Key], Options, ModelFieldIsOptional<Schema, Model, Key>, FieldIsArray<Schema, Model, Key>, ExtResult>;
 } & ('_count' extends keyof I ? I['_count'] extends false | undefined ? {} : {
     _count: SelectCountResult<Schema, Model, I['_count']>;
 } : {}) : Args extends {
     omit: infer O;
-} & Record<string, unknown> ? DefaultModelResult<Schema, Model, O, Options, false, false> : DefaultModelResult<Schema, Model, undefined, Options, false, false>, Optional, Array>;
-type SimplifiedResult<Schema extends SchemaDef, Model extends GetModels<Schema>, Args = {}, Options extends QueryOptions<Schema> = QueryOptions<Schema>, Optional = false, Array = false> = Simplify<ModelResult<Schema, Model, Args, Options, Optional, Array>>;
-type SimplifiedPlainResult<Schema extends SchemaDef, Model extends GetModels<Schema>, Args = {}, Options extends QueryOptions<Schema> = QueryOptions<Schema>> = Simplify<ModelResult<Schema, Model, Args, Options, false, false>>;
+} & Record<string, unknown> ? DefaultModelResult<Schema, Model, O, Options, false, false> : DefaultModelResult<Schema, Model, undefined, Options, false, false>) & SelectAwareExtResult<ExtResult, Model & string, Args>, Optional, Array>;
+type SimplifiedResult<Schema extends SchemaDef, Model extends GetModels<Schema>, Args = {}, Options extends QueryOptions<Schema> = QueryOptions<Schema>, Optional = false, Array = false, ExtResult extends ExtResultBase<Schema> = {}> = Simplify<ModelResult<Schema, Model, Args, Options, Optional, Array, ExtResult>>;
+type SimplifiedPlainResult<Schema extends SchemaDef, Model extends GetModels<Schema>, Args = {}, Options extends QueryOptions<Schema> = QueryOptions<Schema>, ExtResult extends ExtResultBase<Schema> = {}> = Simplify<ModelResult<Schema, Model, Args, Options, false, false, ExtResult>>;
 type TypeDefResult<Schema extends SchemaDef, TypeDef extends GetTypeDefs<Schema>, Partial extends boolean = false> = PartialIf<Optional<{
     [Key in GetTypeDefFields<Schema, TypeDef>]: MapFieldDefType<Schema, GetTypeDefField<Schema, TypeDef, Key>, Partial>;
 }, Partial extends true ? never : keyof {
@@ -1379,24 +1478,24 @@ type WhereUniqueInput<Schema extends SchemaDef, Model extends GetModels<Schema>,
 type OmitInput<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
     [Key in NonRelationFields<Schema, Model>]?: boolean;
 };
-type SelectIncludeOmit<Schema extends SchemaDef, Model extends GetModels<Schema>, AllowCount extends boolean, Options extends QueryOptions<Schema> = QueryOptions<Schema>, AllowRelation extends boolean = true> = {
+type SelectIncludeOmit<Schema extends SchemaDef, Model extends GetModels<Schema>, AllowCount extends boolean, Options extends QueryOptions<Schema> = QueryOptions<Schema>, AllowRelation extends boolean = true, ExtResult extends ExtResultBase<Schema> = {}> = {
     /**
      * Explicitly select fields and relations to be returned by the query.
      */
-    select?: SelectInput<Schema, Model, Options, AllowCount, AllowRelation> | null;
+    select?: (SelectInput<Schema, Model, Options, AllowCount, AllowRelation, ExtResult> & ExtResultSelectOmitFields<ExtResult, Model & string>) | null;
     /**
      * Explicitly omit fields from the query result.
      */
-    omit?: OmitInput<Schema, Model> | null;
+    omit?: (OmitInput<Schema, Model> & ExtResultSelectOmitFields<ExtResult, Model & string>) | null;
 } & (AllowRelation extends true ? {
     /**
      * Specifies relations to be included in the query result. All scalar fields are included.
      */
-    include?: IncludeInput<Schema, Model, Options, AllowCount> | null;
+    include?: IncludeInput<Schema, Model, Options, AllowCount, ExtResult> | null;
 } : {});
-type SelectInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>, AllowCount extends boolean = true, AllowRelation extends boolean = true> = {
+type SelectInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>, AllowCount extends boolean = true, AllowRelation extends boolean = true, ExtResult extends ExtResultBase<Schema> = {}> = {
     [Key in NonRelationFields<Schema, Model>]?: boolean;
-} & (AllowRelation extends true ? IncludeInput<Schema, Model, Options, AllowCount> : {});
+} & (AllowRelation extends true ? IncludeInput<Schema, Model, Options, AllowCount, ExtResult> : {});
 type SelectCount<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema>> = boolean | {
     /**
      * Selects specific relations to count.
@@ -1407,8 +1506,8 @@ type SelectCount<Schema extends SchemaDef, Model extends GetModels<Schema>, Opti
         };
     };
 };
-type IncludeInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>, AllowCount extends boolean = true> = {
-    [Key in RelationFields<Schema, Model> as RelationFieldType<Schema, Model, Key> extends GetSlicedModels<Schema, Options> ? Key : never]?: boolean | FindArgs<Schema, RelationFieldType<Schema, Model, Key>, Options, FieldIsArray<Schema, Model, Key>, FieldIsArray<Schema, Model, Key> extends true ? true : ModelFieldIsOptional<Schema, Model, Key> extends true ? true : false>;
+type IncludeInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>, AllowCount extends boolean = true, ExtResult extends ExtResultBase<Schema> = {}> = {
+    [Key in RelationFields<Schema, Model> as RelationFieldType<Schema, Model, Key> extends GetSlicedModels<Schema, Options> ? Key : never]?: boolean | FindArgs<Schema, RelationFieldType<Schema, Model, Key>, Options, FieldIsArray<Schema, Model, Key>, FieldIsArray<Schema, Model, Key> extends true ? true : ModelFieldIsOptional<Schema, Model, Key> extends true ? true : false, ExtResult>;
 } & (AllowCount extends true ? HasToManyRelations<Schema, Model> extends true ? {
     _count?: SelectCount<Schema, Model, Options>;
 } : {} : {});
@@ -1473,23 +1572,23 @@ type SortAndTakeArgs<Schema extends SchemaDef, Model extends GetModels<Schema>,
      */
     cursor?: WhereUniqueInput<Schema, Model, Options>;
 };
-type FindArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema>, Collection extends boolean, AllowFilter extends boolean = true> = (Collection extends true ? SortAndTakeArgs<Schema, Model, Options> & (ProviderSupportsDistinct<Schema> extends true ? {
+type FindArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema>, Collection extends boolean, AllowFilter extends boolean = true, ExtResult extends ExtResultBase<Schema> = {}> = (Collection extends true ? SortAndTakeArgs<Schema, Model, Options> & (ProviderSupportsDistinct<Schema> extends true ? {
     /**
      * Distinct fields. Only supported by providers that natively support SQL "DISTINCT ON".
      */
     distinct?: OrArray<NonRelationFields<Schema, Model>>;
-} : {}) : {}) & (AllowFilter extends true ? FilterArgs<Schema, Model, Options> : {}) & SelectIncludeOmit<Schema, Model, true, Options>;
-type FindManyArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase = {}> = FindArgs<Schema, Model, Options, true> & ExtractExtQueryArgs<ExtQueryArgs, 'findMany'>;
-type FindFirstArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase = {}> = FindArgs<Schema, Model, Options, true> & ExtractExtQueryArgs<ExtQueryArgs, 'findFirst'>;
+} : {}) : {}) & (AllowFilter extends true ? FilterArgs<Schema, Model, Options> : {}) & SelectIncludeOmit<Schema, Model, true, Options, true, ExtResult>;
+type FindManyArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase = {}, ExtResult extends ExtResultBase<Schema> = {}> = FindArgs<Schema, Model, Options, true, true, ExtResult> & ExtractExtQueryArgs<ExtQueryArgs, 'findMany'>;
+type FindFirstArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase = {}, ExtResult extends ExtResultBase<Schema> = {}> = FindArgs<Schema, Model, Options, true, true, ExtResult> & ExtractExtQueryArgs<ExtQueryArgs, 'findFirst'>;
 type ExistsArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase = {}> = FilterArgs<Schema, Model, Options> & ExtractExtQueryArgs<ExtQueryArgs, 'exists'>;
-type FindUniqueArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase = {}> = {
+type FindUniqueArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase = {}, ExtResult extends ExtResultBase<Schema> = {}> = {
     where: WhereUniqueInput<Schema, Model, Options>;
-} & SelectIncludeOmit<Schema, Model, true, Options> & ExtractExtQueryArgs<ExtQueryArgs, 'findUnique'>;
-type CreateArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase = {}> = {
+} & SelectIncludeOmit<Schema, Model, true, Options, true, ExtResult> & ExtractExtQueryArgs<ExtQueryArgs, 'findUnique'>;
+type CreateArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase = {}, ExtResult extends ExtResultBase<Schema> = {}> = {
     data: CreateInput<Schema, Model, Options>;
-} & SelectIncludeOmit<Schema, Model, true, Options> & ExtractExtQueryArgs<ExtQueryArgs, 'create'>;
+} & SelectIncludeOmit<Schema, Model, true, Options, true, ExtResult> & ExtractExtQueryArgs<ExtQueryArgs, 'create'>;
 type CreateManyArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, _Options extends QueryOptions<Schema> = QueryOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase = {}> = CreateManyInput<Schema, Model> & ExtractExtQueryArgs<ExtQueryArgs, 'createMany'>;
-type CreateManyAndReturnArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase = {}> = CreateManyInput<Schema, Model> & SelectIncludeOmit<Schema, Model, false, Options, false> & ExtractExtQueryArgs<ExtQueryArgs, 'createManyAndReturn'>;
+type CreateManyAndReturnArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase = {}, ExtResult extends ExtResultBase<Schema> = {}> = CreateManyInput<Schema, Model> & SelectIncludeOmit<Schema, Model, false, Options, false, ExtResult> & ExtractExtQueryArgs<ExtQueryArgs, 'createManyAndReturn'>;
 type OptionalWrap<Schema extends SchemaDef, Model extends GetModels<Schema>, T extends object> = Optional<T, keyof T & OptionalFieldsForCreate<Schema, Model>>;
 type CreateScalarPayload<Schema extends SchemaDef, Model extends GetModels<Schema>> = OptionalWrap<Schema, Model, {
     [Key in ScalarFields<Schema, Model, false> as FieldIsDelegateDiscriminator<Schema, Model, Key> extends true ? never : Key]: ScalarCreatePayload<Schema, Model, Key>;
@@ -1502,6 +1601,7 @@ type IsJsonField<Schema extends SchemaDef, Model extends GetModels<Schema>, Fiel
 type CreateFKPayload<Schema extends SchemaDef, Model extends GetModels<Schema>> = OptionalWrap<Schema, Model, {
     [Key in ForeignKeyFields<Schema, Model>]: MapModelFieldType<Schema, Model, Key>;
 }>;
+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>, Field extends RelationFields<Schema, Model>, Options extends QueryOptions<Schema>> = Omit<{
     /**
      * Connects or create a related record.
@@ -1519,7 +1619,7 @@ type CreateRelationFieldPayload<Schema extends SchemaDef, Model extends GetModel
      * Connects an existing record.
      */
     connect?: ConnectInput<Schema, Model, Field, Options>;
-}, (FieldIsArray<Schema, Model, Field> extends true ? never : 'createMany') | (FieldIsDelegateRelation<Schema, Model, Field> extends true ? 'create' | 'createMany' | 'connectOrCreate' : never)>;
+}, (FieldIsArray<Schema, Model, Field> extends true ? never : 'createMany') | (RelationModelAllowsCreate<Schema, Model, Field> extends true ? never : 'create' | 'createMany' | 'connectOrCreate')>;
 type CreateRelationPayload<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema>> = OptionalWrap<Schema, Model, {
     [Key in RelationFields<Schema, Model> as RelationFieldType<Schema, Model, Key> extends GetSlicedModels<Schema, Options> ? Key : never]: CreateRelationFieldPayload<Schema, Model, Key, Options>;
 }>;
@@ -1551,7 +1651,7 @@ type CreateManyInput<Schema extends SchemaDef, Model extends GetModels<Schema>,
 type CreateInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema>, Without extends string = never> = XOR<Omit<CreateWithFKInput<Schema, Model, Options>, Without>, Omit<CreateWithRelationInput<Schema, Model, Options>, Without>>;
 type NestedCreateInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>, Options extends QueryOptions<Schema>> = OrArray<CreateInput<Schema, RelationFieldType<Schema, Model, Field>, Options, OppositeRelationAndFK<Schema, Model, Field>>, FieldIsArray<Schema, Model, Field>>;
 type NestedCreateManyInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>> = CreateManyInput<Schema, RelationFieldType<Schema, Model, Field>, OppositeRelationAndFK<Schema, Model, Field>>;
-type UpdateArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase = {}> = {
+type UpdateArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase = {}, ExtResult extends ExtResultBase<Schema> = {}> = {
     /**
      * The data to update the record with.
      */
@@ -1560,9 +1660,9 @@ type UpdateArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, Optio
      * The unique filter to find the record to update.
      */
     where: WhereUniqueInput<Schema, Model, Options>;
-} & SelectIncludeOmit<Schema, Model, true, Options> & ExtractExtQueryArgs<ExtQueryArgs, 'update'>;
+} & SelectIncludeOmit<Schema, Model, true, Options, true, ExtResult> & ExtractExtQueryArgs<ExtQueryArgs, 'update'>;
 type UpdateManyArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase = {}> = UpdateManyPayload<Schema, Model, Options> & ExtractExtQueryArgs<ExtQueryArgs, 'updateMany'>;
-type UpdateManyAndReturnArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase = {}> = UpdateManyPayload<Schema, Model, Options> & SelectIncludeOmit<Schema, Model, false, Options, false> & ExtractExtQueryArgs<ExtQueryArgs, 'updateManyAndReturn'>;
+type UpdateManyAndReturnArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase = {}, ExtResult extends ExtResultBase<Schema> = {}> = UpdateManyPayload<Schema, Model, Options> & SelectIncludeOmit<Schema, Model, false, Options, false, ExtResult> & ExtractExtQueryArgs<ExtQueryArgs, 'updateManyAndReturn'>;
 type UpdateManyPayload<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>, Without extends string = never> = {
     /**
      * The data to update the records with.
@@ -1577,7 +1677,7 @@ type UpdateManyPayload<Schema extends SchemaDef, Model extends GetModels<Schema>
      */
     limit?: number;
 };
-type UpsertArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase = {}> = {
+type UpsertArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase = {}, ExtResult extends ExtResultBase<Schema> = {}> = {
     /**
      * The data to create the record if it doesn't exist.
      */
@@ -1590,7 +1690,7 @@ type UpsertArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, Optio
      * The unique filter to find the record to update.
      */
     where: WhereUniqueInput<Schema, Model, Options>;
-} & SelectIncludeOmit<Schema, Model, true, Options> & ExtractExtQueryArgs<ExtQueryArgs, 'upsert'>;
+} & SelectIncludeOmit<Schema, Model, true, Options, true, ExtResult> & ExtractExtQueryArgs<ExtQueryArgs, 'upsert'>;
 type UpdateScalarInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Without extends string = never> = Omit<{
     [Key in NonRelationFields<Schema, Model> as FieldIsDelegateDiscriminator<Schema, Model, Key> extends true ? never : Key]?: ScalarUpdatePayload<Schema, Model, Key>;
 }, Without>;
@@ -1675,7 +1775,7 @@ type ToManyRelationUpdateInput<Schema extends SchemaDef, Model extends GetModels
      * Sets the related records to the specified ones.
      */
     set?: SetRelationInput<Schema, Model, Field, Options>;
-}, FieldIsDelegateRelation<Schema, Model, Field> extends true ? 'create' | 'createMany' | 'connectOrCreate' | 'upsert' : never>;
+}, RelationModelAllowsCreate<Schema, Model, Field> extends true ? never : 'create' | 'createMany' | 'connectOrCreate' | 'upsert'>;
 type ToOneRelationUpdateInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>, Options extends QueryOptions<Schema>> = Omit<{
     /**
      * Creates a related record.
@@ -1706,13 +1806,13 @@ type ToOneRelationUpdateInput<Schema extends SchemaDef, Model extends GetModels<
      * Deletes the related record.
      */
     delete?: NestedDeleteInput<Schema, Model, Field, Options>;
-} : {}), FieldIsDelegateRelation<Schema, Model, Field> extends true ? 'create' | 'connectOrCreate' | 'upsert' : never>;
-type DeleteArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase = {}> = {
+} : {}), RelationModelAllowsCreate<Schema, Model, Field> extends true ? never : 'create' | 'connectOrCreate' | 'upsert'>;
+type DeleteArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase = {}, ExtResult extends ExtResultBase<Schema> = {}> = {
     /**
      * The unique filter to find the record to delete.
      */
     where: WhereUniqueInput<Schema, Model, Options>;
-} & SelectIncludeOmit<Schema, Model, true, Options> & ExtractExtQueryArgs<ExtQueryArgs, 'delete'>;
+} & SelectIncludeOmit<Schema, Model, true, Options, true, ExtResult> & ExtractExtQueryArgs<ExtQueryArgs, 'delete'>;
 type DeleteManyArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase = {}> = {
     /**
      * Filter to select records to delete.
@@ -2023,6 +2123,37 @@ type ProviderSupportsDistinct<Schema extends SchemaDef> = Schema['provider']['ty
  * Extracts extended query args for a specific operation.
  */
 type ExtractExtQueryArgs<ExtQueryArgs, Operation extends CoreCrudOperations> = (Operation extends keyof ExtQueryArgs ? ExtQueryArgs[Operation] : {}) & ('$create' extends keyof ExtQueryArgs ? Operation extends CoreCreateOperations ? ExtQueryArgs['$create'] : {} : {}) & ('$read' extends keyof ExtQueryArgs ? (Operation extends CoreReadOperations ? ExtQueryArgs['$read'] : {}) : {}) & ('$update' extends keyof ExtQueryArgs ? Operation extends CoreUpdateOperations ? ExtQueryArgs['$update'] : {} : {}) & ('$delete' extends keyof ExtQueryArgs ? Operation extends CoreDeleteOperations ? ExtQueryArgs['$delete'] : {} : {}) & ('$all' extends keyof ExtQueryArgs ? ExtQueryArgs['$all'] : {});
+/**
+ * Extracts extended result field types for a specific model from ExtResult.
+ * Maps `{ needs, compute }` definitions to `{ fieldName: ReturnType<compute> }`.
+ * When ExtResult is `{}`, this resolves to `{}` (no-op for intersection).
+ */
+type ExtractExtResult<ExtResult extends ExtResultBase, Model extends string> = Uncapitalize<Model> extends keyof ExtResult ? {
+    [K in keyof ExtResult[Uncapitalize<Model>]]: ExtResult[Uncapitalize<Model>][K] extends {
+        compute: (...args: any[]) => infer R;
+    } ? R : never;
+} : {};
+/**
+ * Extracts extended result field names as optional boolean keys for use in select/omit inputs.
+ * When ExtResult is `{}`, this resolves to `{}` (no-op for intersection).
+ */
+type ExtResultSelectOmitFields<ExtResult extends ExtResultBase, Model extends string> = keyof ExtResult extends never ? {} : Uncapitalize<Model> extends keyof ExtResult ? {
+    [K in keyof ExtResult[Uncapitalize<Model>]]?: boolean;
+} : {};
+type TruthyKeys<S, Keys extends string> = {
+    [K in Keys]: K extends keyof S ? (S[K] extends false | undefined ? never : K) : never;
+}[Keys];
+/**
+ * Select/omit-aware version of ExtractExtResult.
+ * - If T has `select`, only includes ext result fields that are explicitly selected.
+ * - If T has `omit`, excludes ext result fields that are explicitly omitted.
+ * - Otherwise, includes all ext result fields.
+ */
+type SelectAwareExtResult<ExtResult extends ExtResultBase, Model extends string, T> = keyof ExtResult extends never ? {} : T extends {
+    select: infer S;
+} ? S extends null | undefined ? ExtractExtResult<ExtResult, Model> : Pick<ExtractExtResult<ExtResult, Model>, TruthyKeys<S, Extract<keyof S & string, keyof ExtractExtResult<ExtResult, Model>>>> : T extends {
+    omit: infer O;
+} ? O extends null | undefined ? ExtractExtResult<ExtResult, Model> : Omit<ExtractExtResult<ExtResult, Model>, TruthyKeys<O, Extract<keyof O & string, keyof ExtractExtResult<ExtResult, Model>>>> : ExtractExtResult<ExtResult, Model>;
 
 /**
  * Zod schema cache statistics.
@@ -2093,7 +2224,7 @@ declare enum TransactionIsolationLevel {
 /**
  * ZenStack client interface.
  */
-type ClientContract<Schema extends SchemaDef, Options extends ClientOptions<Schema> = ClientOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase = {}, ExtClientMembers extends ExtClientMembersBase = {}> = {
+type ClientContract<Schema extends SchemaDef, Options extends ClientOptions<Schema> = ClientOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase = {}, ExtClientMembers extends ExtClientMembersBase = {}, ExtResult extends ExtResultBase<Schema> = {}> = {
     /**
      * The schema definition.
      */
@@ -2141,25 +2272,36 @@ type ClientContract<Schema extends SchemaDef, Options extends ClientOptions<Sche
      */
     get $auth(): AuthType<Schema> | undefined;
     /**
-     * Sets the current user identity.
+     * Returns a new client bound to the specified user identity. The original client remains unchanged.
+     *
+     * @example
+     * ```
+     * const userClient = db.$setAuth({ id: 'user-id' });
+     * ```
      */
-    $setAuth(auth: AuthType<Schema> | undefined): ClientContract<Schema, Options, ExtQueryArgs, ExtClientMembers>;
+    $setAuth(auth: AuthType<Schema> | undefined): ClientContract<Schema, Options, ExtQueryArgs, ExtClientMembers, ExtResult>;
     /**
-     * Returns a new client with new options applied.
+     * Returns a new client with new options applied. The original client remains unchanged.
+     *
      * @example
      * ```
      * const dbNoValidation = db.$setOptions({ ...db.$options, validateInput: false });
      * ```
      */
-    $setOptions<NewOptions extends ClientOptions<Schema>>(options: NewOptions): ClientContract<Schema, NewOptions, ExtQueryArgs, ExtClientMembers>;
+    $setOptions<NewOptions extends ClientOptions<Schema>>(options: NewOptions): ClientContract<Schema, NewOptions, ExtQueryArgs, ExtClientMembers, ExtResult>;
     /**
-     * Returns a new client enabling/disabling query args validation.
+     * Returns a new client enabling/disabling query args validation. The original client remains unchanged.
      *
      * @deprecated Use {@link $setOptions} instead.
      */
-    $setInputValidation(enable: boolean): ClientContract<Schema, Options, ExtQueryArgs, ExtClientMembers>;
+    $setInputValidation(enable: boolean): ClientContract<Schema, Options, ExtQueryArgs, ExtClientMembers, ExtResult>;
     /**
      * The Kysely query builder instance.
+     *
+     * @example
+     * ```
+     * db.$qb.selectFrom('User').selectAll().where('id', '=', 1).execute();
+     * ```
      */
     readonly $qb: ToKysely<Schema>;
     /**
@@ -2168,26 +2310,45 @@ type ClientContract<Schema extends SchemaDef, Options extends ClientOptions<Sche
     readonly $qbRaw: AnyKysely;
     /**
      * Starts an interactive transaction.
+     *
+     * @example
+     * ```
+     * await db.$transaction(async (tx) => {
+     *   const user = await tx.user.update({ where: { id: 1 }, data: { name: 'Alice' } });
+     *   const post = await tx.post.create({ data: { title: 'Hello World', authorId: user.id } });
+     *   return { user, posts: [post] };
+     * ```
      */
-    $transaction<T>(callback: (tx: TransactionClientContract<Schema, Options, ExtQueryArgs, ExtClientMembers>) => Promise<T>, options?: {
+    $transaction<T>(callback: (tx: TransactionClientContract<Schema, Options, ExtQueryArgs, ExtClientMembers, ExtResult>) => Promise<T>, options?: {
         isolationLevel?: TransactionIsolationLevel;
     }): Promise<T>;
     /**
-     * Starts a sequential transaction.
+     * Starts a sequential transaction that runs the provided operations in order.
+     *
+     * @example
+     * ```
+     * await db.$transaction([
+     *   db.user.update({ where: { id: 1 }, data: { name: 'Alice' } }),
+     *   db.post.create({ data: { title: 'Hello World', authorId: 1 } }),
+     * ]);
      */
     $transaction<P extends ZenStackPromise<Schema, any>[]>(arg: [...P], options?: {
         isolationLevel?: TransactionIsolationLevel;
     }): Promise<UnwrapTuplePromises<P>>;
     /**
-     * Returns a new client with the specified plugin installed.
+     * Returns a new client with the specified plugin installed. The original client remains unchanged.
+     *
+     * @see {@link https://zenstack.dev/docs/orm/plugins/|Plugin Documentation}
      */
-    $use<PluginSchema extends SchemaDef = Schema, PluginExtQueryArgs extends ExtQueryArgsBase = {}, PluginExtClientMembers extends ExtClientMembersBase = {}>(plugin: RuntimePlugin<PluginSchema, PluginExtQueryArgs, PluginExtClientMembers>): ClientContract<Schema, Options, ExtQueryArgs & PluginExtQueryArgs, ExtClientMembers & PluginExtClientMembers>;
+    $use<PluginSchema extends SchemaDef = Schema, PluginExtQueryArgs extends ExtQueryArgsBase = {}, PluginExtClientMembers extends ExtClientMembersBase = {}, PluginExtResult extends ExtResultBase<PluginSchema> = {}, _R = {}>(plugin: RuntimePlugin<PluginSchema, PluginExtQueryArgs, PluginExtClientMembers, PluginExtResult> & {
+        result?: ExtResultInferenceArgs<Schema, _R>;
+    }): ClientContract<Schema, Options, ExtQueryArgs & PluginExtQueryArgs, ExtClientMembers & PluginExtClientMembers, ExtResult & PluginExtResult>;
     /**
-     * Returns a new client with the specified plugin removed.
+     * Returns a new client with the specified plugin removed. The original client remains unchanged.
      */
-    $unuse(pluginId: string): ClientContract<Schema, Options, ExtQueryArgs, ExtClientMembers>;
+    $unuse(pluginId: string): ClientContract<Schema, Options, ExtQueryArgs, ExtClientMembers, ExtResult>;
     /**
-     * Returns a new client with all plugins removed.
+     * Returns a new client with all plugins removed. The original client remains unchanged.
      */
     $unuseAll(): ClientContract<Schema, Options>;
     /**
@@ -2212,12 +2373,12 @@ type ClientContract<Schema extends SchemaDef, Options extends ClientOptions<Sche
      */
     get $diagnostics(): Promise<Diagnostics>;
 } & {
-    [Key in GetSlicedModels<Schema, Options> as Uncapitalize<Key>]: ModelOperations<Schema, Key, Options, ExtQueryArgs>;
+    [Key in GetSlicedModels<Schema, Options> as Uncapitalize<Key>]: ModelOperations<Schema, Key, Options, ExtQueryArgs, ExtResult>;
 } & ProcedureOperations<Schema, Options> & ExtClientMembers;
 /**
  * The contract for a client in a transaction.
  */
-type TransactionClientContract<Schema extends SchemaDef, Options extends ClientOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase, ExtClientMembers extends ExtClientMembersBase> = Omit<ClientContract<Schema, Options, ExtQueryArgs, ExtClientMembers>, TransactionUnsupportedMethods>;
+type TransactionClientContract<Schema extends SchemaDef, Options extends ClientOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase, ExtClientMembers extends ExtClientMembersBase, ExtResult extends ExtResultBase<Schema> = {}> = Omit<ClientContract<Schema, Options, ExtQueryArgs, ExtClientMembers, ExtResult>, TransactionUnsupportedMethods>;
 type ProcedureOperations<Schema extends SchemaDef, Options extends ClientOptions<Schema> = ClientOptions<Schema>> = Schema['procedures'] extends Record<string, ProcedureDef> ? {
     /**
      * Custom procedures.
@@ -2250,8 +2411,8 @@ type CRUD_EXT = CRUD | 'post-update';
 declare const CRUD_EXT: readonly ["create", "read", "update", "delete", "post-update"];
 type SliceOperations<T extends Record<string, unknown>, Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends ClientOptions<Schema>> = Omit<{
     [Key in keyof T as Key extends GetSlicedOperations<Schema, Model, Options> ? Key : never]: T[Key];
-}, IsDelegateModel<Schema, Model> extends true ? OperationsIneligibleForDelegateModels : never>;
-type AllModelOperations<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase> = CommonModelOperations<Schema, Model, Options, ExtQueryArgs> & (Schema['provider']['type'] extends 'mysql' ? {} : {
+}, ModelAllowsCreate<Schema, Model> extends true ? never : OperationsRequiringCreate>;
+type AllModelOperations<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase, ExtResult extends ExtResultBase<Schema> = {}> = CommonModelOperations<Schema, Model, Options, ExtQueryArgs, ExtResult> & (Schema['provider']['type'] extends 'mysql' ? {} : {
     /**
      * Creates multiple entities and returns them.
      * @param args - create args. See {@link createMany} for input. Use
@@ -2270,7 +2431,7 @@ type AllModelOperations<Schema extends SchemaDef, Model extends GetModels<Schema
      * });
      * ```
      */
-    createManyAndReturn<T extends CreateManyAndReturnArgs<Schema, Model, Options, ExtQueryArgs>>(args?: SelectSubset<T, CreateManyAndReturnArgs<Schema, Model, Options, ExtQueryArgs>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options>[]>;
+    createManyAndReturn<T extends CreateManyAndReturnArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>(args?: SelectSubset<T, CreateManyAndReturnArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[]>;
     /**
      * Updates multiple entities and returns them.
      * @param args - update args. Only scalar fields are allowed for data.
@@ -2293,9 +2454,9 @@ type AllModelOperations<Schema extends SchemaDef, Model extends GetModels<Schema
      * });
      * ```
      */
-    updateManyAndReturn<T extends UpdateManyAndReturnArgs<Schema, Model, Options, ExtQueryArgs>>(args: Subset<T, UpdateManyAndReturnArgs<Schema, Model, Options, ExtQueryArgs>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options>[]>;
+    updateManyAndReturn<T extends UpdateManyAndReturnArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>(args: Subset<T, UpdateManyAndReturnArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[]>;
 });
-type CommonModelOperations<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase> = {
+type CommonModelOperations<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase, ExtResult extends ExtResultBase<Schema> = {}> = {
     /**
      * Returns a list of entities.
      * @param args - query args
@@ -2377,35 +2538,35 @@ type CommonModelOperations<Schema extends SchemaDef, Model extends GetModels<Sch
      * }); // result: `{ _count: { posts: number } }`
      * ```
      */
-    findMany<T extends FindManyArgs<Schema, Model, Options, ExtQueryArgs>>(args?: SelectSubset<T, FindManyArgs<Schema, Model, Options, ExtQueryArgs>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options>[]>;
+    findMany<T extends FindManyArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>(args?: SelectSubset<T, FindManyArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>[]>;
     /**
      * Returns a uniquely identified entity.
      * @param args - query args
      * @returns a single entity or null if not found
      * @see {@link findMany}
      */
-    findUnique<T extends FindUniqueArgs<Schema, Model, Options, ExtQueryArgs>>(args: SelectSubset<T, FindUniqueArgs<Schema, Model, Options, ExtQueryArgs>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options> | null>;
+    findUnique<T extends FindUniqueArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>(args: SelectSubset<T, FindUniqueArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options, ExtResult> | null>;
     /**
      * Returns a uniquely identified entity or throws `NotFoundError` if not found.
      * @param args - query args
      * @returns a single entity
      * @see {@link findMany}
      */
-    findUniqueOrThrow<T extends FindUniqueArgs<Schema, Model, Options, ExtQueryArgs>>(args: SelectSubset<T, FindUniqueArgs<Schema, Model, Options, ExtQueryArgs>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options>>;
+    findUniqueOrThrow<T extends FindUniqueArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>(args: SelectSubset<T, FindUniqueArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>>;
     /**
      * Returns the first entity.
      * @param args - query args
      * @returns a single entity or null if not found
      * @see {@link findMany}
      */
-    findFirst<T extends FindFirstArgs<Schema, Model, Options, ExtQueryArgs>>(args?: SelectSubset<T, FindFirstArgs<Schema, Model, Options, ExtQueryArgs>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options> | null>;
+    findFirst<T extends FindFirstArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>(args?: SelectSubset<T, FindFirstArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options, ExtResult> | null>;
     /**
      * Returns the first entity or throws `NotFoundError` if not found.
      * @param args - query args
      * @returns a single entity
      * @see {@link findMany}
      */
-    findFirstOrThrow<T extends FindFirstArgs<Schema, Model, Options, ExtQueryArgs>>(args?: SelectSubset<T, FindFirstArgs<Schema, Model, Options, ExtQueryArgs>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options>>;
+    findFirstOrThrow<T extends FindFirstArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>(args?: SelectSubset<T, FindFirstArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>>;
     /**
      * Creates a new entity.
      * @param args - create args
@@ -2458,7 +2619,7 @@ type CommonModelOperations<Schema extends SchemaDef, Model extends GetModels<Sch
      * });
      * ```
      */
-    create<T extends CreateArgs<Schema, Model, Options, ExtQueryArgs>>(args: SelectSubset<T, CreateArgs<Schema, Model, Options, ExtQueryArgs>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options>>;
+    create<T extends CreateArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>(args: SelectSubset<T, CreateArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>>;
     /**
      * Creates multiple entities. Only scalar fields are allowed.
      * @param args - create args
@@ -2602,7 +2763,7 @@ type CommonModelOperations<Schema extends SchemaDef, Model extends GetModels<Sch
      * });
      * ```
      */
-    update<T extends UpdateArgs<Schema, Model, Options, ExtQueryArgs>>(args: SelectSubset<T, UpdateArgs<Schema, Model, Options, ExtQueryArgs>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options>>;
+    update<T extends UpdateArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>(args: SelectSubset<T, UpdateArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>>;
     /**
      * Updates multiple entities.
      * @param args - update args. Only scalar fields are allowed for data.
@@ -2644,7 +2805,7 @@ type CommonModelOperations<Schema extends SchemaDef, Model extends GetModels<Sch
      * });
      * ```
      */
-    upsert<T extends UpsertArgs<Schema, Model, Options, ExtQueryArgs>>(args: SelectSubset<T, UpsertArgs<Schema, Model, Options, ExtQueryArgs>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options>>;
+    upsert<T extends UpsertArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>(args: SelectSubset<T, UpsertArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>>;
     /**
      * Deletes a uniquely identifiable entity.
      * @param args - delete args
@@ -2664,7 +2825,7 @@ type CommonModelOperations<Schema extends SchemaDef, Model extends GetModels<Sch
      * }); // result: `{ id: string; email: string }`
      * ```
      */
-    delete<T extends DeleteArgs<Schema, Model, Options, ExtQueryArgs>>(args: SelectSubset<T, DeleteArgs<Schema, Model, Options, ExtQueryArgs>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options>>;
+    delete<T extends DeleteArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>(args: SelectSubset<T, DeleteArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options, ExtResult>>;
     /**
      * Deletes multiple entities.
      * @param args - delete args
@@ -2775,8 +2936,8 @@ type CommonModelOperations<Schema extends SchemaDef, Model extends GetModels<Sch
      */
     exists<T extends ExistsArgs<Schema, Model, Options, ExtQueryArgs>>(args?: Subset<T, ExistsArgs<Schema, Model, Options, ExtQueryArgs>>): ZenStackPromise<Schema, boolean>;
 };
-type OperationsIneligibleForDelegateModels = 'create' | 'createMany' | 'createManyAndReturn' | 'upsert';
-type ModelOperations<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends ClientOptions<Schema> = ClientOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase = {}> = SliceOperations<AllModelOperations<Schema, Model, Options, ExtQueryArgs>, Schema, Model, Options>;
+type OperationsRequiringCreate = 'create' | 'createMany' | 'createManyAndReturn' | 'upsert';
+type ModelOperations<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends ClientOptions<Schema> = ClientOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase = {}, ExtResult extends ExtResultBase<Schema> = {}> = SliceOperations<AllModelOperations<Schema, Model, Options, ExtQueryArgs, ExtResult>, Schema, Model, Options>;
 /**
  * Type for auth context that includes both scalar and relation fields.
  * Relations are recursively included to allow nested auth data like { user: { profile: { ... } } }
@@ -2815,6 +2976,10 @@ declare class ZodSchemaFactory<Schema extends SchemaDef, Options extends ClientO
     constructor(client: ClientContract<Schema, Options, ExtQueryArgs, any>);
     constructor(schema: Schema, options?: Options);
     private get plugins();
+    /**
+     * Returns model field entries, excluding Unsupported fields.
+     */
+    private getModelFields;
     private shouldIncludeRelations;
     private nextOptions;
     private getCache;
@@ -2852,6 +3017,7 @@ declare class ZodSchemaFactory<Schema extends SchemaDef, Options extends ClientO
     private makeCountSelectionSchema;
     private makeRelationSelectIncludeSchema;
     private makeOmitSchema;
+    private addExtResultFields;
     private makeIncludeSchema;
     private makeOrderBySchema;
     private makeDistinctSchema;
@@ -2912,10 +3078,7 @@ declare class ZodSchemaFactory<Schema extends SchemaDef, Options extends ClientO
      */
     private trimFilterOperators;
     private createUnionFilterSchema;
-    /**
-     * Checks if a model is included in the slicing configuration.
-     * Returns true if the model is allowed, false if it's excluded.
-     */
+    private canCreateModel;
     private isModelAllowed;
 }
 
@@ -3016,13 +3179,18 @@ declare function requireTypeDef(schema: SchemaDef, type: string): _zenstackhq_sc
 declare function getField(schema: SchemaDef, model: string, field: string): FieldDef | undefined;
 declare function requireField(schema: SchemaDef, modelOrType: string, field: string): FieldDef;
 /**
- * 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.
  */
 declare function getModelFields(schema: SchemaDef, model: string, options?: {
     relations?: boolean;
     computed?: boolean;
     inherited?: boolean;
+    unsupported?: boolean;
 }): FieldDef[];
+/**
+ * Checks if a field is of `Unsupported` type.
+ */
+declare function isUnsupportedField(fieldDef: FieldDef): boolean;
 declare function getIdFields<Schema extends SchemaDef>(schema: SchemaDef, model: GetModels<Schema>): readonly string[] | undefined;
 declare function requireIdFields(schema: SchemaDef, model: string): readonly string[];
 declare function getRelationForeignKeyFieldPairs(schema: SchemaDef, model: string, relationField: string): {
@@ -3124,6 +3292,7 @@ declare const queryUtils_isInheritedField: typeof isInheritedField;
 declare const queryUtils_isRelationField: typeof isRelationField;
 declare const queryUtils_isScalarField: typeof isScalarField;
 declare const queryUtils_isTypeDef: typeof isTypeDef;
+declare const queryUtils_isUnsupportedField: typeof isUnsupportedField;
 declare const queryUtils_makeDefaultOrderBy: typeof makeDefaultOrderBy;
 declare const queryUtils_requireField: typeof requireField;
 declare const queryUtils_requireIdFields: typeof requireIdFields;
@@ -3132,7 +3301,7 @@ declare const queryUtils_requireTypeDef: typeof requireTypeDef;
 declare const queryUtils_stripAlias: typeof stripAlias;
 declare const queryUtils_tmpAlias: typeof tmpAlias;
 declare namespace queryUtils {
-  export { queryUtils_TEMP_ALIAS_PREFIX as TEMP_ALIAS_PREFIX, queryUtils_aggregate as aggregate, queryUtils_buildJoinPairs as buildJoinPairs, queryUtils_ensureArray as ensureArray, queryUtils_extractFieldName as extractFieldName, queryUtils_extractIdFields as extractIdFields, queryUtils_extractModelName as extractModelName, queryUtils_fieldHasDefaultValue as fieldHasDefaultValue, queryUtils_flattenCompoundUniqueFilters as flattenCompoundUniqueFilters, queryUtils_getDelegateDescendantModels as getDelegateDescendantModels, queryUtils_getDiscriminatorField as getDiscriminatorField, queryUtils_getEnum as getEnum, queryUtils_getField as getField, queryUtils_getIdFields as getIdFields, queryUtils_getIdValues as getIdValues, queryUtils_getManyToManyRelation as getManyToManyRelation, queryUtils_getModel as getModel, queryUtils_getModelFields as getModelFields, queryUtils_getRelationForeignKeyFieldPairs as getRelationForeignKeyFieldPairs, queryUtils_getTypeDef as getTypeDef, queryUtils_getUniqueFields as getUniqueFields, queryUtils_hasModel as hasModel, queryUtils_isEnum as isEnum, queryUtils_isForeignKeyField as isForeignKeyField, queryUtils_isInheritedField as isInheritedField, queryUtils_isRelationField as isRelationField, queryUtils_isScalarField as isScalarField, queryUtils_isTypeDef as isTypeDef, queryUtils_makeDefaultOrderBy as makeDefaultOrderBy, queryUtils_requireField as requireField, queryUtils_requireIdFields as requireIdFields, queryUtils_requireModel as requireModel, queryUtils_requireTypeDef as requireTypeDef, queryUtils_stripAlias as stripAlias, queryUtils_tmpAlias as tmpAlias };
+  export { queryUtils_TEMP_ALIAS_PREFIX as TEMP_ALIAS_PREFIX, queryUtils_aggregate as aggregate, queryUtils_buildJoinPairs as buildJoinPairs, queryUtils_ensureArray as ensureArray, queryUtils_extractFieldName as extractFieldName, queryUtils_extractIdFields as extractIdFields, queryUtils_extractModelName as extractModelName, queryUtils_fieldHasDefaultValue as fieldHasDefaultValue, queryUtils_flattenCompoundUniqueFilters as flattenCompoundUniqueFilters, queryUtils_getDelegateDescendantModels as getDelegateDescendantModels, queryUtils_getDiscriminatorField as getDiscriminatorField, queryUtils_getEnum as getEnum, queryUtils_getField as getField, queryUtils_getIdFields as getIdFields, queryUtils_getIdValues as getIdValues, queryUtils_getManyToManyRelation as getManyToManyRelation, queryUtils_getModel as getModel, queryUtils_getModelFields as getModelFields, queryUtils_getRelationForeignKeyFieldPairs as getRelationForeignKeyFieldPairs, queryUtils_getTypeDef as getTypeDef, queryUtils_getUniqueFields as getUniqueFields, queryUtils_hasModel as hasModel, queryUtils_isEnum as isEnum, queryUtils_isForeignKeyField as isForeignKeyField, queryUtils_isInheritedField as isInheritedField, queryUtils_isRelationField as isRelationField, queryUtils_isScalarField as isScalarField, queryUtils_isTypeDef as isTypeDef, queryUtils_isUnsupportedField as isUnsupportedField, queryUtils_makeDefaultOrderBy as makeDefaultOrderBy, queryUtils_requireField as requireField, queryUtils_requireIdFields as requireIdFields, queryUtils_requireModel as requireModel, queryUtils_requireTypeDef as requireTypeDef, queryUtils_stripAlias as stripAlias, queryUtils_tmpAlias as tmpAlias };
 }
 
 type VisitResult = void | {
@@ -3170,4 +3339,4 @@ declare namespace schemaUtils {
   export { schemaUtils_ExpressionVisitor as ExpressionVisitor, schemaUtils_MatchingExpressionVisitor as MatchingExpressionVisitor, type schemaUtils_VisitResult as VisitResult };
 }
 
-export { type AfterEntityMutationCallback, type AggregateArgs, type AggregateResult, AllCrudOperations, type AllModelOperations, AllReadOperations, AnyNull, AnyNullClass, type AnyPlugin, type AuthType, BaseCrudDialect, type BatchResult, type BeforeEntityMutationCallback, type BooleanFilter, type BytesFilter, CRUD, CRUD_EXT, type ClientConstructor, type ClientContract, type ClientOptions, type ComputedFieldsOptions, CoreCreateOperations, CoreCrudOperations, CoreDeleteOperations, CoreReadOperations, CoreUpdateOperations, CoreWriteOperations, type CountArgs, type CountResult, type CreateArgs, type CreateInput, type CreateManyAndReturnArgs, type CreateManyArgs, type CreateManyInput, type DateTimeFilter, DbNull, DbNullClass, type DefaultModelResult, type DeleteArgs, type DeleteManyArgs, type EntityMutationHooksDef, type ExistsArgs, type ExtClientMembersBase, type ExtQueryArgsBase, type FilterKind, type FindArgs, type FindFirstArgs, type FindManyArgs, type FindUniqueArgs, type GetAllIncludedOperations, type GetIncludedOperations, type GetProcedure, type GetProcedureNames, type GetProcedureParams, type GetQueryOptions, type GetSlicedFilterKindsForField, type GetSlicedModels, type GetSlicedOperations, type GetSlicedProcedures, type GroupByArgs, type GroupByResult, type HasComputedFields, type HasProcedures, type IncludeInput, InputValidator, type JsonArray, type JsonFilter, JsonNull, JsonNullClass, type JsonNullValues, type JsonObject, type JsonValue, kyselyUtils as KyselyUtils, type ModelOperations, type ModelResult, type ModelSlicingOptions, type NullsOrder, type NumberFilter, ORMError, ORMErrorReason, type OmitConfig, type OmitInput, type OnKyselyQueryArgs, type OnKyselyQueryCallback, type OnProcedureHookContext, type OperationsIneligibleForDelegateModels, type OrderBy, type PluginAfterEntityMutationArgs, type PluginBeforeEntityMutationArgs, type ProcedureEnvelope, type ProcedureFunc, type ProcedureHandlerFunc, type ProcedureOperations, type ProceduresOptions, type ProceedKyselyQueryFunction, type QueryOptions, queryUtils as QueryUtils, RejectedByPolicyReason, type RuntimePlugin, schemaUtils as SchemaUtils, type SelectIncludeOmit, type SelectInput, type SelectSubset, type SimplifiedPlainResult, type SimplifiedResult, type SlicingOptions, type SortOrder, type StringFilter, type Subset, type ToKysely, type TransactionClientContract, TransactionIsolationLevel, type TypeDefResult, type TypedJsonFilter, type UpdateArgs, type UpdateInput, type UpdateManyAndReturnArgs, type UpdateManyArgs, type UpsertArgs, type WhereInput, type WhereUniqueInput, type ZModelFunction, type ZModelFunctionContext, ZenStackClient, type ZenStackPromise, createQuerySchemaFactory, definePlugin, getCrudDialect };
+export { type AfterEntityMutationCallback, type AggregateArgs, type AggregateResult, AllCrudOperations, type AllModelOperations, AllReadOperations, AnyNull, AnyNullClass, type AnyPlugin, type AuthType, BaseCrudDialect, type BatchResult, type BeforeEntityMutationCallback, type BooleanFilter, type BytesFilter, CRUD, CRUD_EXT, type ClientConstructor, type ClientContract, type ClientOptions, type ComputedFieldsOptions, CoreCreateOperations, CoreCrudOperations, CoreDeleteOperations, CoreReadOperations, CoreUpdateOperations, CoreWriteOperations, type CountArgs, type CountResult, type CreateArgs, type CreateInput, type CreateManyAndReturnArgs, type CreateManyArgs, type CreateManyInput, type DateTimeFilter, DbNull, DbNullClass, type DefaultModelResult, type DeleteArgs, type DeleteManyArgs, type EntityMutationHooksDef, type ExistsArgs, type ExtClientMembersBase, type ExtQueryArgsBase, type ExtResultBase, type ExtResultInferenceArgs, type ExtResultSelectOmitFields, type ExtractExtResult, type FilterKind, type FindArgs, type FindFirstArgs, type FindManyArgs, type FindUniqueArgs, type GetAllIncludedOperations, type GetIncludedOperations, type GetProcedure, type GetProcedureNames, type GetProcedureParams, type GetQueryOptions, type GetSlicedFilterKindsForField, type GetSlicedModels, type GetSlicedOperations, type GetSlicedProcedures, type GroupByArgs, type GroupByResult, type HasComputedFields, type HasProcedures, type IncludeInput, InputValidator, type JsonArray, type JsonFilter, JsonNull, JsonNullClass, type JsonNullValues, type JsonObject, type JsonValue, kyselyUtils as KyselyUtils, type MapModelFieldType, type ModelAllowsCreate, type ModelHasRequiredUnsupportedField, type ModelOperations, type ModelResult, type ModelSlicingOptions, type NullsOrder, type NumberFilter, ORMError, ORMErrorReason, type OmitConfig, type OmitInput, type OnKyselyQueryArgs, type OnKyselyQueryCallback, type OnProcedureHookContext, type OperationsRequiringCreate, type OrderBy, type PluginAfterEntityMutationArgs, type PluginBeforeEntityMutationArgs, type ProcedureEnvelope, type ProcedureFunc, type ProcedureHandlerFunc, type ProcedureOperations, type ProceduresOptions, type ProceedKyselyQueryFunction, type QueryOptions, queryUtils as QueryUtils, RejectedByPolicyReason, type RuntimePlugin, schemaUtils as SchemaUtils, type SelectAwareExtResult, type SelectIncludeOmit, type SelectInput, type SelectSubset, type SimplifiedPlainResult, type SimplifiedResult, type SlicingOptions, type SortOrder, type StringFilter, type Subset, type ToKysely, type TransactionClientContract, TransactionIsolationLevel, type TypeDefResult, type TypedJsonFilter, type UpdateArgs, type UpdateInput, type UpdateManyAndReturnArgs, type UpdateManyArgs, type UpsertArgs, type WhereInput, type WhereUniqueInput, type ZModelFunction, type ZModelFunctionContext, ZenStackClient, type ZenStackPromise, createQuerySchemaFactory, definePlugin, getCrudDialect };