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

package/dist/index.d.cts

@@ -1,8 +1,8 @@
 import Decimal from 'decimal.js';
 import * as _zenstackhq_schema from '@zenstackhq/schema';
-import { SchemaDef, GetModels, ScalarFields, ForeignKeyFields, GetModelFields, FieldHasDefault, GetModelFieldType, ModelFieldIsOptional, GetModelField, IsDelegateModel, GetModelDiscriminator, GetSubModels, NonRelationFields, FieldDef, GetEnums, GetEnum, GetTypeDefs, GetTypeDefFields, GetTypeDefField, TypeDefFieldIsOptional, RelationFields, FieldIsArray, RelationFieldType, FieldIsRelation, GetModel, BuiltinType, FieldIsDelegateDiscriminator, FieldType, RelationInfo, FieldIsDelegateRelation, ModelDef, DataSourceProviderType, ProcedureDef, Expression as Expression$1, LiteralExpression, ArrayExpression, FieldExpression, MemberExpression, BinaryExpression, UnaryExpression, CallExpression, ThisExpression, NullExpression } from '@zenstackhq/schema';
+import { SchemaDef, BuiltinType, GetModels, FieldDef, ModelDef, DataSourceProviderType, ScalarFields, ForeignKeyFields, GetModelFields, FieldHasDefault, GetModelFieldType, ModelFieldIsOptional, GetModelField, GetModel, ProcedureDef, IsDelegateModel, GetModelDiscriminator, GetSubModels, NonRelationFields, GetEnums, GetEnum, GetTypeDefs, GetTypeDefFields, GetTypeDefField, TypeDefFieldIsOptional, RelationFields, FieldIsArray, RelationFieldType, FieldIsRelation, FieldIsDelegateDiscriminator, FieldType, RelationInfo, FieldIsDelegateRelation, Expression as Expression$1, LiteralExpression, ArrayExpression, FieldExpression, MemberExpression, BinaryExpression, UnaryExpression, CallExpression, ThisExpression, NullExpression } from '@zenstackhq/schema';
 import * as kysely from 'kysely';
-import { OperationNodeVisitor, OperationNode, SelectQueryNode, SelectionNode, ColumnNode, AliasNode, TableNode, FromNode, ReferenceNode, AndNode, OrNode, ValueListNode, ParensNode, JoinNode, RawNode, WhereNode, InsertQueryNode, DeleteQueryNode, ReturningNode, CreateTableNode, AddColumnNode, ColumnDefinitionNode, DropTableNode, OrderByNode, OrderByItemNode, GroupByNode, GroupByItemNode, UpdateQueryNode, ColumnUpdateNode, LimitNode, OffsetNode, OnConflictNode, OnDuplicateKeyNode, CheckConstraintNode, DataTypeNode, SelectAllNode, IdentifierNode, SchemableIdentifierNode, ValueNode, PrimitiveValueListNode, OperatorNode, CreateIndexNode, DropIndexNode, ListNode, PrimaryKeyConstraintNode, UniqueConstraintNode, ReferencesNode, WithNode, CommonTableExpressionNode, CommonTableExpressionNameNode, HavingNode, CreateSchemaNode, DropSchemaNode, AlterTableNode, DropColumnNode, RenameColumnNode, AlterColumnNode, ModifyColumnNode, AddConstraintNode, DropConstraintNode, ForeignKeyConstraintNode, CreateViewNode, DropViewNode, GeneratedNode, DefaultValueNode, OnNode, ValuesNode, SelectModifierNode, CreateTypeNode, DropTypeNode, ExplainNode, DefaultInsertValueNode, AggregateFunctionNode, OverNode, PartitionByNode, PartitionByItemNode, SetOperationNode, BinaryOperationNode, UnaryOperationNode, UsingNode, FunctionNode, CaseNode, WhenNode, JSONReferenceNode, JSONPathNode, JSONPathLegNode, JSONOperatorChainNode, TupleNode, MergeQueryNode, MatchedNode, AddIndexNode, CastNode, FetchNode, TopNode, OutputNode, RenameConstraintNode, RefreshMaterializedViewNode, OrActionNode, CollateNode, Kysely, Generated, ExpressionBuilder, OperandExpression, SqlBool, SelectQueryBuilder, Expression, ExpressionWrapper, QueryId, RootOperationNode, QueryResult, UnknownRow, Dialect, KyselyConfig } from 'kysely';
+import { OperationNodeVisitor, OperationNode, SelectQueryNode, SelectionNode, ColumnNode, AliasNode, TableNode, FromNode, ReferenceNode, AndNode, OrNode, ValueListNode, ParensNode, JoinNode, RawNode, WhereNode, InsertQueryNode, DeleteQueryNode, ReturningNode, CreateTableNode, AddColumnNode, ColumnDefinitionNode, DropTableNode, OrderByNode, OrderByItemNode, GroupByNode, GroupByItemNode, UpdateQueryNode, ColumnUpdateNode, LimitNode, OffsetNode, OnConflictNode, OnDuplicateKeyNode, CheckConstraintNode, DataTypeNode, SelectAllNode, IdentifierNode, SchemableIdentifierNode, ValueNode, PrimitiveValueListNode, OperatorNode, CreateIndexNode, DropIndexNode, ListNode, PrimaryKeyConstraintNode, UniqueConstraintNode, ReferencesNode, WithNode, CommonTableExpressionNode, CommonTableExpressionNameNode, HavingNode, CreateSchemaNode, DropSchemaNode, AlterTableNode, DropColumnNode, RenameColumnNode, AlterColumnNode, ModifyColumnNode, AddConstraintNode, DropConstraintNode, ForeignKeyConstraintNode, CreateViewNode, DropViewNode, GeneratedNode, DefaultValueNode, OnNode, ValuesNode, SelectModifierNode, CreateTypeNode, DropTypeNode, ExplainNode, DefaultInsertValueNode, AggregateFunctionNode, OverNode, PartitionByNode, PartitionByItemNode, SetOperationNode, BinaryOperationNode, UnaryOperationNode, UsingNode, FunctionNode, CaseNode, WhenNode, JSONReferenceNode, JSONPathNode, JSONPathLegNode, JSONOperatorChainNode, TupleNode, MergeQueryNode, MatchedNode, AddIndexNode, CastNode, FetchNode, TopNode, OutputNode, RenameConstraintNode, RefreshMaterializedViewNode, OrActionNode, CollateNode, Kysely, ExpressionBuilder, SelectQueryBuilder, Expression, SqlBool, ExpressionWrapper, Generated, QueryId, RootOperationNode, QueryResult, UnknownRow, Dialect, KyselyConfig, OperandExpression } from 'kysely';
 
 declare class DefaultOperationNodeVisitor extends OperationNodeVisitor {
     protected defaultVisit(node: OperationNode): void;
@@ -114,6 +114,7 @@ declare namespace kyselyUtils {
 }
 
 type Optional<T extends object, K extends keyof T = keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+type PartialIf<T, Condition extends boolean> = Condition extends true ? Partial<T> : T;
 type NullableIf<T, Condition extends boolean> = Condition extends true ? T | null : T;
 type _Preserve = Date | Function | Decimal | Uint8Array | JsonObject | JsonValue;
 type _Depth = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
@@ -172,6 +173,97 @@ declare const LOGICAL_COMBINATORS: readonly ["AND", "OR", "NOT"];
 declare const AGGREGATE_OPERATORS: readonly ["_count", "_sum", "_avg", "_min", "_max"];
 type AGGREGATE_OPERATORS = (typeof AGGREGATE_OPERATORS)[number];
 
+declare abstract class BaseCrudDialect<Schema extends SchemaDef> {
+    protected readonly schema: Schema;
+    protected readonly options: ClientOptions<Schema>;
+    protected eb: ExpressionBuilder<any, any>;
+    constructor(schema: Schema, options: ClientOptions<Schema>);
+    transformPrimitive(value: unknown, _type: BuiltinType, _forArrayField: boolean): unknown;
+    transformOutput(value: unknown, _type: BuiltinType): unknown;
+    buildSelectModel(model: string, modelAlias: string): SelectQueryBuilder<any, any, {}>;
+    buildFilterSortTake(model: string, args: FindArgs<Schema, GetModels<Schema>, true>, query: SelectQueryBuilder<any, any, {}>, modelAlias: string): SelectQueryBuilder<any, any, {}>;
+    buildFilter(model: string, modelAlias: string, where: boolean | object | undefined): Expression<SqlBool>;
+    private buildCursorFilter;
+    private isLogicalCombinator;
+    protected buildCompositeFilter(model: string, modelAlias: string, key: (typeof LOGICAL_COMBINATORS)[number], payload: any): Expression<SqlBool>;
+    private buildRelationFilter;
+    private buildToOneRelationFilter;
+    private buildToManyRelationFilter;
+    private buildArrayFilter;
+    buildPrimitiveFilter(fieldRef: Expression<any>, fieldDef: FieldDef, payload: any): Expression<SqlBool>;
+    private buildLiteralFilter;
+    private buildStandardFilter;
+    private buildStringFilter;
+    private prepStringCasing;
+    private buildNumberFilter;
+    private buildBooleanFilter;
+    private buildDateTimeFilter;
+    private buildBytesFilter;
+    private buildEnumFilter;
+    buildOrderBy(query: SelectQueryBuilder<any, any, any>, model: string, modelAlias: string, orderBy: OrArray<OrderBy<Schema, GetModels<Schema>, boolean, boolean>> | undefined, negated: boolean): SelectQueryBuilder<any, any, any>;
+    buildSelectAllFields(model: string, query: SelectQueryBuilder<any, any, any>, omit: Record<string, boolean | undefined> | undefined | null, modelAlias: string): SelectQueryBuilder<any, any, any>;
+    shouldOmitField(omit: unknown, model: string, field: string): any;
+    protected buildModelSelect(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(): Expression<SqlBool>;
+    false(): Expression<SqlBool>;
+    isTrue(expression: Expression<SqlBool>): boolean;
+    isFalse(expression: Expression<SqlBool>): boolean;
+    and(...args: Expression<SqlBool>[]): Expression<SqlBool>;
+    or(...args: Expression<SqlBool>[]): Expression<SqlBool>;
+    not(...args: Expression<SqlBool>[]): ExpressionWrapper<any, any, SqlBool>;
+    fieldRef(model: string, field: string, modelAlias?: string, inlineComputedField?: boolean): any;
+    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.
+     */
+    abstract buildJsonObject(value: Record<string, Expression<unknown>>): ExpressionWrapper<any, any, unknown>;
+    /**
+     * Builds an Kysely expression that returns the length of an array.
+     */
+    abstract buildArrayLength(array: Expression<unknown>): ExpressionWrapper<any, any, number>;
+    /**
+     * Builds an array literal SQL string for the given values.
+     */
+    abstract buildArrayLiteralSQL(values: unknown[]): string;
+    /**
+     * Whether the dialect supports updating with a limit on the number of updated rows.
+     */
+    abstract get supportsUpdateWithLimit(): boolean;
+    /**
+     * Whether the dialect supports deleting with a limit on the number of deleted rows.
+     */
+    abstract get supportsDeleteWithLimit(): boolean;
+    /**
+     * Whether the dialect supports DISTINCT ON.
+     */
+    abstract get supportsDistinctOn(): boolean;
+    /**
+     * Whether the dialect support inserting with `DEFAULT` as field value.
+     */
+    abstract get supportInsertWithDefault(): boolean;
+    /**
+     * Gets the SQL column type for the given field definition.
+     */
+    abstract getFieldSqlType(fieldDef: FieldDef): string;
+    abstract getStringCasingBehavior(): {
+        supportsILike: boolean;
+        likeCaseSensitive: boolean;
+    };
+}
+
 type ToKyselySchema<Schema extends SchemaDef> = {
     [Model in GetModels<Schema>]: ToKyselyTable<Schema, Model>;
 };
@@ -184,100 +276,353 @@ type WrapNull<T, Null> = Null extends true ? T | null : T;
 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<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> ? 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;
-} : C extends {
-    select: infer S;
-} ? {
-    [Key in keyof S]: number;
-} : never;
-type ModelResult<Schema extends SchemaDef, Model extends GetModels<Schema>, Args = {}, Optional = false, Array = false> = WrapType<Args extends {
-    select: infer S;
-    omit?: infer O;
-} ? ModelSelectResult<Schema, Model, S, O> : Args extends {
-    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], 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 = {}, 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, WithAggregations extends boolean = false> = {
-    [Key in GetModelFields<Schema, Model> as ScalarOnly extends true ? Key extends RelationFields<Schema, Model> ? never : Key : Key]?: Key extends RelationFields<Schema, Model> ? RelationFilter<Schema, Model, Key> : FieldIsArray<Schema, Model, Key> extends true ? ArrayFilter<Schema, GetModelFieldType<Schema, Model, Key>> : GetModelFieldType<Schema, Model, Key> extends GetEnums<Schema> ? EnumFilter<Schema, GetModelFieldType<Schema, Model, Key>, ModelFieldIsOptional<Schema, Model, Key>, WithAggregations> : PrimitiveFilter<GetModelFieldType<Schema, Model, Key>, ModelFieldIsOptional<Schema, Model, Key>, WithAggregations>;
-} & {
-    $expr?: (eb: ExpressionBuilder<ToKyselySchema<Schema>, Model>) => OperandExpression<SqlBool>;
-} & {
-    AND?: OrArray<WhereInput<Schema, Model, ScalarOnly>>;
-    OR?: WhereInput<Schema, Model, ScalarOnly>[];
-    NOT?: OrArray<WhereInput<Schema, Model, ScalarOnly>>;
-};
-type EnumFilter<Schema extends SchemaDef, T extends GetEnums<Schema>, Nullable extends boolean, WithAggregations extends boolean> = NullableIf<keyof GetEnum<Schema, T>, Nullable> | ({
-    equals?: NullableIf<keyof GetEnum<Schema, T>, Nullable>;
-    in?: (keyof GetEnum<Schema, T>)[];
-    notIn?: (keyof GetEnum<Schema, T>)[];
-    not?: EnumFilter<Schema, T, Nullable, WithAggregations>;
-} & (WithAggregations extends true ? {
-    _count?: NumberFilter<'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 CoreCrudOperation = 'findMany' | 'findUnique' | 'findFirst' | 'create' | 'createMany' | 'createManyAndReturn' | 'update' | 'updateMany' | 'updateManyAndReturn' | 'upsert' | 'delete' | 'deleteMany' | 'count' | 'aggregate' | 'groupBy';
+type AllCrudOperation = CoreCrudOperation | 'findUniqueOrThrow' | 'findFirstOrThrow';
+
+/**
+ * ZenStack runtime plugin.
+ */
+interface RuntimePlugin<Schema extends SchemaDef = SchemaDef> {
+    /**
+     * Plugin ID.
+     */
+    id: string;
+    /**
+     * Plugin display name.
+     */
+    name?: string;
+    /**
+     * Plugin description.
+     */
+    description?: string;
+    /**
+     * Custom function implementations.
+     */
+    functions?: Record<string, ZModelFunction<Schema>>;
+    /**
+     * Intercepts an ORM query.
+     */
+    onQuery?: OnQueryCallback<Schema>;
+    /**
+     * Intercepts an entity mutation.
+     */
+    onEntityMutation?: EntityMutationHooksDef<Schema>;
+    /**
+     * Intercepts a Kysely query.
+     */
+    onKyselyQuery?: OnKyselyQueryCallback<Schema>;
+}
+/**
+ * Defines a ZenStack runtime plugin.
+ */
+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> = {
+    /**
+     * The model that is being queried.
+     */
+    model: GetModels<Schema>;
+    /**
+     * The operation that is being performed.
+     */
+    operation: AllCrudOperation;
+    /**
+     * The query arguments.
+     */
+    args: unknown;
+    /**
+     * The function to proceed with the original query.
+     * It takes the same arguments as the operation method.
+     *
+     * @param args The query arguments.
+     */
+    proceed: (args: unknown) => Promise<unknown>;
+    /**
+     * The ZenStack client that is performing the operation.
+     */
+    client: ClientContract<Schema>;
 };
-type MapScalarType<Schema extends SchemaDef, T extends string> = T extends GetEnums<Schema> ? keyof GetEnum<Schema, T> : MapBaseType$1<T>;
-type PrimitiveFilter<T extends string, Nullable extends boolean, WithAggregations extends boolean> = T extends 'String' ? StringFilter<Nullable, WithAggregations> : T extends 'Int' | 'Float' | 'Decimal' | 'BigInt' ? NumberFilter<T, Nullable, WithAggregations> : T extends 'Boolean' ? BooleanFilter<Nullable, WithAggregations> : T extends 'DateTime' ? DateTimeFilter<Nullable, WithAggregations> : T extends 'Bytes' ? BytesFilter<Nullable, WithAggregations> : T extends 'Json' ? 'Not implemented yet' : never;
-type CommonPrimitiveFilter<DataType, T extends BuiltinType, Nullable extends boolean, WithAggregations extends boolean> = {
-    equals?: NullableIf<DataType, Nullable>;
-    in?: DataType[];
-    notIn?: DataType[];
-    lt?: DataType;
-    lte?: DataType;
-    gt?: DataType;
-    gte?: DataType;
-    not?: PrimitiveFilter<T, Nullable, WithAggregations>;
+type EntityMutationHooksDef<Schema extends SchemaDef> = {
+    /**
+     * Called before entities are mutated.
+     */
+    beforeEntityMutation?: BeforeEntityMutationCallback<Schema>;
+    /**
+     * Called after entities are mutated.
+     */
+    afterEntityMutation?: AfterEntityMutationCallback<Schema>;
+    /**
+     * 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`.
+     */
+    runAfterMutationWithinTransaction?: boolean;
 };
-type StringFilter<Nullable extends boolean, WithAggregations extends boolean> = NullableIf<string, Nullable> | (CommonPrimitiveFilter<string, 'String', Nullable, WithAggregations> & {
-    contains?: string;
-    startsWith?: string;
-    endsWith?: string;
+type MutationHooksArgs<Schema extends SchemaDef> = {
     /**
-     * Not effective for "sqlite" provider
+     * The model that is being mutated.
      */
-    mode?: 'default' | 'insensitive';
-} & (WithAggregations extends true ? {
-    _count?: NumberFilter<'Int', false, false>;
-    _min?: StringFilter<false, false>;
-    _max?: StringFilter<false, false>;
-} : {}));
-type NumberFilter<T extends 'Int' | 'Float' | 'Decimal' | 'BigInt', Nullable extends boolean, WithAggregations extends boolean> = NullableIf<number | bigint, Nullable> | (CommonPrimitiveFilter<number, T, Nullable, WithAggregations> & (WithAggregations extends true ? {
-    _count?: NumberFilter<'Int', false, false>;
-    _avg?: NumberFilter<T, false, false>;
-    _sum?: NumberFilter<T, false, false>;
-    _min?: NumberFilter<T, false, false>;
-    _max?: NumberFilter<T, false, false>;
-} : {}));
+    model: GetModels<Schema>;
+    /**
+     * The mutation action that is being performed.
+     */
+    action: 'create' | 'update' | 'delete';
+    /**
+     * The mutation data. Only available for create and update actions.
+     */
+    queryNode: OperationNode;
+    /**
+     * A query ID that uniquely identifies the mutation operation. You can use it to correlate
+     * data between the before and after mutation hooks.
+     */
+    queryId: QueryId;
+};
+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.
+     *
+     * Mutations initiated from this client will NOT trigger entity mutation hooks to avoid infinite loops.
+     */
+    client: ClientContract<Schema>;
+};
+type PluginAfterEntityMutationArgs<Schema extends SchemaDef> = MutationHooksArgs<Schema> & {
+    /**
+     * 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>;
+};
+type OnKyselyQueryArgs<Schema extends SchemaDef> = {
+    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 ZModelFunctionContext<Schema extends SchemaDef> = {
+    /**
+     * ZenStack client instance
+     */
+    client: ClientContract<Schema>;
+    /**
+     * Database dialect
+     */
+    dialect: BaseCrudDialect<Schema>;
+    /**
+     * The containing model name
+     */
+    model: GetModels<Schema>;
+    /**
+     * The alias name that can be used to refer to the containing model
+     */
+    modelAlias: string;
+    /**
+     * The CRUD operation being performed
+     */
+    operation: CRUD_EXT;
+};
+type ZModelFunction<Schema extends SchemaDef> = (eb: ExpressionBuilder<ToKyselySchema<Schema>, keyof ToKyselySchema<Schema>>, args: Expression<any>[], context: ZModelFunctionContext<Schema>) => Expression<unknown>;
+/**
+ * ZenStack client options.
+ */
+type ClientOptions<Schema extends SchemaDef> = {
+    /**
+     * Kysely dialect.
+     */
+    dialect: Dialect;
+    /**
+     * Custom function definitions.
+     */
+    functions?: Record<string, ZModelFunction<Schema>>;
+    /**
+     * Plugins.
+     */
+    plugins?: RuntimePlugin<Schema>[];
+    /**
+     * Logging configuration.
+     */
+    log?: KyselyConfig['log'];
+    /**
+     * Whether to automatically fix timezone for `DateTime` fields returned by node-pg. Defaults
+     * to `true`.
+     *
+     * Node-pg has a terrible quirk that it interprets the date value as local timezone (as a
+     * `Date` object) although for `DateTime` field the data in DB is stored in UTC.
+     * @see https://github.com/brianc/node-postgres/issues/429
+     */
+    fixPostgresTimezone?: boolean;
+    /**
+     * Whether to enable input validations expressed with attributes like `@email`, `@regex`,
+     * `@@validate`, etc. Defaults to `true`.
+     */
+    validateInput?: boolean;
+    /**
+     * Options for omitting fields in ORM query results.
+     */
+    omit?: OmitOptions<Schema>;
+    /**
+     * Whether to allow overriding omit settings at query time. Defaults to `true`. When set to
+     * `false`, an `omit` clause that sets field to `false` (not omitting) will trigger a validation
+     * error.
+     */
+    allowQueryTimeOmitOverride?: boolean;
+} & (HasComputedFields<Schema> extends true ? {
+    /**
+     * Computed field definitions.
+     */
+    computedFields: ComputedFieldsOptions<Schema>;
+} : {}) & (HasProcedures<Schema> extends true ? {
+    /**
+     * Custom procedure definitions.
+     */
+    procedures: ProceduresOptions<Schema>;
+} : {});
+/**
+ * Options for omitting fields in ORM query results.
+ */
+type OmitOptions<Schema extends SchemaDef> = {
+    [Model in GetModels<Schema>]?: {
+        [Field in GetModelFields<Schema, Model> as Field extends ScalarFields<Schema, Model> ? Field : never]?: boolean;
+    };
+};
+type ComputedFieldsOptions<Schema extends SchemaDef> = {
+    [Model in GetModels<Schema> as 'computedFields' extends keyof GetModel<Schema, Model> ? Model : never]: {
+        [Field in keyof Schema['models'][Model]['computedFields']]: PrependParameter<ExpressionBuilder<ToKyselySchema<Schema>, Model>, Schema['models'][Model]['computedFields'][Field]>;
+    };
+};
+type HasComputedFields<Schema extends SchemaDef> = string extends GetModels<Schema> ? false : keyof ComputedFieldsOptions<Schema> extends never ? false : true;
+type ProceduresOptions<Schema extends SchemaDef> = Schema extends {
+    procedures: Record<string, ProcedureDef>;
+} ? {
+    [Key in keyof Schema['procedures']]: PrependParameter<ClientContract<Schema>, ProcedureFunc<Schema, Schema['procedures'][Key]>>;
+} : {};
+type HasProcedures<Schema extends SchemaDef> = Schema extends {
+    procedures: Record<string, ProcedureDef>;
+} ? true : false;
+
+type DefaultModelResult<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends ClientOptions<Schema> = ClientOptions<Schema>, Omit = undefined, Optional = false, Array = false> = WrapType<IsDelegateModel<Schema, Model> extends true ? DelegateUnionResult<Schema, Model, Options, GetSubModels<Schema, Model>, Omit> : {
+    [Key in NonRelationFields<Schema, Model> as ShouldOmitField<Schema, Model, Options, Key, Omit> extends true ? never : Key]: MapModelFieldType<Schema, Model, Key>;
+}, Optional, Array>;
+type ShouldOmitField<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends ClientOptions<Schema>, Field extends GetModelFields<Schema, Model>, Omit> = QueryLevelOmit<Schema, Model, Field, Omit> extends boolean ? QueryLevelOmit<Schema, Model, Field, Omit> : OptionsLevelOmit<Schema, Model, Field, Options> extends boolean ? OptionsLevelOmit<Schema, Model, Field, Options> : SchemaLevelOmit<Schema, Model, Field>;
+type QueryLevelOmit<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends GetModelFields<Schema, Model>, Omit> = Field extends keyof Omit ? (Omit[Field] extends boolean ? Omit[Field] : undefined) : undefined;
+type OptionsLevelOmit<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends GetModelFields<Schema, Model>, Options extends ClientOptions<Schema>> = Model extends keyof Options['omit'] ? Field extends keyof Options['omit'][Model] ? Options['omit'][Model][Field] extends boolean ? Options['omit'][Model][Field] : undefined : undefined : undefined;
+type SchemaLevelOmit<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends GetModelFields<Schema, Model>> = GetModelField<Schema, Model, Field>['omit'] extends true ? true : false;
+type DelegateUnionResult<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends ClientOptions<Schema>, SubModel extends GetModels<Schema>, Omit = undefined> = SubModel extends string ? DefaultModelResult<Schema, SubModel, Options, Omit> & {
+    [K in GetModelDiscriminator<Schema, Model>]: SubModel;
+} : never;
+type ModelSelectResult<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends ClientOptions<Schema>, Select, Omit> = {
+    [Key in keyof Select as Select[Key] extends false | undefined ? never : Key extends keyof Omit ? Omit[Key] extends true ? never : Key : Key extends '_count' ? Select[Key] extends SelectCount<Schema, Model> ? Key : never : Key]: Key extends '_count' ? SelectCountResult<Schema, Model, Select[Key]> : Key extends NonRelationFields<Schema, Model> ? MapModelFieldType<Schema, Model, Key> : Key extends RelationFields<Schema, Model> ? Select[Key] extends FindArgs<Schema, RelationFieldType<Schema, Model, Key>, FieldIsArray<Schema, Model, Key>> ? 'select' extends keyof Select[Key] ? ModelResult<Schema, RelationFieldType<Schema, Model, Key>, Options, Pick<Select[Key], 'select'>, ModelFieldIsOptional<Schema, Model, Key>, FieldIsArray<Schema, Model, Key>> : ModelResult<Schema, RelationFieldType<Schema, Model, Key>, Options, Pick<Select[Key], 'include' | 'omit'>, ModelFieldIsOptional<Schema, Model, Key>, FieldIsArray<Schema, Model, Key>> : DefaultModelResult<Schema, RelationFieldType<Schema, Model, Key>, Options, Omit, ModelFieldIsOptional<Schema, Model, Key>, FieldIsArray<Schema, Model, Key>> : never;
+};
+type 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;
+} : C extends {
+    select: infer S;
+} ? {
+    [Key in keyof S]: number;
+} : never;
+type ModelResult<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends ClientOptions<Schema> = ClientOptions<Schema>, Args = {}, Optional = false, Array = false> = WrapType<Args extends {
+    select: infer S;
+    omit?: infer O;
+} ? ModelSelectResult<Schema, Model, Options, S, O> : Args extends {
+    include: infer I;
+    omit?: infer O;
+} ? DefaultModelResult<Schema, Model, Options, O> & {
+    [Key in keyof I & RelationFields<Schema, Model> as I[Key] extends false | undefined ? never : Key]: I[Key] extends FindArgs<Schema, RelationFieldType<Schema, Model, Key>, FieldIsArray<Schema, Model, Key>> ? ModelResult<Schema, RelationFieldType<Schema, Model, Key>, Options, I[Key], ModelFieldIsOptional<Schema, Model, Key>, FieldIsArray<Schema, Model, Key>> : DefaultModelResult<Schema, RelationFieldType<Schema, Model, Key>, Options, undefined, ModelFieldIsOptional<Schema, Model, Key>, FieldIsArray<Schema, Model, Key>>;
+} : Args extends {
+    omit: infer O;
+} ? DefaultModelResult<Schema, Model, Options, O> : DefaultModelResult<Schema, Model, Options>, Optional, Array>;
+type SimplifiedModelResult<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends ClientOptions<Schema>, Args = {}, Optional = false, Array = false> = Simplify<ModelResult<Schema, Model, Options, Args, Optional, Array>>;
+type TypeDefResult<Schema extends SchemaDef, TypeDef extends GetTypeDefs<Schema>, Partial extends boolean = false> = PartialIf<Optional<{
+    [Key in GetTypeDefFields<Schema, TypeDef>]: MapFieldDefType<Schema, GetTypeDefField<Schema, TypeDef, Key>, Partial>;
+}, Partial extends true ? never : keyof {
+    [Key in GetTypeDefFields<Schema, TypeDef> as TypeDefFieldIsOptional<Schema, TypeDef, Key> extends true ? Key : never]: true;
+}>, Partial> & Record<string, unknown>;
+type BatchResult = {
+    count: number;
+};
+type WhereInput<Schema extends SchemaDef, Model extends GetModels<Schema>, ScalarOnly extends boolean = false, WithAggregations extends boolean = false> = {
+    [Key in GetModelFields<Schema, Model> as ScalarOnly extends true ? Key extends RelationFields<Schema, Model> ? never : Key : Key]?: Key extends RelationFields<Schema, Model> ? RelationFilter<Schema, Model, Key> : FieldIsArray<Schema, Model, Key> extends true ? ArrayFilter<Schema, GetModelFieldType<Schema, Model, Key>> : GetModelFieldType<Schema, Model, Key> extends GetEnums<Schema> ? EnumFilter<Schema, GetModelFieldType<Schema, Model, Key>, ModelFieldIsOptional<Schema, Model, Key>, WithAggregations> : PrimitiveFilter<GetModelFieldType<Schema, Model, Key>, ModelFieldIsOptional<Schema, Model, Key>, WithAggregations>;
+} & {
+    $expr?: (eb: ExpressionBuilder<ToKyselySchema<Schema>, Model>) => OperandExpression<SqlBool>;
+} & {
+    AND?: OrArray<WhereInput<Schema, Model, ScalarOnly>>;
+    OR?: WhereInput<Schema, Model, ScalarOnly>[];
+    NOT?: OrArray<WhereInput<Schema, Model, ScalarOnly>>;
+};
+type EnumFilter<Schema extends SchemaDef, T extends GetEnums<Schema>, Nullable extends boolean, WithAggregations extends boolean> = NullableIf<keyof GetEnum<Schema, T>, Nullable> | ({
+    equals?: NullableIf<keyof GetEnum<Schema, T>, Nullable>;
+    in?: (keyof GetEnum<Schema, T>)[];
+    notIn?: (keyof GetEnum<Schema, T>)[];
+    not?: EnumFilter<Schema, T, Nullable, WithAggregations>;
+} & (WithAggregations extends true ? {
+    _count?: NumberFilter<'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 MapScalarType<Schema extends SchemaDef, T extends string> = T extends GetEnums<Schema> ? keyof GetEnum<Schema, T> : MapBaseType$1<T>;
+type PrimitiveFilter<T extends string, Nullable extends boolean, WithAggregations extends boolean> = T extends 'String' ? StringFilter<Nullable, WithAggregations> : T extends 'Int' | 'Float' | 'Decimal' | 'BigInt' ? NumberFilter<T, Nullable, WithAggregations> : T extends 'Boolean' ? BooleanFilter<Nullable, WithAggregations> : T extends 'DateTime' ? DateTimeFilter<Nullable, WithAggregations> : T extends 'Bytes' ? BytesFilter<Nullable, WithAggregations> : T extends 'Json' ? 'Not implemented yet' : never;
+type CommonPrimitiveFilter<DataType, T extends BuiltinType, Nullable extends boolean, WithAggregations extends boolean> = {
+    equals?: NullableIf<DataType, Nullable>;
+    in?: DataType[];
+    notIn?: DataType[];
+    lt?: DataType;
+    lte?: DataType;
+    gt?: DataType;
+    gte?: DataType;
+    not?: PrimitiveFilter<T, Nullable, WithAggregations>;
+};
+type StringFilter<Nullable extends boolean, WithAggregations extends boolean> = NullableIf<string, Nullable> | (CommonPrimitiveFilter<string, 'String', Nullable, WithAggregations> & {
+    contains?: string;
+    startsWith?: string;
+    endsWith?: string;
+    /**
+     * Not effective for "sqlite" provider
+     */
+    mode?: 'default' | 'insensitive';
+} & (WithAggregations extends true ? {
+    _count?: NumberFilter<'Int', false, false>;
+    _min?: StringFilter<false, false>;
+    _max?: StringFilter<false, false>;
+} : {}));
+type NumberFilter<T extends 'Int' | 'Float' | 'Decimal' | 'BigInt', Nullable extends boolean, WithAggregations extends boolean> = NullableIf<number | bigint, Nullable> | (CommonPrimitiveFilter<number, T, Nullable, WithAggregations> & (WithAggregations extends true ? {
+    _count?: NumberFilter<'Int', false, false>;
+    _avg?: NumberFilter<T, false, false>;
+    _sum?: NumberFilter<T, false, false>;
+    _min?: NumberFilter<T, false, false>;
+    _max?: NumberFilter<T, false, false>;
+} : {}));
 type DateTimeFilter<Nullable extends boolean, WithAggregations extends boolean> = NullableIf<Date | string, Nullable> | (CommonPrimitiveFilter<Date | string, 'DateTime', Nullable, WithAggregations> & (WithAggregations extends true ? {
     _count?: NumberFilter<'Int', false, false>;
     _min?: DateTimeFilter<false, false>;
@@ -371,8 +716,7 @@ type ToOneRelationFilter<Schema extends SchemaDef, Model extends GetModels<Schem
 }, 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 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 MapFieldDefType<Schema extends SchemaDef, T extends Pick<FieldDef, 'type' | 'optional' | 'array'>, Partial extends boolean = false> = WrapType<T['type'] extends GetEnums<Schema> ? keyof GetEnum<Schema, T['type']> : T['type'] extends GetTypeDefs<Schema> ? TypeDefResult<Schema, T['type'], Partial> & Record<string, unknown> : MapBaseType$1<T['type']>, T['optional'], T['array']>;
 type OptionalFieldsForCreate<Schema extends SchemaDef, Model extends GetModels<Schema>> = keyof {
     [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>;
 };
@@ -491,464 +835,143 @@ type ToOneRelationUpdateInput<Schema extends SchemaDef, Model extends GetModels<
     update?: NestedUpdateInput<Schema, Model, Field>;
     upsert?: NestedUpsertInput<Schema, Model, Field>;
 } & (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>;
-} & SelectIncludeOmit<Schema, Model, true>;
-type DeleteManyArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
-    where?: WhereInput<Schema, Model>;
-    limit?: number;
-};
-type CountArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = Omit<FindArgs<Schema, Model, true>, 'select' | 'include' | 'distinct' | 'omit'> & {
-    select?: CountAggregateInput<Schema, Model> | true;
-};
-type CountAggregateInput<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
-    [Key in NonRelationFields<Schema, Model>]?: true;
-} & {
-    _all?: true;
-};
-type CountResult<Schema extends SchemaDef, _Model extends GetModels<Schema>, Args> = Args extends {
-    select: infer S;
-} ? S extends true ? number : {
-    [Key in keyof S]: number;
-} : number;
-type AggregateArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
-    where?: WhereInput<Schema, Model>;
-    skip?: number;
-    take?: number;
-    orderBy?: OrArray<OrderBy<Schema, Model, true, false>>;
-} & {
-    _count?: true | CountAggregateInput<Schema, Model>;
-    _min?: MinMaxInput<Schema, Model, true>;
-    _max?: MinMaxInput<Schema, Model, true>;
-} & (NumericFields<Schema, Model> extends never ? {} : {
-    _avg?: SumAvgInput<Schema, Model, true>;
-    _sum?: SumAvgInput<Schema, Model, true>;
-});
-type NumericFields<Schema extends SchemaDef, Model extends GetModels<Schema>> = keyof {
-    [Key in GetModelFields<Schema, Model> as GetModelFieldType<Schema, Model, Key> extends '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>, ValueType> = {
-    [Key in NumericFields<Schema, Model>]?: ValueType;
-};
-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> = (Args extends {
-    _count: infer Count;
-} ? {
-    _count: AggCommonOutput<Count>;
-} : {}) & (Args extends {
-    _sum: infer Sum;
-} ? {
-    _sum: AggCommonOutput<Sum>;
-} : {}) & (Args extends {
-    _avg: infer Avg;
-} ? {
-    _avg: AggCommonOutput<Avg>;
-} : {}) & (Args extends {
-    _min: infer Min;
-} ? {
-    _min: AggCommonOutput<Min>;
-} : {}) & (Args extends {
-    _max: infer Max;
-} ? {
-    _max: AggCommonOutput<Max>;
-} : {});
-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?: 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, true>;
-    _sum?: SumAvgInput<Schema, Model, true>;
-});
-type GroupByResult<Schema extends SchemaDef, Model extends GetModels<Schema>, Args extends {
-    by: unknown;
-}> = Array<{
-    [Key in NonRelationFields<Schema, Model> as Key extends ValueOfPotentialTuple<Args['by']> ? Key : never]: MapModelFieldType<Schema, Model, Key>;
-} & (Args extends {
-    _count: infer Count;
-} ? {
-    _count: AggCommonOutput<Count>;
-} : {}) & (Args extends {
-    _avg: infer Avg;
-} ? {
-    _avg: AggCommonOutput<Avg>;
-} : {}) & (Args extends {
-    _sum: infer Sum;
-} ? {
-    _sum: AggCommonOutput<Sum>;
-} : {}) & (Args extends {
-    _min: infer Min;
-} ? {
-    _min: AggCommonOutput<Min>;
-} : {}) & (Args extends {
-    _max: infer Max;
-} ? {
-    _max: AggCommonOutput<Max>;
-} : {})>;
-type ConnectInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>> = FieldIsArray<Schema, Model, Field> extends true ? OrArray<WhereUniqueInput<Schema, RelationFieldType<Schema, Model, Field>>> : WhereUniqueInput<Schema, RelationFieldType<Schema, Model, Field>>;
-type ConnectOrCreateInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>> = FieldIsArray<Schema, Model, Field> extends true ? OrArray<ConnectOrCreatePayload<Schema, RelationFieldType<Schema, Model, Field>, OppositeRelationAndFK<Schema, Model, Field>>> : ConnectOrCreatePayload<Schema, RelationFieldType<Schema, Model, Field>, OppositeRelationAndFK<Schema, Model, Field>>;
-type DisconnectInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>> = FieldIsArray<Schema, Model, Field> extends true ? OrArray<WhereUniqueInput<Schema, RelationFieldType<Schema, Model, Field>>, true> : boolean | WhereInput<Schema, RelationFieldType<Schema, Model, Field>>;
-type SetRelationInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>> = OrArray<WhereUniqueInput<Schema, RelationFieldType<Schema, Model, Field>>>;
-type NestedUpdateInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>> = FieldIsArray<Schema, Model, Field> extends true ? OrArray<{
-    where: WhereUniqueInput<Schema, RelationFieldType<Schema, Model, Field>>;
-    data: UpdateInput<Schema, RelationFieldType<Schema, Model, Field>, OppositeRelationAndFK<Schema, Model, Field>>;
-}, true> : XOR<{
-    where: WhereUniqueInput<Schema, RelationFieldType<Schema, Model, Field>>;
-    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, 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 ProviderSupportsDistinct<Schema extends SchemaDef> = Schema['provider']['type'] extends 'postgresql' ? true : false;
-
-declare abstract class BaseCrudDialect<Schema extends SchemaDef> {
-    protected readonly schema: Schema;
-    protected readonly options: ClientOptions<Schema>;
-    protected eb: ExpressionBuilder<any, any>;
-    constructor(schema: Schema, options: ClientOptions<Schema>);
-    transformPrimitive(value: unknown, _type: BuiltinType, _forArrayField: boolean): unknown;
-    transformOutput(value: unknown, _type: BuiltinType): unknown;
-    buildSelectModel(model: string, modelAlias: string): SelectQueryBuilder<any, any, {}>;
-    buildFilterSortTake(model: string, args: FindArgs<Schema, GetModels<Schema>, true>, query: SelectQueryBuilder<any, any, {}>, modelAlias: string): SelectQueryBuilder<any, any, {}>;
-    buildFilter(model: string, modelAlias: string, where: boolean | object | undefined): Expression<SqlBool>;
-    private buildCursorFilter;
-    private isLogicalCombinator;
-    protected buildCompositeFilter(model: string, modelAlias: string, key: (typeof LOGICAL_COMBINATORS)[number], payload: any): Expression<SqlBool>;
-    private buildRelationFilter;
-    private buildToOneRelationFilter;
-    private buildToManyRelationFilter;
-    private buildArrayFilter;
-    buildPrimitiveFilter(fieldRef: Expression<any>, fieldDef: FieldDef, payload: any): Expression<SqlBool>;
-    private buildLiteralFilter;
-    private buildStandardFilter;
-    private buildStringFilter;
-    private prepStringCasing;
-    private buildNumberFilter;
-    private buildBooleanFilter;
-    private buildDateTimeFilter;
-    private buildBytesFilter;
-    private buildEnumFilter;
-    buildOrderBy(query: SelectQueryBuilder<any, any, any>, model: string, modelAlias: string, orderBy: OrArray<OrderBy<Schema, GetModels<Schema>, boolean, boolean>> | undefined, negated: boolean): SelectQueryBuilder<any, any, any>;
-    buildSelectAllFields(model: string, query: SelectQueryBuilder<any, any, any>, omit: Record<string, boolean | undefined> | undefined | null, modelAlias: string): SelectQueryBuilder<any, any, any>;
-    protected buildModelSelect(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(): Expression<SqlBool>;
-    false(): Expression<SqlBool>;
-    isTrue(expression: Expression<SqlBool>): boolean;
-    isFalse(expression: Expression<SqlBool>): boolean;
-    and(...args: Expression<SqlBool>[]): Expression<SqlBool>;
-    or(...args: Expression<SqlBool>[]): Expression<SqlBool>;
-    not(...args: Expression<SqlBool>[]): ExpressionWrapper<any, any, SqlBool>;
-    fieldRef(model: string, field: string, modelAlias?: string, inlineComputedField?: boolean): any;
-    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.
-     */
-    abstract buildJsonObject(value: Record<string, Expression<unknown>>): ExpressionWrapper<any, any, unknown>;
-    /**
-     * Builds an Kysely expression that returns the length of an array.
-     */
-    abstract buildArrayLength(array: Expression<unknown>): ExpressionWrapper<any, any, number>;
-    /**
-     * Builds an array literal SQL string for the given values.
-     */
-    abstract buildArrayLiteralSQL(values: unknown[]): string;
-    /**
-     * Whether the dialect supports updating with a limit on the number of updated rows.
-     */
-    abstract get supportsUpdateWithLimit(): boolean;
-    /**
-     * Whether the dialect supports deleting with a limit on the number of deleted rows.
-     */
-    abstract get supportsDeleteWithLimit(): boolean;
-    /**
-     * Whether the dialect supports DISTINCT ON.
-     */
-    abstract get supportsDistinctOn(): boolean;
-    /**
-     * Whether the dialect support inserting with `DEFAULT` as field value.
-     */
-    abstract get supportInsertWithDefault(): boolean;
-    /**
-     * Gets the SQL column type for the given field definition.
-     */
-    abstract getFieldSqlType(fieldDef: FieldDef): string;
-    abstract getStringCasingBehavior(): {
-        supportsILike: boolean;
-        likeCaseSensitive: boolean;
-    };
-}
-
-type CoreCrudOperation = 'findMany' | 'findUnique' | 'findFirst' | 'create' | 'createMany' | 'createManyAndReturn' | 'update' | 'updateMany' | 'updateManyAndReturn' | 'upsert' | 'delete' | 'deleteMany' | 'count' | 'aggregate' | 'groupBy';
-type AllCrudOperation = CoreCrudOperation | 'findUniqueOrThrow' | 'findFirstOrThrow';
-
-/**
- * ZenStack runtime plugin.
- */
-interface RuntimePlugin<Schema extends SchemaDef = SchemaDef> {
-    /**
-     * Plugin ID.
-     */
-    id: string;
-    /**
-     * Plugin display name.
-     */
-    name?: string;
-    /**
-     * Plugin description.
-     */
-    description?: string;
-    /**
-     * Custom function implementations.
-     */
-    functions?: Record<string, ZModelFunction<Schema>>;
-    /**
-     * Intercepts an ORM query.
-     */
-    onQuery?: OnQueryCallback<Schema>;
-    /**
-     * Intercepts an entity mutation.
-     */
-    onEntityMutation?: EntityMutationHooksDef<Schema>;
-    /**
-     * Intercepts a Kysely query.
-     */
-    onKyselyQuery?: OnKyselyQueryCallback<Schema>;
-}
-/**
- * Defines a ZenStack runtime plugin.
- */
-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> = {
-    /**
-     * The model that is being queried.
-     */
-    model: GetModels<Schema>;
-    /**
-     * The operation that is being performed.
-     */
-    operation: AllCrudOperation;
-    /**
-     * The query arguments.
-     */
-    args: unknown;
-    /**
-     * The function to proceed with the original query.
-     * It takes the same arguments as the operation method.
-     *
-     * @param args The query arguments.
-     */
-    proceed: (args: unknown) => Promise<unknown>;
-    /**
-     * The ZenStack client that is performing the operation.
-     */
-    client: ClientContract<Schema>;
-};
-type EntityMutationHooksDef<Schema extends SchemaDef> = {
-    /**
-     * Called before entities are mutated.
-     */
-    beforeEntityMutation?: BeforeEntityMutationCallback<Schema>;
-    /**
-     * Called after entities are mutated.
-     */
-    afterEntityMutation?: AfterEntityMutationCallback<Schema>;
-    /**
-     * 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`.
-     */
-    runAfterMutationWithinTransaction?: boolean;
-};
-type MutationHooksArgs<Schema extends SchemaDef> = {
-    /**
-     * The model that is being mutated.
-     */
-    model: GetModels<Schema>;
-    /**
-     * The mutation action that is being performed.
-     */
-    action: 'create' | 'update' | 'delete';
-    /**
-     * The mutation data. Only available for create and update actions.
-     */
-    queryNode: OperationNode;
-    /**
-     * A query ID that uniquely identifies the mutation operation. You can use it to correlate
-     * data between the before and after mutation hooks.
-     */
-    queryId: QueryId;
+    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>;
+} & SelectIncludeOmit<Schema, Model, true>;
+type DeleteManyArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
+    where?: WhereInput<Schema, Model>;
+    limit?: number;
 };
-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.
-     *
-     * Mutations initiated from this client will NOT trigger entity mutation hooks to avoid infinite loops.
-     */
-    client: ClientContract<Schema>;
+type CountArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = Omit<FindArgs<Schema, Model, true>, 'select' | 'include' | 'distinct' | 'omit'> & {
+    select?: CountAggregateInput<Schema, Model> | true;
 };
-type PluginAfterEntityMutationArgs<Schema extends SchemaDef> = MutationHooksArgs<Schema> & {
-    /**
-     * 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>;
+type CountAggregateInput<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
+    [Key in NonRelationFields<Schema, Model>]?: true;
+} & {
+    _all?: true;
 };
-type OnKyselyQueryArgs<Schema extends SchemaDef> = {
-    schema: SchemaDef;
-    client: ClientContract<Schema>;
-    query: RootOperationNode;
-    proceed: ProceedKyselyQueryFunction;
+type CountResult<Schema extends SchemaDef, _Model extends GetModels<Schema>, Args> = Args extends {
+    select: infer S;
+} ? S extends true ? number : {
+    [Key in keyof S]: number;
+} : number;
+type AggregateArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
+    where?: WhereInput<Schema, Model>;
+    skip?: number;
+    take?: number;
+    orderBy?: OrArray<OrderBy<Schema, Model, true, false>>;
+} & {
+    _count?: true | CountAggregateInput<Schema, Model>;
+    _min?: MinMaxInput<Schema, Model, true>;
+    _max?: MinMaxInput<Schema, Model, true>;
+} & (NumericFields<Schema, Model> extends never ? {} : {
+    _avg?: SumAvgInput<Schema, Model, true>;
+    _sum?: SumAvgInput<Schema, Model, true>;
+});
+type NumericFields<Schema extends SchemaDef, Model extends GetModels<Schema>> = keyof {
+    [Key in GetModelFields<Schema, Model> as GetModelFieldType<Schema, Model, Key> extends 'Int' | 'Float' | 'BigInt' | 'Decimal' ? FieldIsArray<Schema, Model, Key> extends true ? never : Key : never]: GetModelField<Schema, Model, Key>;
 };
-type ProceedKyselyQueryFunction = (query: RootOperationNode) => Promise<QueryResult<any>>;
-type OnKyselyQueryCallback<Schema extends SchemaDef> = (args: OnKyselyQueryArgs<Schema>) => Promise<QueryResult<UnknownRow>>;
-
-type ZModelFunctionContext<Schema extends SchemaDef> = {
-    /**
-     * ZenStack client instance
-     */
-    client: ClientContract<Schema>;
-    /**
-     * Database dialect
-     */
-    dialect: BaseCrudDialect<Schema>;
-    /**
-     * The containing model name
-     */
-    model: GetModels<Schema>;
-    /**
-     * The alias name that can be used to refer to the containing model
-     */
-    modelAlias: string;
-    /**
-     * The CRUD operation being performed
-     */
-    operation: CRUD_EXT;
+type SumAvgInput<Schema extends SchemaDef, Model extends GetModels<Schema>, ValueType> = {
+    [Key in NumericFields<Schema, Model>]?: ValueType;
 };
-type ZModelFunction<Schema extends SchemaDef> = (eb: ExpressionBuilder<ToKyselySchema<Schema>, keyof ToKyselySchema<Schema>>, args: Expression<any>[], context: ZModelFunctionContext<Schema>) => Expression<unknown>;
-/**
- * ZenStack client options.
- */
-type ClientOptions<Schema extends SchemaDef> = {
-    /**
-     * Kysely dialect.
-     */
-    dialect: Dialect;
-    /**
-     * Custom function definitions.
-     */
-    functions?: Record<string, ZModelFunction<Schema>>;
-    /**
-     * Plugins.
-     */
-    plugins?: RuntimePlugin<Schema>[];
-    /**
-     * Logging configuration.
-     */
-    log?: KyselyConfig['log'];
-    /**
-     * Whether to automatically fix timezone for `DateTime` fields returned by node-pg. Defaults
-     * to `true`.
-     *
-     * Node-pg has a terrible quirk that it interprets the date value as local timezone (as a
-     * `Date` object) although for `DateTime` field the data in DB is stored in UTC.
-     * @see https://github.com/brianc/node-postgres/issues/429
-     */
-    fixPostgresTimezone?: boolean;
-    /**
-     * Whether to enable input validations expressed with attributes like `@email`, `@regex`,
-     * `@@validate`, etc. Defaults to `true`.
-     */
-    validateInput?: boolean;
-} & (HasComputedFields<Schema> extends true ? {
-    /**
-     * Computed field definitions.
-     */
-    computedFields: ComputedFieldsOptions<Schema>;
-} : {}) & (HasProcedures<Schema> extends true ? {
-    /**
-     * Custom procedure definitions.
-     */
-    procedures: ProceduresOptions<Schema>;
-} : {});
-type ComputedFieldsOptions<Schema extends SchemaDef> = {
-    [Model in GetModels<Schema> as 'computedFields' extends keyof GetModel<Schema, Model> ? Model : never]: {
-        [Field in keyof Schema['models'][Model]['computedFields']]: PrependParameter<ExpressionBuilder<ToKyselySchema<Schema>, Model>, Schema['models'][Model]['computedFields'][Field]>;
-    };
+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 HasComputedFields<Schema extends SchemaDef> = string extends GetModels<Schema> ? false : keyof ComputedFieldsOptions<Schema> extends never ? false : true;
-type ProceduresOptions<Schema extends SchemaDef> = Schema extends {
-    procedures: Record<string, ProcedureDef>;
+type AggregateResult<Schema extends SchemaDef, _Model extends GetModels<Schema>, Args> = (Args extends {
+    _count: infer Count;
 } ? {
-    [Key in keyof Schema['procedures']]: PrependParameter<ClientContract<Schema>, ProcedureFunc<Schema, Schema['procedures'][Key]>>;
-} : {};
-type HasProcedures<Schema extends SchemaDef> = Schema extends {
-    procedures: Record<string, ProcedureDef>;
-} ? true : false;
+    _count: AggCommonOutput<Count>;
+} : {}) & (Args extends {
+    _sum: infer Sum;
+} ? {
+    _sum: AggCommonOutput<Sum>;
+} : {}) & (Args extends {
+    _avg: infer Avg;
+} ? {
+    _avg: AggCommonOutput<Avg>;
+} : {}) & (Args extends {
+    _min: infer Min;
+} ? {
+    _min: AggCommonOutput<Min>;
+} : {}) & (Args extends {
+    _max: infer Max;
+} ? {
+    _max: AggCommonOutput<Max>;
+} : {});
+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?: 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, true>;
+    _sum?: SumAvgInput<Schema, Model, true>;
+});
+type GroupByResult<Schema extends SchemaDef, Model extends GetModels<Schema>, Args extends {
+    by: unknown;
+}> = Array<{
+    [Key in NonRelationFields<Schema, Model> as Key extends ValueOfPotentialTuple<Args['by']> ? Key : never]: MapModelFieldType<Schema, Model, Key>;
+} & (Args extends {
+    _count: infer Count;
+} ? {
+    _count: AggCommonOutput<Count>;
+} : {}) & (Args extends {
+    _avg: infer Avg;
+} ? {
+    _avg: AggCommonOutput<Avg>;
+} : {}) & (Args extends {
+    _sum: infer Sum;
+} ? {
+    _sum: AggCommonOutput<Sum>;
+} : {}) & (Args extends {
+    _min: infer Min;
+} ? {
+    _min: AggCommonOutput<Min>;
+} : {}) & (Args extends {
+    _max: infer Max;
+} ? {
+    _max: AggCommonOutput<Max>;
+} : {})>;
+type ConnectInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>> = FieldIsArray<Schema, Model, Field> extends true ? OrArray<WhereUniqueInput<Schema, RelationFieldType<Schema, Model, Field>>> : WhereUniqueInput<Schema, RelationFieldType<Schema, Model, Field>>;
+type ConnectOrCreateInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>> = FieldIsArray<Schema, Model, Field> extends true ? OrArray<ConnectOrCreatePayload<Schema, RelationFieldType<Schema, Model, Field>, OppositeRelationAndFK<Schema, Model, Field>>> : ConnectOrCreatePayload<Schema, RelationFieldType<Schema, Model, Field>, OppositeRelationAndFK<Schema, Model, Field>>;
+type DisconnectInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>> = FieldIsArray<Schema, Model, Field> extends true ? OrArray<WhereUniqueInput<Schema, RelationFieldType<Schema, Model, Field>>, true> : boolean | WhereInput<Schema, RelationFieldType<Schema, Model, Field>>;
+type SetRelationInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>> = OrArray<WhereUniqueInput<Schema, RelationFieldType<Schema, Model, Field>>>;
+type NestedUpdateInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>> = FieldIsArray<Schema, Model, Field> extends true ? OrArray<{
+    where: WhereUniqueInput<Schema, RelationFieldType<Schema, Model, Field>>;
+    data: UpdateInput<Schema, RelationFieldType<Schema, Model, Field>, OppositeRelationAndFK<Schema, Model, Field>>;
+}, true> : XOR<{
+    where: WhereUniqueInput<Schema, RelationFieldType<Schema, Model, Field>>;
+    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, 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 ProviderSupportsDistinct<Schema extends SchemaDef> = Schema['provider']['type'] extends 'postgresql' ? true : false;
 
 /**
  * A promise that only executes when it's awaited or .then() is called.
@@ -975,12 +998,15 @@ declare enum TransactionIsolationLevel {
 /**
  * ZenStack client interface.
  */
-type ClientContract<Schema extends SchemaDef> = {
+type ClientContract<Schema extends SchemaDef, Options extends ClientOptions<Schema> = ClientOptions<Schema>> = {
+    /**
+     * The schema definition.
+     */
     readonly $schema: Schema;
     /**
      * The client options.
      */
-    readonly $options: ClientOptions<Schema>;
+    readonly $options: Options;
     /**
      * Executes a prepared raw query and returns the number of affected rows.
      * @example
@@ -1022,12 +1048,22 @@ type ClientContract<Schema extends SchemaDef> = {
     /**
      * Sets the current user identity.
      */
-    $setAuth(auth: AuthType<Schema> | undefined): ClientContract<Schema>;
+    $setAuth(auth: AuthType<Schema> | undefined): ClientContract<Schema, Options>;
+    /**
+     * Returns a new client with new options applied.
+     * @example
+     * ```
+     * const dbNoValidation = db.$setOptions({ ...db.$options, validateInput: false });
+     * ```
+     */
+    $setOptions<Options extends ClientOptions<Schema>>(options: Options): ClientContract<Schema, Options>;
     /**
      * Returns a new client enabling/disabling input validations expressed with attributes like
      * `@email`, `@regex`, `@@validate`, etc.
+     *
+     * @deprecated Use `$setOptions` instead.
      */
-    $setInputValidation(enable: boolean): ClientContract<Schema>;
+    $setInputValidation(enable: boolean): ClientContract<Schema, Options>;
     /**
      * The Kysely query builder instance.
      */
@@ -1039,7 +1075,7 @@ type ClientContract<Schema extends SchemaDef> = {
     /**
      * Starts an interactive transaction.
      */
-    $transaction<T>(callback: (tx: Omit<ClientContract<Schema>, TransactionUnsupportedMethods>) => Promise<T>, options?: {
+    $transaction<T>(callback: (tx: Omit<ClientContract<Schema, Options>, TransactionUnsupportedMethods>) => Promise<T>, options?: {
         isolationLevel?: TransactionIsolationLevel;
     }): Promise<T>;
     /**
@@ -1051,15 +1087,15 @@ type ClientContract<Schema extends SchemaDef> = {
     /**
      * Returns a new client with the specified plugin installed.
      */
-    $use(plugin: RuntimePlugin<Schema>): ClientContract<Schema>;
+    $use(plugin: RuntimePlugin<Schema>): ClientContract<Schema, Options>;
     /**
      * Returns a new client with the specified plugin removed.
      */
-    $unuse(pluginId: string): ClientContract<Schema>;
+    $unuse(pluginId: string): ClientContract<Schema, Options>;
     /**
      * Returns a new client with all plugins removed.
      */
-    $unuseAll(): ClientContract<Schema>;
+    $unuseAll(): ClientContract<Schema, Options>;
     /**
      * Eagerly connects to the database.
      */
@@ -1074,12 +1110,12 @@ type ClientContract<Schema extends SchemaDef> = {
      */
     $pushSchema(): Promise<void>;
 } & {
-    [Key in GetModels<Schema> as Uncapitalize<Key>]: ModelOperations<Schema, Key>;
+    [Key in GetModels<Schema> as Uncapitalize<Key>]: ModelOperations<Schema, Key, Options>;
 } & Procedures<Schema>;
 /**
  * The contract for a client in a transaction.
  */
-type TransactionClientContract<Schema extends SchemaDef> = Omit<ClientContract<Schema>, TransactionUnsupportedMethods>;
+type TransactionClientContract<Schema extends SchemaDef, Options extends ClientOptions<Schema>> = Omit<ClientContract<Schema, Options>, TransactionUnsupportedMethods>;
 type _TypeMap = {
     String: string;
     Int: number;
@@ -1107,7 +1143,7 @@ type MapProcedureParams<Schema extends SchemaDef, Params> = {
  * Creates a new ZenStack client instance.
  */
 interface ClientConstructor {
-    new <Schema extends SchemaDef>(schema: Schema, options: ClientOptions<Schema>): ClientContract<Schema>;
+    new <Schema extends SchemaDef, Options extends ClientOptions<Schema>>(schema: Schema, options: Options): ClientContract<Schema, Options>;
 }
 /**
  * CRUD operations.
@@ -1125,7 +1161,7 @@ type CRUD_EXT = CRUD | 'post-update';
  * Extended CRUD operations including 'post-update'.
  */
 declare const CRUD_EXT: readonly ["create", "read", "update", "delete", "post-update"];
-type AllModelOperations<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
+type AllModelOperations<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends ClientOptions<Schema>> = {
     /**
      * Returns a list of entities.
      * @param args - query args
@@ -1207,35 +1243,35 @@ type AllModelOperations<Schema extends SchemaDef, Model extends GetModels<Schema
      * }); // result: `{ _count: { posts: number } }`
      * ```
      */
-    findMany<T extends FindManyArgs<Schema, Model>>(args?: SelectSubset<T, FindManyArgs<Schema, Model>>): ZenStackPromise<Schema, SimplifiedModelResult<Schema, Model, T>[]>;
+    findMany<T extends FindManyArgs<Schema, Model>>(args?: SelectSubset<T, FindManyArgs<Schema, Model>>): ZenStackPromise<Schema, SimplifiedModelResult<Schema, Model, Options, 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>>): ZenStackPromise<Schema, SimplifiedModelResult<Schema, Model, T> | null>;
+    findUnique<T extends FindUniqueArgs<Schema, Model>>(args: SelectSubset<T, FindUniqueArgs<Schema, Model>>): ZenStackPromise<Schema, SimplifiedModelResult<Schema, Model, Options, 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>>): ZenStackPromise<Schema, SimplifiedModelResult<Schema, Model, T>>;
+    findUniqueOrThrow<T extends FindUniqueArgs<Schema, Model>>(args: SelectSubset<T, FindUniqueArgs<Schema, Model>>): ZenStackPromise<Schema, SimplifiedModelResult<Schema, Model, Options, T>>;
     /**
      * Returns the first entity.
      * @param args - query args
      * @returns a single entity or null if not found
      * @see {@link findMany}
      */
-    findFirst<T extends FindFirstArgs<Schema, Model>>(args?: SelectSubset<T, FindFirstArgs<Schema, Model>>): ZenStackPromise<Schema, SimplifiedModelResult<Schema, Model, T> | null>;
+    findFirst<T extends FindFirstArgs<Schema, Model>>(args?: SelectSubset<T, FindFirstArgs<Schema, Model>>): ZenStackPromise<Schema, SimplifiedModelResult<Schema, Model, Options, 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 FindFirstArgs<Schema, Model>>(args?: SelectSubset<T, FindFirstArgs<Schema, Model>>): ZenStackPromise<Schema, SimplifiedModelResult<Schema, Model, T>>;
+    findFirstOrThrow<T extends FindFirstArgs<Schema, Model>>(args?: SelectSubset<T, FindFirstArgs<Schema, Model>>): ZenStackPromise<Schema, SimplifiedModelResult<Schema, Model, Options, T>>;
     /**
      * Creates a new entity.
      * @param args - create args
@@ -1288,7 +1324,7 @@ type AllModelOperations<Schema extends SchemaDef, Model extends GetModels<Schema
      * });
      * ```
      */
-    create<T extends CreateArgs<Schema, Model>>(args: SelectSubset<T, CreateArgs<Schema, Model>>): ZenStackPromise<Schema, SimplifiedModelResult<Schema, Model, T>>;
+    create<T extends CreateArgs<Schema, Model>>(args: SelectSubset<T, CreateArgs<Schema, Model>>): ZenStackPromise<Schema, SimplifiedModelResult<Schema, Model, Options, T>>;
     /**
      * Creates multiple entities. Only scalar fields are allowed.
      * @param args - create args
@@ -1333,7 +1369,7 @@ type AllModelOperations<Schema extends SchemaDef, Model extends GetModels<Schema
      * });
      * ```
      */
-    createManyAndReturn<T extends CreateManyAndReturnArgs<Schema, Model>>(args?: SelectSubset<T, CreateManyAndReturnArgs<Schema, Model>>): ZenStackPromise<Schema, SimplifiedModelResult<Schema, Model, T>[]>;
+    createManyAndReturn<T extends CreateManyAndReturnArgs<Schema, Model>>(args?: SelectSubset<T, CreateManyAndReturnArgs<Schema, Model>>): ZenStackPromise<Schema, SimplifiedModelResult<Schema, Model, Options, T>[]>;
     /**
      * Updates a uniquely identified entity.
      * @param args - update args. See {@link findMany} for how to control
@@ -1451,7 +1487,7 @@ type AllModelOperations<Schema extends SchemaDef, Model extends GetModels<Schema
      * });
      * ```
      */
-    update<T extends UpdateArgs<Schema, Model>>(args: SelectSubset<T, UpdateArgs<Schema, Model>>): ZenStackPromise<Schema, SimplifiedModelResult<Schema, Model, T>>;
+    update<T extends UpdateArgs<Schema, Model>>(args: SelectSubset<T, UpdateArgs<Schema, Model>>): ZenStackPromise<Schema, SimplifiedModelResult<Schema, Model, Options, T>>;
     /**
      * Updates multiple entities.
      * @param args - update args. Only scalar fields are allowed for data.
@@ -1495,7 +1531,7 @@ type AllModelOperations<Schema extends SchemaDef, Model extends GetModels<Schema
      * });
      * ```
      */
-    updateManyAndReturn<T extends UpdateManyAndReturnArgs<Schema, Model>>(args: Subset<T, UpdateManyAndReturnArgs<Schema, Model>>): ZenStackPromise<Schema, SimplifiedModelResult<Schema, Model, T>[]>;
+    updateManyAndReturn<T extends UpdateManyAndReturnArgs<Schema, Model>>(args: Subset<T, UpdateManyAndReturnArgs<Schema, Model>>): ZenStackPromise<Schema, SimplifiedModelResult<Schema, Model, Options, T>[]>;
     /**
      * Creates or updates an entity.
      * @param args - upsert args
@@ -1516,7 +1552,7 @@ type AllModelOperations<Schema extends SchemaDef, Model extends GetModels<Schema
      * });
      * ```
      */
-    upsert<T extends UpsertArgs<Schema, Model>>(args: SelectSubset<T, UpsertArgs<Schema, Model>>): ZenStackPromise<Schema, SimplifiedModelResult<Schema, Model, T>>;
+    upsert<T extends UpsertArgs<Schema, Model>>(args: SelectSubset<T, UpsertArgs<Schema, Model>>): ZenStackPromise<Schema, SimplifiedModelResult<Schema, Model, Options, T>>;
     /**
      * Deletes a uniquely identifiable entity.
      * @param args - delete args
@@ -1536,7 +1572,7 @@ type AllModelOperations<Schema extends SchemaDef, Model extends GetModels<Schema
      * }); // result: `{ id: string; email: string }`
      * ```
      */
-    delete<T extends DeleteArgs<Schema, Model>>(args: SelectSubset<T, DeleteArgs<Schema, Model>>): ZenStackPromise<Schema, SimplifiedModelResult<Schema, Model, T>>;
+    delete<T extends DeleteArgs<Schema, Model>>(args: SelectSubset<T, DeleteArgs<Schema, Model>>): ZenStackPromise<Schema, SimplifiedModelResult<Schema, Model, Options, T>>;
     /**
      * Deletes multiple entities.
      * @param args - delete args
@@ -1630,15 +1666,15 @@ type AllModelOperations<Schema extends SchemaDef, Model extends GetModels<Schema
     groupBy<T extends GroupByArgs<Schema, Model>>(args: Subset<T, GroupByArgs<Schema, Model>>): ZenStackPromise<Schema, Simplify<GroupByResult<Schema, Model, T>>>;
 };
 type OperationsIneligibleForDelegateModels = 'create' | 'createMany' | 'createManyAndReturn' | 'upsert';
-type ModelOperations<Schema extends SchemaDef, Model extends GetModels<Schema>> = Omit<AllModelOperations<Schema, Model>, IsDelegateModel<Schema, Model> extends true ? OperationsIneligibleForDelegateModels : never>;
+type ModelOperations<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends ClientOptions<Schema> = ClientOptions<Schema>> = Omit<AllModelOperations<Schema, Model, Options>, IsDelegateModel<Schema, Model> extends true ? OperationsIneligibleForDelegateModels : never>;
 /**
  * Type for auth context that includes both scalar and relation fields.
  * Relations are recursively included to allow nested auth data like { user: { profile: { ... } } }
  */
-type AuthModelType<Schema extends SchemaDef, Model extends GetModels<Schema>> = Partial<DefaultModelResult<Schema, Model>> & {
+type AuthModelType<Schema extends SchemaDef, Model extends GetModels<Schema>> = Partial<DefaultModelResult<Schema, Model, ClientOptions<Schema>>> & {
     [Key in RelationFields<Schema, Model>]?: FieldIsArray<Schema, Model, Key> extends true ? AuthModelType<Schema, RelationFieldType<Schema, Model, Key>>[] : AuthModelType<Schema, RelationFieldType<Schema, Model, Key>>;
 };
-type AuthType<Schema extends SchemaDef> = string extends GetModels<Schema> ? Record<string, unknown> : Schema['authType'] extends GetModels<Schema> ? AuthModelType<Schema, Schema['authType']> : never;
+type AuthType<Schema extends SchemaDef> = Schema['authType'] extends GetModels<Schema> ? AuthModelType<Schema, Schema['authType']> : Schema['authType'] extends GetTypeDefs<Schema> ? TypeDefResult<Schema, Schema['authType'], true> : Record<string, unknown>;
 
 /**
  * ZenStack ORM client.
@@ -1760,7 +1796,7 @@ declare function fieldHasDefaultValue(fieldDef: FieldDef): boolean | undefined;
 declare function isEnum(schema: SchemaDef, type: string): boolean;
 declare function getEnum(schema: SchemaDef, type: string): _zenstackhq_schema.EnumDef | undefined;
 declare function buildJoinPairs(schema: SchemaDef, model: string, modelAlias: string, relationField: string, relationModelAlias: string): [string, string][];
-declare function makeDefaultOrderBy<Schema extends SchemaDef>(schema: SchemaDef, model: string): OrderBy<Schema, Extract<keyof Schema["models"], string>, true, false>[];
+declare function makeDefaultOrderBy<Schema extends SchemaDef>(schema: SchemaDef, model: string): OrderBy<Schema, GetModels<Schema>, true, false>[];
 declare function getManyToManyRelation(schema: SchemaDef, model: string, field: string): {
     parentFkName: string;
     parentPKName: string;
@@ -1834,23 +1870,38 @@ declare namespace queryUtils {
   export { queryUtils_aggregate as aggregate, queryUtils_buildJoinPairs as buildJoinPairs, queryUtils_ensureArray as ensureArray, queryUtils_extractFieldName as extractFieldName, queryUtils_extractIdFields as extractIdFields, queryUtils_extractModelName as extractModelName, queryUtils_fieldHasDefaultValue as fieldHasDefaultValue, queryUtils_flattenCompoundUniqueFilters as flattenCompoundUniqueFilters, queryUtils_getDelegateDescendantModels as getDelegateDescendantModels, queryUtils_getDiscriminatorField as getDiscriminatorField, queryUtils_getEnum as getEnum, queryUtils_getField as getField, queryUtils_getIdFields as getIdFields, queryUtils_getIdValues as getIdValues, queryUtils_getManyToManyRelation as getManyToManyRelation, queryUtils_getModel as getModel, queryUtils_getRelationForeignKeyFieldPairs as getRelationForeignKeyFieldPairs, queryUtils_getTypeDef as getTypeDef, queryUtils_getUniqueFields as getUniqueFields, queryUtils_hasModel as hasModel, queryUtils_isEnum as isEnum, queryUtils_isForeignKeyField as isForeignKeyField, queryUtils_isInheritedField as isInheritedField, queryUtils_isRelationField as isRelationField, queryUtils_isScalarField as isScalarField, queryUtils_makeDefaultOrderBy as makeDefaultOrderBy, queryUtils_requireField as requireField, queryUtils_requireIdFields as requireIdFields, queryUtils_requireModel as requireModel, queryUtils_stripAlias as stripAlias };
 }
 
+type VisitResult = void | {
+    abort: true;
+};
 declare class ExpressionVisitor {
-    visit(expr: Expression$1): void;
-    protected visitLiteral(_e: LiteralExpression): void;
-    protected visitArray(e: ArrayExpression): void;
-    protected visitField(_e: FieldExpression): void;
-    protected visitMember(e: MemberExpression): void;
-    protected visitBinary(e: BinaryExpression): void;
-    protected visitUnary(e: UnaryExpression): void;
-    protected visitCall(e: CallExpression): void;
-    protected visitThis(_e: ThisExpression): void;
-    protected visitNull(_e: NullExpression): void;
+    visit(expr: Expression$1): VisitResult;
+    protected visitLiteral(_e: LiteralExpression): VisitResult;
+    protected visitArray(e: ArrayExpression): VisitResult;
+    protected visitField(_e: FieldExpression): VisitResult;
+    protected visitMember(e: MemberExpression): VisitResult;
+    protected visitBinary(e: BinaryExpression): VisitResult;
+    protected visitUnary(e: UnaryExpression): VisitResult;
+    protected visitCall(e: CallExpression): VisitResult;
+    protected visitThis(_e: ThisExpression): VisitResult;
+    protected visitNull(_e: NullExpression): VisitResult;
+}
+declare class MatchingExpressionVisitor extends ExpressionVisitor {
+    private predicate;
+    private found;
+    constructor(predicate: (expr: Expression$1) => boolean);
+    find(expr: Expression$1): boolean;
+    visit(expr: Expression$1): void | {
+        readonly abort: true;
+    };
 }
 
 type schemaUtils_ExpressionVisitor = ExpressionVisitor;
 declare const schemaUtils_ExpressionVisitor: typeof ExpressionVisitor;
+type schemaUtils_MatchingExpressionVisitor = MatchingExpressionVisitor;
+declare const schemaUtils_MatchingExpressionVisitor: typeof MatchingExpressionVisitor;
+type schemaUtils_VisitResult = VisitResult;
 declare namespace schemaUtils {
-  export { schemaUtils_ExpressionVisitor as ExpressionVisitor };
+  export { schemaUtils_ExpressionVisitor as ExpressionVisitor, schemaUtils_MatchingExpressionVisitor as MatchingExpressionVisitor, type schemaUtils_VisitResult as VisitResult };
 }
 
-export { type AfterEntityMutationCallback, type AggregateArgs, type AggregateResult, type AllModelOperations, type AuthType, BaseCrudDialect, type BatchResult, type BeforeEntityMutationCallback, type BooleanFilter, type BytesFilter, CRUD, CRUD_EXT, type ClientConstructor, type ClientContract, type ClientOptions, type ComputedFieldsOptions, type CountArgs, type CountResult, type CreateArgs, type CreateInput, type CreateManyAndReturnArgs, type CreateManyArgs, type CreateManyInput, type CoreCrudOperation as CrudOperation, type DateTimeFilter, type DefaultModelResult, type DeleteArgs, type DeleteManyArgs, type EntityMutationHooksDef, type FindArgs, type FindFirstArgs, type FindManyArgs, type FindUniqueArgs, type GroupByArgs, type GroupByResult, type HasComputedFields, type HasProcedures, type IncludeInput, type JsonArray, type JsonObject, type JsonValue, kyselyUtils as KyselyUtils, type ModelOperations, type ModelResult, type NullsOrder, type NumberFilter, ORMError, ORMErrorReason, type OmitInput, type OnKyselyQueryArgs, type OnKyselyQueryCallback, type OperationsIneligibleForDelegateModels, type OrderBy, type PluginAfterEntityMutationArgs, type PluginBeforeEntityMutationArgs, type ProcedureFunc, type Procedures, type ProceduresOptions, type ProceedKyselyQueryFunction, queryUtils as QueryUtils, RejectedByPolicyReason, type RuntimePlugin, schemaUtils as SchemaUtils, type SelectIncludeOmit, type SelectInput, type SelectSubset, type SimplifiedModelResult, type SortOrder, type StringFilter, type Subset, type ToKysely, type TransactionClientContract, TransactionIsolationLevel, type TypeDefResult, type UpdateArgs, type UpdateInput, type UpdateManyAndReturnArgs, type UpdateManyArgs, type UpsertArgs, type WhereInput, type WhereUniqueInput, type ZModelFunction, type ZModelFunctionContext, ZenStackClient, type ZenStackPromise, definePlugin, getCrudDialect };
+export { type AfterEntityMutationCallback, type AggregateArgs, type AggregateResult, type AllModelOperations, type AuthType, BaseCrudDialect, type BatchResult, type BeforeEntityMutationCallback, type BooleanFilter, type BytesFilter, CRUD, CRUD_EXT, type ClientConstructor, type ClientContract, type ClientOptions, type ComputedFieldsOptions, type CountArgs, type CountResult, type CreateArgs, type CreateInput, type CreateManyAndReturnArgs, type CreateManyArgs, type CreateManyInput, type CoreCrudOperation as CrudOperation, type DateTimeFilter, type DefaultModelResult, type DeleteArgs, type DeleteManyArgs, type EntityMutationHooksDef, type FindArgs, type FindFirstArgs, type FindManyArgs, type FindUniqueArgs, type GroupByArgs, type GroupByResult, type HasComputedFields, type HasProcedures, type IncludeInput, type JsonArray, type JsonObject, type JsonValue, kyselyUtils as KyselyUtils, type ModelOperations, type ModelResult, type NullsOrder, type NumberFilter, ORMError, ORMErrorReason, type OmitInput, type OmitOptions, type OnKyselyQueryArgs, type OnKyselyQueryCallback, type OperationsIneligibleForDelegateModels, type OrderBy, type PluginAfterEntityMutationArgs, type PluginBeforeEntityMutationArgs, type ProcedureFunc, type Procedures, type ProceduresOptions, type ProceedKyselyQueryFunction, queryUtils as QueryUtils, RejectedByPolicyReason, type RuntimePlugin, schemaUtils as SchemaUtils, type SelectIncludeOmit, type SelectInput, type SelectSubset, type SimplifiedModelResult, type SortOrder, type StringFilter, type Subset, type ToKysely, type TransactionClientContract, TransactionIsolationLevel, type TypeDefResult, type UpdateArgs, type UpdateInput, type UpdateManyAndReturnArgs, type UpdateManyArgs, type UpsertArgs, type WhereInput, type WhereUniqueInput, type ZModelFunction, type ZModelFunctionContext, ZenStackClient, type ZenStackPromise, definePlugin, getCrudDialect };