@zenstackhq/runtime 3.0.0-alpha.8 → 3.0.0-beta.1

package/dist/{contract-BnvK1nW0.d.cts → contract-CusA0mQO.d.cts}

@@ -1,11 +1,27 @@
 import Decimal, { Decimal as Decimal$1 } from 'decimal.js';
-import { SchemaDef, GetModels, ScalarFields, ForeignKeyFields, GetFields, FieldHasDefault, GetFieldType, FieldIsOptional, NonRelationFields, RelationFields, FieldIsArray, RelationFieldType, GetField, FieldIsRelation, GetEnums, GetEnum, BuiltinType, GetModel, FieldDef, FieldIsRelationArray, FieldType, RelationInfo, DataSourceProviderType, DataSourceProvider, ProcedureDef } from '@zenstackhq/sdk/schema';
-import { Generated, Kysely, ExpressionBuilder, OperandExpression, SqlBool, SelectQueryBuilder, Expression, ExpressionWrapper, RootOperationNode, QueryResult, UnknownRow, OperationNode, SqliteDialectConfig, PostgresDialectConfig, KyselyConfig } from 'kysely';
+import { SchemaDef, GetModels, ScalarFields, ForeignKeyFields, GetModelFields, FieldHasDefault, GetModelFieldType, ModelFieldIsOptional, GetModelField, NonRelationFields, RelationFields, FieldIsArray, RelationFieldType, FieldIsRelation, GetModel, FieldDef, GetEnums, GetEnum, GetTypeDefs, GetTypeDefFields, GetTypeDefField, TypeDefFieldIsOptional, BuiltinType, IsDelegateModel, GetModelDiscriminator, GetSubModels, FieldIsDelegateDiscriminator, FieldType, RelationInfo, FieldIsDelegateRelation, ModelDef, DataSourceProviderType, ProcedureDef } from '@zenstackhq/sdk/schema';
+import { Generated, Kysely, ExpressionBuilder, OperandExpression, SqlBool, SelectQueryBuilder, Expression, ExpressionWrapper, OperationNode, RootOperationNode, QueryResult, UnknownRow, Dialect, KyselyConfig } from 'kysely';
 
 type Optional<T extends object, K extends keyof T = keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
 type NullableIf<T, Condition extends boolean> = Condition extends true ? T | null : T;
+type _Preserve = Date | Function | Decimal | Uint8Array | JsonObject | JsonValue;
+type _Depth = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+type Simplify<T, D extends number = 6> = D extends 0 ? T : T extends object ? T extends _Preserve ? T : {
+    [K in keyof T]: Simplify<T[K], _Depth[D]>;
+} & {} : T;
 type WrapType<T, Optional = false, Array = false> = Optional extends true ? T | null : Array extends true ? T[] : T;
-type MapBaseType$1<T> = T extends 'String' ? string : T extends 'Boolean' ? boolean : T extends 'Int' | 'Float' ? number : T extends 'BigInt' ? bigint : T extends 'Decimal' ? Decimal : T extends 'DateTime' ? Date : T extends 'Json' ? JsonValue : unknown;
+type TypeMap = {
+    String: string;
+    Boolean: boolean;
+    Int: number;
+    Float: number;
+    BigInt: bigint;
+    Decimal: Decimal;
+    DateTime: Date;
+    Bytes: Uint8Array;
+    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;
@@ -27,24 +43,30 @@ type XOR<T, U> = T extends object ? (U extends object ? (Without<T, U> & U) | (W
 type MaybePromise<T> = T | Promise<T>;
 type PrependParameter<Param, Func> = Func extends (...args: any[]) => infer R ? (p: Param, ...args: Parameters<Func>) => R : never;
 type OrUndefinedIf<T, Condition extends boolean> = Condition extends true ? T | undefined : T;
+type UnwrapTuplePromises<T extends readonly unknown[]> = {
+    [K in keyof T]: Awaited<T[K]>;
+};
 
 type ToKyselySchema<Schema extends SchemaDef> = {
     [Model in GetModels<Schema>]: ToKyselyTable<Schema, Model>;
 };
 type ToKysely<Schema extends SchemaDef> = Kysely<ToKyselySchema<Schema>>;
 type ToKyselyTable<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
-    [Field in ScalarFields<Schema, Model, false> | ForeignKeyFields<Schema, Model>]: toKyselyFieldType<Schema, Model, Field>;
+    [Field in ScalarFields<Schema, Model, false> | ForeignKeyFields<Schema, Model> as GetModelField<Schema, Model, Field>['originModel'] extends string ? never : Field]: toKyselyFieldType<Schema, Model, Field>;
 };
 type MapBaseType<T> = T extends 'String' ? string : T extends 'Boolean' ? boolean : T extends 'Int' | 'Float' ? number : T extends 'BigInt' ? bigint : T extends 'Decimal' ? Decimal : T extends 'DateTime' ? string : unknown;
 type WrapNull<T, Null> = Null extends true ? T | null : T;
-type MapType$1<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends GetFields<Schema, Model>> = WrapNull<MapBaseType<GetFieldType<Schema, Model, Field>>, FieldIsOptional<Schema, Model, Field>>;
-type toKyselyFieldType<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends GetFields<Schema, Model>> = FieldHasDefault<Schema, Model, Field> extends true ? Generated<MapType$1<Schema, Model, Field>> : MapType$1<Schema, Model, Field>;
+type MapType$1<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends GetModelFields<Schema, Model>> = WrapNull<MapBaseType<GetModelFieldType<Schema, Model, Field>>, ModelFieldIsOptional<Schema, Model, Field>>;
+type toKyselyFieldType<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends GetModelFields<Schema, Model>> = FieldHasDefault<Schema, Model, Field> extends true ? Generated<MapType$1<Schema, Model, Field>> : MapType$1<Schema, Model, Field>;
 
-type DefaultModelResult<Schema extends SchemaDef, Model extends GetModels<Schema>, Omit = undefined, Optional = false, Array = false> = WrapType<{
-    [Key in NonRelationFields<Schema, Model> as Key extends keyof Omit ? Omit[Key] extends true ? never : Key : Key]: MapFieldType<Schema, Model, Key>;
+type DefaultModelResult<Schema extends SchemaDef, Model extends GetModels<Schema>, Omit = undefined, Optional = false, Array = false> = WrapType<IsDelegateModel<Schema, Model> extends true ? DelegateUnionResult<Schema, Model, GetSubModels<Schema, Model>, Omit> : {
+    [Key in NonRelationFields<Schema, Model> as Key extends keyof Omit ? Omit[Key] extends true ? never : Key : Key]: MapModelFieldType<Schema, Model, Key>;
 }, Optional, Array>;
+type DelegateUnionResult<Schema extends SchemaDef, Model extends GetModels<Schema>, SubModel extends GetModels<Schema>, Omit = undefined> = SubModel extends string ? DefaultModelResult<Schema, SubModel, Omit> & {
+    [K in GetModelDiscriminator<Schema, Model>]: SubModel;
+} : never;
 type ModelSelectResult<Schema extends SchemaDef, Model extends GetModels<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> ? MapFieldType<Schema, Model, Key> : Key extends RelationFields<Schema, Model> ? Select[Key] extends FindArgs<Schema, RelationFieldType<Schema, Model, Key>, FieldIsArray<Schema, Model, Key>> ? ModelResult<Schema, RelationFieldType<Schema, Model, Key>, Select[Key], FieldIsOptional<Schema, Model, Key>, FieldIsArray<Schema, Model, Key>> : DefaultModelResult<Schema, RelationFieldType<Schema, Model, Key>, Omit, FieldIsOptional<Schema, Model, Key>, FieldIsArray<Schema, Model, Key>> : never;
+    [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'>, ModelFieldIsOptional<Schema, Model, Key>, FieldIsArray<Schema, Model, Key>> : ModelResult<Schema, RelationFieldType<Schema, Model, Key>, Pick<Select[Key], 'include' | 'omit'>, ModelFieldIsOptional<Schema, Model, Key>, FieldIsArray<Schema, Model, Key>> : DefaultModelResult<Schema, RelationFieldType<Schema, Model, Key>, Omit, 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;
@@ -60,15 +82,21 @@ type ModelResult<Schema extends SchemaDef, Model extends GetModels<Schema>, Args
     include: infer I;
     omit?: infer O;
 } ? DefaultModelResult<Schema, Model, 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>, I[Key], FieldIsOptional<Schema, Model, Key>, FieldIsArray<Schema, Model, Key>> : DefaultModelResult<Schema, RelationFieldType<Schema, Model, Key>, undefined, FieldIsOptional<Schema, Model, Key>, FieldIsArray<Schema, Model, Key>>;
+    [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], ModelFieldIsOptional<Schema, Model, Key>, FieldIsArray<Schema, Model, Key>> : DefaultModelResult<Schema, RelationFieldType<Schema, Model, Key>, undefined, ModelFieldIsOptional<Schema, Model, Key>, FieldIsArray<Schema, Model, Key>>;
 } : Args extends {
     omit: infer O;
 } ? DefaultModelResult<Schema, Model, O> : DefaultModelResult<Schema, Model>, Optional, Array>;
+type SimplifiedModelResult<Schema extends SchemaDef, Model extends GetModels<Schema>, Args extends SelectIncludeOmit<Schema, Model, boolean> = {}, Optional = false, Array = false> = Simplify<ModelResult<Schema, Model, Args, Optional, Array>>;
+type TypeDefResult<Schema extends SchemaDef, TypeDef extends GetTypeDefs<Schema>> = Optional<{
+    [Key in GetTypeDefFields<Schema, TypeDef>]: MapTypeDefFieldType<Schema, TypeDef, Key>;
+}, keyof {
+    [Key in GetTypeDefFields<Schema, TypeDef> as TypeDefFieldIsOptional<Schema, TypeDef, Key> extends true ? Key : never]: true;
+}>;
 type BatchResult = {
     count: number;
 };
-type WhereInput<Schema extends SchemaDef, Model extends GetModels<Schema>, ScalarOnly extends boolean = false> = {
-    [Key in GetFields<Schema, Model> as ScalarOnly extends true ? Key extends RelationFields<Schema, Model> ? never : Key : Key]?: Key extends RelationFields<Schema, Model> ? RelationFilter<Schema, Model, Key> : GetFieldType<Schema, Model, Key> extends GetEnums<Schema> ? EnumFilter<Schema, GetFieldType<Schema, Model, Key>, FieldIsOptional<Schema, Model, Key>> : FieldIsArray<Schema, Model, Key> extends true ? ArrayFilter<GetFieldType<Schema, Model, Key>> : PrimitiveFilter<GetFieldType<Schema, Model, Key>, FieldIsOptional<Schema, Model, Key>>;
+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<Schema, GetModelFieldType<Schema, Model, Key>, ModelFieldIsOptional<Schema, Model, Key>, WithAggregations>;
 } & {
     $expr?: (eb: ExpressionBuilder<ToKyselySchema<Schema>, Model>) => OperandExpression<SqlBool>;
 } & {
@@ -76,21 +104,26 @@ type WhereInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Scala
     OR?: WhereInput<Schema, Model, ScalarOnly>[];
     NOT?: OrArray<WhereInput<Schema, Model, ScalarOnly>>;
 };
-type EnumFilter<Schema extends SchemaDef, T extends GetEnums<Schema>, Nullable extends boolean> = NullableIf<keyof GetEnum<Schema, T>, Nullable> | {
+type EnumFilter<Schema extends SchemaDef, T extends GetEnums<Schema>, Nullable extends boolean, WithAggregations extends boolean> = NullableIf<keyof GetEnum<Schema, T>, Nullable> | ({
     equals?: NullableIf<keyof GetEnum<Schema, T>, Nullable>;
     in?: (keyof GetEnum<Schema, T>)[];
     notIn?: (keyof GetEnum<Schema, T>)[];
-    not?: EnumFilter<Schema, T, Nullable>;
-};
-type ArrayFilter<T extends string> = {
-    equals?: MapBaseType$1<T>[];
-    has?: MapBaseType$1<T>;
-    hasEvery?: MapBaseType$1<T>[];
-    hasSome?: MapBaseType$1<T>[];
+    not?: EnumFilter<Schema, T, Nullable, WithAggregations>;
+} & (WithAggregations extends true ? {
+    _count?: NumberFilter<Schema, 'Int', false, false>;
+    _min?: EnumFilter<Schema, T, false, false>;
+    _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>[];
     isEmpty?: boolean;
 };
-type PrimitiveFilter<T extends string, Nullable extends boolean> = T extends 'String' ? StringFilter<Nullable> : T extends 'Int' | 'Float' | 'Decimal' | 'BigInt' ? NumberFilter<T, Nullable> : T extends 'Boolean' ? BooleanFilter<Nullable> : T extends 'DateTime' ? DateTimeFilter<Nullable> : T extends 'Json' ? 'Not implemented yet' : never;
-type CommonPrimitiveFilter<DataType, T extends BuiltinType, Nullable extends boolean> = {
+type MapScalarType<Schema extends SchemaDef, T extends string> = T extends GetEnums<Schema> ? keyof GetEnum<Schema, T> : MapBaseType$1<T>;
+type PrimitiveFilter<Schema extends SchemaDef, T extends string, Nullable extends boolean, WithAggregations extends boolean> = T extends 'String' ? StringFilter<Schema, Nullable, WithAggregations> : T extends 'Int' | 'Float' | 'Decimal' | 'BigInt' ? NumberFilter<Schema, T, Nullable, WithAggregations> : T extends 'Boolean' ? BooleanFilter<Schema, Nullable, WithAggregations> : T extends 'DateTime' ? DateTimeFilter<Schema, Nullable, WithAggregations> : T extends 'Bytes' ? BytesFilter<Schema, Nullable, WithAggregations> : T extends 'Json' ? 'Not implemented yet' : never;
+type CommonPrimitiveFilter<Schema extends SchemaDef, DataType, T extends BuiltinType, Nullable extends boolean, WithAggregations extends boolean> = {
     equals?: NullableIf<DataType, Nullable>;
     in?: DataType[];
     notIn?: DataType[];
@@ -98,30 +131,53 @@ type CommonPrimitiveFilter<DataType, T extends BuiltinType, Nullable extends boo
     lte?: DataType;
     gt?: DataType;
     gte?: DataType;
-    not?: PrimitiveFilter<T, Nullable>;
+    not?: PrimitiveFilter<Schema, T, Nullable, WithAggregations>;
 };
-type StringFilter<Nullable extends boolean> = NullableIf<string, Nullable> | (CommonPrimitiveFilter<string, 'String', Nullable> & {
+type StringFilter<Schema extends SchemaDef, Nullable extends boolean, WithAggregations extends boolean> = NullableIf<string, Nullable> | (CommonPrimitiveFilter<Schema, string, 'String', Nullable, WithAggregations> & {
     contains?: string;
     startsWith?: string;
     endsWith?: string;
+} & (WithAggregations extends true ? {
+    _count?: NumberFilter<Schema, 'Int', false, false>;
+    _min?: StringFilter<Schema, false, false>;
+    _max?: StringFilter<Schema, false, false>;
+} : {}) & (ProviderSupportsCaseSensitivity<Schema> extends true ? {
     mode?: 'default' | 'insensitive';
-});
-type NumberFilter<T extends 'Int' | 'Float' | 'Decimal' | 'BigInt', Nullable extends boolean> = NullableIf<number | bigint, Nullable> | CommonPrimitiveFilter<number, T, Nullable>;
-type DateTimeFilter<Nullable extends boolean> = NullableIf<Date | string, Nullable> | CommonPrimitiveFilter<Date | string, 'DateTime', Nullable>;
-type BytesFilter<Nullable extends boolean> = NullableIf<Uint8Array | Buffer, Nullable> | {
+} : {}));
+type NumberFilter<Schema extends SchemaDef, T extends 'Int' | 'Float' | 'Decimal' | 'BigInt', Nullable extends boolean, WithAggregations extends boolean> = NullableIf<number | bigint, Nullable> | (CommonPrimitiveFilter<Schema, number, T, Nullable, WithAggregations> & (WithAggregations extends true ? {
+    _count?: NumberFilter<Schema, 'Int', false, false>;
+    _avg?: NumberFilter<Schema, T, false, false>;
+    _sum?: NumberFilter<Schema, T, false, false>;
+    _min?: NumberFilter<Schema, T, false, false>;
+    _max?: NumberFilter<Schema, T, false, false>;
+} : {}));
+type DateTimeFilter<Schema extends SchemaDef, Nullable extends boolean, WithAggregations extends boolean> = NullableIf<Date | string, Nullable> | (CommonPrimitiveFilter<Schema, Date | string, 'DateTime', Nullable, WithAggregations> & (WithAggregations extends true ? {
+    _count?: NumberFilter<Schema, 'Int', false, false>;
+    _min?: DateTimeFilter<Schema, false, false>;
+    _max?: DateTimeFilter<Schema, false, false>;
+} : {}));
+type BytesFilter<Schema extends SchemaDef, Nullable extends boolean, WithAggregations extends boolean> = NullableIf<Uint8Array | Buffer, Nullable> | ({
     equals?: NullableIf<Uint8Array, Nullable>;
     in?: Uint8Array[];
     notIn?: Uint8Array[];
-    not?: BytesFilter<Nullable>;
-};
-type BooleanFilter<Nullable extends boolean> = NullableIf<boolean, Nullable> | {
+    not?: BytesFilter<Schema, Nullable, WithAggregations>;
+} & (WithAggregations extends true ? {
+    _count?: NumberFilter<Schema, 'Int', false, false>;
+    _min?: BytesFilter<Schema, false, false>;
+    _max?: BytesFilter<Schema, false, false>;
+} : {}));
+type BooleanFilter<Schema extends SchemaDef, Nullable extends boolean, WithAggregations extends boolean> = NullableIf<boolean, Nullable> | ({
     equals?: NullableIf<boolean, Nullable>;
-    not?: BooleanFilter<Nullable>;
-};
+    not?: BooleanFilter<Schema, Nullable, WithAggregations>;
+} & (WithAggregations extends true ? {
+    _count?: NumberFilter<Schema, 'Int', false, false>;
+    _min?: BooleanFilter<Schema, false, false>;
+    _max?: BooleanFilter<Schema, false, 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>]?: FieldIsOptional<Schema, Model, Key> extends true ? SortOrder | {
+    [Key in NonRelationFields<Schema, Model>]?: ModelFieldIsOptional<Schema, Model, Key> extends true ? SortOrder | {
         sort: SortOrder;
         nulls?: NullsOrder;
     } : SortOrder;
@@ -130,47 +186,41 @@ type OrderBy<Schema extends SchemaDef, Model extends GetModels<Schema>, WithRela
         _count?: SortOrder;
     } : OrderBy<Schema, RelationFieldType<Schema, Model, Key>, WithRelation, WithAggregation>;
 } : {}) & (WithAggregation extends true ? {
-    _count?: OrderBy<Schema, Model, WithRelation, false>;
+    _count?: OrderBy<Schema, Model, false, false>;
+    _min?: MinMaxInput<Schema, Model, SortOrder>;
+    _max?: MinMaxInput<Schema, Model, SortOrder>;
 } & (NumericFields<Schema, Model> extends never ? {} : {
-    _avg?: SumAvgInput<Schema, Model>;
-    _sum?: SumAvgInput<Schema, Model>;
-    _min?: MinMaxInput<Schema, Model>;
-    _max?: MinMaxInput<Schema, Model>;
+    _avg?: SumAvgInput<Schema, Model, SortOrder>;
+    _sum?: SumAvgInput<Schema, Model, SortOrder>;
 }) : {});
 type WhereUniqueInput<Schema extends SchemaDef, Model extends GetModels<Schema>> = AtLeast<{
     [Key in keyof GetModel<Schema, Model>['uniqueFields']]?: GetModel<Schema, Model>['uniqueFields'][Key] extends Pick<FieldDef, 'type'> ? MapFieldDefType<Schema, GetModel<Schema, Model>['uniqueFields'][Key]> : {
         [Key1 in keyof GetModel<Schema, Model>['uniqueFields'][Key]]: GetModel<Schema, Model>['uniqueFields'][Key][Key1] extends Pick<FieldDef, 'type'> ? MapFieldDefType<Schema, GetModel<Schema, Model>['uniqueFields'][Key][Key1]> : never;
     };
 } & WhereInput<Schema, Model>, Extract<keyof GetModel<Schema, Model>['uniqueFields'], string>>;
-type OmitFields<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
-    [Key in NonRelationFields<Schema, Model>]?: true;
+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> = {
-    select?: Select<Schema, Model, AllowCount, boolean>;
-    include?: Include<Schema, Model>;
-    omit?: OmitFields<Schema, Model>;
-};
-type Distinct<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
-    distinct?: OrArray<NonRelationFields<Schema, Model>>;
-};
-type Cursor<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
-    cursor?: WhereUniqueInput<Schema, Model>;
+    select?: SelectInput<Schema, Model, AllowCount, boolean>;
+    include?: IncludeInput<Schema, Model>;
+    omit?: OmitInput<Schema, Model>;
 };
-type Select<Schema extends SchemaDef, Model extends GetModels<Schema>, AllowCount extends boolean, AllowRelation extends boolean = true> = {
-    [Key in NonRelationFields<Schema, Model>]?: true;
-} & (AllowRelation extends true ? Include<Schema, Model> : {}) & // relation fields
-(AllowCount extends true ? {
+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> : {}) & // relation fields
+(AllowCount extends true ? HasToManyRelations<Schema, Model> extends true ? {
     _count?: SelectCount<Schema, Model>;
-} : {});
-type SelectCount<Schema extends SchemaDef, Model extends GetModels<Schema>> = true | {
+} : {} : {});
+type SelectCount<Schema extends SchemaDef, Model extends GetModels<Schema>> = boolean | {
     select: {
-        [Key in RelationFields<Schema, Model> as FieldIsArray<Schema, Model, Key> extends true ? Key : never]: true | {
+        [Key in RelationFields<Schema, Model> as FieldIsArray<Schema, Model, Key> extends true ? Key : never]?: boolean | {
             where: WhereInput<Schema, RelationFieldType<Schema, Model, Key>, false>;
         };
     };
 };
-type Include<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
-    [Key in RelationFields<Schema, Model>]?: boolean | FindArgs<Schema, RelationFieldType<Schema, Model, Key>, FieldIsArray<Schema, Model, Key>, FieldIsArray<Schema, Model, Key> extends true ? true : FieldIsOptional<Schema, Model, Key> extends true ? true : false>;
+type IncludeInput<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
+    [Key in RelationFields<Schema, Model>]?: boolean | FindArgs<Schema, RelationFieldType<Schema, Model, Key>, FieldIsArray<Schema, Model, Key>, FieldIsArray<Schema, Model, Key> extends true ? true : ModelFieldIsOptional<Schema, Model, Key> extends true ? true : false>;
 };
 type Subset<T, U> = {
     [key in keyof T]: key extends keyof U ? T[key] : never;
@@ -190,83 +240,94 @@ 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>> & {
-    is?: NullableIf<WhereInput<Schema, RelationFieldType<Schema, Model, Field>>, FieldIsOptional<Schema, Model, Field>>;
-    isNot?: NullableIf<WhereInput<Schema, RelationFieldType<Schema, Model, Field>>, FieldIsOptional<Schema, Model, Field>>;
-}, FieldIsOptional<Schema, Model, Field>>;
+    is?: NullableIf<WhereInput<Schema, RelationFieldType<Schema, Model, Field>>, ModelFieldIsOptional<Schema, Model, Field>>;
+    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>;
-type MapFieldType<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends GetFields<Schema, Model>> = MapFieldDefType<Schema, GetField<Schema, Model, Field>>;
-type MapFieldDefType<Schema extends SchemaDef, T extends Pick<FieldDef, 'type' | 'optional' | 'array'>> = WrapType<T['type'] extends GetEnums<Schema> ? keyof GetEnum<Schema, T['type']> : MapBaseType$1<T['type']>, T['optional'], T['array']>;
+type MapModelFieldType<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends GetModelFields<Schema, Model>> = MapFieldDefType<Schema, GetModelField<Schema, Model, Field>>;
+type MapTypeDefFieldType<Schema extends SchemaDef, TypeDef extends GetTypeDefs<Schema>, Field extends GetTypeDefFields<Schema, TypeDef>> = MapFieldDefType<Schema, GetTypeDefField<Schema, TypeDef, Field>>;
+type MapFieldDefType<Schema extends SchemaDef, T extends Pick<FieldDef, 'type' | 'optional' | 'array'>> = WrapType<T['type'] extends GetEnums<Schema> ? keyof GetEnum<Schema, T['type']> : T['type'] extends GetTypeDefs<Schema> ? TypeDefResult<Schema, T['type']> & Record<string, unknown> : MapBaseType$1<T['type']>, T['optional'], T['array']>;
 type OptionalFieldsForCreate<Schema extends SchemaDef, Model extends GetModels<Schema>> = keyof {
-    [Key in GetFields<Schema, Model> as FieldIsOptional<Schema, Model, Key> extends true ? Key : FieldHasDefault<Schema, Model, Key> extends true ? Key : GetField<Schema, Model, Key>['updatedAt'] extends true ? Key : FieldIsRelationArray<Schema, Model, Key> extends true ? Key : never]: GetField<Schema, Model, Key>;
+    [Key in GetModelFields<Schema, Model> as ModelFieldIsOptional<Schema, Model, Key> extends true ? Key : FieldHasDefault<Schema, Model, Key> extends true ? Key : FieldIsArray<Schema, Model, Key> extends true ? Key : GetModelField<Schema, Model, Key>['updatedAt'] extends true ? Key : never]: GetModelField<Schema, Model, Key>;
 };
-type GetRelation<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends GetFields<Schema, Model>> = GetField<Schema, Model, Field>['relation'];
-type OppositeRelation<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends GetFields<Schema, Model>, FT = FieldType<Schema, Model, Field>> = FT extends GetModels<Schema> ? GetRelation<Schema, Model, Field> extends RelationInfo ? GetRelation<Schema, Model, Field>['opposite'] extends GetFields<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 GetFields<Schema, Model>, Opposite = OppositeRelation<Schema, Model, Field>> = Opposite extends RelationInfo ? (Opposite['fields'] extends string[] ? Opposite['fields'] : []) : [];
-type OppositeRelationAndFK<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends GetFields<Schema, Model>, FT = FieldType<Schema, Model, Field>, Relation = GetField<Schema, Model, Field>['relation'], Opposite = Relation extends RelationInfo ? Relation['opposite'] : never> = FT extends GetModels<Schema> ? Opposite extends GetFields<Schema, FT> ? Opposite | OppositeRelationFields<Schema, Model, Field>[number] : never : never;
-type FindArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, Collection extends boolean, AllowFilter extends boolean = true> = (Collection extends true ? {
+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 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>> = {
+    where?: WhereInput<Schema, Model>;
+};
+type SortAndTakeArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
     skip?: number;
     take?: number;
     orderBy?: OrArray<OrderBy<Schema, Model, true, false>>;
-} : {}) & (AllowFilter extends true ? {
-    where?: WhereInput<Schema, Model>;
-} : {}) & SelectIncludeOmit<Schema, Model, Collection> & Distinct<Schema, Model> & Cursor<Schema, Model>;
+    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> & {
+    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>;
+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, false>;
 type FindUniqueArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
     where?: WhereUniqueInput<Schema, Model>;
 } & SelectIncludeOmit<Schema, Model, true>;
 type CreateArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
     data: CreateInput<Schema, Model>;
-    select?: Select<Schema, Model, true>;
-    include?: Include<Schema, Model>;
-    omit?: OmitFields<Schema, Model>;
+    select?: SelectInput<Schema, Model, true>;
+    include?: IncludeInput<Schema, Model>;
+    omit?: OmitInput<Schema, Model>;
 };
-type CreateManyArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = CreateManyPayload<Schema, Model>;
-type CreateManyAndReturnArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = CreateManyPayload<Schema, Model> & {
-    select?: Select<Schema, Model, false, false>;
-    omit?: OmitFields<Schema, Model>;
+type CreateManyArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = CreateManyInput<Schema, Model>;
+type CreateManyAndReturnArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = CreateManyInput<Schema, Model> & {
+    select?: SelectInput<Schema, Model, false, false>;
+    omit?: OmitInput<Schema, Model>;
 };
 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>]: ScalarCreatePayload<Schema, Model, Key>;
+    [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>> = MapFieldType<Schema, Model, Field> | (FieldIsArray<Schema, Model, Field> extends true ? {
-    set?: MapFieldType<Schema, Model, Field>[];
+type ScalarCreatePayload<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends ScalarFields<Schema, Model, false>> = MapModelFieldType<Schema, Model, Field> | (FieldIsArray<Schema, Model, Field> extends true ? {
+    set?: MapModelFieldType<Schema, Model, Field>;
 } : never);
 type CreateFKPayload<Schema extends SchemaDef, Model extends GetModels<Schema>> = OptionalWrap<Schema, Model, {
-    [Key in ForeignKeyFields<Schema, Model>]: MapFieldType<Schema, Model, Key>;
+    [Key in ForeignKeyFields<Schema, Model>]: MapModelFieldType<Schema, Model, Key>;
 }>;
 type CreateRelationFieldPayload<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>> = Omit<{
+    connectOrCreate?: ConnectOrCreateInput<Schema, Model, Field>;
     create?: NestedCreateInput<Schema, Model, Field>;
     createMany?: NestedCreateManyInput<Schema, Model, Field>;
     connect?: ConnectInput<Schema, Model, Field>;
-    connectOrCreate?: ConnectOrCreateInput<Schema, Model, Field>;
-}, FieldIsArray<Schema, Model, Field> extends true ? never : 'createMany'>;
+}, (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, {
     [Key in RelationFields<Schema, Model>]: CreateRelationFieldPayload<Schema, Model, Key>;
 }>;
-type CreateWithFKInput<Schema extends SchemaDef, Model extends GetModels<Schema>> = CreateScalarPayload<Schema, Model> & CreateFKPayload<Schema, Model>;
+type CreateWithFKInput<Schema extends SchemaDef, Model extends GetModels<Schema>> = CreateScalarPayload<Schema, Model> & CreateFKPayload<Schema, Model> & CreateWithNonOwnedRelationPayload<Schema, Model>;
 type CreateWithRelationInput<Schema extends SchemaDef, Model extends GetModels<Schema>> = CreateScalarPayload<Schema, Model> & CreateRelationPayload<Schema, Model>;
+type CreateWithNonOwnedRelationPayload<Schema extends SchemaDef, Model extends GetModels<Schema>> = OptionalWrap<Schema, Model, {
+    [Key in NonOwnedRelationFields<Schema, Model>]: CreateRelationFieldPayload<Schema, Model, Key>;
+}>;
 type ConnectOrCreatePayload<Schema extends SchemaDef, Model extends GetModels<Schema>, Without extends string = never> = {
     where: WhereUniqueInput<Schema, Model>;
     create: CreateInput<Schema, Model, Without>;
 };
-type CreateManyPayload<Schema extends SchemaDef, Model extends GetModels<Schema>, Without extends string = never> = {
+type CreateManyInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Without extends string = never> = {
     data: OrArray<Omit<CreateScalarPayload<Schema, Model>, Without> & Omit<CreateFKPayload<Schema, Model>, Without>>;
     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>> = CreateManyPayload<Schema, RelationFieldType<Schema, Model, Field>, OppositeRelationAndFK<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>> = {
     data: UpdateInput<Schema, Model>;
     where: WhereUniqueInput<Schema, Model>;
-    select?: Select<Schema, Model, true>;
-    include?: Include<Schema, Model>;
-    omit?: OmitFields<Schema, Model>;
+    select?: SelectInput<Schema, Model, true>;
+    include?: IncludeInput<Schema, Model>;
+    omit?: OmitInput<Schema, Model>;
 };
 type UpdateManyArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = UpdateManyPayload<Schema, Model>;
 type UpdateManyAndReturnArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = UpdateManyPayload<Schema, Model> & {
-    select?: Select<Schema, Model, false, false>;
-    omit?: OmitFields<Schema, Model>;
+    select?: SelectInput<Schema, Model, false, false>;
+    omit?: OmitInput<Schema, Model>;
 };
 type UpdateManyPayload<Schema extends SchemaDef, Model extends GetModels<Schema>, Without extends string = never> = {
     data: OrArray<UpdateScalarInput<Schema, Model, Without>>;
@@ -277,29 +338,29 @@ type UpsertArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
     create: CreateInput<Schema, Model>;
     update: UpdateInput<Schema, Model>;
     where: WhereUniqueInput<Schema, Model>;
-    select?: Select<Schema, Model, true>;
-    include?: Include<Schema, Model>;
-    omit?: OmitFields<Schema, Model>;
+    select?: SelectInput<Schema, Model, true>;
+    include?: IncludeInput<Schema, Model>;
+    omit?: OmitInput<Schema, Model>;
 };
 type UpdateScalarInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Without extends string = never> = Omit<{
-    [Key in NonRelationFields<Schema, Model>]?: ScalarUpdatePayload<Schema, Model, Key>;
+    [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>> = MapFieldType<Schema, Model, Field> | (Field extends NumericFields<Schema, Model> ? {
-    set?: NullableIf<number, FieldIsOptional<Schema, Model, Field>>;
+type ScalarUpdatePayload<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends NonRelationFields<Schema, Model>> = MapModelFieldType<Schema, Model, Field> | (Field extends NumericFields<Schema, Model> ? {
+    set?: NullableIf<number, ModelFieldIsOptional<Schema, Model, Field>>;
     increment?: number;
     decrement?: number;
     multiply?: number;
     divide?: number;
 } : never) | (FieldIsArray<Schema, Model, Field> extends true ? {
-    set?: MapFieldType<Schema, Model, Field>[];
-    push?: OrArray<MapFieldType<Schema, Model, Field>, true>;
+    set?: MapModelFieldType<Schema, Model, Field>[];
+    push?: OrArray<MapModelFieldType<Schema, Model, Field>, true>;
 } : never);
 type UpdateRelationInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Without extends string = never> = Omit<{
     [Key in RelationFields<Schema, Model>]?: UpdateRelationFieldPayload<Schema, Model, Key>;
 }, Without>;
 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>> = {
+type ToManyRelationUpdateInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>> = Omit<{
     create?: NestedCreateInput<Schema, Model, Field>;
     createMany?: NestedCreateManyInput<Schema, Model, Field>;
     connect?: ConnectInput<Schema, Model, Field>;
@@ -311,22 +372,22 @@ type ToManyRelationUpdateInput<Schema extends SchemaDef, Model extends GetModels
     delete?: NestedDeleteInput<Schema, Model, Field>;
     deleteMany?: NestedDeleteManyInput<Schema, Model, Field>;
     set?: SetRelationInput<Schema, Model, Field>;
-};
-type ToOneRelationUpdateInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>> = {
+}, 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<{
     create?: NestedCreateInput<Schema, Model, Field>;
     connect?: ConnectInput<Schema, Model, Field>;
     connectOrCreate?: ConnectOrCreateInput<Schema, Model, Field>;
     update?: NestedUpdateInput<Schema, Model, Field>;
     upsert?: NestedUpsertInput<Schema, Model, Field>;
-} & (FieldIsOptional<Schema, Model, Field> extends true ? {
+} & (ModelFieldIsOptional<Schema, Model, Field> extends true ? {
     disconnect?: DisconnectInput<Schema, Model, Field>;
     delete?: NestedDeleteInput<Schema, Model, Field>;
-} : {});
+} : {}), FieldIsDelegateRelation<Schema, Model, Field> extends true ? 'create' | 'connectOrCreate' | 'upsert' : never>;
 type DeleteArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
     where: WhereUniqueInput<Schema, Model>;
-    select?: Select<Schema, Model, true>;
-    include?: Include<Schema, Model>;
-    omit?: OmitFields<Schema, Model>;
+    select?: SelectInput<Schema, Model, true>;
+    include?: IncludeInput<Schema, Model>;
+    omit?: OmitInput<Schema, Model>;
 };
 type DeleteManyArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
     where?: WhereInput<Schema, Model>;
@@ -352,20 +413,20 @@ type AggregateArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> =
     orderBy?: OrArray<OrderBy<Schema, Model, true, false>>;
 } & {
     _count?: true | CountAggregateInput<Schema, Model>;
+    _min?: MinMaxInput<Schema, Model, true>;
+    _max?: MinMaxInput<Schema, Model, true>;
 } & (NumericFields<Schema, Model> extends never ? {} : {
-    _avg?: SumAvgInput<Schema, Model>;
-    _sum?: SumAvgInput<Schema, Model>;
-    _min?: MinMaxInput<Schema, Model>;
-    _max?: MinMaxInput<Schema, Model>;
+    _avg?: SumAvgInput<Schema, Model, true>;
+    _sum?: SumAvgInput<Schema, Model, true>;
 });
 type NumericFields<Schema extends SchemaDef, Model extends GetModels<Schema>> = keyof {
-    [Key in GetFields<Schema, Model> as GetFieldType<Schema, Model, Key> extends 'Int' | 'Float' | 'BigInt' | 'Decimal' ? FieldIsArray<Schema, Model, Key> extends true ? never : Key : never]: GetField<Schema, Model, Key>;
+    [Key in GetModelFields<Schema, Model> as GetModelFieldType<Schema, Model, Key> extends 'Int' | 'Float' | 'BigInt' | 'Decimal' ? FieldIsArray<Schema, Model, Key> extends true ? never : Key : never]: GetModelField<Schema, Model, Key>;
 };
-type SumAvgInput<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
-    [Key in NumericFields<Schema, Model>]?: true;
+type SumAvgInput<Schema extends SchemaDef, Model extends GetModels<Schema>, ValueType> = {
+    [Key in NumericFields<Schema, Model>]?: ValueType;
 };
-type MinMaxInput<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
-    [Key in GetFields<Schema, Model> as FieldIsArray<Schema, Model, Key> extends true ? never : FieldIsRelation<Schema, Model, Key> extends true ? never : Key]?: true;
+type MinMaxInput<Schema extends SchemaDef, Model extends GetModels<Schema>, ValueType> = {
+    [Key in GetModelFields<Schema, Model> as FieldIsArray<Schema, Model, Key> extends true ? never : FieldIsRelation<Schema, Model, Key> extends true ? never : Key]?: ValueType;
 };
 type AggregateResult<Schema extends SchemaDef, Model extends GetModels<Schema>, Args extends AggregateArgs<Schema, Model>> = (Args extends {
     _count: infer Count;
@@ -391,22 +452,23 @@ type AggregateResult<Schema extends SchemaDef, Model extends GetModels<Schema>,
 type AggCommonOutput<Input> = Input extends true ? number : Input extends {} ? {
     [Key in keyof Input]: number;
 } : 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>> = {
     where?: WhereInput<Schema, Model>;
     orderBy?: OrArray<OrderBy<Schema, Model, false, true>>;
     by: NonRelationFields<Schema, Model> | NonEmptyArray<NonRelationFields<Schema, Model>>;
-    having?: WhereInput<Schema, Model, true>;
+    having?: GroupByHaving<Schema, Model>;
     take?: number;
     skip?: number;
     _count?: true | CountAggregateInput<Schema, Model>;
+    _min?: MinMaxInput<Schema, Model, true>;
+    _max?: MinMaxInput<Schema, Model, true>;
 } & (NumericFields<Schema, Model> extends never ? {} : {
-    _avg?: SumAvgInput<Schema, Model>;
-    _sum?: SumAvgInput<Schema, Model>;
-    _min?: MinMaxInput<Schema, Model>;
-    _max?: MinMaxInput<Schema, Model>;
+    _avg?: SumAvgInput<Schema, Model, true>;
+    _sum?: SumAvgInput<Schema, Model, true>;
 });
 type GroupByResult<Schema extends SchemaDef, Model extends GetModels<Schema>, Args extends GroupByArgs<Schema, Model>> = Array<{
-    [Key in NonRelationFields<Schema, Model> as Key extends ValueOfPotentialTuple<Args['by']> ? Key : never]: MapFieldType<Schema, Model, Key>;
+    [Key in NonRelationFields<Schema, Model> as Key extends ValueOfPotentialTuple<Args['by']> ? Key : never]: MapModelFieldType<Schema, Model, Key>;
 } & (Args extends {
     _count: infer Count;
 } ? {
@@ -440,31 +502,51 @@ type NestedUpdateInput<Schema extends SchemaDef, Model extends GetModels<Schema>
     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<{
-    where: WhereUniqueInput<Schema, Model>;
+    where: WhereUniqueInput<Schema, RelationFieldType<Schema, Model, Field>>;
     create: CreateInput<Schema, RelationFieldType<Schema, Model, Field>, OppositeRelationAndFK<Schema, Model, Field>>;
     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>>>;
 type NestedDeleteInput<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 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[];
+    } ? 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 ProviderSupportsCaseSensitivity<Schema extends SchemaDef> = Schema['provider']['type'] extends 'postgresql' ? true : false;
+type ProviderSupportsDistinct<Schema extends SchemaDef> = Schema['provider']['type'] extends 'postgresql' ? true : false;
 
 type AuthType<Schema extends SchemaDef> = string extends GetModels<Schema> ? Record<string, unknown> : Schema['authType'] extends GetModels<Schema> ? Partial<ModelResult<Schema, Schema['authType']>> : never;
 
+/**
+ * Client API methods that are not supported in transactions.
+ */
+declare const TRANSACTION_UNSUPPORTED_METHODS: readonly ["$transaction", "$disconnect", "$use"];
+/**
+ * Logical combinators used in filters.
+ */
+declare const LOGICAL_COMBINATORS: readonly ["AND", "OR", "NOT"];
+
 declare abstract class BaseCrudDialect<Schema extends SchemaDef> {
     protected readonly schema: Schema;
     protected readonly options: ClientOptions<Schema>;
     constructor(schema: Schema, options: ClientOptions<Schema>);
-    abstract get provider(): DataSourceProviderType;
-    transformPrimitive(value: unknown, _type: BuiltinType): unknown;
-    abstract buildRelationSelection(query: SelectQueryBuilder<any, any, any>, model: string, relationField: string, parentAlias: string, payload: true | FindArgs<Schema, GetModels<Schema>, true>): SelectQueryBuilder<any, any, any>;
-    abstract buildSkipTake(query: SelectQueryBuilder<any, any, any>, skip: number | undefined, take: number | undefined): SelectQueryBuilder<any, any, any>;
+    transformPrimitive(value: unknown, _type: BuiltinType, _forArrayField: boolean): unknown;
+    buildSelectModel(eb: ExpressionBuilder<any, any>, model: string, modelAlias: string): SelectQueryBuilder<any, any, {}>;
+    buildFilterSortTake(model: GetModels<Schema>, args: FindArgs<Schema, GetModels<Schema>, true>, query: SelectQueryBuilder<any, any, {}>, modelAlias: string): SelectQueryBuilder<any, any, {}>;
     buildFilter(eb: ExpressionBuilder<any, any>, model: string, modelAlias: string, where: boolean | object | undefined): Expression<SqlBool>;
-    protected buildCompositeFilter(eb: ExpressionBuilder<any, any>, model: string, modelAlias: string, key: 'AND' | 'OR' | 'NOT', payload: any): Expression<SqlBool>;
+    private buildCursorFilter;
+    private isLogicalCombinator;
+    protected buildCompositeFilter(eb: ExpressionBuilder<any, any>, model: string, modelAlias: string, key: (typeof LOGICAL_COMBINATORS)[number], payload: any): Expression<SqlBool>;
     private buildRelationFilter;
     private buildToOneRelationFilter;
     private buildToManyRelationFilter;
     private buildArrayFilter;
-    buildPrimitiveFilter(eb: ExpressionBuilder<any, any>, model: string, modelAlias: string, field: string, fieldDef: FieldDef, payload: any): Expression<SqlBool>;
+    buildPrimitiveFilter(eb: ExpressionBuilder<any, any>, fieldRef: Expression<any>, fieldDef: FieldDef, payload: any): Expression<SqlBool>;
     private buildLiteralFilter;
     private buildStandardFilter;
     private buildStringFilter;
@@ -475,6 +557,11 @@ declare abstract class BaseCrudDialect<Schema extends SchemaDef> {
     private buildBytesFilter;
     private buildEnumFilter;
     buildOrderBy(query: SelectQueryBuilder<any, any, any>, model: string, modelAlias: string, orderBy: OrArray<OrderBy<Schema, GetModels<Schema>, boolean, boolean>> | undefined, useDefaultIfEmpty: boolean, negated: boolean): SelectQueryBuilder<any, any, any>;
+    buildSelectAllFields(model: string, query: SelectQueryBuilder<any, any, any>, omit: Record<string, boolean | undefined> | undefined, modelAlias: string): SelectQueryBuilder<any, any, any>;
+    protected buildModelSelect(eb: ExpressionBuilder<any, any>, model: GetModels<Schema>, subQueryAlias: string, payload: true | FindArgs<Schema, GetModels<Schema>, true>, selectAllFields: boolean): SelectQueryBuilder<any, any, {}>;
+    buildSelectField(query: SelectQueryBuilder<any, any, any>, model: string, modelAlias: string, field: string): SelectQueryBuilder<any, any, any>;
+    buildDelegateJoin(thisModel: string, thisModelAlias: string, otherModelAlias: string, query: SelectQueryBuilder<any, any, any>): SelectQueryBuilder<any, any, any>;
+    buildCountJson(model: string, eb: ExpressionBuilder<any, any>, parentAlias: string, payload: any): ExpressionWrapper<any, any, unknown>;
     private negateSort;
     true(eb: ExpressionBuilder<any, any>): Expression<SqlBool>;
     false(eb: ExpressionBuilder<any, any>): Expression<SqlBool>;
@@ -483,6 +570,17 @@ declare abstract class BaseCrudDialect<Schema extends SchemaDef> {
     protected and(eb: ExpressionBuilder<any, any>, ...args: Expression<SqlBool>[]): Expression<SqlBool>;
     protected or(eb: ExpressionBuilder<any, any>, ...args: Expression<SqlBool>[]): Expression<SqlBool>;
     protected not(eb: ExpressionBuilder<any, any>, ...args: Expression<SqlBool>[]): ExpressionWrapper<any, any, SqlBool>;
+    fieldRef(model: string, field: string, eb: ExpressionBuilder<any, any>, modelAlias?: string, inlineComputedField?: boolean): ExpressionWrapper<any, any, unknown>;
+    protected canJoinWithoutNestedSelect(modelDef: ModelDef, payload: boolean | FindArgs<Schema, GetModels<Schema>, true>): boolean;
+    abstract get provider(): DataSourceProviderType;
+    /**
+     * Builds selection for a relation field.
+     */
+    abstract buildRelationSelection(query: SelectQueryBuilder<any, any, any>, model: string, relationField: string, parentAlias: string, payload: true | FindArgs<Schema, GetModels<Schema>, true>): SelectQueryBuilder<any, any, any>;
+    /**
+     * Builds skip and take clauses.
+     */
+    abstract buildSkipTake(query: SelectQueryBuilder<any, any, any>, skip: number | undefined, take: number | undefined): SelectQueryBuilder<any, any, any>;
     /**
      * Builds an Kysely expression that returns a JSON object for the given key-value pairs.
      */
@@ -507,154 +605,157 @@ declare abstract class BaseCrudDialect<Schema extends SchemaDef> {
      * Whether the dialect supports DISTINCT ON.
      */
     abstract get supportsDistinctOn(): boolean;
+    /**
+     * Whether the dialect support inserting with `DEFAULT` as field value.
+     */
+    abstract get supportInsertWithDefault(): boolean;
 }
 
-type CrudOperation = 'findMany' | 'findUnique' | 'findFirst' | 'create' | 'createMany' | 'createManyAndReturn' | 'update' | 'updateMany' | 'updateManyAndReturn' | 'upsert' | 'delete' | 'deleteMany' | 'count' | 'aggregate' | 'groupBy';
+type CoreCrudOperation = 'findMany' | 'findUnique' | 'findFirst' | 'create' | 'createMany' | 'createManyAndReturn' | 'update' | 'updateMany' | 'updateManyAndReturn' | 'upsert' | 'delete' | 'deleteMany' | 'count' | 'aggregate' | 'groupBy';
+type AllCrudOperation = CoreCrudOperation | 'findUniqueOrThrow' | 'findFirstOrThrow';
 
 /**
- * The result of the hooks interception filter.
+ * ZenStack runtime plugin.
  */
-type MutationInterceptionFilterResult = {
-    /**
-     * Whether to intercept the mutation or not.
-     */
-    intercept: boolean;
+interface RuntimePlugin<Schema extends SchemaDef = SchemaDef> {
     /**
-     * Whether to use a transaction for the mutation.
+     * Plugin ID.
      */
-    useTransactionForMutation?: boolean;
+    id: string;
     /**
-     * Whether entities should be loaded before the mutation.
+     * Plugin display name.
      */
-    loadBeforeMutationEntity?: boolean;
+    name?: string;
     /**
-     * Whether entities should be loaded after the mutation.
+     * Plugin description.
      */
-    loadAfterMutationEntity?: boolean;
-};
-type MutationHooksArgs<Schema extends SchemaDef> = {
+    description?: string;
     /**
-     * The model that is being mutated.
+     * Intercepts an ORM query.
      */
-    model: GetModels<Schema>;
+    onQuery?: OnQueryCallback<Schema>;
     /**
-     * The mutation action that is being performed.
+     * Intercepts an entity mutation.
      */
-    action: 'create' | 'update' | 'delete';
+    onEntityMutation?: EntityMutationHooksDef<Schema>;
     /**
-     * The mutation data. Only available for create and update actions.
+     * Intercepts a Kysely query.
      */
-    queryNode: OperationNode;
-};
-type PluginBeforeEntityMutationArgs<Schema extends SchemaDef> = MutationHooksArgs<Schema> & {
-    entities?: Record<string, unknown>[];
-};
-type PluginAfterEntityMutationArgs<Schema extends SchemaDef> = MutationHooksArgs<Schema> & {
-    beforeMutationEntities?: Record<string, unknown>[];
-    afterMutationEntities?: Record<string, unknown>[];
-};
-type OnKyselyQueryTransactionCallback = (proceed: ProceedKyselyQueryFunction) => Promise<QueryResult<any>>;
-type OnKyselyQueryTransaction = (callback: OnKyselyQueryTransactionCallback) => Promise<QueryResult<any>>;
-type OnKyselyQueryArgs<Schema extends SchemaDef> = {
-    kysely: ToKysely<Schema>;
-    schema: SchemaDef;
-    client: ClientContract<Schema>;
-    query: RootOperationNode;
-    proceed: ProceedKyselyQueryFunction;
-    transaction: OnKyselyQueryTransaction;
-};
-type ProceedKyselyQueryFunction = (query: RootOperationNode) => Promise<QueryResult<any>>;
+    onKyselyQuery?: OnKyselyQueryCallback<Schema>;
+}
 /**
- * ZenStack runtime plugin.
+ * Defines a ZenStack runtime plugin.
  */
-interface RuntimePlugin<Schema extends SchemaDef = SchemaDef> {
+declare function definePlugin<Schema extends SchemaDef>(plugin: RuntimePlugin<Schema>): RuntimePlugin<Schema>;
+
+type OnQueryCallback<Schema extends SchemaDef> = (ctx: OnQueryHookContext<Schema>) => Promise<unknown>;
+type OnQueryHookContext<Schema extends SchemaDef> = {
     /**
-     * Plugin ID.
+     * The model that is being queried.
      */
-    id: string;
+    model: GetModels<Schema>;
     /**
-     * Plugin display name.
+     * The operation that is being performed.
      */
-    name?: string;
+    operation: AllCrudOperation;
     /**
-     * Plugin description.
+     * The query arguments.
      */
-    description?: string;
+    args: unknown;
     /**
-     * Intercepts an ORM query.
+     * The function to proceed with the original query.
+     * It takes the same arguments as the operation method.
+     *
+     * @param args The query arguments.
      */
-    onQuery?: OnQueryHooks<Schema>;
+    proceed: (args: unknown) => Promise<unknown>;
     /**
-     * Intercepts a Kysely query.
+     * The ZenStack client that is performing the operation.
      */
-    onKyselyQuery?: (args: OnKyselyQueryArgs<Schema>) => Promise<QueryResult<UnknownRow>>;
+    client: ClientContract<Schema>;
+};
+type EntityMutationHooksDef<Schema extends SchemaDef> = {
     /**
-     * This callback determines whether a mutation should be intercepted, and if so,
-     * what data should be loaded before and after the mutation.
+     * Called before entities are mutated.
      */
-    mutationInterceptionFilter?: (args: MutationHooksArgs<Schema>) => MaybePromise<MutationInterceptionFilterResult>;
+    beforeEntityMutation?: BeforeEntityMutationCallback<Schema>;
     /**
-     * Called before an entity is mutated.
-     * @param args.entity Only available if `loadBeforeMutationEntity` is set to true in the
-     * return value of {@link RuntimePlugin.mutationInterceptionFilter}.
+     * Called after entities are mutated.
      */
-    beforeEntityMutation?: (args: PluginBeforeEntityMutationArgs<Schema>) => MaybePromise<void>;
+    afterEntityMutation?: AfterEntityMutationCallback<Schema>;
     /**
-     * Called after an entity is mutated.
-     * @param args.beforeMutationEntity Only available if `loadBeforeMutationEntity` is set to true in the
-     * return value of {@link RuntimePlugin.mutationInterceptionFilter}.
-     * @param args.afterMutationEntity Only available if `loadAfterMutationEntity` is set to true in the
-     * return value of {@link RuntimePlugin.mutationInterceptionFilter}.
+     * Whether to run after-mutation hooks within the transaction that performs the mutation.
+     *
+     * If set to `true`, if the mutation already runs inside a transaction, the callbacks are
+     * executed immediately after the mutation within the transaction boundary. If the mutation
+     * is not running inside a transaction, a new transaction is created to run both the mutation
+     * and the callbacks.
+     *
+     * If set to `false`, the callbacks are executed after the mutation transaction is committed.
+     *
+     * Defaults to `false`.
      */
-    afterEntityMutation?: (args: PluginAfterEntityMutationArgs<Schema>) => MaybePromise<void>;
-}
-type OnQueryHooks<Schema extends SchemaDef = SchemaDef> = {
-    [Model in GetModels<Schema> as Uncapitalize<Model>]?: OnQueryOperationHooks<Schema, Model>;
-} & {
-    $allModels?: OnQueryOperationHooks<Schema, GetModels<Schema>>;
-};
-type OnQueryOperationHooks<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
-    [Operation in keyof ModelOperations<Schema, Model>]?: (ctx: OnQueryHookContext<Schema, Model, Operation>) => ReturnType<ModelOperations<Schema, Model>[Operation]>;
-} & {
-    $allOperations?: (ctx: {
-        model: Model;
-        operation: CrudOperation;
-        args: unknown;
-        query: (args: unknown) => Promise<unknown>;
-    }) => MaybePromise<unknown>;
+    runAfterMutationWithinTransaction?: boolean;
 };
-type OnQueryHookContext<Schema extends SchemaDef, Model extends GetModels<Schema>, Operation extends keyof ModelOperations<Schema, Model>> = {
+type MutationHooksArgs<Schema extends SchemaDef> = {
     /**
-     * The model that is being queried.
+     * The model that is being mutated.
      */
-    model: Model;
+    model: GetModels<Schema>;
     /**
-     * The operation that is being performed.
+     * The mutation action that is being performed.
      */
-    operation: Operation;
+    action: 'create' | 'update' | 'delete';
     /**
-     * The query arguments.
+     * The mutation data. Only available for create and update actions.
      */
-    args: Parameters<ModelOperations<Schema, Model>[Operation]>[0];
+    queryNode: OperationNode;
     /**
-     * The query function to proceed with the original query.
-     * It takes the same arguments as the operation method.
+     * A query ID that uniquely identifies the mutation operation. You can use it to correlate
+     * data between the before and after mutation hooks.
+     */
+    queryId: string;
+};
+type BeforeEntityMutationCallback<Schema extends SchemaDef> = (args: PluginBeforeEntityMutationArgs<Schema>) => MaybePromise<void>;
+type AfterEntityMutationCallback<Schema extends SchemaDef> = (args: PluginAfterEntityMutationArgs<Schema>) => MaybePromise<void>;
+type PluginBeforeEntityMutationArgs<Schema extends SchemaDef> = MutationHooksArgs<Schema> & {
+    /**
+     * Loads the entities that are about to be mutated. The db operation that loads the entities is executed
+     * within the same transaction context as the mutation.
+     */
+    loadBeforeMutationEntities(): Promise<Record<string, unknown>[] | undefined>;
+    /**
+     * The ZenStack client you can use to perform additional operations. The database operations initiated
+     * from this client are executed within the same transaction as the mutation if the mutation is running
+     * inside a transaction.
      *
-     * @param args The query arguments.
-     * @param tx Optional transaction client to use for the query.
+     * Mutations initiated from this client will NOT trigger entity mutation hooks to avoid infinite loops.
      */
-    query: (args: Parameters<ModelOperations<Schema, Model>[Operation]>[0], tx?: ClientContract<Schema>) => ReturnType<ModelOperations<Schema, Model>[Operation]>;
+    client: ClientContract<Schema>;
+};
+type PluginAfterEntityMutationArgs<Schema extends SchemaDef> = MutationHooksArgs<Schema> & {
     /**
-     * The ZenStack client that is performing the operation.
+     * Loads the entities that have been mutated.
+     */
+    loadAfterMutationEntities(): Promise<Record<string, unknown>[] | undefined>;
+    /**
+     * The ZenStack client you can use to perform additional operations.
+     * See {@link EntityMutationHooksDef.runAfterMutationWithinTransaction} for detailed transaction behavior.
+     *
+     * Mutations initiated from this client will NOT trigger entity mutation hooks to avoid infinite loops.
      */
     client: ClientContract<Schema>;
 };
-/**
- * Defines a ZenStack runtime plugin.
- */
-declare function definePlugin<Schema extends SchemaDef>(plugin: RuntimePlugin<Schema>): RuntimePlugin<Schema>;
+type OnKyselyQueryArgs<Schema extends SchemaDef> = {
+    kysely: ToKysely<Schema>;
+    schema: SchemaDef;
+    client: ClientContract<Schema>;
+    query: RootOperationNode;
+    proceed: ProceedKyselyQueryFunction;
+};
+type ProceedKyselyQueryFunction = (query: RootOperationNode) => Promise<QueryResult<any>>;
+type OnKyselyQueryCallback<Schema extends SchemaDef> = (args: OnKyselyQueryArgs<Schema>) => Promise<QueryResult<UnknownRow>>;
 
-type DialectConfig<Provider extends DataSourceProvider> = Provider['type'] extends 'sqlite' ? Optional<SqliteDialectConfig, 'database'> : Provider['type'] extends 'postgresql' ? Optional<PostgresDialectConfig, 'pool'> : never;
 type ZModelFunctionContext<Schema extends SchemaDef> = {
     dialect: BaseCrudDialect<Schema>;
     model: GetModels<Schema>;
@@ -666,9 +767,9 @@ type ZModelFunction<Schema extends SchemaDef> = (eb: ExpressionBuilder<ToKyselyS
  */
 type ClientOptions<Schema extends SchemaDef> = {
     /**
-     * Database dialect configuration.
+     * Kysely dialect.
      */
-    dialectConfig: DialectConfig<Schema['provider']>;
+    dialect: Dialect;
     /**
      * Custom function definitions.
      */
@@ -707,6 +808,28 @@ type HasProcedures<Schema extends SchemaDef> = Schema extends {
     procedures: Record<string, ProcedureDef>;
 } ? true : false;
 
+/**
+ * A promise that only executes when it's awaited or .then() is called.
+ */
+type ZenStackPromise<Schema extends SchemaDef, T> = Promise<T> & {
+    /**
+     * @private
+     * Callable to get a plain promise.
+     */
+    cb: (txClient?: ClientContract<Schema>) => Promise<T>;
+};
+
+type TransactionUnsupportedMethods = (typeof TRANSACTION_UNSUPPORTED_METHODS)[number];
+/**
+ * Transaction isolation levels.
+ */
+declare enum TransactionIsolationLevel {
+    ReadUncommitted = "read uncommitted",
+    ReadCommitted = "read committed",
+    RepeatableRead = "repeatable read",
+    Serializable = "serializable",
+    Snapshot = "snapshot"
+}
 /**
  * ZenStack client interface.
  */
@@ -720,36 +843,36 @@ type ClientContract<Schema extends SchemaDef> = {
      * Executes a prepared raw query and returns the number of affected rows.
      * @example
      * ```
-     * const result = await client.$executeRaw`UPDATE User SET cool = ${true} WHERE email = ${'user@email.com'};`
+     * const result = await db.$executeRaw`UPDATE User SET cool = ${true} WHERE email = ${'user@email.com'};`
      * ```
      */
-    $executeRaw(query: TemplateStringsArray, ...values: any[]): Promise<number>;
+    $executeRaw(query: TemplateStringsArray, ...values: any[]): ZenStackPromise<Schema, number>;
     /**
      * Executes a raw query and returns the number of affected rows.
      * This method is susceptible to SQL injections.
      * @example
      * ```
-     * const result = await client.$executeRawUnsafe('UPDATE User SET cool = $1 WHERE email = $2 ;', true, 'user@email.com')
+     * const result = await db.$executeRawUnsafe('UPDATE User SET cool = $1 WHERE email = $2 ;', true, 'user@email.com')
      * ```
      */
-    $executeRawUnsafe(query: string, ...values: any[]): Promise<number>;
+    $executeRawUnsafe(query: string, ...values: any[]): ZenStackPromise<Schema, number>;
     /**
      * Performs a prepared raw query and returns the `SELECT` data.
      * @example
      * ```
-     * const result = await client.$queryRaw`SELECT * FROM User WHERE id = ${1} OR email = ${'user@email.com'};`
+     * const result = await db.$queryRaw`SELECT * FROM User WHERE id = ${1} OR email = ${'user@email.com'};`
      * ```
      */
-    $queryRaw<T = unknown>(query: TemplateStringsArray, ...values: any[]): Promise<T>;
+    $queryRaw<T = unknown>(query: TemplateStringsArray, ...values: any[]): ZenStackPromise<Schema, T>;
     /**
      * Performs a raw query and returns the `SELECT` data.
      * This method is susceptible to SQL injections.
      * @example
      * ```
-     * const result = await client.$queryRawUnsafe('SELECT * FROM User WHERE id = $1 OR email = $2;', 1, 'user@email.com')
+     * const result = await db.$queryRawUnsafe('SELECT * FROM User WHERE id = $1 OR email = $2;', 1, 'user@email.com')
      * ```
      */
-    $queryRawUnsafe<T = unknown>(query: string, ...values: any[]): Promise<T>;
+    $queryRawUnsafe<T = unknown>(query: string, ...values: any[]): ZenStackPromise<Schema, T>;
     /**
      * The current user identity.
      */
@@ -767,9 +890,17 @@ type ClientContract<Schema extends SchemaDef> = {
      */
     readonly $qbRaw: ToKysely<any>;
     /**
-     * Starts a transaction.
+     * Starts an interactive transaction.
+     */
+    $transaction<T>(callback: (tx: Omit<ClientContract<Schema>, TransactionUnsupportedMethods>) => Promise<T>, options?: {
+        isolationLevel?: TransactionIsolationLevel;
+    }): Promise<T>;
+    /**
+     * Starts a sequential transaction.
      */
-    $transaction<T>(callback: (tx: ClientContract<Schema>) => Promise<T>): Promise<T>;
+    $transaction<P extends ZenStackPromise<Schema, any>[]>(arg: [...P], options?: {
+        isolationLevel?: TransactionIsolationLevel;
+    }): Promise<UnwrapTuplePromises<P>>;
     /**
      * Returns a new client with the specified plugin installed.
      */
@@ -827,7 +958,7 @@ interface ClientConstructor {
  * CRUD operations.
  */
 type CRUD = 'create' | 'read' | 'update' | 'delete';
-interface ModelOperations<Schema extends SchemaDef, Model extends GetModels<Schema>> {
+type AllModelOperations<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
     /**
      * Returns a list of entities.
      * @param args - query args
@@ -836,17 +967,17 @@ interface ModelOperations<Schema extends SchemaDef, Model extends GetModels<Sche
      * @example
      * ```ts
      * // find all users and return all scalar fields
-     * await client.user.findMany();
+     * await db.user.findMany();
      *
      * // find all users with name 'Alex'
-     * await client.user.findMany({
+     * await db.user.findMany({
      *     where: {
      *         name: 'Alex'
      *     }
      * });
      *
      * // select fields
-     * await client.user.findMany({
+     * await db.user.findMany({
      *     select: {
      *         name: true,
      *         email: true,
@@ -854,21 +985,21 @@ interface ModelOperations<Schema extends SchemaDef, Model extends GetModels<Sche
      * }); // result: `Array<{ name: string, email: string }>`
      *
      * // omit fields
-     * await client.user.findMany({
+     * await db.user.findMany({
      *     omit: {
      *         name: true,
      *     }
      * }); // result: `Array<{ id: number; email: string; ... }>`
      *
      * // include relations (and all scalar fields)
-     * await client.user.findMany({
+     * await db.user.findMany({
      *     include: {
      *         posts: true,
      *     }
      * }); // result: `Array<{ ...; posts: Post[] }>`
      *
      * // include relations with filter
-     * await client.user.findMany({
+     * await db.user.findMany({
      *     include: {
      *         posts: {
      *             where: {
@@ -879,14 +1010,14 @@ interface ModelOperations<Schema extends SchemaDef, Model extends GetModels<Sche
      * });
      *
      * // pagination and sorting
-     * await client.user.findMany({
+     * await db.user.findMany({
      *     skip: 10,
      *     take: 10,
      *     orderBy: [{ name: 'asc' }, { email: 'desc' }],
      * });
      *
      * // pagination with cursor (https://www.prisma.io/docs/orm/prisma-client/queries/pagination#cursor-based-pagination)
-     * await client.user.findMany({
+     * await db.user.findMany({
      *     cursor: { id: 10 },
      *     skip: 1,
      *     take: 10,
@@ -894,50 +1025,50 @@ interface ModelOperations<Schema extends SchemaDef, Model extends GetModels<Sche
      * });
      *
      * // distinct
-     * await client.user.findMany({
+     * await db.user.findMany({
      *     distinct: ['name']
      * });
      *
      * // count all relations
-     * await client.user.findMany({
+     * await db.user.findMany({
      *     _count: true,
      * }); // result: `{ _count: { posts: number; ... } }`
      *
      * // count selected relations
-     * await client.user.findMany({
+     * await db.user.findMany({
      *     _count: { select: { posts: true } },
      * }); // result: `{ _count: { posts: number } }`
      * ```
      */
-    findMany<T extends FindArgs<Schema, Model, true>>(args?: SelectSubset<T, FindArgs<Schema, Model, true>>): Promise<ModelResult<Schema, Model, T>[]>;
+    findMany<T extends FindArgs<Schema, Model, true>>(args?: SelectSubset<T, FindArgs<Schema, Model, true>>): ZenStackPromise<Schema, Simplify<ModelResult<Schema, Model, T>>[]>;
     /**
      * 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>>): Promise<ModelResult<Schema, Model, T> | null>;
+    findUnique<T extends FindUniqueArgs<Schema, Model>>(args: SelectSubset<T, FindUniqueArgs<Schema, Model>>): ZenStackPromise<Schema, Simplify<ModelResult<Schema, Model, T>> | 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>>): Promise<ModelResult<Schema, Model, T>>;
+    findUniqueOrThrow<T extends FindUniqueArgs<Schema, Model>>(args: SelectSubset<T, FindUniqueArgs<Schema, Model>>): ZenStackPromise<Schema, Simplify<ModelResult<Schema, Model, T>>>;
     /**
      * Returns the first entity.
      * @param args - query args
      * @returns a single entity or null if not found
      * @see {@link findMany}
      */
-    findFirst<T extends FindArgs<Schema, Model, true>>(args?: SelectSubset<T, FindArgs<Schema, Model, true>>): Promise<ModelResult<Schema, Model, T> | null>;
+    findFirst<T extends FindArgs<Schema, Model, true>>(args?: SelectSubset<T, FindArgs<Schema, Model, true>>): ZenStackPromise<Schema, Simplify<ModelResult<Schema, Model, T>> | 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 FindArgs<Schema, Model, true>>(args?: SelectSubset<T, FindArgs<Schema, Model, true>>): Promise<ModelResult<Schema, Model, T>>;
+    findFirstOrThrow<T extends FindArgs<Schema, Model, true>>(args?: SelectSubset<T, FindArgs<Schema, Model, true>>): ZenStackPromise<Schema, Simplify<ModelResult<Schema, Model, T>>>;
     /**
      * Creates a new entity.
      * @param args - create args
@@ -946,12 +1077,12 @@ interface ModelOperations<Schema extends SchemaDef, Model extends GetModels<Sche
      * @example
      * ```ts
      * // simple create
-     * await client.user.create({
+     * await db.user.create({
      *    data: { name: 'Alex', email: 'alex@zenstack.dev' }
      * });
      *
      * // nested create with relation
-     * await client.user.create({
+     * await db.user.create({
      *    data: {
      *        email: 'alex@zenstack.dev',
      *        posts: { create: { title: 'Hello World' } }
@@ -960,7 +1091,7 @@ interface ModelOperations<Schema extends SchemaDef, Model extends GetModels<Sche
      *
      * // you can use `select`, `omit`, and `include` to control
      * // the fields returned by the query, as with `findMany`
-     * await client.user.create({
+     * await db.user.create({
      *    data: {
      *        email: 'alex@zenstack.dev',
      *        posts: { create: { title: 'Hello World' } }
@@ -969,7 +1100,7 @@ interface ModelOperations<Schema extends SchemaDef, Model extends GetModels<Sche
      * }); // result: `{ id: number; posts: Post[] }`
      *
      * // connect relations
-     * await client.user.create({
+     * await db.user.create({
      *    data: {
      *        email: 'alex@zenstack.dev',
      *        posts: { connect: { id: 1 } }
@@ -977,7 +1108,7 @@ interface ModelOperations<Schema extends SchemaDef, Model extends GetModels<Sche
      * });
      *
      * // connect relations, and create if not found
-     * await client.user.create({
+     * await db.user.create({
      *    data: {
      *        email: 'alex@zenstack.dev',
      *        posts: {
@@ -990,7 +1121,7 @@ interface ModelOperations<Schema extends SchemaDef, Model extends GetModels<Sche
      * });
      * ```
      */
-    create<T extends CreateArgs<Schema, Model>>(args: SelectSubset<T, CreateArgs<Schema, Model>>): Promise<ModelResult<Schema, Model, T>>;
+    create<T extends CreateArgs<Schema, Model>>(args: SelectSubset<T, CreateArgs<Schema, Model>>): ZenStackPromise<Schema, Simplify<ModelResult<Schema, Model, T>>>;
     /**
      * Creates multiple entities. Only scalar fields are allowed.
      * @param args - create args
@@ -999,7 +1130,7 @@ interface ModelOperations<Schema extends SchemaDef, Model extends GetModels<Sche
      * @example
      * ```ts
      * // create multiple entities
-     * await client.user.createMany({
+     * await db.user.createMany({
      *     data: [
      *         { name: 'Alex', email: 'alex@zenstack.dev' },
      *         { name: 'John', email: 'john@zenstack.dev' }
@@ -1007,7 +1138,7 @@ interface ModelOperations<Schema extends SchemaDef, Model extends GetModels<Sche
      * });
      *
      * // skip items that cause unique constraint violation
-     * await client.user.createMany({
+     * await db.user.createMany({
      *     data: [
      *         { name: 'Alex', email: 'alex@zenstack.dev' },
      *         { name: 'John', email: 'john@zenstack.dev' }
@@ -1016,7 +1147,7 @@ interface ModelOperations<Schema extends SchemaDef, Model extends GetModels<Sche
      * });
      * ```
      */
-    createMany<T extends CreateManyArgs<Schema, Model>>(args?: SelectSubset<T, CreateManyArgs<Schema, Model>>): Promise<BatchResult>;
+    createMany<T extends CreateManyArgs<Schema, Model>>(args?: SelectSubset<T, CreateManyArgs<Schema, Model>>): ZenStackPromise<Schema, BatchResult>;
     /**
      * Creates multiple entities and returns them.
      * @param args - create args. See {@link createMany} for input. Use
@@ -1026,7 +1157,7 @@ interface ModelOperations<Schema extends SchemaDef, Model extends GetModels<Sche
      * @example
      * ```ts
      * // create multiple entities and return selected fields
-     * await client.user.createManyAndReturn({
+     * await db.user.createManyAndReturn({
      *     data: [
      *         { name: 'Alex', email: 'alex@zenstack.dev' },
      *         { name: 'John', email: 'john@zenstack.dev' }
@@ -1035,7 +1166,7 @@ interface ModelOperations<Schema extends SchemaDef, Model extends GetModels<Sche
      * });
      * ```
      */
-    createManyAndReturn<T extends CreateManyAndReturnArgs<Schema, Model>>(args?: SelectSubset<T, CreateManyAndReturnArgs<Schema, Model>>): Promise<ModelResult<Schema, Model, T>[]>;
+    createManyAndReturn<T extends CreateManyAndReturnArgs<Schema, Model>>(args?: SelectSubset<T, CreateManyAndReturnArgs<Schema, Model>>): ZenStackPromise<Schema, Simplify<ModelResult<Schema, Model, T>>[]>;
     /**
      * Updates a uniquely identified entity.
      * @param args - update args. See {@link findMany} for how to control
@@ -1045,19 +1176,19 @@ interface ModelOperations<Schema extends SchemaDef, Model extends GetModels<Sche
      * @example
      * ```ts
      * // update fields
-     * await client.user.update({
+     * await db.user.update({
      *     where: { id: 1 },
      *     data: { name: 'Alex' }
      * });
      *
      * // connect a relation
-     * await client.user.update({
+     * await db.user.update({
      *     where: { id: 1 },
      *     data: { posts: { connect: { id: 1 } } }
      * });
      *
      * // connect relation, and create if not found
-     * await client.user.update({
+     * await db.user.update({
      *     where: { id: 1 },
      *     data: {
      *         posts: {
@@ -1070,7 +1201,7 @@ interface ModelOperations<Schema extends SchemaDef, Model extends GetModels<Sche
      * });
      *
      * // create many related entities (only available for one-to-many relations)
-     * await client.user.update({
+     * await db.user.update({
      *     where: { id: 1 },
      *     data: {
      *         posts: {
@@ -1082,19 +1213,19 @@ interface ModelOperations<Schema extends SchemaDef, Model extends GetModels<Sche
      * });
      *
      * // disconnect a one-to-many relation
-     * await client.user.update({
+     * await db.user.update({
      *     where: { id: 1 },
      *     data: { posts: { disconnect: { id: 1 } } }
      * });
      *
      * // disconnect a one-to-one relation
-     * await client.user.update({
+     * await db.user.update({
      *     where: { id: 1 },
      *     data: { profile: { disconnect: true } }
      * });
      *
      * // replace a relation (only available for one-to-many relations)
-     * await client.user.update({
+     * await db.user.update({
      *     where: { id: 1 },
      *     data: {
      *         posts: {
@@ -1104,7 +1235,7 @@ interface ModelOperations<Schema extends SchemaDef, Model extends GetModels<Sche
      * });
      *
      * // update a relation
-     * await client.user.update({
+     * await db.user.update({
      *     where: { id: 1 },
      *     data: {
      *         posts: {
@@ -1114,7 +1245,7 @@ interface ModelOperations<Schema extends SchemaDef, Model extends GetModels<Sche
      * });
      *
      * // upsert a relation
-     * await client.user.update({
+     * await db.user.update({
      *     where: { id: 1 },
      *     data: {
      *         posts: {
@@ -1128,7 +1259,7 @@ interface ModelOperations<Schema extends SchemaDef, Model extends GetModels<Sche
      * });
      *
      * // update many related entities (only available for one-to-many relations)
-     * await client.user.update({
+     * await db.user.update({
      *     where: { id: 1 },
      *     data: {
      *         posts: {
@@ -1141,19 +1272,19 @@ interface ModelOperations<Schema extends SchemaDef, Model extends GetModels<Sche
      * });
      *
      * // delete a one-to-many relation
-     * await client.user.update({
+     * await db.user.update({
      *     where: { id: 1 },
      *     data: { posts: { delete: { id: 1 } } }
      * });
      *
      * // delete a one-to-one relation
-     * await client.user.update({
+     * await db.user.update({
      *     where: { id: 1 },
      *     data: { profile: { delete: true } }
      * });
      * ```
      */
-    update<T extends UpdateArgs<Schema, Model>>(args: SelectSubset<T, UpdateArgs<Schema, Model>>): Promise<ModelResult<Schema, Model, T>>;
+    update<T extends UpdateArgs<Schema, Model>>(args: SelectSubset<T, UpdateArgs<Schema, Model>>): ZenStackPromise<Schema, Simplify<ModelResult<Schema, Model, T>>>;
     /**
      * Updates multiple entities.
      * @param args - update args. Only scalar fields are allowed for data.
@@ -1162,19 +1293,19 @@ interface ModelOperations<Schema extends SchemaDef, Model extends GetModels<Sche
      * @example
      * ```ts
      * // update many entities
-     * await client.user.updateMany({
+     * await db.user.updateMany({
      *     where: { email: { endsWith: '@zenstack.dev' } },
      *     data: { role: 'ADMIN' }
      * });
      *
      * // limit the number of updated entities
-     * await client.user.updateMany({
+     * await db.user.updateMany({
      *     where: { email: { endsWith: '@zenstack.dev' } },
      *     data: { role: 'ADMIN' },
      *     limit: 10
      * });
      */
-    updateMany<T extends UpdateManyArgs<Schema, Model>>(args: Subset<T, UpdateManyArgs<Schema, Model>>): Promise<BatchResult>;
+    updateMany<T extends UpdateManyArgs<Schema, Model>>(args: Subset<T, UpdateManyArgs<Schema, Model>>): ZenStackPromise<Schema, BatchResult>;
     /**
      * Updates multiple entities and returns them.
      * @param args - update args. Only scalar fields are allowed for data.
@@ -1183,21 +1314,21 @@ interface ModelOperations<Schema extends SchemaDef, Model extends GetModels<Sche
      * @example
      * ```ts
      * // update many entities and return selected fields
-     * await client.user.updateManyAndReturn({
+     * await db.user.updateManyAndReturn({
      *     where: { email: { endsWith: '@zenstack.dev' } },
      *     data: { role: 'ADMIN' },
      *     select: { id: true, email: true }
      * }); // result: `Array<{ id: string; email: string }>`
      *
      * // limit the number of updated entities
-     * await client.user.updateManyAndReturn({
+     * await db.user.updateManyAndReturn({
      *     where: { email: { endsWith: '@zenstack.dev' } },
      *     data: { role: 'ADMIN' },
      *     limit: 10
      * });
      * ```
      */
-    updateManyAndReturn<T extends UpdateManyAndReturnArgs<Schema, Model>>(args: Subset<T, UpdateManyAndReturnArgs<Schema, Model>>): Promise<ModelResult<Schema, Model, T>[]>;
+    updateManyAndReturn<T extends UpdateManyAndReturnArgs<Schema, Model>>(args: Subset<T, UpdateManyAndReturnArgs<Schema, Model>>): ZenStackPromise<Schema, Simplify<ModelResult<Schema, Model, T>>[]>;
     /**
      * Creates or updates an entity.
      * @param args - upsert args
@@ -1206,7 +1337,7 @@ interface ModelOperations<Schema extends SchemaDef, Model extends GetModels<Sche
      * @example
      * ```ts
      * // upsert an entity
-     * await client.user.upsert({
+     * await db.user.upsert({
      *     // `where` clause is used to find the entity
      *     where: { id: 1 },
      *     // `create` clause is used if the entity is not found
@@ -1218,7 +1349,7 @@ interface ModelOperations<Schema extends SchemaDef, Model extends GetModels<Sche
      * });
      * ```
      */
-    upsert<T extends UpsertArgs<Schema, Model>>(args: SelectSubset<T, UpsertArgs<Schema, Model>>): Promise<ModelResult<Schema, Model, T>>;
+    upsert<T extends UpsertArgs<Schema, Model>>(args: SelectSubset<T, UpsertArgs<Schema, Model>>): ZenStackPromise<Schema, Simplify<ModelResult<Schema, Model, T>>>;
     /**
      * Deletes a uniquely identifiable entity.
      * @param args - delete args
@@ -1227,18 +1358,18 @@ interface ModelOperations<Schema extends SchemaDef, Model extends GetModels<Sche
      * @example
      * ```ts
      * // delete an entity
-     * await client.user.delete({
+     * await db.user.delete({
      *     where: { id: 1 }
      * });
      *
      * // delete an entity and return selected fields
-     * await client.user.delete({
+     * await db.user.delete({
      *     where: { id: 1 },
      *     select: { id: true, email: true }
      * }); // result: `{ id: string; email: string }`
      * ```
      */
-    delete<T extends DeleteArgs<Schema, Model>>(args: SelectSubset<T, DeleteArgs<Schema, Model>>): Promise<ModelResult<Schema, Model>>;
+    delete<T extends DeleteArgs<Schema, Model>>(args: SelectSubset<T, DeleteArgs<Schema, Model>>): ZenStackPromise<Schema, Simplify<ModelResult<Schema, Model, T>>>;
     /**
      * Deletes multiple entities.
      * @param args - delete args
@@ -1247,18 +1378,18 @@ interface ModelOperations<Schema extends SchemaDef, Model extends GetModels<Sche
      * @example
      * ```ts
      * // delete many entities
-     * await client.user.deleteMany({
+     * await db.user.deleteMany({
      *     where: { email: { endsWith: '@zenstack.dev' } }
      * });
      *
      * // limit the number of deleted entities
-     * await client.user.deleteMany({
+     * await db.user.deleteMany({
      *     where: { email: { endsWith: '@zenstack.dev' } },
      *     limit: 10
      * });
      * ```
      */
-    deleteMany<T extends DeleteManyArgs<Schema, Model>>(args?: Subset<T, DeleteManyArgs<Schema, Model>>): Promise<BatchResult>;
+    deleteMany<T extends DeleteManyArgs<Schema, Model>>(args?: Subset<T, DeleteManyArgs<Schema, Model>>): ZenStackPromise<Schema, BatchResult>;
     /**
      * Counts rows or field values.
      * @param args - count args
@@ -1267,17 +1398,17 @@ interface ModelOperations<Schema extends SchemaDef, Model extends GetModels<Sche
      * @example
      * ```ts
      * // count all
-     * await client.user.count();
+     * await db.user.count();
      *
      * // count with a filter
-     * await client.user.count({ where: { email: { endsWith: '@zenstack.dev' } } });
+     * await db.user.count({ where: { email: { endsWith: '@zenstack.dev' } } });
      *
      * // count rows and field values
-     * await client.user.count({
+     * await db.user.count({
      *     select: { _all: true, email: true }
      * }); // result: `{ _all: number, email: number }`
      */
-    count<T extends CountArgs<Schema, Model>>(args?: Subset<T, CountArgs<Schema, Model>>): Promise<CountResult<Schema, Model, T>>;
+    count<T extends CountArgs<Schema, Model>>(args?: Subset<T, CountArgs<Schema, Model>>): ZenStackPromise<Schema, Simplify<CountResult<Schema, Model, T>>>;
     /**
      * Aggregates rows.
      * @param args - aggregation args
@@ -1286,7 +1417,7 @@ interface ModelOperations<Schema extends SchemaDef, Model extends GetModels<Sche
      * @example
      * ```ts
      * // aggregate rows
-     * await client.profile.aggregate({
+     * await db.profile.aggregate({
      *     where: { email: { endsWith: '@zenstack.dev' } },
      *     _count: true,
      *     _avg: { age: true },
@@ -1295,7 +1426,7 @@ interface ModelOperations<Schema extends SchemaDef, Model extends GetModels<Sche
      *     _max: { age: true }
      * }); // result: `{ _count: number, _avg: { age: number }, ... }`
      */
-    aggregate<T extends AggregateArgs<Schema, Model>>(args: Subset<T, AggregateArgs<Schema, Model>>): Promise<AggregateResult<Schema, Model, T>>;
+    aggregate<T extends AggregateArgs<Schema, Model>>(args: Subset<T, AggregateArgs<Schema, Model>>): ZenStackPromise<Schema, Simplify<AggregateResult<Schema, Model, T>>>;
     /**
      * Groups rows by columns.
      * @param args - groupBy args
@@ -1304,31 +1435,33 @@ interface ModelOperations<Schema extends SchemaDef, Model extends GetModels<Sche
      * @example
      * ```ts
      * // group by a field
-     * await client.profile.groupBy({
+     * await db.profile.groupBy({
      *     by: 'country',
      *     _count: true
      * }); // result: `Array<{ country: string, _count: number }>`
      *
      * // group by multiple fields
-     * await client.profile.groupBy({
+     * await db.profile.groupBy({
      *     by: ['country', 'city'],
      *     _count: true
      * }); // result: `Array<{ country: string, city: string, _count: number }>`
      *
-     * // group by with sorting, the `orderBy` fields must be in the `by` list
-     * await client.profile.groupBy({
+     * // group by with sorting, the `orderBy` fields must be either an aggregation
+     * // or a field used in the `by` list
+     * await db.profile.groupBy({
      *     by: 'country',
      *     orderBy: { country: 'desc' }
      * });
      *
-     * // group by with having (post-aggregation filter), the `having` fields must
-     * // be in the `by` list
-     * await client.profile.groupBy({
+     * // group by with having (post-aggregation filter), the fields used in `having` must
+     * // be either an aggregation, or a field used in the `by` list
+     * await db.profile.groupBy({
      *     by: 'country',
-     *     having: { country: 'US' }
+     *     having: { country: 'US', age: { _avg: { gte: 18 } } }
      * });
      */
-    groupBy<T extends GroupByArgs<Schema, Model>>(args: Subset<T, GroupByArgs<Schema, Model>>): Promise<GroupByResult<Schema, Model, T>>;
-}
+    groupBy<T extends GroupByArgs<Schema, Model>>(args: Subset<T, GroupByArgs<Schema, Model>>): ZenStackPromise<Schema, Simplify<GroupByResult<Schema, Model, T>>>;
+};
+type ModelOperations<Schema extends SchemaDef, Model extends GetModels<Schema>> = Omit<AllModelOperations<Schema, Model>, IsDelegateModel<Schema, Model> extends true ? 'create' | 'createMany' | 'createManyAndReturn' | 'upsert' : never>;
 
-export { type UpdateRelationInput as A, type BatchResult as B, type ClientConstructor as C, type DateTimeFilter as D, type UpdateInput as E, type FindArgs as F, type DeleteArgs as G, type DeleteManyArgs as H, type CountArgs as I, type CountAggregateInput as J, type CountResult as K, type AggregateArgs as L, type ModelResult as M, type NumberFilter as N, type OrderBy as O, type AggregateResult as P, type GroupByArgs as Q, type GroupByResult as R, type StringFilter as S, type ToKysely as T, type UpdateArgs as U, type RuntimePlugin as V, type WhereInput as W, type OnKyselyQueryArgs as X, type ClientContract as a, type ClientOptions as b, type CommonPrimitiveFilter as c, definePlugin as d, type BytesFilter as e, type BooleanFilter as f, type SortOrder as g, type NullsOrder as h, type WhereUniqueInput as i, type SelectIncludeOmit as j, type Subset as k, type SelectSubset as l, type MapFieldType as m, type OptionalFieldsForCreate as n, type OppositeRelationFields as o, type OppositeRelationAndFK as p, type FindUniqueArgs as q, type CreateArgs as r, type CreateManyArgs as s, type CreateManyAndReturnArgs as t, type CreateManyPayload as u, type CreateInput as v, type UpdateManyArgs as w, type UpdateManyAndReturnArgs as x, type UpsertArgs as y, type UpdateScalarInput as z };
+export { type DeleteArgs as A, type BatchResult as B, type ClientConstructor as C, type DateTimeFilter as D, type DeleteManyArgs as E, type FindArgs as F, type CountArgs as G, type CountResult as H, type IncludeInput as I, type JsonArray as J, type AggregateArgs as K, type AggregateResult as L, type ModelResult as M, type NumberFilter as N, type OrderBy as O, type GroupByArgs as P, type GroupByResult as Q, type RuntimePlugin as R, type SimplifiedModelResult as S, type ToKysely as T, type UpdateArgs as U, type OnKyselyQueryArgs as V, type WhereInput as W, type ZenStackPromise as Z, type JsonObject as a, type JsonValue as b, type ClientContract as c, type ClientOptions as d, definePlugin as e, type TypeDefResult as f, type StringFilter as g, type BytesFilter as h, type BooleanFilter as i, type SortOrder as j, type NullsOrder as k, type WhereUniqueInput as l, type OmitInput as m, type SelectIncludeOmit as n, type SelectInput as o, type Subset as p, type SelectSubset as q, type FindManyArgs as r, type FindFirstArgs as s, type FindUniqueArgs as t, type CreateArgs as u, type CreateManyArgs as v, type CreateManyAndReturnArgs as w, type UpdateManyArgs as x, type UpdateManyAndReturnArgs as y, type UpsertArgs as z };