@zenstackhq/orm 3.0.0-beta.27 → 3.0.0-beta.29

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import Decimal from 'decimal.js';
 import * as _zenstackhq_schema from '@zenstackhq/schema';
-import { SchemaDef, BuiltinType, GetModels, FieldDef, ModelDef, DataSourceProviderType, ScalarFields, ForeignKeyFields, GetModelFields, FieldHasDefault, GetModelFieldType, ModelFieldIsOptional, GetModelField, GetModel, ProcedureDef, IsDelegateModel, GetModelDiscriminator, GetSubModels, NonRelationFields, GetEnums, GetEnum, GetTypeDefs, GetTypeDefFields, GetTypeDefField, TypeDefFieldIsOptional, RelationFields, FieldIsArray, RelationFieldType, FieldIsRelation, FieldIsDelegateDiscriminator, FieldType, RelationInfo, FieldIsDelegateRelation, Expression as Expression$1, LiteralExpression, ArrayExpression, FieldExpression, MemberExpression, BinaryExpression, UnaryExpression, CallExpression, ThisExpression, NullExpression } from '@zenstackhq/schema';
+import { SchemaDef, BuiltinType, GetModels, FieldDef, ModelDef, DataSourceProviderType, ScalarFields, ForeignKeyFields, GetModelFields, FieldHasDefault, GetModelFieldType, ModelFieldIsOptional, GetModelField, GetModel, ProcedureDef, NonRelationFields, GetEnums, GetEnum, GetTypeDefs, GetTypeDefFields, GetTypeDefField, TypeDefFieldIsOptional, RelationFields, FieldIsArray, RelationFieldType, FieldIsRelation, GetTypeDefFieldType, TypeDefFieldIsArray, FieldIsDelegateDiscriminator, FieldType, RelationInfo, FieldIsDelegateRelation, IsDelegateModel, Expression as Expression$1, LiteralExpression, ArrayExpression, FieldExpression, MemberExpression, BinaryExpression, UnaryExpression, CallExpression, ThisExpression, NullExpression } from '@zenstackhq/schema';
 import * as kysely from 'kysely';
 import { 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, Kysely, ExpressionBuilder, SelectQueryBuilder, Expression, SqlBool, ExpressionWrapper, Generated, QueryId, RootOperationNode, QueryResult, UnknownRow, Dialect, KyselyConfig, OperandExpression } from 'kysely';
 
@@ -113,6 +113,28 @@ declare namespace kyselyUtils {
   export { type kyselyUtils_AnyKysely as AnyKysely, kyselyUtils_DefaultOperationNodeVisitor as DefaultOperationNodeVisitor };
 }
 
+type JsonValue = string | number | boolean | JsonObject | JsonArray;
+type JsonObject = {
+    [key: string]: JsonValue | null;
+};
+type JsonArray = ReadonlyArray<JsonValue | null>;
+type JsonNullValues = DbNull | JsonNull | AnyNull;
+declare class DbNullClass {
+    private __brand;
+}
+declare const DbNull: DbNullClass;
+type DbNull = typeof DbNull;
+declare class JsonNullClass {
+    private __brand;
+}
+declare const JsonNull: JsonNullClass;
+type JsonNull = typeof JsonNull;
+declare class AnyNullClass {
+    private __brand;
+}
+declare const AnyNull: AnyNullClass;
+type AnyNull = typeof AnyNull;
+
 type Optional<T extends object, K extends keyof T = keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
 type PartialIf<T, Condition extends boolean> = Condition extends true ? Partial<T> : T;
 type NullableIf<T, Condition extends boolean> = Condition extends true ? T | null : T;
@@ -134,11 +156,6 @@ type TypeMap = {
     Json: JsonValue;
 };
 type MapBaseType$1<T extends string> = T extends keyof TypeMap ? TypeMap[T] : unknown;
-type JsonValue = string | number | boolean | null | JsonObject | JsonArray;
-type JsonObject = {
-    [key: string]: JsonValue;
-};
-type JsonArray = Array<JsonValue>;
 type OrArray<T, IF extends boolean = true> = IF extends true ? T | T[] : T;
 type NonEmptyArray<T> = [T, ...T[]];
 type ValueOfPotentialTuple<T> = T extends unknown[] ? T[number] : T;
@@ -190,10 +207,19 @@ declare abstract class BaseCrudDialect<Schema extends SchemaDef> {
     private buildToOneRelationFilter;
     private buildToManyRelationFilter;
     private buildArrayFilter;
-    buildPrimitiveFilter(fieldRef: Expression<any>, fieldDef: FieldDef, payload: any): Expression<SqlBool>;
+    buildPrimitiveFilter(fieldRef: Expression<any>, fieldDef: FieldDef, payload: any): any;
+    private buildJsonFilter;
+    private buildPlainJsonFilter;
+    private buildTypedJsonFilter;
+    private buildTypedJsonArrayFilter;
+    private buildTypeJsonNonArrayFilter;
+    private buildJsonValueFilterClause;
     private buildLiteralFilter;
     private buildStandardFilter;
     private buildStringFilter;
+    private buildJsonStringFilter;
+    private escapeLikePattern;
+    private buildStringLike;
     private prepStringCasing;
     private buildNumberFilter;
     private buildBooleanFilter;
@@ -262,6 +288,18 @@ declare abstract class BaseCrudDialect<Schema extends SchemaDef> {
         supportsILike: boolean;
         likeCaseSensitive: boolean;
     };
+    /**
+     * Builds a JSON path selection expression.
+     */
+    protected abstract buildJsonPathSelection(receiver: Expression<any>, path: string | undefined): Expression<any>;
+    /**
+     * Builds a JSON array filter expression.
+     */
+    protected abstract buildJsonArrayFilter(receiver: Expression<any>, operation: 'array_contains' | 'array_starts_with' | 'array_ends_with', value: unknown): Expression<SqlBool>;
+    /**
+     * Builds a JSON array exists predicate (returning if any element matches the filter).
+     */
+    protected abstract buildJsonArrayExistsPredicate(receiver: Expression<any>, buildFilter: (elem: Expression<any>) => Expression<SqlBool>): Expression<SqlBool>;
 }
 
 type ToKyselySchema<Schema extends SchemaDef> = {
@@ -524,19 +562,24 @@ type ProceduresOptions<Schema extends SchemaDef> = Schema extends {
 type HasProcedures<Schema extends SchemaDef> = Schema extends {
     procedures: Record<string, ProcedureDef>;
 } ? true : false;
+/**
+ * Subset of client options relevant to query operations.
+ */
+type QueryOptions<Schema extends SchemaDef> = Pick<ClientOptions<Schema>, 'omit'>;
+/**
+ * Extract QueryOptions from ClientOptions
+ */
+type ToQueryOptions<T extends ClientOptions<any>> = Pick<T, 'omit'>;
 
-type DefaultModelResult<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends ClientOptions<Schema> = ClientOptions<Schema>, Omit = undefined, Optional = false, Array = false> = WrapType<IsDelegateModel<Schema, Model> extends true ? DelegateUnionResult<Schema, Model, Options, GetSubModels<Schema, Model>, Omit> : {
+type DefaultModelResult<Schema extends SchemaDef, Model extends GetModels<Schema>, Omit = undefined, Options extends QueryOptions<Schema> = QueryOptions<Schema>, Optional = false, Array = false> = WrapType<{
     [Key in NonRelationFields<Schema, Model> as ShouldOmitField<Schema, Model, Options, Key, Omit> extends true ? never : Key]: MapModelFieldType<Schema, Model, Key>;
 }, Optional, Array>;
-type ShouldOmitField<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends ClientOptions<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 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 ClientOptions<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>> = 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 SchemaLevelOmit<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends GetModelFields<Schema, Model>> = GetModelField<Schema, Model, Field>['omit'] extends true ? true : false;
-type DelegateUnionResult<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends ClientOptions<Schema>, SubModel extends GetModels<Schema>, Omit = undefined> = SubModel extends string ? DefaultModelResult<Schema, SubModel, Options, Omit> & {
-    [K in GetModelDiscriminator<Schema, Model>]: SubModel;
-} : never;
-type ModelSelectResult<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends ClientOptions<Schema>, Select, Omit> = {
-    [Key in keyof Select as Select[Key] extends false | undefined ? never : Key extends keyof Omit ? Omit[Key] extends true ? never : Key : Key extends '_count' ? Select[Key] extends SelectCount<Schema, Model> ? Key : never : Key]: Key extends '_count' ? SelectCountResult<Schema, Model, Select[Key]> : Key extends NonRelationFields<Schema, Model> ? MapModelFieldType<Schema, Model, Key> : Key extends RelationFields<Schema, Model> ? Select[Key] extends FindArgs<Schema, RelationFieldType<Schema, Model, Key>, FieldIsArray<Schema, Model, Key>> ? 'select' extends keyof Select[Key] ? ModelResult<Schema, RelationFieldType<Schema, Model, Key>, Options, Pick<Select[Key], 'select'>, ModelFieldIsOptional<Schema, Model, Key>, FieldIsArray<Schema, Model, Key>> : ModelResult<Schema, RelationFieldType<Schema, Model, Key>, Options, Pick<Select[Key], 'include' | 'omit'>, ModelFieldIsOptional<Schema, Model, Key>, FieldIsArray<Schema, Model, Key>> : DefaultModelResult<Schema, RelationFieldType<Schema, Model, Key>, Options, Omit, ModelFieldIsOptional<Schema, Model, Key>, FieldIsArray<Schema, Model, Key>> : never;
+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 keyof Omit ? Omit[Key] extends true ? never : Key : Key extends '_count' ? Select[Key] extends SelectCount<Schema, Model> ? Key : never : Key]: Key extends '_count' ? SelectCountResult<Schema, Model, Select[Key]> : Key extends NonRelationFields<Schema, Model> ? MapModelFieldType<Schema, Model, Key> : Key extends RelationFields<Schema, Model> ? Select[Key] extends FindArgs<Schema, RelationFieldType<Schema, Model, Key>, FieldIsArray<Schema, Model, Key>> ? 'select' extends keyof Select[Key] ? ModelResult<Schema, RelationFieldType<Schema, Model, Key>, Pick<Select[Key], 'select'>, Options, ModelFieldIsOptional<Schema, Model, Key>, FieldIsArray<Schema, Model, Key>> : ModelResult<Schema, RelationFieldType<Schema, Model, Key>, Pick<Select[Key], 'include' | 'omit'>, Options, ModelFieldIsOptional<Schema, Model, Key>, FieldIsArray<Schema, Model, Key>> : DefaultModelResult<Schema, RelationFieldType<Schema, Model, Key>, Omit, Options, ModelFieldIsOptional<Schema, Model, Key>, FieldIsArray<Schema, Model, Key>> : 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;
@@ -545,18 +588,19 @@ type SelectCountResult<Schema extends SchemaDef, Model extends GetModels<Schema>
 } ? {
     [Key in keyof S]: number;
 } : never;
-type ModelResult<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends ClientOptions<Schema> = ClientOptions<Schema>, Args = {}, 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> = WrapType<Args extends {
     select: infer S;
     omit?: infer O;
-} ? ModelSelectResult<Schema, Model, Options, S, O> : Args extends {
+} ? ModelSelectResult<Schema, Model, S, O, Options> : Args extends {
     include: infer I;
     omit?: infer O;
-} ? DefaultModelResult<Schema, Model, Options, O> & {
-    [Key in keyof I & RelationFields<Schema, Model> as I[Key] extends false | undefined ? never : Key]: I[Key] extends FindArgs<Schema, RelationFieldType<Schema, Model, Key>, FieldIsArray<Schema, Model, Key>> ? ModelResult<Schema, RelationFieldType<Schema, Model, Key>, Options, I[Key], ModelFieldIsOptional<Schema, Model, Key>, FieldIsArray<Schema, Model, Key>> : DefaultModelResult<Schema, RelationFieldType<Schema, Model, Key>, Options, undefined, ModelFieldIsOptional<Schema, Model, Key>, FieldIsArray<Schema, Model, Key>>;
+} ? DefaultModelResult<Schema, Model, O, Options, false, false> & {
+    [Key in keyof I & RelationFields<Schema, Model> as I[Key] extends false | undefined ? never : Key]: I[Key] extends FindArgs<Schema, RelationFieldType<Schema, Model, Key>, FieldIsArray<Schema, Model, Key>> ? ModelResult<Schema, RelationFieldType<Schema, Model, Key>, I[Key], Options, ModelFieldIsOptional<Schema, Model, Key>, FieldIsArray<Schema, Model, Key>> : DefaultModelResult<Schema, RelationFieldType<Schema, Model, Key>, undefined, Options, ModelFieldIsOptional<Schema, Model, Key>, FieldIsArray<Schema, Model, Key>>;
 } : Args extends {
     omit: infer O;
-} ? DefaultModelResult<Schema, Model, Options, O> : DefaultModelResult<Schema, Model, Options>, Optional, Array>;
-type SimplifiedModelResult<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends ClientOptions<Schema>, Args = {}, Optional = false, Array = false> = Simplify<ModelResult<Schema, Model, Options, Args, Optional, Array>>;
+} ? 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>>;
 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 {
@@ -566,7 +610,7 @@ type BatchResult = {
     count: number;
 };
 type WhereInput<Schema extends SchemaDef, Model extends GetModels<Schema>, ScalarOnly extends boolean = false, WithAggregations extends boolean = false> = {
-    [Key in GetModelFields<Schema, Model> as ScalarOnly extends true ? Key extends RelationFields<Schema, Model> ? never : Key : Key]?: Key extends RelationFields<Schema, Model> ? RelationFilter<Schema, Model, Key> : FieldIsArray<Schema, Model, Key> extends true ? ArrayFilter<Schema, GetModelFieldType<Schema, Model, Key>> : GetModelFieldType<Schema, Model, Key> extends GetEnums<Schema> ? EnumFilter<Schema, GetModelFieldType<Schema, Model, Key>, ModelFieldIsOptional<Schema, Model, Key>, WithAggregations> : PrimitiveFilter<GetModelFieldType<Schema, Model, Key>, ModelFieldIsOptional<Schema, Model, Key>, WithAggregations>;
+    [Key in GetModelFields<Schema, Model> as ScalarOnly extends true ? Key extends RelationFields<Schema, Model> ? never : Key : Key]?: Key extends RelationFields<Schema, Model> ? RelationFilter<Schema, Model, Key> : FieldIsArray<Schema, Model, Key> extends true ? ArrayFilter<Schema, GetModelFieldType<Schema, Model, Key>> : GetModelFieldType<Schema, Model, Key> extends GetEnums<Schema> ? EnumFilter<Schema, GetModelFieldType<Schema, Model, Key>, ModelFieldIsOptional<Schema, Model, Key>, WithAggregations> : GetModelFieldType<Schema, Model, Key> extends GetTypeDefs<Schema> ? TypedJsonFilter<Schema, GetModelFieldType<Schema, Model, Key>, FieldIsArray<Schema, Model, Key>, ModelFieldIsOptional<Schema, Model, Key>> : PrimitiveFilter<GetModelFieldType<Schema, Model, Key>, ModelFieldIsOptional<Schema, Model, Key>, WithAggregations>;
 } & {
     $expr?: (eb: ExpressionBuilder<ToKyselySchema<Schema>, Model>) => OperandExpression<SqlBool>;
 } & {
@@ -575,94 +619,312 @@ type WhereInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Scala
     NOT?: OrArray<WhereInput<Schema, Model, ScalarOnly>>;
 };
 type EnumFilter<Schema extends SchemaDef, T extends GetEnums<Schema>, Nullable extends boolean, WithAggregations extends boolean> = NullableIf<keyof GetEnum<Schema, T>, Nullable> | ({
+    /**
+     * Checks for equality with the specified enum value.
+     */
     equals?: NullableIf<keyof GetEnum<Schema, T>, Nullable>;
+    /**
+     * Checks if the enum value is in the specified list of values.
+     */
     in?: (keyof GetEnum<Schema, T>)[];
+    /**
+     * Checks if the enum value is not in the specified list of values.
+     */
     notIn?: (keyof GetEnum<Schema, T>)[];
+    /**
+     * Builds a negated filter.
+     */
     not?: EnumFilter<Schema, T, Nullable, WithAggregations>;
 } & (WithAggregations extends true ? {
+    /**
+     * Filters against the count of records.
+     */
     _count?: NumberFilter<'Int', false, false>;
+    /**
+     * Filters against the minimum value.
+     */
     _min?: EnumFilter<Schema, T, false, false>;
+    /**
+     * Filters against the maximum value.
+     */
     _max?: EnumFilter<Schema, T, false, false>;
 } : {}));
-type ArrayFilter<Schema extends SchemaDef, T extends string> = {
-    equals?: MapScalarType<Schema, T>[] | null;
-    has?: MapScalarType<Schema, T> | null;
-    hasEvery?: MapScalarType<Schema, T>[];
-    hasSome?: MapScalarType<Schema, T>[];
+type ArrayFilter<Schema extends SchemaDef, Type extends string> = {
+    /**
+     * Checks if the array equals the specified array.
+     */
+    equals?: MapScalarType<Schema, Type>[] | null;
+    /**
+     * Checks if the array contains all elements of the specified array.
+     */
+    has?: MapScalarType<Schema, Type> | null;
+    /**
+     * Checks if the array contains any of the elements of the specified array.
+     */
+    hasEvery?: MapScalarType<Schema, Type>[];
+    /**
+     * Checks if the array contains some of the elements of the specified array.
+     */
+    hasSome?: MapScalarType<Schema, Type>[];
+    /**
+     * Checks if the array is empty.
+     */
     isEmpty?: boolean;
 };
-type MapScalarType<Schema extends SchemaDef, T extends string> = T extends GetEnums<Schema> ? keyof GetEnum<Schema, T> : MapBaseType$1<T>;
-type PrimitiveFilter<T extends string, Nullable extends boolean, WithAggregations extends boolean> = T extends 'String' ? StringFilter<Nullable, WithAggregations> : T extends 'Int' | 'Float' | 'Decimal' | 'BigInt' ? NumberFilter<T, Nullable, WithAggregations> : T extends 'Boolean' ? BooleanFilter<Nullable, WithAggregations> : T extends 'DateTime' ? DateTimeFilter<Nullable, WithAggregations> : T extends 'Bytes' ? BytesFilter<Nullable, WithAggregations> : T extends 'Json' ? 'Not implemented yet' : never;
+type MapScalarType<Schema extends SchemaDef, Type extends string> = Type extends GetEnums<Schema> ? keyof GetEnum<Schema, Type> : MapBaseType$1<Type>;
+type PrimitiveFilter<T extends string, Nullable extends boolean, WithAggregations extends boolean> = T extends 'String' ? StringFilter<Nullable, WithAggregations> : T extends 'Int' | 'Float' | 'Decimal' | 'BigInt' ? NumberFilter<T, Nullable, WithAggregations> : T extends 'Boolean' ? BooleanFilter<Nullable, WithAggregations> : T extends 'DateTime' ? DateTimeFilter<Nullable, WithAggregations> : T extends 'Bytes' ? BytesFilter<Nullable, WithAggregations> : T extends 'Json' ? JsonFilter : never;
 type CommonPrimitiveFilter<DataType, T extends BuiltinType, Nullable extends boolean, WithAggregations extends boolean> = {
+    /**
+     * Checks for equality with the specified value.
+     */
     equals?: NullableIf<DataType, Nullable>;
+    /**
+     * Checks if the value is in the specified list of values.
+     */
     in?: DataType[];
+    /**
+     * Checks if the value is not in the specified list of values.
+     */
     notIn?: DataType[];
+    /**
+     * Checks if the value is less than the specified value.
+     */
     lt?: DataType;
+    /**
+     * Checks if the value is less than or equal to the specified value.
+     */
     lte?: DataType;
+    /**
+     * Checks if the value is greater than the specified value.
+     */
     gt?: DataType;
+    /**
+     * Checks if the value is greater than or equal to the specified value.
+     */
     gte?: DataType;
+    /**
+     * Builds a negated filter.
+     */
     not?: PrimitiveFilter<T, Nullable, WithAggregations>;
 };
 type StringFilter<Nullable extends boolean, WithAggregations extends boolean> = NullableIf<string, Nullable> | (CommonPrimitiveFilter<string, 'String', Nullable, WithAggregations> & {
+    /**
+     * Checks if the string contains the specified substring.
+     */
     contains?: string;
+    /**
+     * Checks if the string starts with the specified substring.
+     */
     startsWith?: string;
+    /**
+     * Checks if the string ends with the specified substring.
+     */
     endsWith?: string;
     /**
-     * Not effective for "sqlite" provider
+     * Specifies the string comparison mode. Not effective for "sqlite" provider
      */
     mode?: 'default' | 'insensitive';
 } & (WithAggregations extends true ? {
+    /**
+     * Filters against the count of records.
+     */
     _count?: NumberFilter<'Int', false, false>;
+    /**
+     * Filters against the minimum value.
+     */
     _min?: StringFilter<false, false>;
+    /**
+     * Filters against the maximum value.
+     */
     _max?: StringFilter<false, false>;
 } : {}));
 type NumberFilter<T extends 'Int' | 'Float' | 'Decimal' | 'BigInt', Nullable extends boolean, WithAggregations extends boolean> = NullableIf<number | bigint, Nullable> | (CommonPrimitiveFilter<number, T, Nullable, WithAggregations> & (WithAggregations extends true ? {
+    /**
+     * Filters against the count of records.
+     */
     _count?: NumberFilter<'Int', false, false>;
+    /**
+     * Filters against the average value.
+     */
     _avg?: NumberFilter<T, false, false>;
+    /**
+     * Filters against the sum value.
+     */
     _sum?: NumberFilter<T, false, false>;
+    /**
+     * Filters against the minimum value.
+     */
     _min?: NumberFilter<T, false, false>;
+    /**
+     * Filters against the maximum value.
+     */
     _max?: NumberFilter<T, false, false>;
 } : {}));
 type DateTimeFilter<Nullable extends boolean, WithAggregations extends boolean> = NullableIf<Date | string, Nullable> | (CommonPrimitiveFilter<Date | string, 'DateTime', Nullable, WithAggregations> & (WithAggregations extends true ? {
+    /**
+     * Filters against the count of records.
+     */
     _count?: NumberFilter<'Int', false, false>;
+    /**
+     * Filters against the minimum value.
+     */
     _min?: DateTimeFilter<false, false>;
+    /**
+     * Filters against the maximum value.
+     */
     _max?: DateTimeFilter<false, false>;
 } : {}));
 type BytesFilter<Nullable extends boolean, WithAggregations extends boolean> = NullableIf<Uint8Array | Buffer, Nullable> | ({
+    /**
+     * Checks for equality with the specified value.
+     */
     equals?: NullableIf<Uint8Array, Nullable>;
+    /**
+     * Checks if the value is in the specified list of values.
+     */
     in?: Uint8Array[];
+    /**
+     * Checks if the value is not in the specified list of values.
+     */
     notIn?: Uint8Array[];
+    /**
+     * Builds a negated filter.
+     */
     not?: BytesFilter<Nullable, WithAggregations>;
 } & (WithAggregations extends true ? {
+    /**
+     * Filters against the count of records.
+     */
     _count?: NumberFilter<'Int', false, false>;
+    /**
+     * Filters against the minimum value.
+     */
     _min?: BytesFilter<false, false>;
+    /**
+     * Filters against the maximum value.
+     */
     _max?: BytesFilter<false, false>;
 } : {}));
 type BooleanFilter<Nullable extends boolean, WithAggregations extends boolean> = NullableIf<boolean, Nullable> | ({
+    /**
+     * Checks for equality with the specified value.
+     */
     equals?: NullableIf<boolean, Nullable>;
+    /**
+     * Builds a negated filter.
+     */
     not?: BooleanFilter<Nullable, WithAggregations>;
 } & (WithAggregations extends true ? {
+    /**
+     * Filters against the count of records.
+     */
     _count?: NumberFilter<'Int', false, false>;
+    /**
+     * Filters against the minimum value.
+     */
     _min?: BooleanFilter<false, false>;
+    /**
+     * Filters against the maximum value.
+     */
     _max?: BooleanFilter<false, false>;
 } : {}));
+type JsonFilter = {
+    /**
+     * JSON path to select the value to filter on. If omitted, the whole JSON value is used.
+     */
+    path?: string;
+    /**
+     * Checks for equality with the specified value.
+     */
+    equals?: JsonValue | JsonNullValues;
+    /**
+     * Builds a negated filter.
+     */
+    not?: JsonValue | JsonNullValues;
+    /**
+     * Checks if the value is a string and contains the specified substring.
+     */
+    string_contains?: string;
+    /**
+     * Checks if the value is a string and starts with the specified substring.
+     */
+    string_starts_with?: string;
+    /**
+     * Checks if the value is a string and ends with the specified substring.
+     */
+    string_ends_with?: string;
+    /**
+     * String comparison mode. Not effective for "sqlite" provider
+     */
+    mode?: 'default' | 'insensitive';
+    /**
+     * Checks if the value is an array and contains the specified value.
+     */
+    array_contains?: JsonValue;
+    /**
+     * Checks if the value is an array and starts with the specified value.
+     */
+    array_starts_with?: JsonValue;
+    /**
+     * Checks if the value is an array and ends with the specified value.
+     */
+    array_ends_with?: JsonValue;
+};
+type TypedJsonFilter<Schema extends SchemaDef, TypeDefName extends GetTypeDefs<Schema>, Array extends boolean, Optional extends boolean> = XOR<JsonFilter, TypedJsonTypedFilter<Schema, TypeDefName, Array, Optional>>;
+type TypedJsonTypedFilter<Schema extends SchemaDef, TypeDefName extends GetTypeDefs<Schema>, Array extends boolean, Optional extends boolean> = (Array extends true ? ArrayTypedJsonFilter<Schema, TypeDefName> : NonArrayTypedJsonFilter<Schema, TypeDefName>) | (Optional extends true ? null : never);
+type ArrayTypedJsonFilter<Schema extends SchemaDef, TypeDefName extends GetTypeDefs<Schema>> = {
+    some?: TypedJsonFieldsFilter<Schema, TypeDefName>;
+    every?: TypedJsonFieldsFilter<Schema, TypeDefName>;
+    none?: TypedJsonFieldsFilter<Schema, TypeDefName>;
+};
+type NonArrayTypedJsonFilter<Schema extends SchemaDef, TypeDefName extends GetTypeDefs<Schema>> = {
+    is?: TypedJsonFieldsFilter<Schema, TypeDefName>;
+    isNot?: TypedJsonFieldsFilter<Schema, TypeDefName>;
+} | TypedJsonFieldsFilter<Schema, TypeDefName>;
+type TypedJsonFieldsFilter<Schema extends SchemaDef, TypeDefName extends GetTypeDefs<Schema>> = {
+    [Key in GetTypeDefFields<Schema, TypeDefName>]?: GetTypeDefFieldType<Schema, TypeDefName, Key> extends GetTypeDefs<Schema> ? TypedJsonFilter<Schema, GetTypeDefFieldType<Schema, TypeDefName, Key>, TypeDefFieldIsArray<Schema, TypeDefName, Key>, TypeDefFieldIsOptional<Schema, TypeDefName, Key>> : TypeDefFieldIsArray<Schema, TypeDefName, Key> extends true ? ArrayFilter<Schema, GetTypeDefFieldType<Schema, TypeDefName, Key>> : GetTypeDefFieldType<Schema, TypeDefName, Key> extends GetEnums<Schema> ? EnumFilter<Schema, GetTypeDefFieldType<Schema, TypeDefName, Key>, TypeDefFieldIsOptional<Schema, TypeDefName, Key>, false> : PrimitiveFilter<GetTypeDefFieldType<Schema, TypeDefName, Key>, TypeDefFieldIsOptional<Schema, TypeDefName, Key>, false>;
+};
 type SortOrder = 'asc' | 'desc';
 type NullsOrder = 'first' | 'last';
 type OrderBy<Schema extends SchemaDef, Model extends GetModels<Schema>, WithRelation extends boolean, WithAggregation extends boolean> = {
     [Key in NonRelationFields<Schema, Model>]?: ModelFieldIsOptional<Schema, Model, Key> extends true ? SortOrder | {
+        /**
+         * Sort order
+         */
         sort: SortOrder;
+        /**
+         * Treatment of null values
+         */
         nulls?: NullsOrder;
     } : SortOrder;
 } & (WithRelation extends true ? {
     [Key in RelationFields<Schema, Model>]?: FieldIsArray<Schema, Model, Key> extends true ? {
+        /**
+         * Sorts by the count of related records.
+         */
         _count?: SortOrder;
     } : OrderBy<Schema, RelationFieldType<Schema, Model, Key>, WithRelation, WithAggregation>;
 } : {}) & (WithAggregation extends true ? {
+    /**
+     * Sorts by the count of records.
+     */
     _count?: OrderBy<Schema, Model, false, false>;
+    /**
+     * Sorts by the minimum value.
+     */
     _min?: MinMaxInput<Schema, Model, SortOrder>;
+    /**
+     * Sorts by the maximum value.
+     */
     _max?: MinMaxInput<Schema, Model, SortOrder>;
 } & (NumericFields<Schema, Model> extends never ? {} : {
+    /**
+     * Sorts by the average value.
+     */
     _avg?: SumAvgInput<Schema, Model, SortOrder>;
+    /**
+     * Sorts by the sum value.
+     */
     _sum?: SumAvgInput<Schema, Model, SortOrder>;
 }) : {});
 type WhereUniqueInput<Schema extends SchemaDef, Model extends GetModels<Schema>> = AtLeast<{
@@ -674,14 +936,26 @@ 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, AllowRelation extends boolean = true> = {
+    /**
+     * Explicitly select fields and relations to be returned by the query.
+     */
     select?: SelectInput<Schema, Model, AllowCount, AllowRelation> | null;
+    /**
+     * Specifies relations to be included in the query result. All scalar fields are included.
+     */
     include?: IncludeInput<Schema, Model, AllowCount> | null;
+    /**
+     * Explicitly omit fields from the query result.
+     */
     omit?: OmitInput<Schema, Model> | null;
 };
 type SelectInput<Schema extends SchemaDef, Model extends GetModels<Schema>, AllowCount extends boolean = true, AllowRelation extends boolean = true> = {
     [Key in NonRelationFields<Schema, Model>]?: boolean;
 } & (AllowRelation extends true ? IncludeInput<Schema, Model, AllowCount> : {});
 type SelectCount<Schema extends SchemaDef, Model extends GetModels<Schema>> = boolean | {
+    /**
+     * Selects specific relations to count.
+     */
     select: {
         [Key in RelationFields<Schema, Model> as FieldIsArray<Schema, Model, Key> extends true ? Key : never]?: boolean | {
             where: WhereInput<Schema, RelationFieldType<Schema, Model, Key>, false>;
@@ -711,7 +985,13 @@ type ToManyRelationFilter<Schema extends SchemaDef, Model extends GetModels<Sche
     none?: WhereInput<Schema, RelationFieldType<Schema, Model, Field>>;
 };
 type ToOneRelationFilter<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>> = NullableIf<WhereInput<Schema, RelationFieldType<Schema, Model, Field>> & {
+    /**
+     * Checks if the related record matches the specified filter.
+     */
     is?: NullableIf<WhereInput<Schema, RelationFieldType<Schema, Model, Field>>, ModelFieldIsOptional<Schema, Model, Field>>;
+    /**
+     * Checks if the related record does not match the specified filter.
+     */
     isNot?: NullableIf<WhereInput<Schema, RelationFieldType<Schema, Model, Field>>, ModelFieldIsOptional<Schema, Model, Field>>;
 }, ModelFieldIsOptional<Schema, Model, Field>>;
 type RelationFilter<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>> = FieldIsArray<Schema, Model, Field> extends true ? ToManyRelationFilter<Schema, Model, Field> : ToOneRelationFilter<Schema, Model, Field>;
@@ -722,20 +1002,38 @@ type OptionalFieldsForCreate<Schema extends SchemaDef, Model extends GetModels<S
 };
 type GetRelation<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends GetModelFields<Schema, Model>> = GetModelField<Schema, Model, Field>['relation'];
 type OppositeRelation<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends GetModelFields<Schema, Model>, FT = FieldType<Schema, Model, Field>> = FT extends GetModels<Schema> ? GetRelation<Schema, Model, Field> extends RelationInfo ? GetRelation<Schema, Model, Field>['opposite'] extends GetModelFields<Schema, FT> ? Schema['models'][FT]['fields'][GetRelation<Schema, Model, Field>['opposite']]['relation'] : never : never : never;
-type OppositeRelationFields<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends GetModelFields<Schema, Model>, Opposite = OppositeRelation<Schema, Model, Field>> = Opposite extends RelationInfo ? (Opposite['fields'] extends string[] ? Opposite['fields'] : []) : [];
+type OppositeRelationFields<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends GetModelFields<Schema, Model>, Opposite = OppositeRelation<Schema, Model, Field>> = Opposite extends RelationInfo ? (Opposite['fields'] extends readonly string[] ? Opposite['fields'] : []) : [];
 type OppositeRelationAndFK<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends GetModelFields<Schema, Model>, FT = FieldType<Schema, Model, Field>, Relation = GetModelField<Schema, Model, Field>['relation'], Opposite = Relation extends RelationInfo ? Relation['opposite'] : never> = FT extends GetModels<Schema> ? Opposite extends GetModelFields<Schema, FT> ? Opposite | OppositeRelationFields<Schema, Model, Field>[number] : never : never;
 type FilterArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
+    /**
+     * Filter conditions
+     */
     where?: WhereInput<Schema, Model>;
 };
 type SortAndTakeArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
+    /**
+     * Number of records to skip
+     */
     skip?: number;
+    /**
+     * Number of records to take
+     */
     take?: number;
+    /**
+     * Order by clauses
+     */
     orderBy?: OrArray<OrderBy<Schema, Model, true, false>>;
+    /**
+     * Cursor for pagination
+     */
     cursor?: WhereUniqueInput<Schema, Model>;
 };
-type FindArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, Collection extends boolean, AllowFilter extends boolean = true> = ProviderSupportsDistinct<Schema> extends true ? (Collection extends true ? SortAndTakeArgs<Schema, Model> & {
+type FindArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, Collection extends boolean, AllowFilter extends boolean = true> = (Collection extends true ? SortAndTakeArgs<Schema, Model> & {
+    /**
+     * Distinct fields
+     */
     distinct?: OrArray<NonRelationFields<Schema, Model>>;
-} : {}) & (AllowFilter extends true ? FilterArgs<Schema, Model> : {}) & SelectIncludeOmit<Schema, Model, Collection> : (Collection extends true ? SortAndTakeArgs<Schema, Model> : {}) & (AllowFilter extends true ? FilterArgs<Schema, Model> : {}) & SelectIncludeOmit<Schema, Model, Collection>;
+} : {}) & (AllowFilter extends true ? FilterArgs<Schema, Model> : {}) & SelectIncludeOmit<Schema, Model, Collection>;
 type FindManyArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = FindArgs<Schema, Model, true>;
 type FindFirstArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = FindArgs<Schema, Model, true>;
 type FindUniqueArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
@@ -750,16 +1048,30 @@ type OptionalWrap<Schema extends SchemaDef, Model extends GetModels<Schema>, T e
 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>;
 }>;
-type ScalarCreatePayload<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends ScalarFields<Schema, Model, false>> = Simplify<MapModelFieldType<Schema, Model, Field> | (FieldIsArray<Schema, Model, Field> extends true ? {
+type ScalarCreatePayload<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends ScalarFields<Schema, Model, false>> = ScalarFieldMutationPayload<Schema, Model, Field> | (FieldIsArray<Schema, Model, Field> extends true ? {
     set?: MapModelFieldType<Schema, Model, Field>;
-} : never)>;
+} : never);
+type ScalarFieldMutationPayload<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends GetModelFields<Schema, Model>> = IsJsonField<Schema, Model, Field> extends true ? ModelFieldIsOptional<Schema, Model, Field> extends true ? JsonValue | JsonNull | DbNull : JsonValue | JsonNull : MapModelFieldType<Schema, Model, Field>;
+type IsJsonField<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends GetModelFields<Schema, Model>> = GetModelFieldType<Schema, Model, Field> extends 'Json' ? true : false;
 type CreateFKPayload<Schema extends SchemaDef, Model extends GetModels<Schema>> = OptionalWrap<Schema, Model, {
     [Key in ForeignKeyFields<Schema, Model>]: MapModelFieldType<Schema, Model, Key>;
 }>;
 type CreateRelationFieldPayload<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>> = Omit<{
+    /**
+     * Connects or create a related record.
+     */
     connectOrCreate?: ConnectOrCreateInput<Schema, Model, Field>;
+    /**
+     * Creates a related record.
+     */
     create?: NestedCreateInput<Schema, Model, Field>;
+    /**
+     * Creates a batch of related records.
+     */
     createMany?: NestedCreateManyInput<Schema, Model, Field>;
+    /**
+     * Connects an existing record.
+     */
     connect?: ConnectInput<Schema, Model, Field>;
 }, (FieldIsArray<Schema, Model, Field> extends true ? never : 'createMany') | (FieldIsDelegateRelation<Schema, Model, Field> extends true ? 'create' | 'createMany' | 'connectOrCreate' : never)>;
 type CreateRelationPayload<Schema extends SchemaDef, Model extends GetModels<Schema>> = OptionalWrap<Schema, Model, {
@@ -771,43 +1083,100 @@ type CreateWithNonOwnedRelationPayload<Schema extends SchemaDef, Model extends G
     [Key in NonOwnedRelationFields<Schema, Model>]: CreateRelationFieldPayload<Schema, Model, Key>;
 }>;
 type ConnectOrCreatePayload<Schema extends SchemaDef, Model extends GetModels<Schema>, Without extends string = never> = {
+    /**
+     * The unique filter to find an existing record to connect.
+     */
     where: WhereUniqueInput<Schema, Model>;
+    /**
+     * The data to create a new record if no existing record is found.
+     */
     create: CreateInput<Schema, Model, Without>;
 };
 type CreateManyInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Without extends string = never> = {
+    /**
+     * The data for the records to create.
+     */
     data: OrArray<Omit<CreateScalarPayload<Schema, Model>, Without> & Omit<CreateFKPayload<Schema, Model>, Without>>;
+    /**
+     * Specifies whether to skip creating records that would violate unique constraints.
+     */
     skipDuplicates?: boolean;
 };
 type CreateInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Without extends string = never> = XOR<Omit<CreateWithFKInput<Schema, Model>, Without>, Omit<CreateWithRelationInput<Schema, Model>, Without>>;
 type NestedCreateInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>> = OrArray<CreateInput<Schema, RelationFieldType<Schema, Model, Field>, 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>> = {
+    /**
+     * The data to update the record with.
+     */
     data: UpdateInput<Schema, Model>;
+    /**
+     * The unique filter to find the record to update.
+     */
     where: WhereUniqueInput<Schema, Model>;
 } & SelectIncludeOmit<Schema, Model, true>;
 type UpdateManyArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = UpdateManyPayload<Schema, Model>;
 type UpdateManyAndReturnArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = UpdateManyPayload<Schema, Model> & Omit<SelectIncludeOmit<Schema, Model, false, false>, 'include'>;
 type UpdateManyPayload<Schema extends SchemaDef, Model extends GetModels<Schema>, Without extends string = never> = {
+    /**
+     * The data to update the records with.
+     */
     data: OrArray<UpdateScalarInput<Schema, Model, Without>>;
+    /**
+     * The filter to select records to update.
+     */
     where?: WhereInput<Schema, Model>;
+    /**
+     * Limit the number of records to update.
+     */
     limit?: number;
 };
 type UpsertArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
+    /**
+     * The data to create the record if it doesn't exist.
+     */
     create: CreateInput<Schema, Model>;
+    /**
+     * The data to update the record with if it exists.
+     */
     update: UpdateInput<Schema, Model>;
+    /**
+     * The unique filter to find the record to update.
+     */
     where: WhereUniqueInput<Schema, Model>;
 } & SelectIncludeOmit<Schema, Model, true>;
 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>;
-type ScalarUpdatePayload<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends NonRelationFields<Schema, Model>> = MapModelFieldType<Schema, Model, Field> | (Field extends NumericFields<Schema, Model> ? {
+type ScalarUpdatePayload<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends NonRelationFields<Schema, Model>> = ScalarFieldMutationPayload<Schema, Model, Field> | (Field extends NumericFields<Schema, Model> ? {
+    /**
+     * Sets the field to the specified value.
+     */
     set?: NullableIf<number, ModelFieldIsOptional<Schema, Model, Field>>;
+    /**
+     * Increments the field by the specified value.
+     */
     increment?: number;
+    /**
+     * Decrements the field by the specified value.
+     */
     decrement?: number;
+    /**
+     * Multiplies the field by the specified value.
+     */
     multiply?: number;
+    /**
+     * Divides the field by the specified value.
+     */
     divide?: number;
 } : never) | (FieldIsArray<Schema, Model, Field> extends true ? {
+    /**
+     * Sets the field to the specified array.
+     */
     set?: MapModelFieldType<Schema, Model, Field>[];
+    /**
+     * Appends the specified values to the array field.
+     */
     push?: OrArray<MapModelFieldType<Schema, Model, Field>, true>;
 } : never);
 type UpdateRelationInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Without extends string = never> = Omit<{
@@ -816,36 +1185,102 @@ type UpdateRelationInput<Schema extends SchemaDef, Model extends GetModels<Schem
 type UpdateInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Without extends string = never> = UpdateScalarInput<Schema, Model, Without> & UpdateRelationInput<Schema, Model, Without>;
 type UpdateRelationFieldPayload<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>> = FieldIsArray<Schema, Model, Field> extends true ? ToManyRelationUpdateInput<Schema, Model, Field> : ToOneRelationUpdateInput<Schema, Model, Field>;
 type ToManyRelationUpdateInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>> = Omit<{
+    /**
+     * Creates related records.
+     */
     create?: NestedCreateInput<Schema, Model, Field>;
+    /**
+     * Creates a batch of related records.
+     */
     createMany?: NestedCreateManyInput<Schema, Model, Field>;
+    /**
+     * Connects existing records.
+     */
     connect?: ConnectInput<Schema, Model, Field>;
+    /**
+     * Connects or create related records.
+     */
     connectOrCreate?: ConnectOrCreateInput<Schema, Model, Field>;
+    /**
+     * Disconnects related records.
+     */
     disconnect?: DisconnectInput<Schema, Model, Field>;
+    /**
+     * Updates related records.
+     */
     update?: NestedUpdateInput<Schema, Model, Field>;
+    /**
+     * Upserts related records.
+     */
     upsert?: NestedUpsertInput<Schema, Model, Field>;
+    /**
+     * Updates a batch of related records.
+     */
     updateMany?: NestedUpdateManyInput<Schema, Model, Field>;
+    /**
+     * Deletes related records.
+     */
     delete?: NestedDeleteInput<Schema, Model, Field>;
+    /**
+     * Deletes a batch of related records.
+     */
     deleteMany?: NestedDeleteManyInput<Schema, Model, Field>;
+    /**
+     * Sets the related records to the specified ones.
+     */
     set?: SetRelationInput<Schema, Model, Field>;
 }, FieldIsDelegateRelation<Schema, Model, Field> extends true ? 'create' | 'createMany' | 'connectOrCreate' | 'upsert' : never>;
 type ToOneRelationUpdateInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>> = Omit<{
+    /**
+     * Creates a related record.
+     */
     create?: NestedCreateInput<Schema, Model, Field>;
+    /**
+     * Connects an existing record.
+     */
     connect?: ConnectInput<Schema, Model, Field>;
+    /**
+     * Connects or create a related record.
+     */
     connectOrCreate?: ConnectOrCreateInput<Schema, Model, Field>;
+    /**
+     * Updates the related record.
+     */
     update?: NestedUpdateInput<Schema, Model, Field>;
+    /**
+     * Upserts the related record.
+     */
     upsert?: NestedUpsertInput<Schema, Model, Field>;
 } & (ModelFieldIsOptional<Schema, Model, Field> extends true ? {
+    /**
+     * Disconnects the related record.
+     */
     disconnect?: DisconnectInput<Schema, Model, Field>;
+    /**
+     * Deletes the related record.
+     */
     delete?: NestedDeleteInput<Schema, Model, Field>;
 } : {}), FieldIsDelegateRelation<Schema, Model, Field> extends true ? 'create' | 'connectOrCreate' | 'upsert' : never>;
 type DeleteArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
+    /**
+     * The unique filter to find the record to delete.
+     */
     where: WhereUniqueInput<Schema, Model>;
 } & SelectIncludeOmit<Schema, Model, true>;
 type DeleteManyArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
+    /**
+     * Filter to select records to delete.
+     */
     where?: WhereInput<Schema, Model>;
+    /**
+     * Limits the number of records to delete.
+     */
     limit?: number;
 };
 type CountArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = Omit<FindArgs<Schema, Model, true>, 'select' | 'include' | 'distinct' | 'omit'> & {
+    /**
+     * Selects fields to count
+     */
     select?: CountAggregateInput<Schema, Model> | true;
 };
 type CountAggregateInput<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
@@ -859,16 +1294,43 @@ type CountResult<Schema extends SchemaDef, _Model extends GetModels<Schema>, Arg
     [Key in keyof S]: number;
 } : number;
 type AggregateArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
+    /**
+     * Filter conditions
+     */
     where?: WhereInput<Schema, Model>;
+    /**
+     * Number of records to skip for the aggregation
+     */
     skip?: number;
+    /**
+     * Number of records to take for the aggregation
+     */
     take?: number;
+    /**
+     * Order by clauses
+     */
     orderBy?: OrArray<OrderBy<Schema, Model, true, false>>;
 } & {
+    /**
+     * Performs count aggregation.
+     */
     _count?: true | CountAggregateInput<Schema, Model>;
+    /**
+     * Performs minimum value aggregation.
+     */
     _min?: MinMaxInput<Schema, Model, true>;
+    /**
+     * Performs maximum value aggregation.
+     */
     _max?: MinMaxInput<Schema, Model, true>;
 } & (NumericFields<Schema, Model> extends never ? {} : {
+    /**
+     * Performs average value aggregation.
+     */
     _avg?: SumAvgInput<Schema, Model, true>;
+    /**
+     * Performs sum value aggregation.
+     */
     _sum?: SumAvgInput<Schema, Model, true>;
 });
 type NumericFields<Schema extends SchemaDef, Model extends GetModels<Schema>> = keyof {
@@ -883,22 +1345,37 @@ type MinMaxInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Valu
 type AggregateResult<Schema extends SchemaDef, _Model extends GetModels<Schema>, Args> = (Args extends {
     _count: infer Count;
 } ? {
+    /**
+     * Count aggregation result
+     */
     _count: AggCommonOutput<Count>;
 } : {}) & (Args extends {
     _sum: infer Sum;
 } ? {
+    /**
+     * Sum aggregation result
+     */
     _sum: AggCommonOutput<Sum>;
 } : {}) & (Args extends {
     _avg: infer Avg;
 } ? {
+    /**
+     * Average aggregation result
+     */
     _avg: AggCommonOutput<Avg>;
 } : {}) & (Args extends {
     _min: infer Min;
 } ? {
+    /**
+     * Minimum aggregation result
+     */
     _min: AggCommonOutput<Min>;
 } : {}) & (Args extends {
     _max: infer Max;
 } ? {
+    /**
+     * Maximum aggregation result
+     */
     _max: AggCommonOutput<Max>;
 } : {});
 type AggCommonOutput<Input> = Input extends true ? number : Input extends {} ? {
@@ -906,17 +1383,50 @@ type AggCommonOutput<Input> = Input extends true ? number : Input extends {} ? {
 } : never;
 type GroupByHaving<Schema extends SchemaDef, Model extends GetModels<Schema>> = Omit<WhereInput<Schema, Model, true, true>, '$expr'>;
 type GroupByArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
+    /**
+     * Filter conditions
+     */
     where?: WhereInput<Schema, Model>;
+    /**
+     * Order by clauses
+     */
     orderBy?: OrArray<OrderBy<Schema, Model, false, true>>;
+    /**
+     * Fields to group by
+     */
     by: NonRelationFields<Schema, Model> | NonEmptyArray<NonRelationFields<Schema, Model>>;
+    /**
+     * Filter conditions for the grouped records
+     */
     having?: GroupByHaving<Schema, Model>;
+    /**
+     * Number of records to take for grouping
+     */
     take?: number;
+    /**
+     * Number of records to skip for grouping
+     */
     skip?: number;
+    /**
+     * Performs count aggregation.
+     */
     _count?: true | CountAggregateInput<Schema, Model>;
+    /**
+     * Performs minimum value aggregation.
+     */
     _min?: MinMaxInput<Schema, Model, true>;
+    /**
+     * Performs maximum value aggregation.
+     */
     _max?: MinMaxInput<Schema, Model, true>;
 } & (NumericFields<Schema, Model> extends never ? {} : {
+    /**
+     * Performs average value aggregation.
+     */
     _avg?: SumAvgInput<Schema, Model, true>;
+    /**
+     * Performs sum value aggregation.
+     */
     _sum?: SumAvgInput<Schema, Model, true>;
 });
 type GroupByResult<Schema extends SchemaDef, Model extends GetModels<Schema>, Args extends {
@@ -926,22 +1436,37 @@ type GroupByResult<Schema extends SchemaDef, Model extends GetModels<Schema>, Ar
 } & (Args extends {
     _count: infer Count;
 } ? {
+    /**
+     * Count aggregation result
+     */
     _count: AggCommonOutput<Count>;
 } : {}) & (Args extends {
     _avg: infer Avg;
 } ? {
+    /**
+     * Average aggregation result
+     */
     _avg: AggCommonOutput<Avg>;
 } : {}) & (Args extends {
     _sum: infer Sum;
 } ? {
+    /**
+     * Sum aggregation result
+     */
     _sum: AggCommonOutput<Sum>;
 } : {}) & (Args extends {
     _min: infer Min;
 } ? {
+    /**
+     * Minimum aggregation result
+     */
     _min: AggCommonOutput<Min>;
 } : {}) & (Args extends {
     _max: infer Max;
 } ? {
+    /**
+     * Maximum aggregation result
+     */
     _max: AggCommonOutput<Max>;
 } : {})>;
 type ConnectInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>> = FieldIsArray<Schema, Model, Field> extends true ? OrArray<WhereUniqueInput<Schema, RelationFieldType<Schema, Model, Field>>> : WhereUniqueInput<Schema, RelationFieldType<Schema, Model, Field>>;
@@ -949,15 +1474,36 @@ type ConnectOrCreateInput<Schema extends SchemaDef, Model extends GetModels<Sche
 type DisconnectInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>> = FieldIsArray<Schema, Model, Field> extends true ? OrArray<WhereUniqueInput<Schema, RelationFieldType<Schema, Model, Field>>, true> : boolean | WhereInput<Schema, RelationFieldType<Schema, Model, Field>>;
 type SetRelationInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>> = OrArray<WhereUniqueInput<Schema, RelationFieldType<Schema, Model, Field>>>;
 type NestedUpdateInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>> = FieldIsArray<Schema, Model, Field> extends true ? OrArray<{
+    /**
+     * Unique filter to select the record to update.
+     */
     where: WhereUniqueInput<Schema, RelationFieldType<Schema, Model, Field>>;
+    /**
+     * The data to update the record with.
+     */
     data: UpdateInput<Schema, RelationFieldType<Schema, Model, Field>, OppositeRelationAndFK<Schema, Model, Field>>;
 }, true> : XOR<{
-    where: WhereUniqueInput<Schema, RelationFieldType<Schema, Model, Field>>;
+    /**
+     * Filter to select the record to update.
+     */
+    where?: WhereInput<Schema, RelationFieldType<Schema, Model, Field>>;
+    /**
+     * The data to update the record with.
+     */
     data: UpdateInput<Schema, RelationFieldType<Schema, Model, Field>, OppositeRelationAndFK<Schema, Model, Field>>;
 }, UpdateInput<Schema, RelationFieldType<Schema, Model, Field>, OppositeRelationAndFK<Schema, Model, Field>>>;
 type NestedUpsertInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>> = OrArray<{
+    /**
+     * Unique filter to select the record to update.
+     */
     where: WhereUniqueInput<Schema, RelationFieldType<Schema, Model, Field>>;
+    /**
+     * The data to create the record if it doesn't exist.
+     */
     create: CreateInput<Schema, RelationFieldType<Schema, Model, Field>, OppositeRelationAndFK<Schema, Model, Field>>;
+    /**
+     * The data to update the record with if it exists.
+     */
     update: UpdateInput<Schema, RelationFieldType<Schema, Model, Field>, OppositeRelationAndFK<Schema, Model, Field>>;
 }, FieldIsArray<Schema, Model, Field>>;
 type NestedUpdateManyInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>> = OrArray<UpdateManyPayload<Schema, RelationFieldType<Schema, Model, Field>, OppositeRelationAndFK<Schema, Model, Field>>>;
@@ -965,13 +1511,12 @@ type NestedDeleteInput<Schema extends SchemaDef, Model extends GetModels<Schema>
 type NestedDeleteManyInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>> = OrArray<WhereInput<Schema, RelationFieldType<Schema, Model, Field>, true>>;
 type NonOwnedRelationFields<Schema extends SchemaDef, Model extends GetModels<Schema>> = keyof {
     [Key in RelationFields<Schema, Model> as GetModelField<Schema, Model, Key>['relation'] extends {
-        references: unknown[];
+        references: readonly unknown[];
     } ? never : Key]: true;
 };
 type HasToManyRelations<Schema extends SchemaDef, Model extends GetModels<Schema>> = keyof {
     [Key in RelationFields<Schema, Model> as FieldIsArray<Schema, Model, Key> extends true ? Key : never]: true;
 } extends never ? false : true;
-type ProviderSupportsDistinct<Schema extends SchemaDef> = Schema['provider']['type'] extends 'postgresql' ? true : false;
 
 /**
  * A promise that only executes when it's awaited or .then() is called.
@@ -1110,7 +1655,7 @@ type ClientContract<Schema extends SchemaDef, Options extends ClientOptions<Sche
      */
     $pushSchema(): Promise<void>;
 } & {
-    [Key in GetModels<Schema> as Uncapitalize<Key>]: ModelOperations<Schema, Key, Options>;
+    [Key in GetModels<Schema> as Uncapitalize<Key>]: ModelOperations<Schema, Key, ToQueryOptions<Options>>;
 } & Procedures<Schema>;
 /**
  * The contract for a client in a transaction.
@@ -1161,7 +1706,7 @@ type CRUD_EXT = CRUD | 'post-update';
  * Extended CRUD operations including 'post-update'.
  */
 declare const CRUD_EXT: readonly ["create", "read", "update", "delete", "post-update"];
-type AllModelOperations<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends ClientOptions<Schema>> = {
+type AllModelOperations<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema>> = {
     /**
      * Returns a list of entities.
      * @param args - query args
@@ -1243,35 +1788,35 @@ type AllModelOperations<Schema extends SchemaDef, Model extends GetModels<Schema
      * }); // result: `{ _count: { posts: number } }`
      * ```
      */
-    findMany<T extends FindManyArgs<Schema, Model>>(args?: SelectSubset<T, FindManyArgs<Schema, Model>>): ZenStackPromise<Schema, SimplifiedModelResult<Schema, Model, Options, T>[]>;
+    findMany<T extends FindManyArgs<Schema, Model>>(args?: SelectSubset<T, FindManyArgs<Schema, Model>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options>[]>;
     /**
      * 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>>(args: SelectSubset<T, FindUniqueArgs<Schema, Model>>): ZenStackPromise<Schema, SimplifiedModelResult<Schema, Model, Options, T> | null>;
+    findUnique<T extends FindUniqueArgs<Schema, Model>>(args: SelectSubset<T, FindUniqueArgs<Schema, Model>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options> | 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>>(args: SelectSubset<T, FindUniqueArgs<Schema, Model>>): ZenStackPromise<Schema, SimplifiedModelResult<Schema, Model, Options, T>>;
+    findUniqueOrThrow<T extends FindUniqueArgs<Schema, Model>>(args: SelectSubset<T, FindUniqueArgs<Schema, Model>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options>>;
     /**
      * 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>>(args?: SelectSubset<T, FindFirstArgs<Schema, Model>>): ZenStackPromise<Schema, SimplifiedModelResult<Schema, Model, Options, T> | null>;
+    findFirst<T extends FindFirstArgs<Schema, Model>>(args?: SelectSubset<T, FindFirstArgs<Schema, Model>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options> | 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>>(args?: SelectSubset<T, FindFirstArgs<Schema, Model>>): ZenStackPromise<Schema, SimplifiedModelResult<Schema, Model, Options, T>>;
+    findFirstOrThrow<T extends FindFirstArgs<Schema, Model>>(args?: SelectSubset<T, FindFirstArgs<Schema, Model>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options>>;
     /**
      * Creates a new entity.
      * @param args - create args
@@ -1324,7 +1869,7 @@ type AllModelOperations<Schema extends SchemaDef, Model extends GetModels<Schema
      * });
      * ```
      */
-    create<T extends CreateArgs<Schema, Model>>(args: SelectSubset<T, CreateArgs<Schema, Model>>): ZenStackPromise<Schema, SimplifiedModelResult<Schema, Model, Options, T>>;
+    create<T extends CreateArgs<Schema, Model>>(args: SelectSubset<T, CreateArgs<Schema, Model>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options>>;
     /**
      * Creates multiple entities. Only scalar fields are allowed.
      * @param args - create args
@@ -1369,7 +1914,7 @@ type AllModelOperations<Schema extends SchemaDef, Model extends GetModels<Schema
      * });
      * ```
      */
-    createManyAndReturn<T extends CreateManyAndReturnArgs<Schema, Model>>(args?: SelectSubset<T, CreateManyAndReturnArgs<Schema, Model>>): ZenStackPromise<Schema, SimplifiedModelResult<Schema, Model, Options, T>[]>;
+    createManyAndReturn<T extends CreateManyAndReturnArgs<Schema, Model>>(args?: SelectSubset<T, CreateManyAndReturnArgs<Schema, Model>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options>[]>;
     /**
      * Updates a uniquely identified entity.
      * @param args - update args. See {@link findMany} for how to control
@@ -1487,7 +2032,7 @@ type AllModelOperations<Schema extends SchemaDef, Model extends GetModels<Schema
      * });
      * ```
      */
-    update<T extends UpdateArgs<Schema, Model>>(args: SelectSubset<T, UpdateArgs<Schema, Model>>): ZenStackPromise<Schema, SimplifiedModelResult<Schema, Model, Options, T>>;
+    update<T extends UpdateArgs<Schema, Model>>(args: SelectSubset<T, UpdateArgs<Schema, Model>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options>>;
     /**
      * Updates multiple entities.
      * @param args - update args. Only scalar fields are allowed for data.
@@ -1531,7 +2076,7 @@ type AllModelOperations<Schema extends SchemaDef, Model extends GetModels<Schema
      * });
      * ```
      */
-    updateManyAndReturn<T extends UpdateManyAndReturnArgs<Schema, Model>>(args: Subset<T, UpdateManyAndReturnArgs<Schema, Model>>): ZenStackPromise<Schema, SimplifiedModelResult<Schema, Model, Options, T>[]>;
+    updateManyAndReturn<T extends UpdateManyAndReturnArgs<Schema, Model>>(args: Subset<T, UpdateManyAndReturnArgs<Schema, Model>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options>[]>;
     /**
      * Creates or updates an entity.
      * @param args - upsert args
@@ -1552,7 +2097,7 @@ type AllModelOperations<Schema extends SchemaDef, Model extends GetModels<Schema
      * });
      * ```
      */
-    upsert<T extends UpsertArgs<Schema, Model>>(args: SelectSubset<T, UpsertArgs<Schema, Model>>): ZenStackPromise<Schema, SimplifiedModelResult<Schema, Model, Options, T>>;
+    upsert<T extends UpsertArgs<Schema, Model>>(args: SelectSubset<T, UpsertArgs<Schema, Model>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options>>;
     /**
      * Deletes a uniquely identifiable entity.
      * @param args - delete args
@@ -1572,7 +2117,7 @@ type AllModelOperations<Schema extends SchemaDef, Model extends GetModels<Schema
      * }); // result: `{ id: string; email: string }`
      * ```
      */
-    delete<T extends DeleteArgs<Schema, Model>>(args: SelectSubset<T, DeleteArgs<Schema, Model>>): ZenStackPromise<Schema, SimplifiedModelResult<Schema, Model, Options, T>>;
+    delete<T extends DeleteArgs<Schema, Model>>(args: SelectSubset<T, DeleteArgs<Schema, Model>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options>>;
     /**
      * Deletes multiple entities.
      * @param args - delete args
@@ -1666,12 +2211,12 @@ type AllModelOperations<Schema extends SchemaDef, Model extends GetModels<Schema
     groupBy<T extends GroupByArgs<Schema, Model>>(args: Subset<T, GroupByArgs<Schema, Model>>): ZenStackPromise<Schema, Simplify<GroupByResult<Schema, Model, T>>>;
 };
 type OperationsIneligibleForDelegateModels = 'create' | 'createMany' | 'createManyAndReturn' | 'upsert';
-type ModelOperations<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends ClientOptions<Schema> = ClientOptions<Schema>> = Omit<AllModelOperations<Schema, Model, Options>, IsDelegateModel<Schema, Model> extends true ? OperationsIneligibleForDelegateModels : never>;
+type ModelOperations<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>> = Omit<AllModelOperations<Schema, Model, Options>, IsDelegateModel<Schema, Model> extends true ? OperationsIneligibleForDelegateModels : never>;
 /**
  * Type for auth context that includes both scalar and relation fields.
  * Relations are recursively included to allow nested auth data like { user: { profile: { ... } } }
  */
-type AuthModelType<Schema extends SchemaDef, Model extends GetModels<Schema>> = Partial<DefaultModelResult<Schema, Model, ClientOptions<Schema>>> & {
+type AuthModelType<Schema extends SchemaDef, Model extends GetModels<Schema>> = Partial<DefaultModelResult<Schema, Model>> & {
     [Key in RelationFields<Schema, Model>]?: FieldIsArray<Schema, Model, Key> extends true ? AuthModelType<Schema, RelationFieldType<Schema, Model, Key>>[] : AuthModelType<Schema, RelationFieldType<Schema, Model, Key>>;
 };
 type AuthType<Schema extends SchemaDef> = Schema['authType'] extends GetModels<Schema> ? AuthModelType<Schema, Schema['authType']> : Schema['authType'] extends GetTypeDefs<Schema> ? TypeDefResult<Schema, Schema['authType'], true> : Record<string, unknown>;
@@ -1769,10 +2314,11 @@ declare function hasModel(schema: SchemaDef, model: string): boolean;
 declare function getModel(schema: SchemaDef, model: string): ModelDef | undefined;
 declare function getTypeDef(schema: SchemaDef, type: string): _zenstackhq_schema.TypeDefDef | undefined;
 declare function requireModel(schema: SchemaDef, model: string): ModelDef;
+declare function requireTypeDef(schema: SchemaDef, type: string): _zenstackhq_schema.TypeDefDef;
 declare function getField(schema: SchemaDef, model: string, field: string): FieldDef | undefined;
 declare function requireField(schema: SchemaDef, modelOrType: string, field: string): FieldDef;
-declare function getIdFields<Schema extends SchemaDef>(schema: SchemaDef, model: GetModels<Schema>): string[] | undefined;
-declare function requireIdFields(schema: SchemaDef, model: string): string[];
+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): {
     keyPairs: {
         fk: string;
@@ -1795,6 +2341,7 @@ declare function getIdValues(schema: SchemaDef, model: string, data: any): Recor
 declare function fieldHasDefaultValue(fieldDef: FieldDef): boolean | undefined;
 declare function isEnum(schema: SchemaDef, type: string): boolean;
 declare function getEnum(schema: SchemaDef, type: string): _zenstackhq_schema.EnumDef | undefined;
+declare function isTypeDef(schema: SchemaDef, type: string): boolean;
 declare function buildJoinPairs(schema: SchemaDef, model: string, modelAlias: string, relationField: string, relationModelAlias: string): [string, string][];
 declare function makeDefaultOrderBy<Schema extends SchemaDef>(schema: SchemaDef, model: string): OrderBy<Schema, GetModels<Schema>, true, false>[];
 declare function getManyToManyRelation(schema: SchemaDef, model: string, field: string): {
@@ -1861,13 +2408,15 @@ declare const queryUtils_isForeignKeyField: typeof isForeignKeyField;
 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_makeDefaultOrderBy: typeof makeDefaultOrderBy;
 declare const queryUtils_requireField: typeof requireField;
 declare const queryUtils_requireIdFields: typeof requireIdFields;
 declare const queryUtils_requireModel: typeof requireModel;
+declare const queryUtils_requireTypeDef: typeof requireTypeDef;
 declare const queryUtils_stripAlias: typeof stripAlias;
 declare namespace queryUtils {
-  export { 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_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_makeDefaultOrderBy as makeDefaultOrderBy, queryUtils_requireField as requireField, queryUtils_requireIdFields as requireIdFields, queryUtils_requireModel as requireModel, queryUtils_stripAlias as stripAlias };
+  export { 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_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 };
 }
 
 type VisitResult = void | {
@@ -1904,4 +2453,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, type AllModelOperations, type AuthType, BaseCrudDialect, type BatchResult, type BeforeEntityMutationCallback, type BooleanFilter, type BytesFilter, CRUD, CRUD_EXT, type ClientConstructor, type ClientContract, type ClientOptions, type ComputedFieldsOptions, type CountArgs, type CountResult, type CreateArgs, type CreateInput, type CreateManyAndReturnArgs, type CreateManyArgs, type CreateManyInput, type CoreCrudOperation as CrudOperation, type DateTimeFilter, type DefaultModelResult, type DeleteArgs, type DeleteManyArgs, type EntityMutationHooksDef, type FindArgs, type FindFirstArgs, type FindManyArgs, type FindUniqueArgs, type GroupByArgs, type GroupByResult, type HasComputedFields, type HasProcedures, type IncludeInput, type JsonArray, type JsonObject, type JsonValue, kyselyUtils as KyselyUtils, type ModelOperations, type ModelResult, type NullsOrder, type NumberFilter, ORMError, ORMErrorReason, type OmitInput, type OmitOptions, type OnKyselyQueryArgs, type OnKyselyQueryCallback, type OperationsIneligibleForDelegateModels, type OrderBy, type PluginAfterEntityMutationArgs, type PluginBeforeEntityMutationArgs, type ProcedureFunc, type Procedures, type ProceduresOptions, type ProceedKyselyQueryFunction, queryUtils as QueryUtils, RejectedByPolicyReason, type RuntimePlugin, schemaUtils as SchemaUtils, type SelectIncludeOmit, type SelectInput, type SelectSubset, type SimplifiedModelResult, type SortOrder, type StringFilter, type Subset, type ToKysely, type TransactionClientContract, TransactionIsolationLevel, type TypeDefResult, type UpdateArgs, type UpdateInput, type UpdateManyAndReturnArgs, type UpdateManyArgs, type UpsertArgs, type WhereInput, type WhereUniqueInput, type ZModelFunction, type ZModelFunctionContext, ZenStackClient, type ZenStackPromise, definePlugin, getCrudDialect };
+export { type AfterEntityMutationCallback, type AggregateArgs, type AggregateResult, type AllModelOperations, AnyNull, AnyNullClass, type AuthType, BaseCrudDialect, type BatchResult, type BeforeEntityMutationCallback, type BooleanFilter, type BytesFilter, CRUD, CRUD_EXT, type ClientConstructor, type ClientContract, type ClientOptions, type ComputedFieldsOptions, type CountArgs, type CountResult, type CreateArgs, type CreateInput, type CreateManyAndReturnArgs, type CreateManyArgs, type CreateManyInput, type CoreCrudOperation as CrudOperation, type DateTimeFilter, DbNull, DbNullClass, type DefaultModelResult, type DeleteArgs, type DeleteManyArgs, type EntityMutationHooksDef, type FindArgs, type FindFirstArgs, type FindManyArgs, type FindUniqueArgs, type GroupByArgs, type GroupByResult, type HasComputedFields, type HasProcedures, type IncludeInput, type JsonArray, type JsonFilter, JsonNull, JsonNullClass, type JsonNullValues, type JsonObject, type JsonValue, kyselyUtils as KyselyUtils, type ModelOperations, type ModelResult, type NullsOrder, type NumberFilter, ORMError, ORMErrorReason, type OmitInput, type OmitOptions, type OnKyselyQueryArgs, type OnKyselyQueryCallback, type OperationsIneligibleForDelegateModels, type OrderBy, type PluginAfterEntityMutationArgs, type PluginBeforeEntityMutationArgs, type ProcedureFunc, type Procedures, 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 SortOrder, type StringFilter, type Subset, type ToKysely, type ToQueryOptions, 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, definePlugin, getCrudDialect };