@zenstackhq/orm 3.2.1 → 3.3.0-beta.2

package/dist/index.d.ts

@@ -1,9 +1,78 @@
 import * as _zenstackhq_schema from '@zenstackhq/schema';
-import { SchemaDef, BuiltinType, GetModels, FieldDef, ModelDef, DataSourceProviderType, ScalarFields, ForeignKeyFields, GetModelFields, FieldHasDefault, GetModelFieldType, ModelFieldIsOptional, GetModelField, GetModel, ProcedureDef, NonRelationFields, GetEnums, GetEnum, GetTypeDefs, GetTypeDefFields, GetTypeDefField, TypeDefFieldIsOptional, RelationFields, FieldIsArray, RelationFieldType, FieldIsRelation, GetTypeDefFieldType, TypeDefFieldIsArray, FieldIsDelegateDiscriminator, FieldType, RelationInfo, FieldIsDelegateRelation, IsDelegateModel, Expression as Expression$1, LiteralExpression, ArrayExpression, FieldExpression, MemberExpression, BinaryExpression, UnaryExpression, CallExpression, ThisExpression, NullExpression } from '@zenstackhq/schema';
+import { SchemaDef, GetModels, ScalarFields, ForeignKeyFields, GetModelFields, FieldHasDefault, GetModelFieldType, ModelFieldIsOptional, GetModelField, NonRelationFields, FieldDef, GetEnums, GetEnum, GetTypeDefs, GetTypeDefFields, GetTypeDefField, TypeDefFieldIsOptional, RelationFields, FieldIsArray, RelationFieldType, FieldIsRelation, GetModel, BuiltinType, GetTypeDefFieldType, TypeDefFieldIsArray, FieldIsDelegateDiscriminator, FieldType, RelationInfo, FieldIsDelegateRelation, ProcedureDef, ModelDef, DataSourceProviderType, IsDelegateModel, Expression as Expression$1, LiteralExpression, ArrayExpression, FieldExpression, MemberExpression, BinaryExpression, UnaryExpression, CallExpression, ThisExpression, NullExpression } from '@zenstackhq/schema';
 import * as kysely from 'kysely';
-import { OperationNodeVisitor, OperationNode, SelectQueryNode, SelectionNode, ColumnNode, AliasNode, TableNode, FromNode, ReferenceNode, AndNode, OrNode, ValueListNode, ParensNode, JoinNode, RawNode, WhereNode, InsertQueryNode, DeleteQueryNode, ReturningNode, CreateTableNode, AddColumnNode, ColumnDefinitionNode, DropTableNode, OrderByNode, OrderByItemNode, GroupByNode, GroupByItemNode, UpdateQueryNode, ColumnUpdateNode, LimitNode, OffsetNode, OnConflictNode, OnDuplicateKeyNode, CheckConstraintNode, DataTypeNode, SelectAllNode, IdentifierNode, SchemableIdentifierNode, ValueNode, PrimitiveValueListNode, OperatorNode, CreateIndexNode, DropIndexNode, ListNode, PrimaryKeyConstraintNode, UniqueConstraintNode, ReferencesNode, WithNode, CommonTableExpressionNode, CommonTableExpressionNameNode, HavingNode, CreateSchemaNode, DropSchemaNode, AlterTableNode, DropColumnNode, RenameColumnNode, AlterColumnNode, ModifyColumnNode, AddConstraintNode, DropConstraintNode, ForeignKeyConstraintNode, CreateViewNode, DropViewNode, GeneratedNode, DefaultValueNode, OnNode, ValuesNode, SelectModifierNode, CreateTypeNode, DropTypeNode, ExplainNode, DefaultInsertValueNode, AggregateFunctionNode, OverNode, PartitionByNode, PartitionByItemNode, SetOperationNode, BinaryOperationNode, UnaryOperationNode, UsingNode, FunctionNode, CaseNode, WhenNode, JSONReferenceNode, JSONPathNode, JSONPathLegNode, JSONOperatorChainNode, TupleNode, MergeQueryNode, MatchedNode, AddIndexNode, CastNode, FetchNode, TopNode, OutputNode, RenameConstraintNode, RefreshMaterializedViewNode, OrActionNode, CollateNode, Kysely, ExpressionBuilder, SelectQueryBuilder, Expression, SqlBool, ExpressionWrapper, Generated, QueryId, RootOperationNode, QueryResult, UnknownRow, Dialect, KyselyConfig, OperandExpression } from 'kysely';
+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 Decimal from 'decimal.js';
-import { z } from 'zod';
+import { z, ZodType } from 'zod';
+
+type JsonValue = string | number | boolean | JsonObject | JsonArray;
+type JsonObject = {
+    [key: string]: JsonValue | null;
+};
+type JsonArray = ReadonlyArray<JsonValue | null>;
+type JsonNullValues = DbNull | JsonNull | AnyNull;
+declare class DbNullClass {
+    private __brand;
+}
+declare const DbNull: DbNullClass;
+type DbNull = typeof DbNull;
+declare class JsonNullClass {
+    private __brand;
+}
+declare const JsonNull: JsonNullClass;
+type JsonNull = typeof JsonNull;
+declare class AnyNullClass {
+    private __brand;
+}
+declare const AnyNull: AnyNullClass;
+type AnyNull = typeof AnyNull;
+
+type Optional<T extends object, K extends keyof T = keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+type PartialIf<T, Condition extends boolean> = Condition extends true ? Partial<T> : T;
+type NullableIf<T, Condition extends boolean> = Condition extends true ? T | null : T;
+type _Preserve = Date | Function | Decimal | Uint8Array | JsonObject | JsonValue;
+type _Depth = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+type Simplify<T, D extends number = 6> = D extends 0 ? T : T extends object ? T extends _Preserve ? T : {
+    [K in keyof T]: Simplify<T[K], _Depth[D]>;
+} & {} : T;
+type WrapType<T, Optional = false, Array = false> = Array extends true ? Optional extends true ? T[] | null : T[] : Optional extends true ? T | null : T;
+type TypeMap = {
+    String: string;
+    Boolean: boolean;
+    Int: number;
+    Float: number;
+    BigInt: bigint;
+    Decimal: Decimal;
+    DateTime: Date;
+    Bytes: Uint8Array;
+    Json: JsonValue;
+    Null: null;
+    Object: Record<string, unknown>;
+    Any: unknown;
+    Unsupported: unknown;
+    Void: void;
+    Undefined: undefined;
+};
+type MapBaseType$1<T extends string> = T extends keyof TypeMap ? TypeMap[T] : unknown;
+type OrArray<T, IF extends boolean = true> = IF extends true ? T | T[] : T;
+type NonEmptyArray<T> = [T, ...T[]];
+type ValueOfPotentialTuple<T> = T extends unknown[] ? T[number] : T;
+type NoExpand<T> = T extends unknown ? T : never;
+type AtLeast<O extends object, K extends string> = NoExpand<O extends unknown ? (K extends keyof O ? {
+    [P in K]: O[P];
+} & O : O) | ({
+    [P in keyof O as P extends K ? K : never]-?: O[P];
+} & O) : never>;
+type Without<T, U> = {
+    [P in Exclude<keyof T, keyof U>]?: never;
+};
+type XOR<T, U> = T extends object ? (U extends object ? (Without<T, U> & U) | (Without<U, T> & T) : U) : T;
+type MaybePromise<T> = T | Promise<T>;
+type PrependParameter<Param, Func> = Func extends (...args: any[]) => infer R ? (p: Param, ...args: Parameters<Func>) => R : never;
+type OrUndefinedIf<T, Condition extends boolean> = Condition extends true ? T | undefined : T;
+type UnwrapTuplePromises<T extends readonly unknown[]> = {
+    [K in keyof T]: Awaited<T[K]>;
+};
 
 declare class DefaultOperationNodeVisitor extends OperationNodeVisitor {
     protected defaultVisit(node: OperationNode): void;
@@ -114,75 +183,6 @@ declare namespace kyselyUtils {
   export { type kyselyUtils_AnyKysely as AnyKysely, kyselyUtils_DefaultOperationNodeVisitor as DefaultOperationNodeVisitor };
 }
 
-type JsonValue = string | number | boolean | JsonObject | JsonArray;
-type JsonObject = {
-    [key: string]: JsonValue | null;
-};
-type JsonArray = ReadonlyArray<JsonValue | null>;
-type JsonNullValues = DbNull | JsonNull | AnyNull;
-declare class DbNullClass {
-    private __brand;
-}
-declare const DbNull: DbNullClass;
-type DbNull = typeof DbNull;
-declare class JsonNullClass {
-    private __brand;
-}
-declare const JsonNull: JsonNullClass;
-type JsonNull = typeof JsonNull;
-declare class AnyNullClass {
-    private __brand;
-}
-declare const AnyNull: AnyNullClass;
-type AnyNull = typeof AnyNull;
-
-type Optional<T extends object, K extends keyof T = keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
-type PartialIf<T, Condition extends boolean> = Condition extends true ? Partial<T> : T;
-type NullableIf<T, Condition extends boolean> = Condition extends true ? T | null : T;
-type _Preserve = Date | Function | Decimal | Uint8Array | JsonObject | JsonValue;
-type _Depth = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
-type Simplify<T, D extends number = 6> = D extends 0 ? T : T extends object ? T extends _Preserve ? T : {
-    [K in keyof T]: Simplify<T[K], _Depth[D]>;
-} & {} : T;
-type WrapType<T, Optional = false, Array = false> = Array extends true ? Optional extends true ? T[] | null : T[] : Optional extends true ? T | null : T;
-type TypeMap = {
-    String: string;
-    Boolean: boolean;
-    Int: number;
-    Float: number;
-    BigInt: bigint;
-    Decimal: Decimal;
-    DateTime: Date;
-    Bytes: Uint8Array;
-    Json: JsonValue;
-    Null: null;
-    Object: Record<string, unknown>;
-    Any: unknown;
-    Unsupported: unknown;
-    Void: void;
-    Undefined: undefined;
-};
-type MapBaseType$1<T extends string> = T extends keyof TypeMap ? TypeMap[T] : unknown;
-type OrArray<T, IF extends boolean = true> = IF extends true ? T | T[] : T;
-type NonEmptyArray<T> = [T, ...T[]];
-type ValueOfPotentialTuple<T> = T extends unknown[] ? T[number] : T;
-type NoExpand<T> = T extends unknown ? T : never;
-type AtLeast<O extends object, K extends string> = NoExpand<O extends unknown ? (K extends keyof O ? {
-    [P in K]: O[P];
-} & O : O) | ({
-    [P in keyof O as P extends K ? K : never]-?: O[P];
-} & O) : never>;
-type Without<T, U> = {
-    [P in Exclude<keyof T, keyof U>]?: never;
-};
-type XOR<T, U> = T extends object ? (U extends object ? (Without<T, U> & U) | (Without<U, T> & T) : U) : T;
-type MaybePromise<T> = T | Promise<T>;
-type PrependParameter<Param, Func> = Func extends (...args: any[]) => infer R ? (p: Param, ...args: Parameters<Func>) => R : never;
-type OrUndefinedIf<T, Condition extends boolean> = Condition extends true ? T | undefined : T;
-type UnwrapTuplePromises<T extends readonly unknown[]> = {
-    [K in keyof T]: Awaited<T[K]>;
-};
-
 /**
  * Client API methods that are not supported in transactions.
  */
@@ -197,118 +197,6 @@ 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, _array: boolean): 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): any;
-    private buildJsonFilter;
-    private buildPlainJsonFilter;
-    private buildTypedJsonFilter;
-    private buildTypedJsonArrayFilter;
-    private buildTypeJsonNonArrayFilter;
-    private buildJsonValueFilterClause;
-    private buildLiteralFilter;
-    private buildStandardFilter;
-    private buildStringFilter;
-    private buildJsonStringFilter;
-    private escapeLikePattern;
-    private buildStringLike;
-    private prepStringCasing;
-    private buildNumberFilter;
-    private buildBooleanFilter;
-    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;
-    };
-    /**
-     * Builds a JSON path selection expression.
-     */
-    protected abstract buildJsonPathSelection(receiver: Expression<any>, path: string | undefined): Expression<any>;
-    /**
-     * Builds a JSON array filter expression.
-     */
-    protected abstract buildJsonArrayFilter(receiver: Expression<any>, operation: 'array_contains' | 'array_starts_with' | 'array_ends_with', value: unknown): Expression<SqlBool>;
-    /**
-     * Builds a JSON array exists predicate (returning if any element matches the filter).
-     */
-    protected abstract buildJsonArrayExistsPredicate(receiver: Expression<any>, buildFilter: (elem: Expression<any>) => Expression<SqlBool>): Expression<SqlBool>;
-}
-
 type ToKyselySchema<Schema extends SchemaDef> = {
     [Model in GetModels<Schema>]: ToKyselyTable<Schema, Model>;
 };
@@ -321,478 +209,256 @@ 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>;
 
-declare class InputValidator<Schema extends SchemaDef> {
-    private readonly client;
-    constructor(client: ClientContract<Schema>);
-    private get schema();
-    private get options();
-    private get extraValidationsEnabled();
-    validateProcedureInput(proc: string, input: unknown): unknown;
-    private makeProcedureParamSchema;
-    validateFindArgs(model: GetModels<Schema>, args: unknown, options: {
-        unique: boolean;
-        findOne: boolean;
-    }): FindArgs<Schema, GetModels<Schema>, true> | undefined;
-    validateExistsArgs(model: GetModels<Schema>, args: unknown): ExistsArgs<Schema, GetModels<Schema>> | undefined;
-    validateCreateArgs(model: GetModels<Schema>, args: unknown): CreateArgs<Schema, GetModels<Schema>>;
-    validateCreateManyArgs(model: GetModels<Schema>, args: unknown): CreateManyArgs<Schema, GetModels<Schema>>;
-    validateCreateManyAndReturnArgs(model: GetModels<Schema>, args: unknown): CreateManyAndReturnArgs<Schema, GetModels<Schema>> | undefined;
-    validateUpdateArgs(model: GetModels<Schema>, args: unknown): UpdateArgs<Schema, GetModels<Schema>>;
-    validateUpdateManyArgs(model: GetModels<Schema>, args: unknown): UpdateManyArgs<Schema, GetModels<Schema>>;
-    validateUpdateManyAndReturnArgs(model: GetModels<Schema>, args: unknown): UpdateManyAndReturnArgs<Schema, GetModels<Schema>>;
-    validateUpsertArgs(model: GetModels<Schema>, args: unknown): UpsertArgs<Schema, GetModels<Schema>>;
-    validateDeleteArgs(model: GetModels<Schema>, args: unknown): DeleteArgs<Schema, GetModels<Schema>>;
-    validateDeleteManyArgs(model: GetModels<Schema>, args: unknown): DeleteManyArgs<Schema, GetModels<Schema>> | undefined;
-    validateCountArgs(model: GetModels<Schema>, args: unknown): CountArgs<Schema, GetModels<Schema>> | undefined;
-    validateAggregateArgs(model: GetModels<Schema>, args: unknown): AggregateArgs<Schema, GetModels<Schema>>;
-    validateGroupByArgs(model: GetModels<Schema>, args: unknown): GroupByArgs<Schema, GetModels<Schema>>;
-    private getSchemaCache;
-    private setSchemaCache;
-    private validate;
-    private makeFindSchema;
-    private makeExistsSchema;
-    private makeScalarSchema;
-    private makeEnumSchema;
-    private makeTypeDefSchema;
-    private makeWhereSchema;
-    private makeTypedJsonFilterSchema;
-    private isTypeDefType;
-    private makeEnumFilterSchema;
-    private makeArrayFilterSchema;
-    private internalMakeArrayFilterSchema;
-    private makePrimitiveFilterSchema;
-    private makeJsonValueSchema;
-    private makeJsonFilterSchema;
-    private makeDateTimeFilterSchema;
-    private makeBooleanFilterSchema;
-    private makeBytesFilterSchema;
-    private makeCommonPrimitiveFilterComponents;
-    private makeCommonPrimitiveFilterSchema;
-    private makeNumberFilterSchema;
-    private makeStringFilterSchema;
-    private makeStringModeSchema;
-    private makeSelectSchema;
-    private makeCountSelectionSchema;
-    private makeRelationSelectIncludeSchema;
-    private makeOmitSchema;
-    private makeIncludeSchema;
-    private makeOrderBySchema;
-    private makeDistinctSchema;
-    private makeCursorSchema;
-    private makeCreateSchema;
-    private makeCreateManySchema;
-    private makeCreateManyAndReturnSchema;
-    private makeCreateDataSchema;
-    private isDelegateDiscriminator;
-    private makeRelationManipulationSchema;
-    private makeSetDataSchema;
-    private makeConnectDataSchema;
-    private makeDisconnectDataSchema;
-    private makeDeleteRelationDataSchema;
-    private makeConnectOrCreateDataSchema;
-    private makeCreateManyDataSchema;
-    private makeUpdateSchema;
-    private makeUpdateManySchema;
-    private makeUpdateManyAndReturnSchema;
-    private makeUpsertSchema;
-    private makeUpdateDataSchema;
-    private makeDeleteSchema;
-    private makeDeleteManySchema;
-    makeCountSchema(model: GetModels<Schema>): z.ZodOptional<z.ZodObject<{
-        where: z.ZodOptional<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
-        skip: z.ZodOptional<z.ZodNumber>;
-        take: z.ZodOptional<z.ZodNumber>;
-        orderBy: z.ZodOptional<z.ZodObject<Record<string, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>, z.core.$strict>> | z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<Record<string, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>, z.core.$strict>, z.ZodArray<z.ZodObject<Record<string, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>, z.core.$strict>>]>>;
-        select: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodObject<{
-            _all: z.ZodOptional<z.ZodLiteral<true>>;
-        }, z.core.$strict>]>>;
-    }, z.core.$strip>>;
-    private makeCountAggregateInputSchema;
-    makeAggregateSchema(model: GetModels<Schema>): z.ZodOptional<z.ZodObject<{
-        where: z.ZodOptional<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
-        skip: z.ZodOptional<z.ZodNumber>;
-        take: z.ZodOptional<z.ZodNumber>;
-        orderBy: z.ZodOptional<z.ZodObject<Record<string, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>, z.core.$strict>> | z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<Record<string, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>, z.core.$strict>, z.ZodArray<z.ZodObject<Record<string, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>, z.core.$strict>>]>>;
-        _count: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodObject<{
-            _all: z.ZodOptional<z.ZodLiteral<true>>;
-        }, z.core.$strict>]>>;
-        _avg: z.ZodOptional<z.ZodObject<Record<string, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>, z.core.$strict>>;
-        _sum: z.ZodOptional<z.ZodObject<Record<string, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>, z.core.$strict>>;
-        _min: z.ZodOptional<z.ZodObject<Record<string, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>, z.core.$strict>>;
-        _max: z.ZodOptional<z.ZodObject<Record<string, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>, z.core.$strict>>;
-    }, z.core.$strip>>;
-    makeSumAvgInputSchema(model: GetModels<Schema>): z.ZodObject<Record<string, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>, z.core.$strict>;
-    makeMinMaxInputSchema(model: GetModels<Schema>): z.ZodObject<Record<string, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>, z.core.$strict>;
-    private makeGroupBySchema;
-    private onlyAggregationFields;
-    private makeHavingSchema;
-    private makeSkipSchema;
-    private makeTakeSchema;
-    private refineForSelectIncludeMutuallyExclusive;
-    private refineForSelectOmitMutuallyExclusive;
-    private nullableIf;
-    private orArray;
-    private isNumericField;
-    private get providerSupportsCaseSensitivity();
-}
-
-type CoreCrudOperation = 'findMany' | 'findUnique' | 'findFirst' | 'create' | 'createMany' | 'createManyAndReturn' | 'update' | 'updateMany' | 'updateManyAndReturn' | 'upsert' | 'delete' | 'deleteMany' | 'count' | 'aggregate' | 'groupBy' | 'exists';
-type AllCrudOperation = CoreCrudOperation | 'findUniqueOrThrow' | 'findFirstOrThrow';
-
-/**
- * ZenStack runtime plugin.
- */
-interface RuntimePlugin<Schema extends SchemaDef = SchemaDef> {
+type DefaultModelResult<Schema extends SchemaDef, Model extends GetModels<Schema>, Omit = undefined, Options extends QueryOptions<Schema> = QueryOptions<Schema>, Optional = false, Array = false> = WrapType<{
+    [Key in NonRelationFields<Schema, Model> as ShouldOmitField<Schema, Model, Options, Key, Omit> extends true ? never : Key]: MapModelFieldType<Schema, Model, Key>;
+}, Optional, Array>;
+type ShouldOmitField<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema>, Field extends GetModelFields<Schema, Model>, Omit> = QueryLevelOmit<Schema, Model, Field, Omit> extends boolean ? QueryLevelOmit<Schema, Model, Field, Omit> : OptionsLevelOmit<Schema, Model, Field, Options> extends boolean ? OptionsLevelOmit<Schema, Model, Field, Options> : SchemaLevelOmit<Schema, Model, Field>;
+type QueryLevelOmit<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends GetModelFields<Schema, Model>, Omit> = Field extends keyof Omit ? (Omit[Field] extends boolean ? Omit[Field] : undefined) : undefined;
+type OptionsLevelOmit<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends GetModelFields<Schema, Model>, Options extends QueryOptions<Schema>> = Model extends keyof Options['omit'] ? Field extends keyof Options['omit'][Model] ? Options['omit'][Model][Field] extends boolean ? Options['omit'][Model][Field] : undefined : undefined : undefined;
+type SchemaLevelOmit<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends GetModelFields<Schema, Model>> = GetModelField<Schema, Model, Field>['omit'] extends true ? true : false;
+type ModelSelectResult<Schema extends SchemaDef, Model extends GetModels<Schema>, Select, Omit, Options extends QueryOptions<Schema>> = {
+    [Key in keyof Select as Select[Key] extends false | undefined ? never : Key extends '_count' ? Select[Key] extends SelectCount<Schema, Model> ? Key : never : Key extends keyof Omit ? Omit[Key] extends true ? never : Key : Key]: Key extends '_count' ? SelectCountResult<Schema, Model, Select[Key]> : Key extends NonRelationFields<Schema, Model> ? MapModelFieldType<Schema, Model, Key> : Key extends RelationFields<Schema, Model> ? ModelResult<Schema, RelationFieldType<Schema, Model, Key>, Select[Key], Options, ModelFieldIsOptional<Schema, Model, Key>, FieldIsArray<Schema, Model, Key>> : never;
+};
+type 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 = {}, Options extends QueryOptions<Schema> = QueryOptions<Schema>, Optional = false, Array = false> = WrapType<Args extends {
+    select: infer S extends object;
+    omit?: infer O extends object;
+} & Record<string, unknown> ? ModelSelectResult<Schema, Model, S, O, Options> : Args extends {
+    include: infer I extends object;
+    omit?: infer O extends object;
+} & Record<string, unknown> ? // select all non-omitted scalar fields
+DefaultModelResult<Schema, Model, O, Options, false, false> & {
+    [Key in keyof I & RelationFields<Schema, Model> as I[Key] extends false | undefined ? never : Key]: ModelResult<Schema, RelationFieldType<Schema, Model, Key>, I[Key], Options, ModelFieldIsOptional<Schema, Model, Key>, FieldIsArray<Schema, Model, Key>>;
+} & ('_count' extends keyof I ? I['_count'] extends false | undefined ? {} : {
+    _count: SelectCountResult<Schema, Model, I['_count']>;
+} : {}) : Args extends {
+    omit: infer O;
+} & Record<string, unknown> ? DefaultModelResult<Schema, Model, O, Options, false, false> : DefaultModelResult<Schema, Model, undefined, Options, false, false>, Optional, Array>;
+type SimplifiedResult<Schema extends SchemaDef, Model extends GetModels<Schema>, Args = {}, Options extends QueryOptions<Schema> = QueryOptions<Schema>, Optional = false, Array = false> = Simplify<ModelResult<Schema, Model, Args, Options, Optional, Array>>;
+type SimplifiedPlainResult<Schema extends SchemaDef, Model extends GetModels<Schema>, Args = {}, Options extends QueryOptions<Schema> = QueryOptions<Schema>> = Simplify<ModelResult<Schema, Model, Args, Options, false, false>>;
+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> : GetModelFieldType<Schema, Model, Key> extends GetTypeDefs<Schema> ? TypedJsonFilter<Schema, GetModelFieldType<Schema, Model, Key>, FieldIsArray<Schema, Model, Key>, ModelFieldIsOptional<Schema, Model, Key>> : PrimitiveFilter<GetModelFieldType<Schema, Model, Key>, ModelFieldIsOptional<Schema, Model, Key>, WithAggregations>;
+} & {
+    $expr?: (eb: ExpressionBuilder<ToKyselySchema<Schema>, Model>) => OperandExpression<SqlBool>;
+} & {
+    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> | ({
     /**
-     * Plugin ID.
+     * Checks for equality with the specified enum value.
      */
-    id: string;
+    equals?: NullableIf<keyof GetEnum<Schema, T>, Nullable>;
     /**
-     * Plugin display name.
+     * Checks if the enum value is in the specified list of values.
      */
-    name?: string;
+    in?: (keyof GetEnum<Schema, T>)[];
     /**
-     * Plugin description.
+     * Checks if the enum value is not in the specified list of values.
      */
-    description?: string;
+    notIn?: (keyof GetEnum<Schema, T>)[];
     /**
-     * Custom function implementations.
-     * @private
+     * Builds a negated filter.
      */
-    functions?: Record<string, ZModelFunction<Schema>>;
+    not?: EnumFilter<Schema, T, Nullable, WithAggregations>;
+} & (WithAggregations extends true ? {
     /**
-     * Intercepts an ORM query.
+     * Filters against the count of records.
      */
-    onQuery?: OnQueryCallback<Schema>;
+    _count?: NumberFilter<'Int', false, false>;
     /**
-     * Intercepts a procedure invocation.
+     * Filters against the minimum value.
      */
-    onProcedure?: OnProcedureCallback<Schema>;
+    _min?: EnumFilter<Schema, T, false, false>;
     /**
-     * Intercepts an entity mutation.
+     * Filters against the maximum value.
      */
-    onEntityMutation?: EntityMutationHooksDef<Schema>;
+    _max?: EnumFilter<Schema, T, false, false>;
+} : {}));
+type ArrayFilter<Schema extends SchemaDef, Type extends string> = {
     /**
-     * Intercepts a Kysely query.
+     * Checks if the array equals the specified array.
      */
-    onKyselyQuery?: OnKyselyQueryCallback<Schema>;
-}
-/**
- * Defines a ZenStack runtime plugin.
- */
-declare function definePlugin<Schema extends SchemaDef>(plugin: RuntimePlugin<Schema>): RuntimePlugin<Schema>;
-
-type OnProcedureCallback<Schema extends SchemaDef> = (ctx: OnProcedureHookContext<Schema>) => Promise<unknown>;
-type OnProcedureHookContext<Schema extends SchemaDef> = {
+    equals?: MapScalarType<Schema, Type>[] | null;
     /**
-     * The procedure name.
+     * Checks if the array contains all elements of the specified array.
      */
-    name: string;
+    has?: MapScalarType<Schema, Type> | null;
     /**
-     * Whether the procedure is a mutation.
+     * Checks if the array contains any of the elements of the specified array.
      */
-    mutation: boolean;
+    hasEvery?: MapScalarType<Schema, Type>[];
     /**
-     * Procedure invocation input (envelope).
-     *
-     * The canonical shape is `{ args?: Record<string, unknown> }`.
-     * When a procedure has required params, `args` is required.
+     * Checks if the array contains some of the elements of the specified array.
      */
-    input: unknown;
+    hasSome?: MapScalarType<Schema, Type>[];
     /**
-     * Continues the invocation. The input passed here is forwarded to the next handler.
+     * Checks if the array is empty.
      */
-    proceed: (input: unknown) => Promise<unknown>;
+    isEmpty?: boolean;
+};
+type MapScalarType<Schema extends SchemaDef, Type extends string> = Type extends GetEnums<Schema> ? keyof GetEnum<Schema, Type> : MapBaseType$1<Type>;
+type PrimitiveFilter<T extends string, Nullable extends boolean, WithAggregations extends boolean> = T extends 'String' ? StringFilter<Nullable, WithAggregations> : T extends 'Int' | 'Float' | 'Decimal' | 'BigInt' ? NumberFilter<T, Nullable, WithAggregations> : T extends 'Boolean' ? BooleanFilter<Nullable, WithAggregations> : T extends 'DateTime' ? DateTimeFilter<Nullable, WithAggregations> : T extends 'Bytes' ? BytesFilter<Nullable, WithAggregations> : T extends 'Json' ? JsonFilter : never;
+type CommonPrimitiveFilter<DataType, T extends BuiltinType, Nullable extends boolean, WithAggregations extends boolean> = {
     /**
-     * The ZenStack client that is invoking the procedure.
+     * Checks for equality with the specified value.
      */
-    client: ClientContract<Schema>;
-};
-type OnQueryCallback<Schema extends SchemaDef> = (ctx: OnQueryHookContext<Schema>) => Promise<unknown>;
-type OnQueryHookContext<Schema extends SchemaDef> = {
+    equals?: NullableIf<DataType, Nullable>;
     /**
-     * The model that is being queried.
+     * Checks if the value is in the specified list of values.
      */
-    model: GetModels<Schema>;
+    in?: DataType[];
     /**
-     * The operation that is being performed.
+     * Checks if the value is not in the specified list of values.
      */
-    operation: AllCrudOperation;
+    notIn?: DataType[];
     /**
-     * The query arguments.
+     * Checks if the value is less than the specified value.
      */
-    args: unknown;
+    lt?: DataType;
     /**
-     * The function to proceed with the original query.
-     * It takes the same arguments as the operation method.
-     *
-     * @param args The query arguments.
+     * Checks if the value is less than or equal to the specified value.
      */
-    proceed: (args: unknown) => Promise<unknown>;
+    lte?: DataType;
     /**
-     * The ZenStack client that is performing the operation.
+     * Checks if the value is greater than the specified value.
      */
-    client: ClientContract<Schema>;
-};
-type EntityMutationHooksDef<Schema extends SchemaDef> = {
+    gt?: DataType;
     /**
-     * Called before entities are mutated.
+     * Checks if the value is greater than or equal to the specified value.
      */
-    beforeEntityMutation?: BeforeEntityMutationCallback<Schema>;
+    gte?: DataType;
     /**
-     * Called after entities are mutated.
+     * Checks if the value is between the specified values (inclusive).
      */
-    afterEntityMutation?: AfterEntityMutationCallback<Schema>;
+    between?: [start: DataType, end: DataType];
     /**
-     * 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`.
+     * Builds a negated filter.
      */
-    runAfterMutationWithinTransaction?: boolean;
+    not?: PrimitiveFilter<T, Nullable, WithAggregations>;
 };
-type MutationHooksArgs<Schema extends SchemaDef> = {
+type StringFilter<Nullable extends boolean, WithAggregations extends boolean> = NullableIf<string, Nullable> | (CommonPrimitiveFilter<string, 'String', Nullable, WithAggregations> & {
     /**
-     * The model that is being mutated.
+     * Checks if the string contains the specified substring.
      */
-    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> & {
+    contains?: string;
     /**
-     * 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.
+     * Checks if the string starts with the specified substring.
      */
-    loadBeforeMutationEntities(): Promise<Record<string, unknown>[] | undefined>;
+    startsWith?: string;
     /**
-     * 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.
+     * Checks if the string ends with the specified substring.
      */
-    client: ClientContract<Schema>;
-};
-type PluginAfterEntityMutationArgs<Schema extends SchemaDef> = MutationHooksArgs<Schema> & {
+    endsWith?: string;
     /**
-     * Loads the entities that have been mutated.
+     * Specifies the string comparison mode. Not effective for "sqlite" provider
      */
-    loadAfterMutationEntities(): Promise<Record<string, unknown>[] | undefined>;
+    mode?: 'default' | 'insensitive';
+} & (WithAggregations extends true ? {
     /**
-     * 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.
+     * Filters against the count of records.
      */
-    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> = {
+    _count?: NumberFilter<'Int', false, false>;
     /**
-     * ZenStack client instance
+     * Filters against the minimum value.
      */
-    client: ClientContract<Schema>;
+    _min?: StringFilter<false, false>;
     /**
-     * Database dialect
+     * Filters against the maximum value.
      */
-    dialect: BaseCrudDialect<Schema>;
+    _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 ? {
     /**
-     * The containing model name
+     * Filters against the count of records.
      */
-    model: GetModels<Schema>;
+    _count?: NumberFilter<'Int', false, false>;
     /**
-     * The alias name that can be used to refer to the containing model
+     * Filters against the average value.
      */
-    modelAlias: string;
+    _avg?: NumberFilter<T, false, false>;
     /**
-     * The CRUD operation being performed
+     * Filters against the sum value.
      */
-    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> = {
+    _sum?: NumberFilter<T, false, false>;
     /**
-     * Kysely dialect.
+     * Filters against the minimum value.
      */
-    dialect: Dialect;
+    _min?: NumberFilter<T, false, false>;
     /**
-     * Custom function definitions.
-     *
-     * @private
+     * Filters against the maximum value.
      */
-    functions?: Record<string, ZModelFunction<Schema>>;
+    _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 ? {
     /**
-     * Plugins.
+     * Filters against the count of records.
      */
-    plugins?: RuntimePlugin<Schema>[];
+    _count?: NumberFilter<'Int', false, false>;
     /**
-     * Logging configuration.
+     * Filters against the minimum value.
      */
-    log?: KyselyConfig['log'];
+    _min?: DateTimeFilter<false, false>;
     /**
-     * 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
+     * Filters against the maximum value.
      */
-    fixPostgresTimezone?: boolean;
+    _max?: DateTimeFilter<false, false>;
+} : {}));
+type BytesFilter<Nullable extends boolean, WithAggregations extends boolean> = NullableIf<Uint8Array | Buffer, Nullable> | ({
     /**
-     * Whether to enable input validations expressed with attributes like `@email`, `@regex`,
-     * `@@validate`, etc. Defaults to `true`.
+     * Checks for equality with the specified value.
      */
-    validateInput?: boolean;
+    equals?: NullableIf<Uint8Array, Nullable>;
     /**
-     * Options for omitting fields in ORM query results.
+     * Checks if the value is in the specified list of values.
      */
-    omit?: OmitOptions<Schema>;
+    in?: Uint8Array[];
     /**
-     * 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.
+     * Checks if the value is not in the specified list of values.
      */
-    allowQueryTimeOmitOverride?: boolean;
-} & (HasComputedFields<Schema> extends true ? {
+    notIn?: Uint8Array[];
     /**
-     * Computed field definitions.
+     * Builds a negated filter.
      */
-    computedFields: ComputedFieldsOptions<Schema>;
-} : {}) & (HasProcedures<Schema> extends true ? {
+    not?: BytesFilter<Nullable, WithAggregations>;
+} & (WithAggregations extends true ? {
     /**
-     * Custom procedure definitions.
+     * Filters against the count of records.
      */
-    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 GetProcedureNames<Schema>]: ProcedureHandlerFunc<Schema, Key>;
-} : {};
-type HasProcedures<Schema extends SchemaDef> = Schema extends {
-    procedures: Record<string, ProcedureDef>;
-} ? true : false;
-/**
- * Subset of client options relevant to query operations.
- */
-type QueryOptions<Schema extends SchemaDef> = Pick<ClientOptions<Schema>, 'omit'>;
-/**
- * Extract QueryOptions from ClientOptions
- */
-type ToQueryOptions<T extends ClientOptions<any>> = Pick<T, 'omit'>;
-
-type DefaultModelResult<Schema extends SchemaDef, Model extends GetModels<Schema>, Omit = undefined, Options extends QueryOptions<Schema> = QueryOptions<Schema>, Optional = false, Array = false> = WrapType<{
-    [Key in NonRelationFields<Schema, Model> as ShouldOmitField<Schema, Model, Options, Key, Omit> extends true ? never : Key]: MapModelFieldType<Schema, Model, Key>;
-}, Optional, Array>;
-type ShouldOmitField<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema>, Field extends GetModelFields<Schema, Model>, Omit> = QueryLevelOmit<Schema, Model, Field, Omit> extends boolean ? QueryLevelOmit<Schema, Model, Field, Omit> : OptionsLevelOmit<Schema, Model, Field, Options> extends boolean ? OptionsLevelOmit<Schema, Model, Field, Options> : SchemaLevelOmit<Schema, Model, Field>;
-type QueryLevelOmit<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends GetModelFields<Schema, Model>, Omit> = Field extends keyof Omit ? (Omit[Field] extends boolean ? Omit[Field] : undefined) : undefined;
-type OptionsLevelOmit<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends GetModelFields<Schema, Model>, Options extends QueryOptions<Schema>> = Model extends keyof Options['omit'] ? Field extends keyof Options['omit'][Model] ? Options['omit'][Model][Field] extends boolean ? Options['omit'][Model][Field] : undefined : undefined : undefined;
-type SchemaLevelOmit<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends GetModelFields<Schema, Model>> = GetModelField<Schema, Model, Field>['omit'] extends true ? true : false;
-type ModelSelectResult<Schema extends SchemaDef, Model extends GetModels<Schema>, Select, Omit, Options extends QueryOptions<Schema>> = {
-    [Key in keyof Select as Select[Key] extends false | undefined ? never : Key extends '_count' ? Select[Key] extends SelectCount<Schema, Model> ? Key : never : Key extends keyof Omit ? Omit[Key] extends true ? never : Key : Key]: Key extends '_count' ? SelectCountResult<Schema, Model, Select[Key]> : Key extends NonRelationFields<Schema, Model> ? MapModelFieldType<Schema, Model, Key> : Key extends RelationFields<Schema, Model> ? ModelResult<Schema, RelationFieldType<Schema, Model, Key>, Select[Key], Options, ModelFieldIsOptional<Schema, Model, Key>, FieldIsArray<Schema, Model, Key>> : never;
-};
-type 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 = {}, Options extends QueryOptions<Schema> = QueryOptions<Schema>, Optional = false, Array = false> = WrapType<Args extends {
-    select: infer S extends object;
-    omit?: infer O extends object;
-} & Record<string, unknown> ? ModelSelectResult<Schema, Model, S, O, Options> : Args extends {
-    include: infer I extends object;
-    omit?: infer O extends object;
-} & Record<string, unknown> ? // select all non-omitted scalar fields
-DefaultModelResult<Schema, Model, O, Options, false, false> & {
-    [Key in keyof I & RelationFields<Schema, Model> as I[Key] extends false | undefined ? never : Key]: ModelResult<Schema, RelationFieldType<Schema, Model, Key>, I[Key], Options, ModelFieldIsOptional<Schema, Model, Key>, FieldIsArray<Schema, Model, Key>>;
-} & ('_count' extends keyof I ? I['_count'] extends false | undefined ? {} : {
-    _count: SelectCountResult<Schema, Model, I['_count']>;
-} : {}) : Args extends {
-    omit: infer O;
-} & Record<string, unknown> ? DefaultModelResult<Schema, Model, O, Options, false, false> : DefaultModelResult<Schema, Model, undefined, Options, false, false>, Optional, Array>;
-type SimplifiedResult<Schema extends SchemaDef, Model extends GetModels<Schema>, Args = {}, Options extends QueryOptions<Schema> = QueryOptions<Schema>, Optional = false, Array = false> = Simplify<ModelResult<Schema, Model, Args, Options, Optional, Array>>;
-type SimplifiedPlainResult<Schema extends SchemaDef, Model extends GetModels<Schema>, Args = {}, Options extends QueryOptions<Schema> = QueryOptions<Schema>> = Simplify<ModelResult<Schema, Model, Args, Options, false, false>>;
-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> : GetModelFieldType<Schema, Model, Key> extends GetTypeDefs<Schema> ? TypedJsonFilter<Schema, GetModelFieldType<Schema, Model, Key>, FieldIsArray<Schema, Model, Key>, ModelFieldIsOptional<Schema, Model, Key>> : PrimitiveFilter<GetModelFieldType<Schema, Model, Key>, ModelFieldIsOptional<Schema, Model, Key>, WithAggregations>;
-} & {
-    $expr?: (eb: ExpressionBuilder<ToKyselySchema<Schema>, Model>) => OperandExpression<SqlBool>;
-} & {
-    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> | ({
+    _count?: NumberFilter<'Int', false, false>;
     /**
-     * Checks for equality with the specified enum value.
+     * Filters against the minimum value.
      */
-    equals?: NullableIf<keyof GetEnum<Schema, T>, Nullable>;
+    _min?: BytesFilter<false, false>;
     /**
-     * Checks if the enum value is in the specified list of values.
+     * Filters against the maximum value.
      */
-    in?: (keyof GetEnum<Schema, T>)[];
+    _max?: BytesFilter<false, false>;
+} : {}));
+type BooleanFilter<Nullable extends boolean, WithAggregations extends boolean> = NullableIf<boolean, Nullable> | ({
     /**
-     * Checks if the enum value is not in the specified list of values.
+     * Checks for equality with the specified value.
      */
-    notIn?: (keyof GetEnum<Schema, T>)[];
+    equals?: NullableIf<boolean, Nullable>;
     /**
      * Builds a negated filter.
      */
-    not?: EnumFilter<Schema, T, Nullable, WithAggregations>;
+    not?: BooleanFilter<Nullable, WithAggregations>;
 } & (WithAggregations extends true ? {
     /**
      * Filters against the count of records.
@@ -801,204 +467,25 @@ type EnumFilter<Schema extends SchemaDef, T extends GetEnums<Schema>, Nullable e
     /**
      * Filters against the minimum value.
      */
-    _min?: EnumFilter<Schema, T, false, false>;
+    _min?: BooleanFilter<false, false>;
     /**
      * Filters against the maximum value.
      */
-    _max?: EnumFilter<Schema, T, false, false>;
+    _max?: BooleanFilter<false, false>;
 } : {}));
-type ArrayFilter<Schema extends SchemaDef, Type extends string> = {
+type JsonFilter = {
     /**
-     * Checks if the array equals the specified array.
+     * JSON path to select the value to filter on. If omitted, the whole JSON value is used.
      */
-    equals?: MapScalarType<Schema, Type>[] | null;
+    path?: string;
     /**
-     * Checks if the array contains all elements of the specified array.
+     * Checks for equality with the specified value.
      */
-    has?: MapScalarType<Schema, Type> | null;
+    equals?: JsonValue | JsonNullValues;
     /**
-     * Checks if the array contains any of the elements of the specified array.
+     * Builds a negated filter.
      */
-    hasEvery?: MapScalarType<Schema, Type>[];
-    /**
-     * Checks if the array contains some of the elements of the specified array.
-     */
-    hasSome?: MapScalarType<Schema, Type>[];
-    /**
-     * Checks if the array is empty.
-     */
-    isEmpty?: boolean;
-};
-type MapScalarType<Schema extends SchemaDef, Type extends string> = Type extends GetEnums<Schema> ? keyof GetEnum<Schema, Type> : MapBaseType$1<Type>;
-type PrimitiveFilter<T extends string, Nullable extends boolean, WithAggregations extends boolean> = T extends 'String' ? StringFilter<Nullable, WithAggregations> : T extends 'Int' | 'Float' | 'Decimal' | 'BigInt' ? NumberFilter<T, Nullable, WithAggregations> : T extends 'Boolean' ? BooleanFilter<Nullable, WithAggregations> : T extends 'DateTime' ? DateTimeFilter<Nullable, WithAggregations> : T extends 'Bytes' ? BytesFilter<Nullable, WithAggregations> : T extends 'Json' ? JsonFilter : never;
-type CommonPrimitiveFilter<DataType, T extends BuiltinType, Nullable extends boolean, WithAggregations extends boolean> = {
-    /**
-     * Checks for equality with the specified value.
-     */
-    equals?: NullableIf<DataType, Nullable>;
-    /**
-     * Checks if the value is in the specified list of values.
-     */
-    in?: DataType[];
-    /**
-     * Checks if the value is not in the specified list of values.
-     */
-    notIn?: DataType[];
-    /**
-     * Checks if the value is less than the specified value.
-     */
-    lt?: DataType;
-    /**
-     * Checks if the value is less than or equal to the specified value.
-     */
-    lte?: DataType;
-    /**
-     * Checks if the value is greater than the specified value.
-     */
-    gt?: DataType;
-    /**
-     * Checks if the value is greater than or equal to the specified value.
-     */
-    gte?: DataType;
-    /**
-     * Builds a negated filter.
-     */
-    not?: PrimitiveFilter<T, Nullable, WithAggregations>;
-};
-type StringFilter<Nullable extends boolean, WithAggregations extends boolean> = NullableIf<string, Nullable> | (CommonPrimitiveFilter<string, 'String', Nullable, WithAggregations> & {
-    /**
-     * Checks if the string contains the specified substring.
-     */
-    contains?: string;
-    /**
-     * Checks if the string starts with the specified substring.
-     */
-    startsWith?: string;
-    /**
-     * Checks if the string ends with the specified substring.
-     */
-    endsWith?: string;
-    /**
-     * Specifies the string comparison mode. Not effective for "sqlite" provider
-     */
-    mode?: 'default' | 'insensitive';
-} & (WithAggregations extends true ? {
-    /**
-     * Filters against the count of records.
-     */
-    _count?: NumberFilter<'Int', false, false>;
-    /**
-     * Filters against the minimum value.
-     */
-    _min?: StringFilter<false, false>;
-    /**
-     * Filters against the maximum value.
-     */
-    _max?: StringFilter<false, false>;
-} : {}));
-type NumberFilter<T extends 'Int' | 'Float' | 'Decimal' | 'BigInt', Nullable extends boolean, WithAggregations extends boolean> = NullableIf<number | bigint, Nullable> | (CommonPrimitiveFilter<number, T, Nullable, WithAggregations> & (WithAggregations extends true ? {
-    /**
-     * Filters against the count of records.
-     */
-    _count?: NumberFilter<'Int', false, false>;
-    /**
-     * Filters against the average value.
-     */
-    _avg?: NumberFilter<T, false, false>;
-    /**
-     * Filters against the sum value.
-     */
-    _sum?: NumberFilter<T, false, false>;
-    /**
-     * Filters against the minimum value.
-     */
-    _min?: NumberFilter<T, false, false>;
-    /**
-     * Filters against the maximum value.
-     */
-    _max?: NumberFilter<T, false, false>;
-} : {}));
-type DateTimeFilter<Nullable extends boolean, WithAggregations extends boolean> = NullableIf<Date | string, Nullable> | (CommonPrimitiveFilter<Date | string, 'DateTime', Nullable, WithAggregations> & (WithAggregations extends true ? {
-    /**
-     * Filters against the count of records.
-     */
-    _count?: NumberFilter<'Int', false, false>;
-    /**
-     * Filters against the minimum value.
-     */
-    _min?: DateTimeFilter<false, false>;
-    /**
-     * Filters against the maximum value.
-     */
-    _max?: DateTimeFilter<false, false>;
-} : {}));
-type BytesFilter<Nullable extends boolean, WithAggregations extends boolean> = NullableIf<Uint8Array | Buffer, Nullable> | ({
-    /**
-     * Checks for equality with the specified value.
-     */
-    equals?: NullableIf<Uint8Array, Nullable>;
-    /**
-     * Checks if the value is in the specified list of values.
-     */
-    in?: Uint8Array[];
-    /**
-     * Checks if the value is not in the specified list of values.
-     */
-    notIn?: Uint8Array[];
-    /**
-     * Builds a negated filter.
-     */
-    not?: BytesFilter<Nullable, WithAggregations>;
-} & (WithAggregations extends true ? {
-    /**
-     * Filters against the count of records.
-     */
-    _count?: NumberFilter<'Int', false, false>;
-    /**
-     * Filters against the minimum value.
-     */
-    _min?: BytesFilter<false, false>;
-    /**
-     * Filters against the maximum value.
-     */
-    _max?: BytesFilter<false, false>;
-} : {}));
-type BooleanFilter<Nullable extends boolean, WithAggregations extends boolean> = NullableIf<boolean, Nullable> | ({
-    /**
-     * Checks for equality with the specified value.
-     */
-    equals?: NullableIf<boolean, Nullable>;
-    /**
-     * Builds a negated filter.
-     */
-    not?: BooleanFilter<Nullable, WithAggregations>;
-} & (WithAggregations extends true ? {
-    /**
-     * Filters against the count of records.
-     */
-    _count?: NumberFilter<'Int', false, false>;
-    /**
-     * Filters against the minimum value.
-     */
-    _min?: BooleanFilter<false, false>;
-    /**
-     * Filters against the maximum value.
-     */
-    _max?: BooleanFilter<false, false>;
-} : {}));
-type JsonFilter = {
-    /**
-     * JSON path to select the value to filter on. If omitted, the whole JSON value is used.
-     */
-    path?: string;
-    /**
-     * Checks for equality with the specified value.
-     */
-    equals?: JsonValue | JsonNullValues;
-    /**
-     * Builds a negated filter.
-     */
-    not?: JsonValue | JsonNullValues;
+    not?: JsonValue | JsonNullValues;
     /**
      * Checks if the value is a string and contains the specified substring.
      */
@@ -1373,364 +860,834 @@ type ToManyRelationUpdateInput<Schema extends SchemaDef, Model extends GetModels
      */
     upsert?: NestedUpsertInput<Schema, Model, Field>;
     /**
-     * Updates a batch of related records.
+     * Updates a batch of related records.
+     */
+    updateMany?: NestedUpdateManyInput<Schema, Model, Field>;
+    /**
+     * Deletes related records.
+     */
+    delete?: NestedDeleteInput<Schema, Model, Field>;
+    /**
+     * Deletes a batch of related records.
+     */
+    deleteMany?: NestedDeleteManyInput<Schema, Model, Field>;
+    /**
+     * Sets the related records to the specified ones.
+     */
+    set?: SetRelationInput<Schema, Model, Field>;
+}, FieldIsDelegateRelation<Schema, Model, Field> extends true ? 'create' | 'createMany' | 'connectOrCreate' | 'upsert' : never>;
+type ToOneRelationUpdateInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>> = Omit<{
+    /**
+     * Creates a related record.
+     */
+    create?: NestedCreateInput<Schema, Model, Field>;
+    /**
+     * Connects an existing record.
+     */
+    connect?: ConnectInput<Schema, Model, Field>;
+    /**
+     * Connects or create a related record.
+     */
+    connectOrCreate?: ConnectOrCreateInput<Schema, Model, Field>;
+    /**
+     * Updates the related record.
+     */
+    update?: NestedUpdateInput<Schema, Model, Field>;
+    /**
+     * Upserts the related record.
+     */
+    upsert?: NestedUpsertInput<Schema, Model, Field>;
+} & (ModelFieldIsOptional<Schema, Model, Field> extends true ? {
+    /**
+     * Disconnects the related record.
+     */
+    disconnect?: DisconnectInput<Schema, Model, Field>;
+    /**
+     * Deletes the related record.
+     */
+    delete?: NestedDeleteInput<Schema, Model, Field>;
+} : {}), FieldIsDelegateRelation<Schema, Model, Field> extends true ? 'create' | 'connectOrCreate' | 'upsert' : never>;
+type DeleteArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
+    /**
+     * The unique filter to find the record to delete.
+     */
+    where: WhereUniqueInput<Schema, Model>;
+} & SelectIncludeOmit<Schema, Model, true>;
+type DeleteManyArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
+    /**
+     * Filter to select records to delete.
+     */
+    where?: WhereInput<Schema, Model>;
+    /**
+     * Limits the number of records to delete.
+     */
+    limit?: number;
+};
+type CountArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = Omit<FindArgs<Schema, Model, true>, 'select' | 'include' | 'distinct' | 'omit'> & {
+    /**
+     * Selects fields to count
+     */
+    select?: CountAggregateInput<Schema, Model> | true;
+};
+type CountAggregateInput<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
+    [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>> = {
+    /**
+     * Filter conditions
+     */
+    where?: WhereInput<Schema, Model>;
+    /**
+     * Number of records to skip for the aggregation
+     */
+    skip?: number;
+    /**
+     * Number of records to take for the aggregation
+     */
+    take?: number;
+    /**
+     * Order by clauses
+     */
+    orderBy?: OrArray<OrderBy<Schema, Model, true, false>>;
+} & {
+    /**
+     * Performs count aggregation.
+     */
+    _count?: true | CountAggregateInput<Schema, Model>;
+    /**
+     * Performs minimum value aggregation.
+     */
+    _min?: MinMaxInput<Schema, Model, true>;
+    /**
+     * Performs maximum value aggregation.
+     */
+    _max?: MinMaxInput<Schema, Model, true>;
+} & (NumericFields<Schema, Model> extends never ? {} : {
+    /**
+     * Performs average value aggregation.
+     */
+    _avg?: SumAvgInput<Schema, Model, true>;
+    /**
+     * Performs sum value aggregation.
+     */
+    _sum?: SumAvgInput<Schema, Model, true>;
+});
+type NumericFields<Schema extends SchemaDef, Model extends GetModels<Schema>> = keyof {
+    [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 aggregation result
+     */
+    _count: AggCommonOutput<Count>;
+} : {}) & (Args extends {
+    _sum: infer Sum;
+} ? {
+    /**
+     * Sum aggregation result
+     */
+    _sum: AggCommonOutput<Sum>;
+} : {}) & (Args extends {
+    _avg: infer Avg;
+} ? {
+    /**
+     * Average aggregation result
+     */
+    _avg: AggCommonOutput<Avg>;
+} : {}) & (Args extends {
+    _min: infer Min;
+} ? {
+    /**
+     * Minimum aggregation result
+     */
+    _min: AggCommonOutput<Min>;
+} : {}) & (Args extends {
+    _max: infer Max;
+} ? {
+    /**
+     * Maximum aggregation result
+     */
+    _max: AggCommonOutput<Max>;
+} : {});
+type AggCommonOutput<Input> = Input extends true ? number : Input extends {} ? {
+    [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>> = {
+    /**
+     * Filter conditions
+     */
+    where?: WhereInput<Schema, Model>;
+    /**
+     * Order by clauses
+     */
+    orderBy?: OrArray<OrderBy<Schema, Model, false, true>>;
+    /**
+     * Fields to group by
+     */
+    by: NonRelationFields<Schema, Model> | NonEmptyArray<NonRelationFields<Schema, Model>>;
+    /**
+     * Filter conditions for the grouped records
+     */
+    having?: GroupByHaving<Schema, Model>;
+    /**
+     * Number of records to take for grouping
+     */
+    take?: number;
+    /**
+     * Number of records to skip for grouping
+     */
+    skip?: number;
+    /**
+     * Performs count aggregation.
+     */
+    _count?: true | CountAggregateInput<Schema, Model>;
+    /**
+     * Performs minimum value aggregation.
+     */
+    _min?: MinMaxInput<Schema, Model, true>;
+    /**
+     * Performs maximum value aggregation.
+     */
+    _max?: MinMaxInput<Schema, Model, true>;
+} & (NumericFields<Schema, Model> extends never ? {} : {
+    /**
+     * Performs average value aggregation.
+     */
+    _avg?: SumAvgInput<Schema, Model, true>;
+    /**
+     * Performs sum value aggregation.
+     */
+    _sum?: SumAvgInput<Schema, Model, true>;
+});
+type GroupByResult<Schema extends SchemaDef, Model extends GetModels<Schema>, Args extends {
+    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 aggregation result
+     */
+    _count: AggCommonOutput<Count>;
+} : {}) & (Args extends {
+    _avg: infer Avg;
+} ? {
+    /**
+     * Average aggregation result
+     */
+    _avg: AggCommonOutput<Avg>;
+} : {}) & (Args extends {
+    _sum: infer Sum;
+} ? {
+    /**
+     * Sum aggregation result
+     */
+    _sum: AggCommonOutput<Sum>;
+} : {}) & (Args extends {
+    _min: infer Min;
+} ? {
+    /**
+     * Minimum aggregation result
+     */
+    _min: AggCommonOutput<Min>;
+} : {}) & (Args extends {
+    _max: infer Max;
+} ? {
+    /**
+     * Maximum aggregation result
+     */
+    _max: AggCommonOutput<Max>;
+} : {})>;
+type ConnectInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>> = FieldIsArray<Schema, Model, Field> extends true ? OrArray<WhereUniqueInput<Schema, RelationFieldType<Schema, Model, Field>>> : WhereUniqueInput<Schema, RelationFieldType<Schema, Model, Field>>;
+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<{
+    /**
+     * Unique filter to select the record to update.
+     */
+    where: WhereUniqueInput<Schema, RelationFieldType<Schema, Model, Field>>;
+    /**
+     * The data to update the record with.
+     */
+    data: UpdateInput<Schema, RelationFieldType<Schema, Model, Field>, OppositeRelationAndFK<Schema, Model, Field>>;
+}, true> : XOR<{
+    /**
+     * Filter to select the record to update.
+     */
+    where?: WhereInput<Schema, RelationFieldType<Schema, Model, Field>>;
+    /**
+     * The data to update the record with.
+     */
+    data: UpdateInput<Schema, RelationFieldType<Schema, Model, Field>, OppositeRelationAndFK<Schema, Model, Field>>;
+}, UpdateInput<Schema, RelationFieldType<Schema, Model, Field>, OppositeRelationAndFK<Schema, Model, Field>>>;
+type NestedUpsertInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>> = OrArray<{
+    /**
+     * Unique filter to select the record to update.
+     */
+    where: WhereUniqueInput<Schema, RelationFieldType<Schema, Model, Field>>;
+    /**
+     * The data to create the record if it doesn't exist.
+     */
+    create: CreateInput<Schema, RelationFieldType<Schema, Model, Field>, OppositeRelationAndFK<Schema, Model, Field>>;
+    /**
+     * The data to update the record with if it exists.
+     */
+    update: UpdateInput<Schema, RelationFieldType<Schema, Model, Field>, OppositeRelationAndFK<Schema, Model, Field>>;
+}, FieldIsArray<Schema, Model, Field>>;
+type NestedUpdateManyInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>> = OrArray<UpdateManyPayload<Schema, RelationFieldType<Schema, Model, Field>, OppositeRelationAndFK<Schema, Model, Field>>>;
+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 GetProcedureNames<Schema extends SchemaDef> = Schema extends {
+    procedures: Record<string, ProcedureDef>;
+} ? keyof Schema['procedures'] : never;
+type GetProcedureParams<Schema extends SchemaDef, ProcName extends GetProcedureNames<Schema>> = Schema extends {
+    procedures: Record<string, ProcedureDef>;
+} ? Schema['procedures'][ProcName]['params'] : never;
+type GetProcedure<Schema extends SchemaDef, ProcName extends GetProcedureNames<Schema>> = Schema extends {
+    procedures: Record<string, ProcedureDef>;
+} ? Schema['procedures'][ProcName] : never;
+type _OptionalProcedureParamNames<Params> = keyof {
+    [K in keyof Params as Params[K] extends {
+        optional: true;
+    } ? K : never]: K;
+};
+type _RequiredProcedureParamNames<Params> = keyof {
+    [K in keyof Params as Params[K] extends {
+        optional: true;
+    } ? never : K]: K;
+};
+type _HasRequiredProcedureParams<Params> = _RequiredProcedureParamNames<Params> extends never ? false : true;
+type MapProcedureArgsObject<Schema extends SchemaDef, Params> = Simplify<Optional<{
+    [K in keyof Params]: MapProcedureParam<Schema, Params[K]>;
+}, _OptionalProcedureParamNames<Params>>>;
+type ProcedureEnvelope<Schema extends SchemaDef, ProcName extends GetProcedureNames<Schema>, Params = GetProcedureParams<Schema, ProcName>> = keyof Params extends never ? {
+    args?: Record<string, never>;
+} : _HasRequiredProcedureParams<Params> extends true ? {
+    args: MapProcedureArgsObject<Schema, Params>;
+} : {
+    args?: MapProcedureArgsObject<Schema, Params>;
+};
+type ProcedureHandlerCtx<Schema extends SchemaDef, ProcName extends GetProcedureNames<Schema>> = {
+    client: ClientContract<Schema>;
+} & ProcedureEnvelope<Schema, ProcName>;
+/**
+ * Shape of a procedure's runtime function.
+ */
+type ProcedureFunc<Schema extends SchemaDef, ProcName extends GetProcedureNames<Schema>> = (...args: _HasRequiredProcedureParams<GetProcedureParams<Schema, ProcName>> extends true ? [input: ProcedureEnvelope<Schema, ProcName>] : [input?: ProcedureEnvelope<Schema, ProcName>]) => MaybePromise<MapProcedureReturn<Schema, GetProcedure<Schema, ProcName>>>;
+/**
+ * Signature for procedure handlers configured via client options.
+ */
+type ProcedureHandlerFunc<Schema extends SchemaDef, ProcName extends GetProcedureNames<Schema>> = (ctx: ProcedureHandlerCtx<Schema, ProcName>) => MaybePromise<MapProcedureReturn<Schema, GetProcedure<Schema, ProcName>>>;
+type MapProcedureReturn<Schema extends SchemaDef, Proc> = Proc extends {
+    returnType: infer R;
+} ? Proc extends {
+    returnArray: true;
+} ? Array<MapType<Schema, R & string>> : MapType<Schema, R & string> : never;
+type MapProcedureParam<Schema extends SchemaDef, P> = P extends {
+    type: infer U;
+} ? OrUndefinedIf<P extends {
+    array: true;
+} ? Array<MapType<Schema, U & string>> : MapType<Schema, U & string>, P extends {
+    optional: true;
+} ? true : false> : never;
+type NonOwnedRelationFields<Schema extends SchemaDef, Model extends GetModels<Schema>> = keyof {
+    [Key in RelationFields<Schema, Model> as GetModelField<Schema, Model, Key>['relation'] extends {
+        references: readonly unknown[];
+    } ? never : Key]: true;
+};
+type HasToManyRelations<Schema extends SchemaDef, Model extends GetModels<Schema>> = keyof {
+    [Key in RelationFields<Schema, Model> as FieldIsArray<Schema, Model, Key> extends true ? Key : never]: true;
+} extends never ? false : true;
+type EnumValue<Schema extends SchemaDef, Enum extends GetEnums<Schema>> = GetEnum<Schema, Enum>[keyof GetEnum<Schema, Enum>];
+type MapType<Schema extends SchemaDef, T extends string> = T extends keyof TypeMap ? TypeMap[T] : T extends GetModels<Schema> ? ModelResult<Schema, T> : T extends GetTypeDefs<Schema> ? TypeDefResult<Schema, T> : T extends GetEnums<Schema> ? EnumValue<Schema, T> : unknown;
+
+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, _array: boolean): 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): any;
+    private buildJsonFilter;
+    private buildPlainJsonFilter;
+    private buildTypedJsonFilter;
+    private buildTypedJsonArrayFilter;
+    private buildTypeJsonNonArrayFilter;
+    private buildJsonValueFilterClause;
+    private buildLiteralFilter;
+    private buildStandardFilter;
+    private buildStringFilter;
+    private buildJsonStringFilter;
+    private escapeLikePattern;
+    private buildStringLike;
+    private prepStringCasing;
+    private buildNumberFilter;
+    private buildBooleanFilter;
+    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;
+    };
+    /**
+     * Builds a JSON path selection expression.
+     */
+    protected abstract buildJsonPathSelection(receiver: Expression<any>, path: string | undefined): Expression<any>;
+    /**
+     * Builds a JSON array filter expression.
+     */
+    protected abstract buildJsonArrayFilter(receiver: Expression<any>, operation: 'array_contains' | 'array_starts_with' | 'array_ends_with', value: unknown): Expression<SqlBool>;
+    /**
+     * Builds a JSON array exists predicate (returning if any element matches the filter).
+     */
+    protected abstract buildJsonArrayExistsPredicate(receiver: Expression<any>, buildFilter: (elem: Expression<any>) => Expression<SqlBool>): Expression<SqlBool>;
+}
+
+declare class InputValidator<Schema extends SchemaDef> {
+    private readonly client;
+    private readonly schemaCache;
+    constructor(client: ClientContract<Schema>);
+    private get schema();
+    private get options();
+    private get extraValidationsEnabled();
+    validateProcedureInput(proc: string, input: unknown): unknown;
+    private makeProcedureParamSchema;
+    validateFindArgs(model: GetModels<Schema>, args: unknown, operation: CoreCrudOperations): FindArgs<Schema, GetModels<Schema>, true> | undefined;
+    validateExistsArgs(model: GetModels<Schema>, args: unknown): ExistsArgs<Schema, GetModels<Schema>> | undefined;
+    validateCreateArgs(model: GetModels<Schema>, args: unknown): CreateArgs<Schema, GetModels<Schema>>;
+    validateCreateManyArgs(model: GetModels<Schema>, args: unknown): CreateManyArgs<Schema, GetModels<Schema>>;
+    validateCreateManyAndReturnArgs(model: GetModels<Schema>, args: unknown): CreateManyAndReturnArgs<Schema, GetModels<Schema>> | undefined;
+    validateUpdateArgs(model: GetModels<Schema>, args: unknown): UpdateArgs<Schema, GetModels<Schema>>;
+    validateUpdateManyArgs(model: GetModels<Schema>, args: unknown): UpdateManyArgs<Schema, GetModels<Schema>>;
+    validateUpdateManyAndReturnArgs(model: GetModels<Schema>, args: unknown): UpdateManyAndReturnArgs<Schema, GetModels<Schema>>;
+    validateUpsertArgs(model: GetModels<Schema>, args: unknown): UpsertArgs<Schema, GetModels<Schema>>;
+    validateDeleteArgs(model: GetModels<Schema>, args: unknown): DeleteArgs<Schema, GetModels<Schema>>;
+    validateDeleteManyArgs(model: GetModels<Schema>, args: unknown): DeleteManyArgs<Schema, GetModels<Schema>> | undefined;
+    validateCountArgs(model: GetModels<Schema>, args: unknown): CountArgs<Schema, GetModels<Schema>> | undefined;
+    validateAggregateArgs(model: GetModels<Schema>, args: unknown): AggregateArgs<Schema, GetModels<Schema>>;
+    validateGroupByArgs(model: GetModels<Schema>, args: unknown): GroupByArgs<Schema, GetModels<Schema>>;
+    private getSchemaCache;
+    private setSchemaCache;
+    private validate;
+    private mergePluginArgsSchema;
+    private getPluginExtQueryArgsSchema;
+    private makeFindSchema;
+    private makeExistsSchema;
+    private makeScalarSchema;
+    private makeEnumSchema;
+    private makeTypeDefSchema;
+    private makeWhereSchema;
+    private makeTypedJsonFilterSchema;
+    private isTypeDefType;
+    private makeEnumFilterSchema;
+    private makeArrayFilterSchema;
+    private internalMakeArrayFilterSchema;
+    private makePrimitiveFilterSchema;
+    private makeJsonValueSchema;
+    private makeJsonFilterSchema;
+    private makeDateTimeFilterSchema;
+    private makeBooleanFilterSchema;
+    private makeBytesFilterSchema;
+    private makeCommonPrimitiveFilterComponents;
+    private makeCommonPrimitiveFilterSchema;
+    private makeNumberFilterSchema;
+    private makeStringFilterSchema;
+    private makeStringModeSchema;
+    private makeSelectSchema;
+    private makeCountSelectionSchema;
+    private makeRelationSelectIncludeSchema;
+    private makeOmitSchema;
+    private makeIncludeSchema;
+    private makeOrderBySchema;
+    private makeDistinctSchema;
+    private makeCursorSchema;
+    private makeCreateSchema;
+    private makeCreateManySchema;
+    private makeCreateManyAndReturnSchema;
+    private makeCreateDataSchema;
+    private isDelegateDiscriminator;
+    private makeRelationManipulationSchema;
+    private makeSetDataSchema;
+    private makeConnectDataSchema;
+    private makeDisconnectDataSchema;
+    private makeDeleteRelationDataSchema;
+    private makeConnectOrCreateDataSchema;
+    private makeCreateManyDataSchema;
+    private makeUpdateSchema;
+    private makeUpdateManySchema;
+    private makeUpdateManyAndReturnSchema;
+    private makeUpsertSchema;
+    private makeUpdateDataSchema;
+    private makeDeleteSchema;
+    private makeDeleteManySchema;
+    makeCountSchema(model: GetModels<Schema>): z.ZodOptional<z.ZodObject<z.core.$ZodLooseShape, z.core.$strict>>;
+    private makeCountAggregateInputSchema;
+    makeAggregateSchema(model: GetModels<Schema>): z.ZodOptional<z.ZodObject<z.core.$ZodLooseShape, z.core.$strict>>;
+    makeSumAvgInputSchema(model: GetModels<Schema>): z.ZodObject<Record<string, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>, z.core.$strict>;
+    makeMinMaxInputSchema(model: GetModels<Schema>): z.ZodObject<Record<string, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>, z.core.$strict>;
+    private makeGroupBySchema;
+    private onlyAggregationFields;
+    private makeHavingSchema;
+    private makeSkipSchema;
+    private makeTakeSchema;
+    private refineForSelectIncludeMutuallyExclusive;
+    private refineForSelectOmitMutuallyExclusive;
+    private nullableIf;
+    private orArray;
+    private isNumericField;
+    private get providerSupportsCaseSensitivity();
+}
+
+/**
+ * List of core CRUD operations. It excludes the 'orThrow' variants.
+ */
+declare const CoreCrudOperations: readonly ["findMany", "findUnique", "findFirst", "create", "createMany", "createManyAndReturn", "update", "updateMany", "updateManyAndReturn", "upsert", "delete", "deleteMany", "count", "aggregate", "groupBy", "exists"];
+/**
+ * List of core CRUD operations. It excludes the 'orThrow' variants.
+ */
+type CoreCrudOperations = (typeof CoreCrudOperations)[number];
+/**
+ * List of core read operations. It excludes the 'orThrow' variants.
+ */
+declare const CoreReadOperations: readonly ["findMany", "findUnique", "findFirst", "count", "aggregate", "groupBy", "exists"];
+/**
+ * List of core read operations. It excludes the 'orThrow' variants.
+ */
+type CoreReadOperations = (typeof CoreReadOperations)[number];
+/**
+ * List of core write operations.
+ */
+declare const CoreWriteOperations: readonly ["create", "createMany", "createManyAndReturn", "update", "updateMany", "updateManyAndReturn", "upsert", "delete", "deleteMany"];
+/**
+ * List of core write operations.
+ */
+type CoreWriteOperations = (typeof CoreWriteOperations)[number];
+/**
+ * List of core create operations.
+ */
+declare const CoreCreateOperations: readonly ["create", "createMany", "createManyAndReturn", "upsert"];
+/**
+ * List of core create operations.
+ */
+type CoreCreateOperations = (typeof CoreCreateOperations)[number];
+/**
+ * List of core update operations.
+ */
+declare const CoreUpdateOperations: readonly ["update", "updateMany", "updateManyAndReturn", "upsert"];
+/**
+ * List of core update operations.
+ */
+type CoreUpdateOperations = (typeof CoreUpdateOperations)[number];
+/**
+ * List of core delete operations.
+ */
+declare const CoreDeleteOperations: readonly ["delete", "deleteMany"];
+/**
+ * List of core delete operations.
+ */
+type CoreDeleteOperations = (typeof CoreDeleteOperations)[number];
+/**
+ * List of all CRUD operations, including 'orThrow' variants.
+ */
+declare const AllCrudOperations: readonly ["findMany", "findUnique", "findFirst", "create", "createMany", "createManyAndReturn", "update", "updateMany", "updateManyAndReturn", "upsert", "delete", "deleteMany", "count", "aggregate", "groupBy", "exists", "findUniqueOrThrow", "findFirstOrThrow"];
+/**
+ * List of all CRUD operations, including 'orThrow' variants.
+ */
+type AllCrudOperations = (typeof AllCrudOperations)[number];
+/**
+ * List of all read operations, including 'orThrow' variants.
+ */
+declare const AllReadOperations: readonly ["findMany", "findUnique", "findFirst", "count", "aggregate", "groupBy", "exists", "findUniqueOrThrow", "findFirstOrThrow"];
+/**
+ * List of all read operations, including 'orThrow' variants.
+ */
+type AllReadOperations = (typeof AllReadOperations)[number];
+
+type AllowedExtQueryArgKeys = CoreCrudOperations | '$create' | '$read' | '$update' | '$delete' | '$all';
+/**
+ * Base shape of plugin-extended query args.
+ */
+type ExtQueryArgsBase = {
+    [K in AllowedExtQueryArgKeys]?: object;
+};
+/**
+ * Base type for plugin-extended client members (methods and properties).
+ * Member names should start with '$' to avoid model name conflicts.
+ */
+type ExtClientMembersBase = Record<string, unknown>;
+/**
+ * ZenStack runtime plugin.
+ */
+interface RuntimePlugin<Schema extends SchemaDef, ExtQueryArgs extends ExtQueryArgsBase, ExtClientMembers extends Record<string, unknown>> {
+    /**
+     * Plugin ID.
      */
-    updateMany?: NestedUpdateManyInput<Schema, Model, Field>;
+    id: string;
     /**
-     * Deletes related records.
+     * Plugin display name.
      */
-    delete?: NestedDeleteInput<Schema, Model, Field>;
+    name?: string;
     /**
-     * Deletes a batch of related records.
+     * Plugin description.
      */
-    deleteMany?: NestedDeleteManyInput<Schema, Model, Field>;
+    description?: string;
     /**
-     * Sets the related records to the specified ones.
+     * Custom function implementations.
+     * @private
      */
-    set?: SetRelationInput<Schema, Model, Field>;
-}, FieldIsDelegateRelation<Schema, Model, Field> extends true ? 'create' | 'createMany' | 'connectOrCreate' | 'upsert' : never>;
-type ToOneRelationUpdateInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>> = Omit<{
+    functions?: Record<string, ZModelFunction<Schema>>;
     /**
-     * Creates a related record.
+     * Intercepts an ORM query.
      */
-    create?: NestedCreateInput<Schema, Model, Field>;
+    onQuery?: OnQueryCallback<Schema>;
     /**
-     * Connects an existing record.
+     * Intercepts a procedure invocation.
      */
-    connect?: ConnectInput<Schema, Model, Field>;
+    onProcedure?: OnProcedureCallback<Schema>;
     /**
-     * Connects or create a related record.
+     * Intercepts an entity mutation.
      */
-    connectOrCreate?: ConnectOrCreateInput<Schema, Model, Field>;
+    onEntityMutation?: EntityMutationHooksDef<Schema>;
     /**
-     * Updates the related record.
+     * Intercepts a Kysely query.
      */
-    update?: NestedUpdateInput<Schema, Model, Field>;
+    onKyselyQuery?: OnKyselyQueryCallback<Schema>;
     /**
-     * Upserts the related record.
+     * Extended query args configuration.
      */
-    upsert?: NestedUpsertInput<Schema, Model, Field>;
-} & (ModelFieldIsOptional<Schema, Model, Field> extends true ? {
+    queryArgs?: {
+        [K in keyof ExtQueryArgs]: ZodType<ExtQueryArgs[K]>;
+    };
     /**
-     * Disconnects the related record.
+     * Extended client members (methods and properties).
      */
-    disconnect?: DisconnectInput<Schema, Model, Field>;
+    client?: ExtClientMembers;
+}
+type AnyPlugin = RuntimePlugin<any, any, any>;
+/**
+ * Defines a ZenStack runtime plugin.
+ */
+declare function definePlugin<Schema extends SchemaDef, const ExtQueryArgs extends ExtQueryArgsBase = {}, const ExtClientMembers extends Record<string, unknown> = {}>(plugin: RuntimePlugin<Schema, ExtQueryArgs, ExtClientMembers>): RuntimePlugin<any, ExtQueryArgs, ExtClientMembers>;
+type OnProcedureCallback<Schema extends SchemaDef> = (ctx: OnProcedureHookContext<Schema>) => Promise<unknown>;
+type OnProcedureHookContext<Schema extends SchemaDef> = {
     /**
-     * Deletes the related record.
+     * The procedure name.
      */
-    delete?: NestedDeleteInput<Schema, Model, Field>;
-} : {}), FieldIsDelegateRelation<Schema, Model, Field> extends true ? 'create' | 'connectOrCreate' | 'upsert' : never>;
-type DeleteArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
+    name: string;
     /**
-     * The unique filter to find the record to delete.
+     * Whether the procedure is a mutation.
      */
-    where: WhereUniqueInput<Schema, Model>;
-} & SelectIncludeOmit<Schema, Model, true>;
-type DeleteManyArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
+    mutation: boolean;
     /**
-     * Filter to select records to delete.
+     * Procedure invocation input (envelope).
+     *
+     * The canonical shape is `{ args?: Record<string, unknown> }`.
+     * When a procedure has required params, `args` is required.
      */
-    where?: WhereInput<Schema, Model>;
+    input: unknown;
     /**
-     * Limits the number of records to delete.
+     * Continues the invocation. The input passed here is forwarded to the next handler.
      */
-    limit?: number;
-};
-type CountArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = Omit<FindArgs<Schema, Model, true>, 'select' | 'include' | 'distinct' | 'omit'> & {
+    proceed: (input: unknown) => Promise<unknown>;
     /**
-     * Selects fields to count
+     * The ZenStack client that is invoking the procedure.
      */
-    select?: CountAggregateInput<Schema, Model> | true;
-};
-type CountAggregateInput<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
-    [Key in NonRelationFields<Schema, Model>]?: true;
-} & {
-    _all?: true;
+    client: ClientContract<Schema>;
 };
-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>> = {
-    /**
-     * Filter conditions
-     */
-    where?: WhereInput<Schema, Model>;
-    /**
-     * Number of records to skip for the aggregation
-     */
-    skip?: number;
-    /**
-     * Number of records to take for the aggregation
-     */
-    take?: number;
-    /**
-     * Order by clauses
-     */
-    orderBy?: OrArray<OrderBy<Schema, Model, true, false>>;
-} & {
+type OnQueryCallback<Schema extends SchemaDef> = (ctx: OnQueryHookContext<Schema>) => Promise<unknown>;
+type OnQueryHookContext<Schema extends SchemaDef> = {
     /**
-     * Performs count aggregation.
+     * The model that is being queried.
      */
-    _count?: true | CountAggregateInput<Schema, Model>;
+    model: GetModels<Schema>;
     /**
-     * Performs minimum value aggregation.
+     * The operation that is being performed.
      */
-    _min?: MinMaxInput<Schema, Model, true>;
+    operation: AllCrudOperations;
     /**
-     * Performs maximum value aggregation.
+     * The query arguments.
      */
-    _max?: MinMaxInput<Schema, Model, true>;
-} & (NumericFields<Schema, Model> extends never ? {} : {
+    args: Record<string, unknown> | undefined;
     /**
-     * Performs average value aggregation.
+     * The function to proceed with the original query.
+     * It takes the same arguments as the operation method.
+     *
+     * @param args The query arguments.
      */
-    _avg?: SumAvgInput<Schema, Model, true>;
+    proceed: (args: Record<string, unknown> | undefined) => Promise<unknown>;
     /**
-     * Performs sum value aggregation.
+     * The ZenStack client that is performing the operation.
      */
-    _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;
+    client: ClientContract<Schema>;
 };
-type AggregateResult<Schema extends SchemaDef, _Model extends GetModels<Schema>, Args> = (Args extends {
-    _count: infer Count;
-} ? {
-    /**
-     * Count aggregation result
-     */
-    _count: AggCommonOutput<Count>;
-} : {}) & (Args extends {
-    _sum: infer Sum;
-} ? {
-    /**
-     * Sum aggregation result
-     */
-    _sum: AggCommonOutput<Sum>;
-} : {}) & (Args extends {
-    _avg: infer Avg;
-} ? {
-    /**
-     * Average aggregation result
-     */
-    _avg: AggCommonOutput<Avg>;
-} : {}) & (Args extends {
-    _min: infer Min;
-} ? {
-    /**
-     * Minimum aggregation result
-     */
-    _min: AggCommonOutput<Min>;
-} : {}) & (Args extends {
-    _max: infer Max;
-} ? {
-    /**
-     * Maximum aggregation result
-     */
-    _max: AggCommonOutput<Max>;
-} : {});
-type AggCommonOutput<Input> = Input extends true ? number : Input extends {} ? {
-    [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>> = {
-    /**
-     * Filter conditions
-     */
-    where?: WhereInput<Schema, Model>;
-    /**
-     * Order by clauses
-     */
-    orderBy?: OrArray<OrderBy<Schema, Model, false, true>>;
-    /**
-     * Fields to group by
-     */
-    by: NonRelationFields<Schema, Model> | NonEmptyArray<NonRelationFields<Schema, Model>>;
-    /**
-     * Filter conditions for the grouped records
-     */
-    having?: GroupByHaving<Schema, Model>;
-    /**
-     * Number of records to take for grouping
-     */
-    take?: number;
-    /**
-     * Number of records to skip for grouping
-     */
-    skip?: number;
-    /**
-     * Performs count aggregation.
-     */
-    _count?: true | CountAggregateInput<Schema, Model>;
-    /**
-     * Performs minimum value aggregation.
-     */
-    _min?: MinMaxInput<Schema, Model, true>;
-    /**
-     * Performs maximum value aggregation.
-     */
-    _max?: MinMaxInput<Schema, Model, true>;
-} & (NumericFields<Schema, Model> extends never ? {} : {
-    /**
-     * Performs average value aggregation.
-     */
-    _avg?: SumAvgInput<Schema, Model, true>;
-    /**
-     * Performs sum value aggregation.
-     */
-    _sum?: SumAvgInput<Schema, Model, true>;
-});
-type GroupByResult<Schema extends SchemaDef, Model extends GetModels<Schema>, Args extends {
-    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 aggregation result
-     */
-    _count: AggCommonOutput<Count>;
-} : {}) & (Args extends {
-    _avg: infer Avg;
-} ? {
+type EntityMutationHooksDef<Schema extends SchemaDef> = {
     /**
-     * Average aggregation result
+     * Called before entities are mutated.
      */
-    _avg: AggCommonOutput<Avg>;
-} : {}) & (Args extends {
-    _sum: infer Sum;
-} ? {
+    beforeEntityMutation?: BeforeEntityMutationCallback<Schema>;
     /**
-     * Sum aggregation result
-     */
-    _sum: AggCommonOutput<Sum>;
-} : {}) & (Args extends {
-    _min: infer Min;
-} ? {
+     * Called after entities are mutated.
+     */
+    afterEntityMutation?: AfterEntityMutationCallback<Schema>;
     /**
-     * Minimum aggregation result
+     * 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`.
      */
-    _min: AggCommonOutput<Min>;
-} : {}) & (Args extends {
-    _max: infer Max;
-} ? {
+    runAfterMutationWithinTransaction?: boolean;
+};
+type MutationHooksArgs<Schema extends SchemaDef> = {
     /**
-     * Maximum aggregation result
+     * The model that is being mutated.
      */
-    _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<{
+    model: GetModels<Schema>;
     /**
-     * Unique filter to select the record to update.
+     * The mutation action that is being performed.
      */
-    where: WhereUniqueInput<Schema, RelationFieldType<Schema, Model, Field>>;
+    action: 'create' | 'update' | 'delete';
     /**
-     * The data to update the record with.
+     * The mutation data. Only available for create and update actions.
      */
-    data: UpdateInput<Schema, RelationFieldType<Schema, Model, Field>, OppositeRelationAndFK<Schema, Model, Field>>;
-}, true> : XOR<{
+    queryNode: OperationNode;
     /**
-     * Filter to select the record to update.
+     * A query ID that uniquely identifies the mutation operation. You can use it to correlate
+     * data between the before and after mutation hooks.
      */
-    where?: WhereInput<Schema, RelationFieldType<Schema, Model, Field>>;
+    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> & {
     /**
-     * The data to update the record with.
+     * 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.
      */
-    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<{
+    loadBeforeMutationEntities(): Promise<Record<string, unknown>[] | undefined>;
     /**
-     * Unique filter to select the record to update.
+     * 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.
      */
-    where: WhereUniqueInput<Schema, RelationFieldType<Schema, Model, Field>>;
+    client: ClientContract<Schema>;
+};
+type PluginAfterEntityMutationArgs<Schema extends SchemaDef> = MutationHooksArgs<Schema> & {
     /**
-     * The data to create the record if it doesn't exist.
+     * Loads the entities that have been mutated.
      */
-    create: CreateInput<Schema, RelationFieldType<Schema, Model, Field>, OppositeRelationAndFK<Schema, Model, Field>>;
+    loadAfterMutationEntities(): Promise<Record<string, unknown>[] | undefined>;
     /**
-     * The data to update the record with if it exists.
+     * 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.
      */
-    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 GetProcedureNames<Schema extends SchemaDef> = Schema extends {
-    procedures: Record<string, ProcedureDef>;
-} ? keyof Schema['procedures'] : never;
-type GetProcedureParams<Schema extends SchemaDef, ProcName extends GetProcedureNames<Schema>> = Schema extends {
-    procedures: Record<string, ProcedureDef>;
-} ? Schema['procedures'][ProcName]['params'] : never;
-type GetProcedure<Schema extends SchemaDef, ProcName extends GetProcedureNames<Schema>> = Schema extends {
-    procedures: Record<string, ProcedureDef>;
-} ? Schema['procedures'][ProcName] : never;
-type _OptionalProcedureParamNames<Params> = keyof {
-    [K in keyof Params as Params[K] extends {
-        optional: true;
-    } ? K : never]: K;
-};
-type _RequiredProcedureParamNames<Params> = keyof {
-    [K in keyof Params as Params[K] extends {
-        optional: true;
-    } ? never : K]: K;
-};
-type _HasRequiredProcedureParams<Params> = _RequiredProcedureParamNames<Params> extends never ? false : true;
-type MapProcedureArgsObject<Schema extends SchemaDef, Params> = Simplify<Optional<{
-    [K in keyof Params]: MapProcedureParam<Schema, Params[K]>;
-}, _OptionalProcedureParamNames<Params>>>;
-type ProcedureEnvelope<Schema extends SchemaDef, ProcName extends GetProcedureNames<Schema>, Params = GetProcedureParams<Schema, ProcName>> = keyof Params extends never ? {
-    args?: Record<string, never>;
-} : _HasRequiredProcedureParams<Params> extends true ? {
-    args: MapProcedureArgsObject<Schema, Params>;
-} : {
-    args?: MapProcedureArgsObject<Schema, Params>;
+    client: ClientContract<Schema>;
 };
-type ProcedureHandlerCtx<Schema extends SchemaDef, ProcName extends GetProcedureNames<Schema>> = {
+type OnKyselyQueryArgs<Schema extends SchemaDef> = {
+    schema: SchemaDef;
     client: ClientContract<Schema>;
-} & ProcedureEnvelope<Schema, ProcName>;
-/**
- * Shape of a procedure's runtime function.
- */
-type ProcedureFunc<Schema extends SchemaDef, ProcName extends GetProcedureNames<Schema>> = (...args: _HasRequiredProcedureParams<GetProcedureParams<Schema, ProcName>> extends true ? [input: ProcedureEnvelope<Schema, ProcName>] : [input?: ProcedureEnvelope<Schema, ProcName>]) => MaybePromise<MapProcedureReturn<Schema, GetProcedure<Schema, ProcName>>>;
-/**
- * Signature for procedure handlers configured via client options.
- */
-type ProcedureHandlerFunc<Schema extends SchemaDef, ProcName extends GetProcedureNames<Schema>> = (ctx: ProcedureHandlerCtx<Schema, ProcName>) => MaybePromise<MapProcedureReturn<Schema, GetProcedure<Schema, ProcName>>>;
-type MapProcedureReturn<Schema extends SchemaDef, Proc> = Proc extends {
-    returnType: infer R;
-} ? Proc extends {
-    returnArray: true;
-} ? Array<MapType<Schema, R & string>> : MapType<Schema, R & string> : never;
-type MapProcedureParam<Schema extends SchemaDef, P> = P extends {
-    type: infer U;
-} ? OrUndefinedIf<P extends {
-    array: true;
-} ? Array<MapType<Schema, U & string>> : MapType<Schema, U & string>, P extends {
-    optional: true;
-} ? true : false> : never;
-type NonOwnedRelationFields<Schema extends SchemaDef, Model extends GetModels<Schema>> = keyof {
-    [Key in RelationFields<Schema, Model> as GetModelField<Schema, Model, Key>['relation'] extends {
-        references: readonly unknown[];
-    } ? never : Key]: true;
+    query: RootOperationNode;
+    proceed: ProceedKyselyQueryFunction;
 };
-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 EnumValue<Schema extends SchemaDef, Enum extends GetEnums<Schema>> = GetEnum<Schema, Enum>[keyof GetEnum<Schema, Enum>];
-type MapType<Schema extends SchemaDef, T extends string> = T extends keyof TypeMap ? TypeMap[T] : T extends GetModels<Schema> ? ModelResult<Schema, T> : T extends GetTypeDefs<Schema> ? TypeDefResult<Schema, T> : T extends GetEnums<Schema> ? EnumValue<Schema, T> : unknown;
+type ProceedKyselyQueryFunction = (query: RootOperationNode) => Promise<QueryResult<any>>;
+type OnKyselyQueryCallback<Schema extends SchemaDef> = (args: OnKyselyQueryArgs<Schema>) => Promise<QueryResult<UnknownRow>>;
 
 /**
  * A promise that only executes when it's awaited or .then() is called.
@@ -1744,6 +1701,10 @@ type ZenStackPromise<Schema extends SchemaDef, T> = Promise<T> & {
 };
 
 type TransactionUnsupportedMethods = (typeof TRANSACTION_UNSUPPORTED_METHODS)[number];
+/**
+ * Extracts extended query args for a specific operation.
+ */
+type ExtractExtQueryArgs<ExtQueryArgs, Operation extends CoreCrudOperations> = (Operation extends keyof ExtQueryArgs ? ExtQueryArgs[Operation] : {}) & ('$create' extends keyof ExtQueryArgs ? Operation extends CoreCreateOperations ? ExtQueryArgs['$create'] : {} : {}) & ('$read' extends keyof ExtQueryArgs ? (Operation extends CoreReadOperations ? ExtQueryArgs['$read'] : {}) : {}) & ('$update' extends keyof ExtQueryArgs ? Operation extends CoreUpdateOperations ? ExtQueryArgs['$update'] : {} : {}) & ('$delete' extends keyof ExtQueryArgs ? Operation extends CoreDeleteOperations ? ExtQueryArgs['$delete'] : {} : {}) & ('$all' extends keyof ExtQueryArgs ? ExtQueryArgs['$all'] : {});
 /**
  * Transaction isolation levels.
  */
@@ -1757,7 +1718,7 @@ declare enum TransactionIsolationLevel {
 /**
  * ZenStack client interface.
  */
-type ClientContract<Schema extends SchemaDef, Options extends ClientOptions<Schema> = ClientOptions<Schema>> = {
+type ClientContract<Schema extends SchemaDef, Options extends ClientOptions<Schema> = ClientOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase = {}, ExtClientMembers extends ExtClientMembersBase = {}> = {
     /**
      * The schema definition.
      */
@@ -1807,7 +1768,7 @@ type ClientContract<Schema extends SchemaDef, Options extends ClientOptions<Sche
     /**
      * Sets the current user identity.
      */
-    $setAuth(auth: AuthType<Schema> | undefined): ClientContract<Schema, Options>;
+    $setAuth(auth: AuthType<Schema> | undefined): ClientContract<Schema, Options, ExtQueryArgs, ExtClientMembers>;
     /**
      * Returns a new client with new options applied.
      * @example
@@ -1815,14 +1776,14 @@ type ClientContract<Schema extends SchemaDef, Options extends ClientOptions<Sche
      * const dbNoValidation = db.$setOptions({ ...db.$options, validateInput: false });
      * ```
      */
-    $setOptions<Options extends ClientOptions<Schema>>(options: Options): ClientContract<Schema, Options>;
+    $setOptions<NewOptions extends ClientOptions<Schema>>(options: NewOptions): ClientContract<Schema, NewOptions, ExtQueryArgs, ExtClientMembers>;
     /**
      * Returns a new client enabling/disabling input validations expressed with attributes like
      * `@email`, `@regex`, `@@validate`, etc.
      *
-     * @deprecated Use `$setOptions` instead.
+     * @deprecated Use {@link $setOptions} instead.
      */
-    $setInputValidation(enable: boolean): ClientContract<Schema, Options>;
+    $setInputValidation(enable: boolean): ClientContract<Schema, Options, ExtQueryArgs, ExtClientMembers>;
     /**
      * The Kysely query builder instance.
      */
@@ -1834,7 +1795,7 @@ type ClientContract<Schema extends SchemaDef, Options extends ClientOptions<Sche
     /**
      * Starts an interactive transaction.
      */
-    $transaction<T>(callback: (tx: Omit<ClientContract<Schema, Options>, TransactionUnsupportedMethods>) => Promise<T>, options?: {
+    $transaction<T>(callback: (tx: TransactionClientContract<Schema, Options, ExtQueryArgs, ExtClientMembers>) => Promise<T>, options?: {
         isolationLevel?: TransactionIsolationLevel;
     }): Promise<T>;
     /**
@@ -1846,11 +1807,11 @@ type ClientContract<Schema extends SchemaDef, Options extends ClientOptions<Sche
     /**
      * Returns a new client with the specified plugin installed.
      */
-    $use(plugin: RuntimePlugin<Schema>): ClientContract<Schema, Options>;
+    $use<PluginSchema extends SchemaDef = Schema, PluginExtQueryArgs extends ExtQueryArgsBase = {}, PluginExtClientMembers extends ExtClientMembersBase = {}>(plugin: RuntimePlugin<PluginSchema, PluginExtQueryArgs, PluginExtClientMembers>): ClientContract<Schema, Options, ExtQueryArgs & PluginExtQueryArgs, ExtClientMembers & PluginExtClientMembers>;
     /**
      * Returns a new client with the specified plugin removed.
      */
-    $unuse(pluginId: string): ClientContract<Schema, Options>;
+    $unuse(pluginId: string): ClientContract<Schema, Options, ExtQueryArgs, ExtClientMembers>;
     /**
      * Returns a new client with all plugins removed.
      */
@@ -1869,12 +1830,12 @@ type ClientContract<Schema extends SchemaDef, Options extends ClientOptions<Sche
      */
     $pushSchema(): Promise<void>;
 } & {
-    [Key in GetModels<Schema> as Uncapitalize<Key>]: ModelOperations<Schema, Key, ToQueryOptions<Options>>;
-} & ProcedureOperations<Schema>;
+    [Key in GetModels<Schema> as Uncapitalize<Key>]: ModelOperations<Schema, Key, ToQueryOptions<Options>, ExtQueryArgs>;
+} & ProcedureOperations<Schema> & ExtClientMembers;
 /**
  * The contract for a client in a transaction.
  */
-type TransactionClientContract<Schema extends SchemaDef, Options extends ClientOptions<Schema>> = Omit<ClientContract<Schema, Options>, TransactionUnsupportedMethods>;
+type TransactionClientContract<Schema extends SchemaDef, Options extends ClientOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase, ExtClientMembers extends ExtClientMembersBase> = Omit<ClientContract<Schema, Options, ExtQueryArgs, ExtClientMembers>, TransactionUnsupportedMethods>;
 type ProcedureOperations<Schema extends SchemaDef> = Schema['procedures'] extends Record<string, ProcedureDef> ? {
     /**
      * Custom procedures.
@@ -1905,7 +1866,7 @@ type CRUD_EXT = CRUD | 'post-update';
  * Extended CRUD operations including 'post-update'.
  */
 declare const CRUD_EXT: readonly ["create", "read", "update", "delete", "post-update"];
-type AllModelOperations<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema>> = {
+type AllModelOperations<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema>, ExtQueryArgs> = {
     /**
      * Returns a list of entities.
      * @param args - query args
@@ -1987,35 +1948,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, SimplifiedPlainResult<Schema, Model, T, Options>[]>;
+    findMany<T extends FindManyArgs<Schema, Model> & ExtractExtQueryArgs<ExtQueryArgs, 'findMany'>>(args?: SelectSubset<T, FindManyArgs<Schema, Model> & ExtractExtQueryArgs<ExtQueryArgs, 'findMany'>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options>[]>;
     /**
      * Returns a uniquely identified entity.
      * @param args - query args
      * @returns a single entity or null if not found
      * @see {@link findMany}
      */
-    findUnique<T extends FindUniqueArgs<Schema, Model>>(args: SelectSubset<T, FindUniqueArgs<Schema, Model>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options> | null>;
+    findUnique<T extends FindUniqueArgs<Schema, Model> & ExtractExtQueryArgs<ExtQueryArgs, 'findUnique'>>(args: SelectSubset<T, FindUniqueArgs<Schema, Model> & ExtractExtQueryArgs<ExtQueryArgs, 'findUnique'>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options> | null>;
     /**
      * Returns a uniquely identified entity or throws `NotFoundError` if not found.
      * @param args - query args
      * @returns a single entity
      * @see {@link findMany}
      */
-    findUniqueOrThrow<T extends FindUniqueArgs<Schema, Model>>(args: SelectSubset<T, FindUniqueArgs<Schema, Model>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options>>;
+    findUniqueOrThrow<T extends FindUniqueArgs<Schema, Model> & ExtractExtQueryArgs<ExtQueryArgs, 'findUnique'>>(args: SelectSubset<T, FindUniqueArgs<Schema, Model> & ExtractExtQueryArgs<ExtQueryArgs, 'findUnique'>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options>>;
     /**
      * Returns the first entity.
      * @param args - query args
      * @returns a single entity or null if not found
      * @see {@link findMany}
      */
-    findFirst<T extends FindFirstArgs<Schema, Model>>(args?: SelectSubset<T, FindFirstArgs<Schema, Model>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options> | null>;
+    findFirst<T extends FindFirstArgs<Schema, Model> & ExtractExtQueryArgs<ExtQueryArgs, 'findFirst'>>(args?: SelectSubset<T, FindFirstArgs<Schema, Model> & ExtractExtQueryArgs<ExtQueryArgs, 'findFirst'>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options> | null>;
     /**
      * Returns the first entity or throws `NotFoundError` if not found.
      * @param args - query args
      * @returns a single entity
      * @see {@link findMany}
      */
-    findFirstOrThrow<T extends FindFirstArgs<Schema, Model>>(args?: SelectSubset<T, FindFirstArgs<Schema, Model>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options>>;
+    findFirstOrThrow<T extends FindFirstArgs<Schema, Model> & ExtractExtQueryArgs<ExtQueryArgs, 'findFirst'>>(args?: SelectSubset<T, FindFirstArgs<Schema, Model> & ExtractExtQueryArgs<ExtQueryArgs, 'findFirst'>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options>>;
     /**
      * Creates a new entity.
      * @param args - create args
@@ -2068,7 +2029,7 @@ type AllModelOperations<Schema extends SchemaDef, Model extends GetModels<Schema
      * });
      * ```
      */
-    create<T extends CreateArgs<Schema, Model>>(args: SelectSubset<T, CreateArgs<Schema, Model>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options>>;
+    create<T extends CreateArgs<Schema, Model> & ExtractExtQueryArgs<ExtQueryArgs, 'create'>>(args: SelectSubset<T, CreateArgs<Schema, Model> & ExtractExtQueryArgs<ExtQueryArgs, 'create'>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options>>;
     /**
      * Creates multiple entities. Only scalar fields are allowed.
      * @param args - create args
@@ -2094,7 +2055,7 @@ type AllModelOperations<Schema extends SchemaDef, Model extends GetModels<Schema
      * });
      * ```
      */
-    createMany<T extends CreateManyArgs<Schema, Model>>(args?: SelectSubset<T, CreateManyArgs<Schema, Model>>): ZenStackPromise<Schema, BatchResult>;
+    createMany<T extends CreateManyArgs<Schema, Model> & ExtractExtQueryArgs<ExtQueryArgs, 'createMany'>>(args?: SelectSubset<T, CreateManyArgs<Schema, Model> & ExtractExtQueryArgs<ExtQueryArgs, 'createMany'>>): ZenStackPromise<Schema, BatchResult>;
     /**
      * Creates multiple entities and returns them.
      * @param args - create args. See {@link createMany} for input. Use
@@ -2113,7 +2074,7 @@ type AllModelOperations<Schema extends SchemaDef, Model extends GetModels<Schema
      * });
      * ```
      */
-    createManyAndReturn<T extends CreateManyAndReturnArgs<Schema, Model>>(args?: SelectSubset<T, CreateManyAndReturnArgs<Schema, Model>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options>[]>;
+    createManyAndReturn<T extends CreateManyAndReturnArgs<Schema, Model> & ExtractExtQueryArgs<ExtQueryArgs, 'createManyAndReturn'>>(args?: SelectSubset<T, CreateManyAndReturnArgs<Schema, Model> & ExtractExtQueryArgs<ExtQueryArgs, 'createManyAndReturn'>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options>[]>;
     /**
      * Updates a uniquely identified entity.
      * @param args - update args. See {@link findMany} for how to control
@@ -2231,7 +2192,7 @@ type AllModelOperations<Schema extends SchemaDef, Model extends GetModels<Schema
      * });
      * ```
      */
-    update<T extends UpdateArgs<Schema, Model>>(args: SelectSubset<T, UpdateArgs<Schema, Model>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options>>;
+    update<T extends UpdateArgs<Schema, Model> & ExtractExtQueryArgs<ExtQueryArgs, 'update'>>(args: SelectSubset<T, UpdateArgs<Schema, Model> & ExtractExtQueryArgs<ExtQueryArgs, 'update'>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options>>;
     /**
      * Updates multiple entities.
      * @param args - update args. Only scalar fields are allowed for data.
@@ -2252,7 +2213,7 @@ type AllModelOperations<Schema extends SchemaDef, Model extends GetModels<Schema
      *     limit: 10
      * });
      */
-    updateMany<T extends UpdateManyArgs<Schema, Model>>(args: Subset<T, UpdateManyArgs<Schema, Model>>): ZenStackPromise<Schema, BatchResult>;
+    updateMany<T extends UpdateManyArgs<Schema, Model> & ExtractExtQueryArgs<ExtQueryArgs, 'updateMany'>>(args: Subset<T, UpdateManyArgs<Schema, Model> & ExtractExtQueryArgs<ExtQueryArgs, 'updateMany'>>): ZenStackPromise<Schema, BatchResult>;
     /**
      * Updates multiple entities and returns them.
      * @param args - update args. Only scalar fields are allowed for data.
@@ -2275,7 +2236,7 @@ type AllModelOperations<Schema extends SchemaDef, Model extends GetModels<Schema
      * });
      * ```
      */
-    updateManyAndReturn<T extends UpdateManyAndReturnArgs<Schema, Model>>(args: Subset<T, UpdateManyAndReturnArgs<Schema, Model>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options>[]>;
+    updateManyAndReturn<T extends UpdateManyAndReturnArgs<Schema, Model> & ExtractExtQueryArgs<ExtQueryArgs, 'updateManyAndReturn'>>(args: Subset<T, UpdateManyAndReturnArgs<Schema, Model> & ExtractExtQueryArgs<ExtQueryArgs, 'updateManyAndReturn'>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options>[]>;
     /**
      * Creates or updates an entity.
      * @param args - upsert args
@@ -2296,7 +2257,7 @@ type AllModelOperations<Schema extends SchemaDef, Model extends GetModels<Schema
      * });
      * ```
      */
-    upsert<T extends UpsertArgs<Schema, Model>>(args: SelectSubset<T, UpsertArgs<Schema, Model>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options>>;
+    upsert<T extends UpsertArgs<Schema, Model> & ExtractExtQueryArgs<ExtQueryArgs, 'upsert'>>(args: SelectSubset<T, UpsertArgs<Schema, Model> & ExtractExtQueryArgs<ExtQueryArgs, 'upsert'>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options>>;
     /**
      * Deletes a uniquely identifiable entity.
      * @param args - delete args
@@ -2316,7 +2277,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, SimplifiedPlainResult<Schema, Model, T, Options>>;
+    delete<T extends DeleteArgs<Schema, Model> & ExtractExtQueryArgs<ExtQueryArgs, 'delete'>>(args: SelectSubset<T, DeleteArgs<Schema, Model> & ExtractExtQueryArgs<ExtQueryArgs, 'delete'>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options>>;
     /**
      * Deletes multiple entities.
      * @param args - delete args
@@ -2336,7 +2297,7 @@ type AllModelOperations<Schema extends SchemaDef, Model extends GetModels<Schema
      * });
      * ```
      */
-    deleteMany<T extends DeleteManyArgs<Schema, Model>>(args?: Subset<T, DeleteManyArgs<Schema, Model>>): ZenStackPromise<Schema, BatchResult>;
+    deleteMany<T extends DeleteManyArgs<Schema, Model> & ExtractExtQueryArgs<ExtQueryArgs, 'deleteMany'>>(args?: Subset<T, DeleteManyArgs<Schema, Model> & ExtractExtQueryArgs<ExtQueryArgs, 'deleteMany'>>): ZenStackPromise<Schema, BatchResult>;
     /**
      * Counts rows or field values.
      * @param args - count args
@@ -2355,7 +2316,7 @@ type AllModelOperations<Schema extends SchemaDef, Model extends GetModels<Schema
      *     select: { _all: true, email: true }
      * }); // result: `{ _all: number, email: number }`
      */
-    count<T extends CountArgs<Schema, Model>>(args?: Subset<T, CountArgs<Schema, Model>>): ZenStackPromise<Schema, Simplify<CountResult<Schema, Model, T>>>;
+    count<T extends CountArgs<Schema, Model> & ExtractExtQueryArgs<ExtQueryArgs, 'count'>>(args?: Subset<T, CountArgs<Schema, Model> & ExtractExtQueryArgs<ExtQueryArgs, 'count'>>): ZenStackPromise<Schema, Simplify<CountResult<Schema, Model, T>>>;
     /**
      * Aggregates rows.
      * @param args - aggregation args
@@ -2373,7 +2334,7 @@ type AllModelOperations<Schema extends SchemaDef, Model extends GetModels<Schema
      *     _max: { age: true }
      * }); // result: `{ _count: number, _avg: { age: number }, ... }`
      */
-    aggregate<T extends AggregateArgs<Schema, Model>>(args: Subset<T, AggregateArgs<Schema, Model>>): ZenStackPromise<Schema, Simplify<AggregateResult<Schema, Model, T>>>;
+    aggregate<T extends AggregateArgs<Schema, Model> & ExtractExtQueryArgs<ExtQueryArgs, 'aggregate'>>(args: Subset<T, AggregateArgs<Schema, Model> & ExtractExtQueryArgs<ExtQueryArgs, 'aggregate'>>): ZenStackPromise<Schema, Simplify<AggregateResult<Schema, Model, T>>>;
     /**
      * Groups rows by columns.
      * @param args - groupBy args
@@ -2407,7 +2368,7 @@ type AllModelOperations<Schema extends SchemaDef, Model extends GetModels<Schema
      *     having: { country: 'US', age: { _avg: { gte: 18 } } }
      * });
      */
-    groupBy<T extends GroupByArgs<Schema, Model>>(args: Subset<T, GroupByArgs<Schema, Model>>): ZenStackPromise<Schema, Simplify<GroupByResult<Schema, Model, T>>>;
+    groupBy<T extends GroupByArgs<Schema, Model> & ExtractExtQueryArgs<ExtQueryArgs, 'groupBy'>>(args: Subset<T, GroupByArgs<Schema, Model> & ExtractExtQueryArgs<ExtQueryArgs, 'groupBy'>>): ZenStackPromise<Schema, Simplify<GroupByResult<Schema, Model, T>>>;
     /**
      * Checks if an entity exists.
      * @param args - exists args
@@ -2425,10 +2386,10 @@ type AllModelOperations<Schema extends SchemaDef, Model extends GetModels<Schema
      *     where: { posts: { some: { published: true } } },
      * }); // result: `boolean`
      */
-    exists<T extends ExistsArgs<Schema, Model>>(args?: Subset<T, ExistsArgs<Schema, Model>>): ZenStackPromise<Schema, boolean>;
+    exists<T extends ExistsArgs<Schema, Model> & ExtractExtQueryArgs<ExtQueryArgs, 'exists'>>(args?: Subset<T, ExistsArgs<Schema, Model> & ExtractExtQueryArgs<ExtQueryArgs, 'exists'>>): ZenStackPromise<Schema, boolean>;
 };
 type OperationsIneligibleForDelegateModels = 'create' | 'createMany' | 'createManyAndReturn' | 'upsert';
-type ModelOperations<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>> = Omit<AllModelOperations<Schema, Model, Options>, IsDelegateModel<Schema, Model> extends true ? OperationsIneligibleForDelegateModels : never>;
+type ModelOperations<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>, ExtQueryArgs = {}> = Omit<AllModelOperations<Schema, Model, Options, ExtQueryArgs>, 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: { ... } } }
@@ -2438,6 +2399,117 @@ type AuthModelType<Schema extends SchemaDef, Model extends GetModels<Schema>> =
 };
 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>;
 
+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.
+     *
+     * @private
+     */
+    functions?: Record<string, ZModelFunction<Schema>>;
+    /**
+     * Plugins.
+     */
+    plugins?: AnyPlugin[];
+    /**
+     * 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?: OmitConfig<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>;
+} : {});
+/**
+ * Config for omitting fields in ORM query results.
+ */
+type OmitConfig<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 GetProcedureNames<Schema>]: ProcedureHandlerFunc<Schema, Key>;
+} : {};
+type HasProcedures<Schema extends SchemaDef> = Schema extends {
+    procedures: Record<string, ProcedureDef>;
+} ? true : false;
+/**
+ * Subset of client options relevant to query operations.
+ */
+type QueryOptions<Schema extends SchemaDef> = Pick<ClientOptions<Schema>, 'omit'>;
+/**
+ * Extract QueryOptions from ClientOptions
+ */
+type ToQueryOptions<T extends ClientOptions<any>> = Pick<T, 'omit'>;
+
 /**
  * ZenStack ORM client.
  */
@@ -2670,4 +2742,4 @@ declare namespace schemaUtils {
   export { schemaUtils_ExpressionVisitor as ExpressionVisitor, schemaUtils_MatchingExpressionVisitor as MatchingExpressionVisitor, type schemaUtils_VisitResult as VisitResult };
 }
 
-export { type AfterEntityMutationCallback, type AggregateArgs, type AggregateResult, type AllModelOperations, AnyNull, AnyNullClass, type AuthType, BaseCrudDialect, type BatchResult, type BeforeEntityMutationCallback, type BooleanFilter, type BytesFilter, CRUD, CRUD_EXT, type ClientConstructor, type ClientContract, type ClientOptions, type ComputedFieldsOptions, type CountArgs, type CountResult, type CreateArgs, type CreateInput, type CreateManyAndReturnArgs, type CreateManyArgs, type CreateManyInput, type CoreCrudOperation as CrudOperation, type DateTimeFilter, DbNull, DbNullClass, type DefaultModelResult, type DeleteArgs, type DeleteManyArgs, type EntityMutationHooksDef, type ExistsArgs, type FindArgs, type FindFirstArgs, type FindManyArgs, type FindUniqueArgs, type GetProcedure, type GetProcedureNames, type GetProcedureParams, type GroupByArgs, type GroupByResult, type HasComputedFields, type HasProcedures, type IncludeInput, InputValidator, type JsonArray, type JsonFilter, JsonNull, JsonNullClass, type JsonNullValues, type JsonObject, type JsonValue, kyselyUtils as KyselyUtils, type ModelOperations, type ModelResult, type NullsOrder, type NumberFilter, ORMError, ORMErrorReason, type OmitInput, type OmitOptions, type OnKyselyQueryArgs, type OnKyselyQueryCallback, type OnProcedureHookContext, type OperationsIneligibleForDelegateModels, type OrderBy, type PluginAfterEntityMutationArgs, type PluginBeforeEntityMutationArgs, type ProcedureEnvelope, type ProcedureFunc, type ProcedureHandlerFunc, type ProcedureOperations, type ProceduresOptions, type ProceedKyselyQueryFunction, type QueryOptions, queryUtils as QueryUtils, RejectedByPolicyReason, type RuntimePlugin, schemaUtils as SchemaUtils, type SelectIncludeOmit, type SelectInput, type SelectSubset, type SimplifiedPlainResult, type SimplifiedResult, type SortOrder, type StringFilter, type Subset, type ToKysely, type ToQueryOptions, type TransactionClientContract, TransactionIsolationLevel, type TypeDefResult, type TypedJsonFilter, type UpdateArgs, type UpdateInput, type UpdateManyAndReturnArgs, type UpdateManyArgs, type UpsertArgs, type WhereInput, type WhereUniqueInput, type ZModelFunction, type ZModelFunctionContext, ZenStackClient, type ZenStackPromise, definePlugin, getCrudDialect };
+export { type AfterEntityMutationCallback, type AggregateArgs, type AggregateResult, AllCrudOperations, type AllModelOperations, AllReadOperations, AnyNull, AnyNullClass, type AnyPlugin, type AuthType, BaseCrudDialect, type BatchResult, type BeforeEntityMutationCallback, type BooleanFilter, type BytesFilter, CRUD, CRUD_EXT, type ClientConstructor, type ClientContract, type ClientOptions, type ComputedFieldsOptions, CoreCreateOperations, CoreCrudOperations, CoreDeleteOperations, CoreReadOperations, CoreUpdateOperations, CoreWriteOperations, type CountArgs, type CountResult, type CreateArgs, type CreateInput, type CreateManyAndReturnArgs, type CreateManyArgs, type CreateManyInput, type DateTimeFilter, DbNull, DbNullClass, type DefaultModelResult, type DeleteArgs, type DeleteManyArgs, type EntityMutationHooksDef, type ExistsArgs, type ExtClientMembersBase, type ExtQueryArgsBase, type FindArgs, type FindFirstArgs, type FindManyArgs, type FindUniqueArgs, type GetProcedure, type GetProcedureNames, type GetProcedureParams, type GroupByArgs, type GroupByResult, type HasComputedFields, type HasProcedures, type IncludeInput, InputValidator, type JsonArray, type JsonFilter, JsonNull, JsonNullClass, type JsonNullValues, type JsonObject, type JsonValue, kyselyUtils as KyselyUtils, type ModelOperations, type ModelResult, type NullsOrder, type NumberFilter, ORMError, ORMErrorReason, type OmitConfig, type OmitInput, type OnKyselyQueryArgs, type OnKyselyQueryCallback, type OnProcedureHookContext, type OperationsIneligibleForDelegateModels, type OrderBy, type PluginAfterEntityMutationArgs, type PluginBeforeEntityMutationArgs, type ProcedureEnvelope, type ProcedureFunc, type ProcedureHandlerFunc, type ProcedureOperations, type ProceduresOptions, type ProceedKyselyQueryFunction, type QueryOptions, queryUtils as QueryUtils, RejectedByPolicyReason, type RuntimePlugin, schemaUtils as SchemaUtils, type SelectIncludeOmit, type SelectInput, type SelectSubset, type SimplifiedPlainResult, type SimplifiedResult, type SortOrder, type StringFilter, type Subset, type ToKysely, type ToQueryOptions, type TransactionClientContract, TransactionIsolationLevel, type TypeDefResult, type TypedJsonFilter, type UpdateArgs, type UpdateInput, type UpdateManyAndReturnArgs, type UpdateManyArgs, type UpsertArgs, type WhereInput, type WhereUniqueInput, type ZModelFunction, type ZModelFunctionContext, ZenStackClient, type ZenStackPromise, definePlugin, getCrudDialect };