@zenstackhq/orm 3.4.0-beta.1 → 3.4.0-beta.3

package/dist/index.d.ts

@@ -1,79 +1,10 @@
 import * as _zenstackhq_schema 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, UpdatedAtInfo, FieldIsDelegateDiscriminator, FieldType, RelationInfo, FieldIsDelegateRelation, ProcedureDef, ModelDef, DataSourceProviderType, IsDelegateModel, Expression as Expression$1, LiteralExpression, ArrayExpression, FieldExpression, MemberExpression, BinaryExpression, UnaryExpression, CallExpression, BindingExpression, ThisExpression, NullExpression } from '@zenstackhq/schema';
+import { SchemaDef, BuiltinType, GetModels, FieldDef, ModelDef, DataSourceProviderType, ScalarFields, ForeignKeyFields, GetModelFields, FieldHasDefault, GetModelFieldType, ModelFieldIsOptional, GetModelField, GetModel, ProcedureDef, NonRelationFields, GetEnums, GetEnum, GetTypeDefs, GetTypeDefFields, GetTypeDefField, TypeDefFieldIsOptional, RelationFields, FieldIsArray, RelationFieldType, FieldIsRelation, GetTypeDefFieldType, TypeDefFieldIsArray, UpdatedAtInfo, FieldIsDelegateDiscriminator, FieldType, RelationInfo, FieldIsDelegateRelation, IsDelegateModel, Expression as Expression$1, LiteralExpression, ArrayExpression, FieldExpression, MemberExpression, BinaryExpression, UnaryExpression, CallExpression, BindingExpression, ThisExpression, NullExpression } from '@zenstackhq/schema';
 import * as kysely from 'kysely';
-import { OperationNodeVisitor, OperationNode, SelectQueryNode, SelectionNode, ColumnNode, AliasNode, TableNode, FromNode, ReferenceNode, AndNode, OrNode, ValueListNode, ParensNode, JoinNode, RawNode, WhereNode, InsertQueryNode, DeleteQueryNode, ReturningNode, CreateTableNode, AddColumnNode, ColumnDefinitionNode, DropTableNode, OrderByNode, OrderByItemNode, GroupByNode, GroupByItemNode, UpdateQueryNode, ColumnUpdateNode, LimitNode, OffsetNode, OnConflictNode, OnDuplicateKeyNode, CheckConstraintNode, DataTypeNode, SelectAllNode, IdentifierNode, SchemableIdentifierNode, ValueNode, PrimitiveValueListNode, OperatorNode, CreateIndexNode, DropIndexNode, ListNode, PrimaryKeyConstraintNode, UniqueConstraintNode, ReferencesNode, WithNode, CommonTableExpressionNode, CommonTableExpressionNameNode, HavingNode, CreateSchemaNode, DropSchemaNode, AlterTableNode, DropColumnNode, RenameColumnNode, AlterColumnNode, ModifyColumnNode, AddConstraintNode, DropConstraintNode, ForeignKeyConstraintNode, CreateViewNode, DropViewNode, GeneratedNode, DefaultValueNode, OnNode, ValuesNode, SelectModifierNode, CreateTypeNode, DropTypeNode, ExplainNode, DefaultInsertValueNode, AggregateFunctionNode, OverNode, PartitionByNode, PartitionByItemNode, SetOperationNode, BinaryOperationNode, UnaryOperationNode, UsingNode, FunctionNode, CaseNode, WhenNode, JSONReferenceNode, JSONPathNode, JSONPathLegNode, JSONOperatorChainNode, TupleNode, MergeQueryNode, MatchedNode, AddIndexNode, CastNode, FetchNode, TopNode, OutputNode, RenameConstraintNode, RefreshMaterializedViewNode, OrActionNode, CollateNode, Kysely, Generated, ExpressionBuilder, OperandExpression, SqlBool, SelectQueryBuilder, Expression, ExpressionWrapper, AliasableExpression, QueryId, RootOperationNode, QueryResult, UnknownRow, Dialect, KyselyConfig } from 'kysely';
+import { OperationNodeVisitor, OperationNode, SelectQueryNode, SelectionNode, ColumnNode, AliasNode, TableNode, FromNode, ReferenceNode, AndNode, OrNode, ValueListNode, ParensNode, JoinNode, RawNode, WhereNode, InsertQueryNode, DeleteQueryNode, ReturningNode, CreateTableNode, AddColumnNode, ColumnDefinitionNode, DropTableNode, OrderByNode, OrderByItemNode, GroupByNode, GroupByItemNode, UpdateQueryNode, ColumnUpdateNode, LimitNode, OffsetNode, OnConflictNode, OnDuplicateKeyNode, CheckConstraintNode, DataTypeNode, SelectAllNode, IdentifierNode, SchemableIdentifierNode, ValueNode, PrimitiveValueListNode, OperatorNode, CreateIndexNode, DropIndexNode, ListNode, PrimaryKeyConstraintNode, UniqueConstraintNode, ReferencesNode, WithNode, CommonTableExpressionNode, CommonTableExpressionNameNode, HavingNode, CreateSchemaNode, DropSchemaNode, AlterTableNode, DropColumnNode, RenameColumnNode, AlterColumnNode, ModifyColumnNode, AddConstraintNode, DropConstraintNode, ForeignKeyConstraintNode, CreateViewNode, DropViewNode, GeneratedNode, DefaultValueNode, OnNode, ValuesNode, SelectModifierNode, CreateTypeNode, DropTypeNode, ExplainNode, DefaultInsertValueNode, AggregateFunctionNode, OverNode, PartitionByNode, PartitionByItemNode, SetOperationNode, BinaryOperationNode, UnaryOperationNode, UsingNode, FunctionNode, CaseNode, WhenNode, JSONReferenceNode, JSONPathNode, JSONPathLegNode, JSONOperatorChainNode, TupleNode, MergeQueryNode, MatchedNode, AddIndexNode, CastNode, FetchNode, TopNode, OutputNode, RenameConstraintNode, RefreshMaterializedViewNode, OrActionNode, CollateNode, Kysely, ExpressionBuilder, SelectQueryBuilder, Expression, SqlBool, ExpressionWrapper, AliasableExpression, Generated, QueryId, RootOperationNode, QueryResult, UnknownRow, Dialect, KyselyConfig, OperandExpression } from 'kysely';
 import Decimal from 'decimal.js';
 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;
     protected visitSelectQuery(node: SelectQueryNode): void;
@@ -183,6 +114,75 @@ 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.
  */
@@ -194,1554 +194,1883 @@ declare const LOGICAL_COMBINATORS: readonly ["AND", "OR", "NOT"];
 /**
  * Aggregation operators.
  */
-declare const AGGREGATE_OPERATORS: readonly ["_count", "_sum", "_avg", "_min", "_max"];
-type AGGREGATE_OPERATORS = (typeof AGGREGATE_OPERATORS)[number];
-
-type ToKyselySchema<Schema extends SchemaDef> = {
-    [Model in GetModels<Schema>]: ToKyselyTable<Schema, Model>;
-};
-type ToKysely<Schema extends SchemaDef> = Kysely<ToKyselySchema<Schema>>;
-type ToKyselyTable<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
-    [Field in ScalarFields<Schema, Model, false> | ForeignKeyFields<Schema, Model> as GetModelField<Schema, Model, Field>['originModel'] extends string ? never : Field]: toKyselyFieldType<Schema, Model, Field>;
+declare const AggregateOperators: readonly ["_count", "_sum", "_avg", "_min", "_max"];
+type AggregateOperators = (typeof AggregateOperators)[number];
+/**
+ * Mapping of filter operators to their corresponding filter kind categories.
+ */
+declare const FILTER_PROPERTY_TO_KIND: {
+    readonly equals: "Equality";
+    readonly not: "Equality";
+    readonly in: "Equality";
+    readonly notIn: "Equality";
+    readonly lt: "Range";
+    readonly lte: "Range";
+    readonly gt: "Range";
+    readonly gte: "Range";
+    readonly between: "Range";
+    readonly contains: "Like";
+    readonly startsWith: "Like";
+    readonly endsWith: "Like";
+    readonly mode: "Like";
+    readonly is: "Relation";
+    readonly isNot: "Relation";
+    readonly some: "Relation";
+    readonly every: "Relation";
+    readonly none: "Relation";
+    readonly path: "Json";
+    readonly string_contains: "Json";
+    readonly string_starts_with: "Json";
+    readonly string_ends_with: "Json";
+    readonly array_contains: "Json";
+    readonly array_starts_with: "Json";
+    readonly array_ends_with: "Json";
+    readonly has: "List";
+    readonly hasEvery: "List";
+    readonly hasSome: "List";
+    readonly isEmpty: "List";
 };
-type MapBaseType<T> = T extends 'String' ? string : T extends 'Boolean' ? boolean : T extends 'Int' | 'Float' ? number : T extends 'BigInt' ? bigint : T extends 'Decimal' ? Decimal : T extends 'DateTime' ? string : unknown;
-type WrapNull<T, Null> = Null extends true ? T | null : T;
-type MapType$1<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends 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>;
+/**
+ * Mapping of filter operators to their corresponding filter kind categories.
+ */
+type FilterPropertyToKind = typeof FILTER_PROPERTY_TO_KIND;
 
-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> | ({
-    /**
-     * Checks for equality with the specified enum value.
-     */
-    equals?: NullableIf<keyof GetEnum<Schema, T>, Nullable>;
-    /**
-     * Checks if the enum value is in the specified list of values.
-     */
-    in?: (keyof GetEnum<Schema, T>)[];
-    /**
-     * Checks if the enum value is not in the specified list of values.
-     */
-    notIn?: (keyof GetEnum<Schema, T>)[];
-    /**
-     * Builds a negated filter.
-     */
-    not?: EnumFilter<Schema, T, Nullable, WithAggregations>;
-} & (WithAggregations extends true ? {
-    /**
-     * Filters against the count of records.
-     */
-    _count?: NumberFilter<'Int', false, false>;
+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>);
     /**
-     * Filters against the minimum value.
+     * Whether the dialect supports updating with a limit on the number of updated rows.
      */
-    _min?: EnumFilter<Schema, T, false, false>;
+    abstract get supportsUpdateWithLimit(): boolean;
     /**
-     * Filters against the maximum value.
+     * Whether the dialect supports deleting with a limit on the number of deleted rows.
      */
-    _max?: EnumFilter<Schema, T, false, false>;
-} : {}));
-type ArrayFilter<Schema extends SchemaDef, Type extends string> = {
+    abstract get supportsDeleteWithLimit(): boolean;
     /**
-     * Checks if the array equals the specified array.
+     * Whether the dialect supports DISTINCT ON.
      */
-    equals?: MapScalarType<Schema, Type>[] | null;
+    abstract get supportsDistinctOn(): boolean;
     /**
-     * Checks if the array contains all elements of the specified array.
+     * Whether the dialect support inserting with `DEFAULT` as field value.
      */
-    has?: MapScalarType<Schema, Type> | null;
+    abstract get supportsDefaultAsFieldValue(): boolean;
     /**
-     * Checks if the array contains any of the elements of the specified array.
+     * Whether the dialect supports the RETURNING clause in INSERT/UPDATE/DELETE statements.
      */
-    hasEvery?: MapScalarType<Schema, Type>[];
+    abstract get supportsReturning(): boolean;
     /**
-     * Checks if the array contains some of the elements of the specified array.
+     * Whether the dialect supports `INSERT INTO ... DEFAULT VALUES` syntax.
      */
-    hasSome?: MapScalarType<Schema, Type>[];
+    abstract get supportsInsertDefaultValues(): boolean;
     /**
-     * Checks if the array is empty.
+     * How to perform insert ignore operation.
      */
-    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> = {
+    abstract get insertIgnoreMethod(): 'onConflict' | 'ignore';
     /**
-     * Checks for equality with the specified value.
+     * Transforms input value before sending to database.
      */
-    equals?: NullableIf<DataType, Nullable>;
+    transformInput(value: unknown, _type: BuiltinType, _forArrayField: boolean): unknown;
     /**
-     * Checks if the value is in the specified list of values.
+     * Transforms output value received from database.
      */
-    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;
-    /**
-     * Checks if the value is between the specified values (inclusive).
-     */
-    between?: [start: DataType, end: 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>;
+    transformOutput(value: unknown, _type: BuiltinType, _array: boolean): unknown;
+    buildSelectModel(model: string, modelAlias: string): SelectQueryBuilder<any, any, {}>;
+    buildFilterSortTake(model: string, args: FindArgs<Schema, GetModels<Schema>, any, 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;
+    protected buildJsonEqualityFilter(lhs: Expression<any>, rhs: unknown): ExpressionWrapper<any, any, SqlBool>;
+    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, take: number | undefined): 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>, any, 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): AliasableExpression<unknown>;
+    protected negateSort(sort: SortOrder, negated: boolean): SortOrder;
+    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>, any, true>): boolean;
+    abstract get provider(): DataSourceProviderType;
     /**
-     * Filters against the minimum value.
+     * Builds selection for a relation field.
      */
-    _min?: StringFilter<false, false>;
+    abstract buildRelationSelection(query: SelectQueryBuilder<any, any, any>, model: string, relationField: string, parentAlias: string, payload: true | FindArgs<Schema, GetModels<Schema>, any, true>): SelectQueryBuilder<any, any, any>;
     /**
-     * Filters against the maximum value.
+     * Builds skip and take clauses.
      */
-    _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 ? {
+    abstract buildSkipTake(query: SelectQueryBuilder<any, any, any>, skip: number | undefined, take: number | undefined): SelectQueryBuilder<any, any, any>;
     /**
-     * Filters against the count of records.
+     * Builds an Kysely expression that returns a JSON object for the given key-value pairs.
      */
-    _count?: NumberFilter<'Int', false, false>;
+    abstract buildJsonObject(value: Record<string, Expression<unknown>>): AliasableExpression<unknown>;
     /**
-     * Filters against the average value.
+     * Builds an Kysely expression that returns the length of an array.
      */
-    _avg?: NumberFilter<T, false, false>;
+    abstract buildArrayLength(array: Expression<unknown>): AliasableExpression<number>;
     /**
-     * Filters against the sum value.
+     * Builds an array value expression.
      */
-    _sum?: NumberFilter<T, false, false>;
+    abstract buildArrayValue(values: Expression<unknown>[], elemType: string): AliasableExpression<unknown>;
     /**
-     * Filters against the minimum value.
+     * Builds an expression that checks if an array contains a single value.
      */
-    _min?: NumberFilter<T, false, false>;
+    abstract buildArrayContains(field: Expression<unknown>, value: Expression<unknown>, elemType?: string): AliasableExpression<SqlBool>;
     /**
-     * Filters against the maximum value.
+     * Builds an expression that checks if an array contains all values from another array.
      */
-    _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 ? {
+    abstract buildArrayHasEvery(field: Expression<unknown>, values: Expression<unknown>): AliasableExpression<SqlBool>;
     /**
-     * Filters against the count of records.
+     * Builds an expression that checks if an array overlaps with another array.
      */
-    _count?: NumberFilter<'Int', false, false>;
+    abstract buildArrayHasSome(field: Expression<unknown>, values: Expression<unknown>): AliasableExpression<SqlBool>;
     /**
-     * Filters against the minimum value.
+     * Casts the given expression to an integer type.
      */
-    _min?: DateTimeFilter<false, false>;
+    abstract castInt<T extends Expression<any>>(expression: T): T;
     /**
-     * Filters against the maximum value.
+     * Casts the given expression to a text type.
      */
-    _max?: DateTimeFilter<false, false>;
-} : {}));
-type BytesFilter<Nullable extends boolean, WithAggregations extends boolean> = NullableIf<Uint8Array | Buffer, Nullable> | ({
+    abstract castText<T extends Expression<any>>(expression: T): T;
     /**
-     * Checks for equality with the specified value.
+     * Trims double quotes from the start and end of a text expression.
      */
-    equals?: NullableIf<Uint8Array, Nullable>;
+    abstract trimTextQuotes<T extends Expression<string>>(expression: T): T;
+    abstract getStringCasingBehavior(): {
+        supportsILike: boolean;
+        likeCaseSensitive: boolean;
+    };
     /**
-     * Checks if the value is in the specified list of values.
+     * Builds a VALUES table and select all fields from it.
      */
-    in?: Uint8Array[];
+    abstract buildValuesTableSelect(fields: FieldDef[], rows: unknown[][]): SelectQueryBuilder<any, any, any>;
     /**
-     * Checks if the value is not in the specified list of values.
+     * Builds a JSON path selection expression.
      */
-    notIn?: Uint8Array[];
+    protected abstract buildJsonPathSelection(receiver: Expression<any>, path: string | undefined): Expression<any>;
     /**
-     * Builds a negated filter.
+     * Builds a JSON array filter expression.
      */
-    not?: BytesFilter<Nullable, WithAggregations>;
-} & (WithAggregations extends true ? {
+    protected abstract buildJsonArrayFilter(receiver: Expression<any>, operation: 'array_contains' | 'array_starts_with' | 'array_ends_with', value: unknown): Expression<SqlBool>;
     /**
-     * Filters against the count of records.
+     * Builds a JSON array exists predicate (returning if any element matches the filter).
      */
-    _count?: NumberFilter<'Int', false, false>;
+    protected abstract buildJsonArrayExistsPredicate(receiver: Expression<any>, buildFilter: (elem: Expression<any>) => Expression<SqlBool>): Expression<SqlBool>;
     /**
-     * Filters against the minimum value.
+     * Builds an ORDER BY clause for a field with NULLS FIRST/LAST support.
      */
-    _min?: BytesFilter<false, false>;
+    protected abstract buildOrderByField(query: SelectQueryBuilder<any, any, any>, field: Expression<unknown>, sort: SortOrder, nulls: 'first' | 'last'): SelectQueryBuilder<any, any, any>;
+}
+
+type ToKyselySchema<Schema extends SchemaDef> = {
+    [Model in GetModels<Schema>]: ToKyselyTable<Schema, Model>;
+};
+type ToKysely<Schema extends SchemaDef> = Kysely<ToKyselySchema<Schema>>;
+type ToKyselyTable<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
+    [Field in ScalarFields<Schema, Model, false> | ForeignKeyFields<Schema, Model> as GetModelField<Schema, Model, Field>['originModel'] extends string ? never : Field]: toKyselyFieldType<Schema, Model, Field>;
+};
+type MapBaseType<T> = T extends 'String' ? string : T extends 'Boolean' ? boolean : T extends 'Int' | 'Float' ? number : T extends 'BigInt' ? bigint : T extends 'Decimal' ? Decimal : T extends 'DateTime' ? string : unknown;
+type WrapNull<T, Null> = Null extends true ? T | null : T;
+type MapType$1<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends 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;
+    private readonly schemaCache;
+    private readonly allFilterKinds;
+    constructor(client: ClientContract<Schema>);
+    private get schema();
+    private get options();
+    private get extraValidationsEnabled();
+    validateFindArgs(model: GetModels<Schema>, args: unknown, operation: CoreCrudOperations): FindArgs<Schema, GetModels<Schema>, any, true> | undefined;
+    validateExistsArgs(model: GetModels<Schema>, args: unknown): ExistsArgs<Schema, GetModels<Schema>, any> | undefined;
+    validateCreateArgs(model: GetModels<Schema>, args: unknown): CreateArgs<Schema, GetModels<Schema>, any>;
+    validateCreateManyArgs(model: GetModels<Schema>, args: unknown): CreateManyArgs<Schema, GetModels<Schema>>;
+    validateCreateManyAndReturnArgs(model: GetModels<Schema>, args: unknown): CreateManyAndReturnArgs<Schema, GetModels<Schema>, any> | undefined;
+    validateUpdateArgs(model: GetModels<Schema>, args: unknown): UpdateArgs<Schema, GetModels<Schema>, any>;
+    validateUpdateManyArgs(model: GetModels<Schema>, args: unknown): UpdateManyArgs<Schema, GetModels<Schema>, any>;
+    validateUpdateManyAndReturnArgs(model: GetModels<Schema>, args: unknown): UpdateManyAndReturnArgs<Schema, GetModels<Schema>, any>;
+    validateUpsertArgs(model: GetModels<Schema>, args: unknown): UpsertArgs<Schema, GetModels<Schema>, any>;
+    validateDeleteArgs(model: GetModels<Schema>, args: unknown): DeleteArgs<Schema, GetModels<Schema>, any>;
+    validateDeleteManyArgs(model: GetModels<Schema>, args: unknown): DeleteManyArgs<Schema, GetModels<Schema>, any> | undefined;
+    validateCountArgs(model: GetModels<Schema>, args: unknown): CountArgs<Schema, GetModels<Schema>, any> | undefined;
+    validateAggregateArgs(model: GetModels<Schema>, args: unknown): AggregateArgs<Schema, GetModels<Schema>, any>;
+    validateGroupByArgs(model: GetModels<Schema>, args: unknown): GroupByArgs<Schema, GetModels<Schema>, any>;
+    validateProcedureInput(proc: string, input: unknown): unknown;
+    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: string): z.ZodOptional<z.ZodObject<z.core.$ZodLooseShape, z.core.$strict>>;
+    private makeCountAggregateInputSchema;
+    makeAggregateSchema(model: string): z.ZodOptional<z.ZodObject<z.core.$ZodLooseShape, z.core.$strict>>;
+    makeSumAvgInputSchema(model: string): z.ZodObject<Record<string, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>, z.core.$strict>;
+    makeMinMaxInputSchema(model: string): z.ZodObject<Record<string, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>, z.core.$strict>;
+    private makeGroupBySchema;
+    private onlyAggregationFields;
+    private makeHavingSchema;
+    private makeProcedureParamSchema;
+    getCache(cacheKey: string): z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>> | undefined;
+    setCache(cacheKey: string, schema: ZodType): Map<string, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+    private printCacheStats;
+    private makeSkipSchema;
+    private makeTakeSchema;
+    private refineForSelectIncludeMutuallyExclusive;
+    private refineForSelectOmitMutuallyExclusive;
+    private nullableIf;
+    private orArray;
+    private isNumericField;
+    private get providerSupportsCaseSensitivity();
     /**
-     * Filters against the maximum value.
+     * Gets the effective set of allowed FilterKind values for a specific model and field.
+     * Respects the precedence: field-level > model-level $all > global $all.
      */
-    _max?: BytesFilter<false, false>;
-} : {}));
-type BooleanFilter<Nullable extends boolean, WithAggregations extends boolean> = NullableIf<boolean, Nullable> | ({
+    private getEffectiveFilterKinds;
     /**
-     * Checks for equality with the specified value.
+     * Computes the effective set of filter kinds based on inclusion and exclusion lists.
      */
-    equals?: NullableIf<boolean, Nullable>;
+    private computeFilterKinds;
     /**
-     * Builds a negated filter.
+     * Filters operators based on allowed filter kinds.
      */
-    not?: BooleanFilter<Nullable, WithAggregations>;
-} & (WithAggregations extends true ? {
+    private trimFilterOperators;
+    private createUnionFilterSchema;
     /**
-     * Filters against the count of records.
+     * Checks if a model is included in the slicing configuration.
+     * Returns true if the model is allowed, false if it's excluded.
      */
-    _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 = {
+    private isModelAllowed;
+}
+
+/**
+ * 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>> {
     /**
-     * JSON path to select the value to filter on. If omitted, the whole JSON value is used.
+     * Plugin ID.
      */
-    path?: string;
+    id: string;
     /**
-     * Checks for equality with the specified value.
+     * Plugin display name.
      */
-    equals?: JsonValue | JsonNullValues;
+    name?: string;
     /**
-     * Builds a negated filter.
+     * Plugin description.
      */
-    not?: JsonValue | JsonNullValues;
+    description?: string;
     /**
-     * Checks if the value is a string and contains the specified substring.
+     * Custom function implementations.
+     * @private
      */
-    string_contains?: string;
+    functions?: Record<string, ZModelFunction<Schema>>;
     /**
-     * Checks if the value is a string and starts with the specified substring.
+     * Intercepts an ORM query.
      */
-    string_starts_with?: string;
+    onQuery?: OnQueryCallback<Schema>;
     /**
-     * Checks if the value is a string and ends with the specified substring.
+     * Intercepts a procedure invocation.
      */
-    string_ends_with?: string;
+    onProcedure?: OnProcedureCallback<Schema>;
     /**
-     * String comparison mode. Not effective for "sqlite" provider
+     * Intercepts an entity mutation.
      */
-    mode?: 'default' | 'insensitive';
+    onEntityMutation?: EntityMutationHooksDef<Schema>;
     /**
-     * Checks if the value is an array and contains the specified value.
+     * Intercepts a Kysely query.
      */
-    array_contains?: JsonValue;
+    onKyselyQuery?: OnKyselyQueryCallback<Schema>;
     /**
-     * Checks if the value is an array and starts with the specified value.
+     * Extended query args configuration.
      */
-    array_starts_with?: JsonValue;
+    queryArgs?: {
+        [K in keyof ExtQueryArgs]: ZodType<ExtQueryArgs[K]>;
+    };
     /**
-     * Checks if the value is an array and ends with the specified value.
+     * Extended client members (methods and properties).
      */
-    array_ends_with?: JsonValue;
-};
-type TypedJsonFilter<Schema extends SchemaDef, TypeDefName extends GetTypeDefs<Schema>, Array extends boolean, Optional extends boolean> = XOR<JsonFilter, TypedJsonTypedFilter<Schema, TypeDefName, Array, Optional>>;
-type TypedJsonTypedFilter<Schema extends SchemaDef, TypeDefName extends GetTypeDefs<Schema>, Array extends boolean, Optional extends boolean> = (Array extends true ? ArrayTypedJsonFilter<Schema, TypeDefName> : NonArrayTypedJsonFilter<Schema, TypeDefName>) | (Optional extends true ? null : never);
-type ArrayTypedJsonFilter<Schema extends SchemaDef, TypeDefName extends GetTypeDefs<Schema>> = {
-    some?: TypedJsonFieldsFilter<Schema, TypeDefName>;
-    every?: TypedJsonFieldsFilter<Schema, TypeDefName>;
-    none?: TypedJsonFieldsFilter<Schema, TypeDefName>;
-};
-type NonArrayTypedJsonFilter<Schema extends SchemaDef, TypeDefName extends GetTypeDefs<Schema>> = {
-    is?: TypedJsonFieldsFilter<Schema, TypeDefName>;
-    isNot?: TypedJsonFieldsFilter<Schema, TypeDefName>;
-} | TypedJsonFieldsFilter<Schema, TypeDefName>;
-type TypedJsonFieldsFilter<Schema extends SchemaDef, TypeDefName extends GetTypeDefs<Schema>> = {
-    [Key in GetTypeDefFields<Schema, TypeDefName>]?: GetTypeDefFieldType<Schema, TypeDefName, Key> extends GetTypeDefs<Schema> ? TypedJsonFilter<Schema, GetTypeDefFieldType<Schema, TypeDefName, Key>, TypeDefFieldIsArray<Schema, TypeDefName, Key>, TypeDefFieldIsOptional<Schema, TypeDefName, Key>> : TypeDefFieldIsArray<Schema, TypeDefName, Key> extends true ? ArrayFilter<Schema, GetTypeDefFieldType<Schema, TypeDefName, Key>> : GetTypeDefFieldType<Schema, TypeDefName, Key> extends GetEnums<Schema> ? EnumFilter<Schema, GetTypeDefFieldType<Schema, TypeDefName, Key>, TypeDefFieldIsOptional<Schema, TypeDefName, Key>, false> : PrimitiveFilter<GetTypeDefFieldType<Schema, TypeDefName, Key>, TypeDefFieldIsOptional<Schema, TypeDefName, Key>, false>;
-};
-type SortOrder = 'asc' | 'desc';
-type NullsOrder = 'first' | 'last';
-type OrderBy<Schema extends SchemaDef, Model extends GetModels<Schema>, WithRelation extends boolean, WithAggregation extends boolean> = {
-    [Key in NonRelationFields<Schema, Model>]?: ModelFieldIsOptional<Schema, Model, Key> extends true ? SortOrder | {
-        /**
-         * Sort order
-         */
-        sort: SortOrder;
-        /**
-         * Treatment of null values
-         */
-        nulls?: NullsOrder;
-    } : SortOrder;
-} & (WithRelation extends true ? {
-    [Key in RelationFields<Schema, Model>]?: FieldIsArray<Schema, Model, Key> extends true ? {
-        /**
-         * Sorts by the count of related records.
-         */
-        _count?: SortOrder;
-    } : OrderBy<Schema, RelationFieldType<Schema, Model, Key>, WithRelation, WithAggregation>;
-} : {}) & (WithAggregation extends true ? {
+    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> = {
     /**
-     * Sorts by the count of records.
+     * The procedure name.
      */
-    _count?: OrderBy<Schema, Model, false, false>;
+    name: string;
     /**
-     * Sorts by the minimum value.
+     * Whether the procedure is a mutation.
      */
-    _min?: MinMaxInput<Schema, Model, SortOrder>;
+    mutation: boolean;
     /**
-     * Sorts by the maximum value.
+     * Procedure invocation input (envelope).
+     *
+     * The canonical shape is `{ args?: Record<string, unknown> }`.
+     * When a procedure has required params, `args` is required.
      */
-    _max?: MinMaxInput<Schema, Model, SortOrder>;
-} & (NumericFields<Schema, Model> extends never ? {} : {
+    input: unknown;
     /**
-     * Sorts by the average value.
+     * Continues the invocation. The input passed here is forwarded to the next handler.
      */
-    _avg?: SumAvgInput<Schema, Model, SortOrder>;
+    proceed: (input: unknown) => Promise<unknown>;
     /**
-     * Sorts by the sum value.
+     * The ZenStack client that is invoking the procedure.
      */
-    _sum?: SumAvgInput<Schema, Model, SortOrder>;
-}) : {});
-type WhereUniqueInput<Schema extends SchemaDef, Model extends GetModels<Schema>> = AtLeast<{
-    [Key in keyof GetModel<Schema, Model>['uniqueFields']]?: GetModel<Schema, Model>['uniqueFields'][Key] extends Pick<FieldDef, 'type'> ? MapFieldDefType<Schema, GetModel<Schema, Model>['uniqueFields'][Key]> : {
-        [Key1 in keyof GetModel<Schema, Model>['uniqueFields'][Key]]: GetModel<Schema, Model>['uniqueFields'][Key][Key1] extends Pick<FieldDef, 'type'> ? MapFieldDefType<Schema, GetModel<Schema, Model>['uniqueFields'][Key][Key1]> : never;
-    };
-} & WhereInput<Schema, Model>, Extract<keyof GetModel<Schema, Model>['uniqueFields'], string>>;
-type OmitInput<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
-    [Key in NonRelationFields<Schema, Model>]?: boolean;
+    client: ClientContract<Schema>;
 };
-type SelectIncludeOmit<Schema extends SchemaDef, Model extends GetModels<Schema>, AllowCount extends boolean, AllowRelation extends boolean = true> = {
-    /**
-     * Explicitly select fields and relations to be returned by the query.
-     */
-    select?: SelectInput<Schema, Model, AllowCount, AllowRelation> | null;
+type OnQueryCallback<Schema extends SchemaDef> = (ctx: OnQueryHookContext<Schema>) => Promise<unknown>;
+type OnQueryHookContext<Schema extends SchemaDef> = {
     /**
-     * Specifies relations to be included in the query result. All scalar fields are included.
+     * The model that is being queried.
      */
-    include?: IncludeInput<Schema, Model, AllowCount> | null;
+    model: GetModels<Schema>;
     /**
-     * Explicitly omit fields from the query result.
+     * The operation that is being performed.
      */
-    omit?: OmitInput<Schema, Model> | null;
-};
-type SelectInput<Schema extends SchemaDef, Model extends GetModels<Schema>, AllowCount extends boolean = true, AllowRelation extends boolean = true> = {
-    [Key in NonRelationFields<Schema, Model>]?: boolean;
-} & (AllowRelation extends true ? IncludeInput<Schema, Model, AllowCount> : {});
-type SelectCount<Schema extends SchemaDef, Model extends GetModels<Schema>> = boolean | {
+    operation: AllCrudOperations;
     /**
-     * Selects specific relations to count.
+     * The query arguments.
      */
-    select: {
-        [Key in RelationFields<Schema, Model> as FieldIsArray<Schema, Model, Key> extends true ? Key : never]?: boolean | {
-            where: WhereInput<Schema, RelationFieldType<Schema, Model, Key>, false>;
-        };
-    };
-};
-type IncludeInput<Schema extends SchemaDef, Model extends GetModels<Schema>, AllowCount extends boolean = true> = {
-    [Key in RelationFields<Schema, Model>]?: boolean | FindArgs<Schema, RelationFieldType<Schema, Model, Key>, FieldIsArray<Schema, Model, Key>, FieldIsArray<Schema, Model, Key> extends true ? true : ModelFieldIsOptional<Schema, Model, Key> extends true ? true : false>;
-} & (AllowCount extends true ? HasToManyRelations<Schema, Model> extends true ? {
-    _count?: SelectCount<Schema, Model>;
-} : {} : {});
-type Subset<T, U> = {
-    [key in keyof T]: key extends keyof U ? T[key] : never;
-};
-type SelectSubset<T, U> = {
-    [key in keyof T]: key extends keyof U ? T[key] : never;
-} & (T extends {
-    select: any;
-    include: any;
-} ? 'Please either choose `select` or `include`.' : T extends {
-    select: any;
-    omit: any;
-} ? 'Please either choose `select` or `omit`.' : {});
-type ToManyRelationFilter<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>> = {
-    every?: WhereInput<Schema, RelationFieldType<Schema, Model, Field>>;
-    some?: WhereInput<Schema, RelationFieldType<Schema, Model, Field>>;
-    none?: WhereInput<Schema, RelationFieldType<Schema, Model, Field>>;
-};
-type ToOneRelationFilter<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>> = NullableIf<WhereInput<Schema, RelationFieldType<Schema, Model, Field>> & {
+    args: Record<string, unknown> | undefined;
     /**
-     * Checks if the related record matches the specified filter.
+     * The function to proceed with the original query.
+     * It takes the same arguments as the operation method.
+     *
+     * @param args The query arguments.
      */
-    is?: NullableIf<WhereInput<Schema, RelationFieldType<Schema, Model, Field>>, ModelFieldIsOptional<Schema, Model, Field>>;
+    proceed: (args: Record<string, unknown> | undefined) => Promise<unknown>;
     /**
-     * Checks if the related record does not match the specified filter.
+     * The ZenStack client that is performing the operation.
      */
-    isNot?: NullableIf<WhereInput<Schema, RelationFieldType<Schema, Model, Field>>, ModelFieldIsOptional<Schema, Model, Field>>;
-}, ModelFieldIsOptional<Schema, Model, Field>>;
-type RelationFilter<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>> = FieldIsArray<Schema, Model, Field> extends true ? ToManyRelationFilter<Schema, Model, Field> : ToOneRelationFilter<Schema, Model, Field>;
-type MapModelFieldType<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends GetModelFields<Schema, Model>> = MapFieldDefType<Schema, GetModelField<Schema, Model, Field>>;
-type MapFieldDefType<Schema extends SchemaDef, T extends Pick<FieldDef, 'type' | 'optional' | 'array'>, Partial extends boolean = false> = WrapType<T['type'] extends GetEnums<Schema> ? keyof GetEnum<Schema, T['type']> : T['type'] extends GetTypeDefs<Schema> ? TypeDefResult<Schema, T['type'], Partial> & Record<string, unknown> : MapBaseType$1<T['type']>, T['optional'], T['array']>;
-type OptionalFieldsForCreate<Schema extends SchemaDef, Model extends GetModels<Schema>> = keyof {
-    [Key in GetModelFields<Schema, Model> as ModelFieldIsOptional<Schema, Model, Key> extends true ? Key : FieldHasDefault<Schema, Model, Key> extends true ? Key : FieldIsArray<Schema, Model, Key> extends true ? Key : GetModelField<Schema, Model, Key>['updatedAt'] extends (true | UpdatedAtInfo) ? Key : never]: GetModelField<Schema, Model, Key>;
+    client: ClientContract<Schema>;
 };
-type GetRelation<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends GetModelFields<Schema, Model>> = GetModelField<Schema, Model, Field>['relation'];
-type OppositeRelation<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends GetModelFields<Schema, Model>, FT = FieldType<Schema, Model, Field>> = FT extends GetModels<Schema> ? GetRelation<Schema, Model, Field> extends RelationInfo ? GetRelation<Schema, Model, Field>['opposite'] extends GetModelFields<Schema, FT> ? Schema['models'][FT]['fields'][GetRelation<Schema, Model, Field>['opposite']]['relation'] : never : never : never;
-type OppositeRelationFields<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends GetModelFields<Schema, Model>, Opposite = OppositeRelation<Schema, Model, Field>> = Opposite extends RelationInfo ? (Opposite['fields'] extends readonly string[] ? Opposite['fields'] : []) : [];
-type OppositeRelationAndFK<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends GetModelFields<Schema, Model>, FT = FieldType<Schema, Model, Field>, Relation = GetModelField<Schema, Model, Field>['relation'], Opposite = Relation extends RelationInfo ? Relation['opposite'] : never> = FT extends GetModels<Schema> ? Opposite extends GetModelFields<Schema, FT> ? Opposite | OppositeRelationFields<Schema, Model, Field>[number] : never : never;
-type FilterArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
+type EntityMutationHooksDef<Schema extends SchemaDef> = {
     /**
-     * Filter conditions
+     * Called before entities are mutated.
      */
-    where?: WhereInput<Schema, Model>;
-};
-type SortAndTakeArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
+    beforeEntityMutation?: BeforeEntityMutationCallback<Schema>;
     /**
-     * Number of records to skip
+     * Called after entities are mutated.
      */
-    skip?: number;
-    /**
-     * Number of records to take
-     */
-    take?: number;
-    /**
-     * Order by clauses
-     */
-    orderBy?: OrArray<OrderBy<Schema, Model, true, false>>;
+    afterEntityMutation?: AfterEntityMutationCallback<Schema>;
     /**
-     * Cursor for pagination
+     * 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`.
      */
-    cursor?: WhereUniqueInput<Schema, Model>;
+    runAfterMutationWithinTransaction?: boolean;
 };
-type FindArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, Collection extends boolean, AllowFilter extends boolean = true> = (Collection extends true ? SortAndTakeArgs<Schema, Model> & (ProviderSupportsDistinct<Schema> extends true ? {
-    /**
-     * Distinct fields. Only supported by providers that natively support SQL "DISTINCT ON".
-     */
-    distinct?: OrArray<NonRelationFields<Schema, Model>>;
-} : {}) : {}) & (AllowFilter extends true ? FilterArgs<Schema, Model> : {}) & SelectIncludeOmit<Schema, Model, Collection>;
-type FindManyArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = FindArgs<Schema, Model, true>;
-type FindFirstArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = FindArgs<Schema, Model, true>;
-type ExistsArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = FilterArgs<Schema, Model>;
-type FindUniqueArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
-    where: WhereUniqueInput<Schema, Model>;
-} & SelectIncludeOmit<Schema, Model, true>;
-type CreateArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
-    data: CreateInput<Schema, Model>;
-} & SelectIncludeOmit<Schema, Model, true>;
-type CreateManyArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = CreateManyInput<Schema, Model>;
-type CreateManyAndReturnArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = CreateManyInput<Schema, Model> & Omit<SelectIncludeOmit<Schema, Model, false, false>, 'include'>;
-type OptionalWrap<Schema extends SchemaDef, Model extends GetModels<Schema>, T extends object> = Optional<T, keyof T & OptionalFieldsForCreate<Schema, Model>>;
-type CreateScalarPayload<Schema extends SchemaDef, Model extends GetModels<Schema>> = OptionalWrap<Schema, Model, {
-    [Key in ScalarFields<Schema, Model, false> as FieldIsDelegateDiscriminator<Schema, Model, Key> extends true ? never : Key]: ScalarCreatePayload<Schema, Model, Key>;
-}>;
-type ScalarCreatePayload<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends ScalarFields<Schema, Model, false>> = ScalarFieldMutationPayload<Schema, Model, Field> | (FieldIsArray<Schema, Model, Field> extends true ? {
-    set?: MapModelFieldType<Schema, Model, Field>;
-} : never);
-type ScalarFieldMutationPayload<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends GetModelFields<Schema, Model>> = IsJsonField<Schema, Model, Field> extends true ? ModelFieldIsOptional<Schema, Model, Field> extends true ? JsonValue | JsonNull | DbNull : JsonValue | JsonNull : MapModelFieldType<Schema, Model, Field>;
-type IsJsonField<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends GetModelFields<Schema, Model>> = GetModelFieldType<Schema, Model, Field> extends 'Json' ? true : false;
-type CreateFKPayload<Schema extends SchemaDef, Model extends GetModels<Schema>> = OptionalWrap<Schema, Model, {
-    [Key in ForeignKeyFields<Schema, Model>]: MapModelFieldType<Schema, Model, Key>;
-}>;
-type CreateRelationFieldPayload<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>> = Omit<{
-    /**
-     * Connects or create a related record.
-     */
-    connectOrCreate?: ConnectOrCreateInput<Schema, Model, Field>;
-    /**
-     * Creates a related record.
-     */
-    create?: NestedCreateInput<Schema, Model, Field>;
+type MutationHooksArgs<Schema extends SchemaDef> = {
     /**
-     * Creates a batch of related records.
+     * The model that is being mutated.
      */
-    createMany?: NestedCreateManyInput<Schema, Model, Field>;
+    model: GetModels<Schema>;
     /**
-     * Connects an existing record.
+     * The mutation action that is being performed.
      */
-    connect?: ConnectInput<Schema, Model, Field>;
-}, (FieldIsArray<Schema, Model, Field> extends true ? never : 'createMany') | (FieldIsDelegateRelation<Schema, Model, Field> extends true ? 'create' | 'createMany' | 'connectOrCreate' : never)>;
-type CreateRelationPayload<Schema extends SchemaDef, Model extends GetModels<Schema>> = OptionalWrap<Schema, Model, {
-    [Key in RelationFields<Schema, Model>]: CreateRelationFieldPayload<Schema, Model, Key>;
-}>;
-type CreateWithFKInput<Schema extends SchemaDef, Model extends GetModels<Schema>> = CreateScalarPayload<Schema, Model> & CreateFKPayload<Schema, Model> & CreateWithNonOwnedRelationPayload<Schema, Model>;
-type CreateWithRelationInput<Schema extends SchemaDef, Model extends GetModels<Schema>> = CreateScalarPayload<Schema, Model> & CreateRelationPayload<Schema, Model>;
-type CreateWithNonOwnedRelationPayload<Schema extends SchemaDef, Model extends GetModels<Schema>> = OptionalWrap<Schema, Model, {
-    [Key in NonOwnedRelationFields<Schema, Model>]: CreateRelationFieldPayload<Schema, Model, Key>;
-}>;
-type ConnectOrCreatePayload<Schema extends SchemaDef, Model extends GetModels<Schema>, Without extends string = never> = {
+    action: 'create' | 'update' | 'delete';
     /**
-     * The unique filter to find an existing record to connect.
+     * The mutation data. Only available for create and update actions.
      */
-    where: WhereUniqueInput<Schema, Model>;
+    queryNode: OperationNode;
     /**
-     * The data to create a new record if no existing record is found.
+     * A query ID that uniquely identifies the mutation operation. You can use it to correlate
+     * data between the before and after mutation hooks.
      */
-    create: CreateInput<Schema, Model, Without>;
+    queryId: QueryId;
 };
-type CreateManyInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Without extends string = never> = {
+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 for the records to create.
+     * 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: OrArray<Omit<CreateScalarPayload<Schema, Model>, Without> & Omit<CreateFKPayload<Schema, Model>, Without>>;
+    loadBeforeMutationEntities(): Promise<Record<string, unknown>[] | undefined>;
     /**
-     * Specifies whether to skip creating records that would violate unique constraints.
+     * 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.
      */
-    skipDuplicates?: boolean;
+    client: ClientContract<Schema>;
 };
-type CreateInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Without extends string = never> = XOR<Omit<CreateWithFKInput<Schema, Model>, Without>, Omit<CreateWithRelationInput<Schema, Model>, Without>>;
-type NestedCreateInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>> = OrArray<CreateInput<Schema, RelationFieldType<Schema, Model, Field>, OppositeRelationAndFK<Schema, Model, Field>>, FieldIsArray<Schema, Model, Field>>;
-type NestedCreateManyInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>> = CreateManyInput<Schema, RelationFieldType<Schema, Model, Field>, OppositeRelationAndFK<Schema, Model, Field>>;
-type UpdateArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
-    /**
-     * The data to update the record with.
-     */
-    data: UpdateInput<Schema, Model>;
-    /**
-     * The unique filter to find the record to update.
-     */
-    where: WhereUniqueInput<Schema, Model>;
-} & SelectIncludeOmit<Schema, Model, true>;
-type UpdateManyArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = UpdateManyPayload<Schema, Model>;
-type UpdateManyAndReturnArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = UpdateManyPayload<Schema, Model> & Omit<SelectIncludeOmit<Schema, Model, false, false>, 'include'>;
-type UpdateManyPayload<Schema extends SchemaDef, Model extends GetModels<Schema>, Without extends string = never> = {
+type PluginAfterEntityMutationArgs<Schema extends SchemaDef> = MutationHooksArgs<Schema> & {
     /**
-     * The data to update the records with.
+     * Loads the entities that have been mutated.
      */
-    data: OrArray<UpdateScalarInput<Schema, Model, Without>>;
+    loadAfterMutationEntities(): Promise<Record<string, unknown>[] | undefined>;
     /**
-     * The filter to select records to update.
+     * The entities before mutation. Only available if `beforeEntityMutation` hook is provided and
+     * the `loadBeforeMutationEntities` function is called in that hook.
      */
-    where?: WhereInput<Schema, Model>;
+    beforeMutationEntities?: Record<string, unknown>[];
     /**
-     * Limit the number of records to update.
+     * 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.
      */
-    limit?: number;
+    client: ClientContract<Schema>;
 };
-type UpsertArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
-    /**
-     * The data to create the record if it doesn't exist.
-     */
-    create: CreateInput<Schema, Model>;
-    /**
-     * The data to update the record with if it exists.
-     */
-    update: UpdateInput<Schema, Model>;
-    /**
-     * The unique filter to find the record to update.
-     */
-    where: WhereUniqueInput<Schema, Model>;
-} & SelectIncludeOmit<Schema, Model, true>;
-type UpdateScalarInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Without extends string = never> = Omit<{
-    [Key in NonRelationFields<Schema, Model> as FieldIsDelegateDiscriminator<Schema, Model, Key> extends true ? never : Key]?: ScalarUpdatePayload<Schema, Model, Key>;
-}, Without>;
-type ScalarUpdatePayload<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends NonRelationFields<Schema, Model>> = ScalarFieldMutationPayload<Schema, Model, Field> | (Field extends NumericFields<Schema, Model> ? {
-    /**
-     * Sets the field to the specified value.
-     */
-    set?: NullableIf<number, ModelFieldIsOptional<Schema, Model, Field>>;
-    /**
-     * Increments the field by the specified value.
-     */
-    increment?: number;
+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> = {
     /**
-     * Decrements the field by the specified value.
+     * ZenStack client instance
      */
-    decrement?: number;
+    client: ClientContract<Schema>;
     /**
-     * Multiplies the field by the specified value.
+     * Database dialect
      */
-    multiply?: number;
+    dialect: BaseCrudDialect<Schema>;
     /**
-     * Divides the field by the specified value.
+     * The containing model name
      */
-    divide?: number;
-} : never) | (FieldIsArray<Schema, Model, Field> extends true ? {
+    model: GetModels<Schema>;
     /**
-     * Sets the field to the specified array.
+     * The alias name that can be used to refer to the containing model
      */
-    set?: MapModelFieldType<Schema, Model, Field>[];
+    modelAlias: string;
     /**
-     * Appends the specified values to the array field.
+     * The CRUD operation being performed
      */
-    push?: OrArray<MapModelFieldType<Schema, Model, Field>, true>;
-} : never);
-type UpdateRelationInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Without extends string = never> = Omit<{
-    [Key in RelationFields<Schema, Model>]?: UpdateRelationFieldPayload<Schema, Model, Key>;
-}, Without>;
-type UpdateInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Without extends string = never> = UpdateScalarInput<Schema, Model, Without> & UpdateRelationInput<Schema, Model, Without>;
-type UpdateRelationFieldPayload<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>> = FieldIsArray<Schema, Model, Field> extends true ? ToManyRelationUpdateInput<Schema, Model, Field> : ToOneRelationUpdateInput<Schema, Model, Field>;
-type ToManyRelationUpdateInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>> = Omit<{
+    operation: CRUD_EXT;
+};
+type ZModelFunction<Schema extends SchemaDef> = (eb: ExpressionBuilder<ToKyselySchema<Schema>, keyof ToKyselySchema<Schema>>, args: Expression<any>[], context: ZModelFunctionContext<Schema>) => Expression<unknown>;
+/**
+ * Options for slicing ORM client's capabilities by including/excluding certain models, operations,
+ * filters, etc.
+ */
+type SlicingOptions<Schema extends SchemaDef> = {
     /**
-     * Creates related records.
+     * Models to include in the client. If not specified, all models are included by default.
      */
-    create?: NestedCreateInput<Schema, Model, Field>;
+    includedModels?: readonly GetModels<Schema>[];
     /**
-     * Creates a batch of related records.
+     * Models to exclude from the client. Exclusion takes precedence over inclusion.
      */
-    createMany?: NestedCreateManyInput<Schema, Model, Field>;
+    excludedModels?: readonly GetModels<Schema>[];
     /**
-     * Connects existing records.
+     * Model slicing options.
      */
-    connect?: ConnectInput<Schema, Model, Field>;
+    models?: {
+        [Model in GetModels<Schema>]?: ModelSlicingOptions<Schema, Model>;
+    } & {
+        /**
+         * Slicing options that apply to all models. Model-specific options will override these general
+         * options if both are specified.
+         */
+        $all?: ModelSlicingOptions<Schema, GetModels<Schema>>;
+    };
     /**
-     * Connects or create related records.
+     * Procedures to include in the client. If not specified, all procedures are included by default.
      */
-    connectOrCreate?: ConnectOrCreateInput<Schema, Model, Field>;
+    includedProcedures?: readonly GetProcedureNames<Schema>[];
     /**
-     * Disconnects related records.
+     * Procedures to exclude from the client. Exclusion takes precedence over inclusion.
      */
-    disconnect?: DisconnectInput<Schema, Model, Field>;
+    excludedProcedures?: readonly GetProcedureNames<Schema>[];
+};
+/**
+ * Kinds of filter operations.
+ */
+type FilterKind = FilterPropertyToKind[keyof FilterPropertyToKind];
+/**
+ * Model slicing options.
+ */
+type ModelSlicingOptions<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
     /**
-     * Updates related records.
+     * ORM query operations to include for the model. If not specified, all operations are included
+     * by default.
      */
-    update?: NestedUpdateInput<Schema, Model, Field>;
+    includedOperations?: readonly AllCrudOperations[];
     /**
-     * Upserts related records.
+     * ORM query operations to exclude for the model. Exclusion takes precedence over inclusion.
      */
-    upsert?: NestedUpsertInput<Schema, Model, Field>;
+    excludedOperations?: readonly AllCrudOperations[];
     /**
-     * Updates a batch of related records.
+     * Field-level slicing options.
      */
-    updateMany?: NestedUpdateManyInput<Schema, Model, Field>;
+    fields?: {
+        [Field in GetModelFields<Schema, Model>]?: FieldSlicingOptions;
+    } & {
+        /**
+         * Field slicing options that apply to all fields. Field-specific options will override these
+         * general options if both are specified.
+         */
+        $all?: FieldSlicingOptions;
+    };
+};
+/**
+ * Field slicing options.
+ */
+type FieldSlicingOptions = {
     /**
-     * Deletes related records.
+     * Filter kinds to include for the field. If not specified, all filter kinds are included by default.
      */
-    delete?: NestedDeleteInput<Schema, Model, Field>;
+    includedFilterKinds?: readonly FilterKind[];
     /**
-     * Deletes a batch of related records.
+     * Filter kinds to exclude for the field. Exclusion takes precedence over inclusion.
      */
-    deleteMany?: NestedDeleteManyInput<Schema, Model, Field>;
+    excludedFilterKinds?: readonly FilterKind[];
+};
+/**
+ * Partial ORM client options that defines customizable behaviors.
+ */
+type QueryOptions<Schema extends SchemaDef> = {
     /**
-     * Sets the related records to the specified ones.
+     * Options for omitting fields in ORM query results.
      */
-    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<{
+    omit?: OmitConfig<Schema>;
     /**
-     * Creates a related record.
+     * Whether to allow overriding omit settings at query time. Defaults to `true`. When set to `false`, a
+     * query-time `omit` clause that sets the field to `false` (not omitting) will trigger a validation error.
      */
-    create?: NestedCreateInput<Schema, Model, Field>;
+    allowQueryTimeOmitOverride?: boolean;
     /**
-     * Connects an existing record.
+     * Options for slicing ORM client's capabilities by including/excluding certain models, operations, filters, etc.
      */
-    connect?: ConnectInput<Schema, Model, Field>;
+    slicing?: SlicingOptions<Schema>;
+};
+/**
+ * ZenStack client options.
+ */
+type ClientOptions<Schema extends SchemaDef> = QueryOptions<Schema> & {
     /**
-     * Connects or create a related record.
+     * Kysely dialect.
      */
-    connectOrCreate?: ConnectOrCreateInput<Schema, Model, Field>;
+    dialect: Dialect;
     /**
-     * Updates the related record.
+     * Custom function definitions.
+     *
+     * @private
      */
-    update?: NestedUpdateInput<Schema, Model, Field>;
+    functions?: Record<string, ZModelFunction<Schema>>;
     /**
-     * Upserts the related record.
+     * Plugins.
      */
-    upsert?: NestedUpsertInput<Schema, Model, Field>;
-} & (ModelFieldIsOptional<Schema, Model, Field> extends true ? {
+    plugins?: AnyPlugin[];
     /**
-     * Disconnects the related record.
+     * Logging configuration.
      */
-    disconnect?: DisconnectInput<Schema, Model, Field>;
+    log?: KyselyConfig['log'];
     /**
-     * Deletes the related record.
+     * 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
      */
-    delete?: NestedDeleteInput<Schema, Model, Field>;
-} : {}), FieldIsDelegateRelation<Schema, Model, Field> extends true ? 'create' | 'connectOrCreate' | 'upsert' : never>;
-type DeleteArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
+    fixPostgresTimezone?: boolean;
     /**
-     * The unique filter to find the record to delete.
+     * Whether to enable input validations expressed with attributes like `@email`, `@regex`,
+     * `@@validate`, etc. Defaults to `true`.
      */
-    where: WhereUniqueInput<Schema, Model>;
-} & SelectIncludeOmit<Schema, Model, true>;
-type DeleteManyArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
+    validateInput?: boolean;
+} & (HasComputedFields<Schema> extends true ? {
     /**
-     * Filter to select records to delete.
+     * Computed field definitions.
      */
-    where?: WhereInput<Schema, Model>;
+    computedFields: ComputedFieldsOptions<Schema>;
+} : {}) & (HasProcedures<Schema> extends true ? {
     /**
-     * Limits the number of records to delete.
+     * Custom procedure definitions.
      */
-    limit?: number;
+    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 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 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 CountAggregateInput<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
-    [Key in NonRelationFields<Schema, Model>]?: true;
-} & {
-    _all?: true;
+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;
+/**
+ * Extracts QueryOptions from an object with '$options' property.
+ */
+type GetQueryOptions<T extends {
+    $options: any;
+}> = T['$options'];
+
+type IsNever<T> = [T] extends [never] ? true : false;
+/**
+ * Filters models based on slicing configuration.
+ */
+type GetSlicedModels<Schema extends SchemaDef, Options extends QueryOptions<Schema>> = Options['slicing'] extends infer S ? S extends SlicingOptions<Schema> ? S['includedModels'] extends readonly GetModels<Schema>[] ? Exclude<Extract<S['includedModels'][number], GetModels<Schema>>, S['excludedModels'] extends readonly GetModels<Schema>[] ? S['excludedModels'][number] : never> : Exclude<GetModels<Schema>, S['excludedModels'] extends readonly GetModels<Schema>[] ? S['excludedModels'][number] : never> : GetModels<Schema> : GetModels<Schema>;
+/**
+ * Filters query operations based on slicing configuration for a specific model.
+ */
+type GetSlicedOperations<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema>> = Options['slicing'] extends infer Slicing ? Slicing extends SlicingOptions<Schema> ? GetIncludedOperations<Slicing, Model> extends infer IO ? GetExcludedOperations<Slicing, Model> extends infer EO ? IO extends '_none_' ? never : IsNever<IO> extends false ? Exclude<IO, EO> : Exclude<AllCrudOperations, EO> : AllCrudOperations : AllCrudOperations : AllCrudOperations : AllCrudOperations;
+type GetIncludedOperations<Slicing extends SlicingOptions<any>, Model extends string> = 'models' extends keyof Slicing ? Slicing extends {
+    models: infer Config;
+} ? Model extends keyof Config ? 'includedOperations' extends keyof Config[Model] ? Config[Model] extends {
+    includedOperations: readonly [];
+} ? '_none_' : Config[Model] extends {
+    includedOperations: readonly (infer IO)[];
+} ? IO : never : GetAllIncludedOperations<Slicing> : GetAllIncludedOperations<Slicing> : AllCrudOperations : AllCrudOperations;
+type GetAllIncludedOperations<Slicing extends SlicingOptions<any>> = 'models' extends keyof Slicing ? Slicing extends {
+    models: infer Config;
+} ? '$all' extends keyof Config ? Config['$all'] extends {
+    includedOperations: readonly [];
+} ? '_none_' : Config['$all'] extends {
+    includedOperations: readonly (infer IO)[];
+} ? IO : AllCrudOperations : AllCrudOperations : AllCrudOperations : AllCrudOperations;
+type GetExcludedOperations<Slicing extends SlicingOptions<any>, Model extends string> = 'models' extends keyof Slicing ? Slicing extends {
+    models: infer Config;
+} ? Model extends keyof Config ? Config[Model] extends {
+    excludedOperations: readonly (infer EO)[];
+} ? EO : GetAllExcludedOperations<Slicing> : GetAllExcludedOperations<Slicing> : never : never;
+type GetAllExcludedOperations<Slicing extends SlicingOptions<any>> = 'models' extends keyof Slicing ? Slicing extends {
+    models: infer M;
+} ? '$all' extends keyof M ? M['$all'] extends {
+    excludedOperations: readonly (infer EO)[];
+} ? EO : never : never : never : never;
+/**
+ * Filters procedures based on slicing configuration.
+ */
+type GetSlicedProcedures<Schema extends SchemaDef, Options extends QueryOptions<Schema>> = Options['slicing'] extends infer S ? S extends SlicingOptions<Schema> ? S['includedProcedures'] extends readonly (infer IncludedProc)[] ? Exclude<Extract<IncludedProc, GetProcedureNames<Schema>>, S['excludedProcedures'] extends readonly (infer ExcludedProc)[] ? Extract<ExcludedProc, GetProcedureNames<Schema>> : never> : Exclude<GetProcedureNames<Schema>, S['excludedProcedures'] extends readonly (infer ExcludedProc)[] ? Extract<ExcludedProc, GetProcedureNames<Schema>> : never> : GetProcedureNames<Schema> : GetProcedureNames<Schema>;
+/**
+ * Filters filter kinds for a specific field, considering field-level slicing configuration with $all fallback.
+ */
+type GetSlicedFilterKindsForField<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends string, Options extends QueryOptions<Schema>> = Options extends {
+    slicing: infer S;
+} ? S extends SlicingOptions<Schema> ? GetFieldIncludedFilterKinds<S, Model, Field> extends infer IFK ? GetFieldExcludedFilterKinds<S, Model, Field> extends infer EFK ? '_none_' extends IFK ? never : IsNever<IFK> extends true ? IsNever<EFK> extends true ? FilterKind : Exclude<FilterKind, EFK> : Exclude<IFK, EFK> : FilterKind : FilterKind : FilterKind : FilterKind;
+type GetIncludedFilterKindsFromModelConfig<ModelConfig, Field extends string> = ModelConfig extends {
+    includedFilterKinds: readonly [];
+} ? '_none_' : 'fields' extends keyof ModelConfig ? ModelConfig['fields'] extends infer FieldsConfig ? Field extends keyof FieldsConfig ? 'includedFilterKinds' extends keyof FieldsConfig[Field] ? FieldsConfig[Field] extends {
+    includedFilterKinds: readonly [];
+} ? '_none_' : FieldsConfig[Field] extends {
+    includedFilterKinds: readonly (infer IFK)[];
+} ? IFK : never : GetAllFieldsIncludedFilterKinds<FieldsConfig> : GetAllFieldsIncludedFilterKinds<FieldsConfig> : never : never;
+type GetFieldIncludedFilterKinds<S extends SlicingOptions<any>, Model extends string, Field extends string> = S extends {
+    models?: infer Config;
+} ? Model extends keyof Config ? GetIncludedFilterKindsFromModelConfig<Config[Model], Field> : '$all' extends keyof Config ? GetIncludedFilterKindsFromModelConfig<Config['$all'], Field> : never : never;
+type GetAllFieldsIncludedFilterKinds<FieldsConfig> = '$all' extends keyof FieldsConfig ? FieldsConfig['$all'] extends {
+    includedFilterKinds: readonly [];
+} ? '_none_' : FieldsConfig['$all'] extends {
+    includedFilterKinds: readonly (infer IFK)[];
+} ? IFK : never : never;
+type GetExcludedFilterKindsFromModelConfig<ModelConfig, Field extends string> = 'fields' extends keyof ModelConfig ? ModelConfig['fields'] extends infer FieldsConfig ? Field extends keyof FieldsConfig ? FieldsConfig[Field] extends {
+    excludedFilterKinds: readonly (infer EFK)[];
+} ? EFK : GetAllFieldsExcludedFilterKinds<FieldsConfig> : GetAllFieldsExcludedFilterKinds<FieldsConfig> : never : never;
+type GetFieldExcludedFilterKinds<S extends SlicingOptions<any>, Model extends string, Field extends string> = S extends {
+    models?: infer Config;
+} ? Model extends keyof Config ? GetExcludedFilterKindsFromModelConfig<Config[Model], Field> : '$all' extends keyof Config ? GetExcludedFilterKindsFromModelConfig<Config['$all'], Field> : never : never;
+type GetAllFieldsExcludedFilterKinds<FieldsConfig> = '$all' extends keyof FieldsConfig ? FieldsConfig['$all'] extends {
+    excludedFilterKinds: readonly (infer EFK)[];
+} ? EFK : never : never;
+
+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, Options> ? Key : never : Key extends keyof Omit ? Omit[Key] extends true ? never : Key : Key]: Key extends '_count' ? SelectCountResult<Schema, Model, Select[Key]> : Key extends NonRelationFields<Schema, Model> ? MapModelFieldType<Schema, Model, Key> : Key extends RelationFields<Schema, Model> ? ModelResult<Schema, RelationFieldType<Schema, Model, Key>, Select[Key], Options, ModelFieldIsOptional<Schema, Model, Key>, FieldIsArray<Schema, Model, Key>> : never;
 };
-type CountResult<Schema extends SchemaDef, _Model extends GetModels<Schema>, Args> = Args extends {
+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;
-} ? S extends true ? number : {
+} ? {
     [Key in keyof S]: number;
-} : number;
-type AggregateArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
+} : 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>, Options extends QueryOptions<Schema> = QueryOptions<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]?: FieldFilter<Schema, Model, Key, Options, WithAggregations>;
+} & {
+    $expr?: (eb: ExpressionBuilder<ToKyselySchema<Schema>, Model>) => OperandExpression<SqlBool>;
+} & {
+    AND?: OrArray<WhereInput<Schema, Model, Options, ScalarOnly>>;
+    OR?: WhereInput<Schema, Model, Options, ScalarOnly>[];
+    NOT?: OrArray<WhereInput<Schema, Model, Options, ScalarOnly>>;
+};
+type FieldFilter<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends GetModelFields<Schema, Model>, Options extends QueryOptions<Schema>, WithAggregations extends boolean, AllowedKinds extends FilterKind = GetSlicedFilterKindsForField<Schema, Model, Field, Options>> = Field extends RelationFields<Schema, Model> ? RelationFilter<Schema, Model, Field, Options, AllowedKinds> : FieldIsArray<Schema, Model, Field> extends true ? ArrayFilter<Schema, GetModelFieldType<Schema, Model, Field>, AllowedKinds> : GetModelFieldType<Schema, Model, Field> extends GetEnums<Schema> ? EnumFilter<Schema, GetModelFieldType<Schema, Model, Field>, ModelFieldIsOptional<Schema, Model, Field>, WithAggregations, AllowedKinds> : GetModelFieldType<Schema, Model, Field> extends GetTypeDefs<Schema> ? TypedJsonFilter<Schema, GetModelFieldType<Schema, Model, Field>, FieldIsArray<Schema, Model, Field>, ModelFieldIsOptional<Schema, Model, Field>, AllowedKinds> : PrimitiveFilter<GetModelFieldType<Schema, Model, Field>, ModelFieldIsOptional<Schema, Model, Field>, WithAggregations, AllowedKinds>;
+type EnumFilter<Schema extends SchemaDef, T extends GetEnums<Schema>, Nullable extends boolean, WithAggregations extends boolean, AllowedKinds extends FilterKind> = ('Equality' extends AllowedKinds ? NullableIf<keyof GetEnum<Schema, T>, Nullable> : never) | (('Equality' extends AllowedKinds ? {
     /**
-     * Filter conditions
+     * Checks for equality with the specified enum value.
      */
-    where?: WhereInput<Schema, Model>;
+    equals?: NullableIf<keyof GetEnum<Schema, T>, Nullable>;
     /**
-     * Number of records to skip for the aggregation
+     * Checks if the enum value is in the specified list of values.
      */
-    skip?: number;
+    in?: (keyof GetEnum<Schema, T>)[];
     /**
-     * Number of records to take for the aggregation
+     * Checks if the enum value is not in the specified list of values.
      */
-    take?: number;
+    notIn?: (keyof GetEnum<Schema, T>)[];
+} : {}) & {
     /**
-     * Order by clauses
+     * Builds a negated filter.
      */
-    orderBy?: OrArray<OrderBy<Schema, Model, true, false>>;
-} & {
+    not?: EnumFilter<Schema, T, Nullable, WithAggregations, AllowedKinds>;
+} & (WithAggregations extends true ? {
     /**
-     * Performs count aggregation.
+     * Filters against the count of records.
      */
-    _count?: true | CountAggregateInput<Schema, Model>;
+    _count?: NumberFilter<'Int', false, false, AllowedKinds>;
     /**
-     * Performs minimum value aggregation.
+     * Filters against the minimum value.
      */
-    _min?: MinMaxInput<Schema, Model, true>;
+    _min?: EnumFilter<Schema, T, false, false, AllowedKinds>;
     /**
-     * Performs maximum value aggregation.
+     * Filters against the maximum value.
      */
-    _max?: MinMaxInput<Schema, Model, true>;
-} & (NumericFields<Schema, Model> extends never ? {} : {
+    _max?: EnumFilter<Schema, T, false, false, AllowedKinds>;
+} : {}));
+type ArrayFilter<Schema extends SchemaDef, Type extends string, AllowedKinds extends FilterKind> = ('Equality' extends AllowedKinds ? {
     /**
-     * Performs average value aggregation.
+     * Checks if the array equals the specified array.
      */
-    _avg?: SumAvgInput<Schema, Model, true>;
+    equals?: MapScalarType<Schema, Type>[] | null;
+} : {}) & ('List' extends AllowedKinds ? {
     /**
-     * Performs sum value aggregation.
+     * Checks if the array contains all elements of the specified array.
      */
-    _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;
-} ? {
+    has?: MapScalarType<Schema, Type> | null;
     /**
-     * Count aggregation result
+     * Checks if the array contains any of the elements of the specified array.
      */
-    _count: AggCommonOutput<Count>;
-} : {}) & (Args extends {
-    _sum: infer Sum;
-} ? {
+    hasEvery?: MapScalarType<Schema, Type>[];
     /**
-     * Sum aggregation result
+     * Checks if the array contains some of the elements of the specified array.
      */
-    _sum: AggCommonOutput<Sum>;
-} : {}) & (Args extends {
-    _avg: infer Avg;
-} ? {
+    hasSome?: MapScalarType<Schema, Type>[];
     /**
-     * Average aggregation result
+     * Checks if the array is empty.
      */
-    _avg: AggCommonOutput<Avg>;
-} : {}) & (Args extends {
-    _min: infer Min;
-} ? {
+    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, AllowedKinds extends FilterKind> = T extends 'String' ? StringFilter<Nullable, WithAggregations, AllowedKinds> : T extends 'Int' | 'Float' | 'Decimal' | 'BigInt' ? NumberFilter<T, Nullable, WithAggregations, AllowedKinds> : T extends 'Boolean' ? BooleanFilter<Nullable, WithAggregations, AllowedKinds> : T extends 'DateTime' ? DateTimeFilter<Nullable, WithAggregations, AllowedKinds> : T extends 'Bytes' ? BytesFilter<Nullable, WithAggregations, AllowedKinds> : T extends 'Json' ? JsonFilter<AllowedKinds> : never;
+type CommonPrimitiveFilter<DataType, T extends BuiltinType, Nullable extends boolean, WithAggregations extends boolean, AllowedKinds extends FilterKind> = ('Equality' extends AllowedKinds ? {
     /**
-     * Minimum aggregation result
+     * Checks for equality with the specified value.
      */
-    _min: AggCommonOutput<Min>;
-} : {}) & (Args extends {
-    _max: infer Max;
-} ? {
+    equals?: NullableIf<DataType, Nullable>;
     /**
-     * Maximum aggregation result
+     * Checks if the value is in the specified list of values.
      */
-    _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>> = {
+    in?: DataType[];
     /**
-     * Filter conditions
+     * Checks if the value is not in the specified list of values.
      */
-    where?: WhereInput<Schema, Model>;
+    notIn?: DataType[];
+} : {}) & ('Range' extends AllowedKinds ? {
     /**
-     * Order by clauses
+     * Checks if the value is less than the specified value.
      */
-    orderBy?: OrArray<OrderBy<Schema, Model, false, true>>;
+    lt?: DataType;
     /**
-     * Fields to group by
+     * Checks if the value is less than or equal to the specified value.
      */
-    by: NonRelationFields<Schema, Model> | NonEmptyArray<NonRelationFields<Schema, Model>>;
+    lte?: DataType;
     /**
-     * Filter conditions for the grouped records
+     * Checks if the value is greater than the specified value.
      */
-    having?: GroupByHaving<Schema, Model>;
+    gt?: DataType;
     /**
-     * Number of records to take for grouping
+     * Checks if the value is greater than or equal to the specified value.
      */
-    take?: number;
+    gte?: DataType;
     /**
-     * Number of records to skip for grouping
+     * Checks if the value is between the specified values (inclusive).
      */
-    skip?: number;
+    between?: [start: DataType, end: DataType];
+} : {}) & {
     /**
-     * Performs count aggregation.
+     * Builds a negated filter.
      */
-    _count?: true | CountAggregateInput<Schema, Model>;
+    not?: PrimitiveFilter<T, Nullable, WithAggregations, AllowedKinds>;
+};
+type StringFilter<Nullable extends boolean, WithAggregations extends boolean, AllowedKinds extends FilterKind = FilterKind> = ('Equality' extends AllowedKinds ? NullableIf<string, Nullable> : never) | (CommonPrimitiveFilter<string, 'String', Nullable, WithAggregations, AllowedKinds> & ('Like' extends AllowedKinds ? {
     /**
-     * Performs minimum value aggregation.
+     * Checks if the string contains the specified substring.
      */
-    _min?: MinMaxInput<Schema, Model, true>;
+    contains?: string;
     /**
-     * Performs maximum value aggregation.
+     * Checks if the string starts with the specified substring.
      */
-    _max?: MinMaxInput<Schema, Model, true>;
-} & (NumericFields<Schema, Model> extends never ? {} : {
+    startsWith?: string;
     /**
-     * Performs average value aggregation.
+     * Checks if the string ends with the specified substring.
      */
-    _avg?: SumAvgInput<Schema, Model, true>;
+    endsWith?: string;
     /**
-     * Performs sum value aggregation.
+     * Specifies the string comparison mode. Not effective for "sqlite" provider
      */
-    _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;
-} ? {
+    mode?: 'default' | 'insensitive';
+} : {}) & (WithAggregations extends true ? {
     /**
-     * Count aggregation result
+     * Filters against the count of records.
      */
-    _count: AggCommonOutput<Count>;
-} : {}) & (Args extends {
-    _avg: infer Avg;
-} ? {
+    _count?: NumberFilter<'Int', false, false, AllowedKinds>;
     /**
-     * Average aggregation result
+     * Filters against the minimum value.
      */
-    _avg: AggCommonOutput<Avg>;
-} : {}) & (Args extends {
-    _sum: infer Sum;
-} ? {
+    _min?: StringFilter<false, false, AllowedKinds>;
     /**
-     * Sum aggregation result
+     * Filters against the maximum value.
      */
-    _sum: AggCommonOutput<Sum>;
-} : {}) & (Args extends {
-    _min: infer Min;
-} ? {
+    _max?: StringFilter<false, false, AllowedKinds>;
+} : {}));
+type NumberFilter<T extends 'Int' | 'Float' | 'Decimal' | 'BigInt', Nullable extends boolean, WithAggregations extends boolean, AllowedKinds extends FilterKind = FilterKind> = ('Equality' extends AllowedKinds ? NullableIf<number | bigint, Nullable> : never) | (CommonPrimitiveFilter<number, T, Nullable, WithAggregations, AllowedKinds> & (WithAggregations extends true ? {
     /**
-     * Minimum aggregation result
+     * Filters against the count of records.
      */
-    _min: AggCommonOutput<Min>;
-} : {}) & (Args extends {
-    _max: infer Max;
-} ? {
+    _count?: NumberFilter<'Int', false, false, AllowedKinds>;
     /**
-     * Maximum aggregation result
+     * Filters against the average value.
      */
-    _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<{
+    _avg?: NumberFilter<T, false, false, AllowedKinds>;
     /**
-     * Unique filter to select the record to update.
+     * Filters against the sum value.
      */
-    where: WhereUniqueInput<Schema, RelationFieldType<Schema, Model, Field>>;
+    _sum?: NumberFilter<T, false, false, AllowedKinds>;
     /**
-     * The data to update the record with.
+     * Filters against the minimum value.
      */
-    data: UpdateInput<Schema, RelationFieldType<Schema, Model, Field>, OppositeRelationAndFK<Schema, Model, Field>>;
-}, true> : XOR<{
+    _min?: NumberFilter<T, false, false, AllowedKinds>;
     /**
-     * Filter to select the record to update.
+     * Filters against the maximum value.
      */
-    where?: WhereInput<Schema, RelationFieldType<Schema, Model, Field>>;
+    _max?: NumberFilter<T, false, false, AllowedKinds>;
+} : {}));
+type DateTimeFilter<Nullable extends boolean, WithAggregations extends boolean, AllowedKinds extends FilterKind = FilterKind> = ('Equality' extends AllowedKinds ? NullableIf<Date | string, Nullable> : never) | (CommonPrimitiveFilter<Date | string, 'DateTime', Nullable, WithAggregations, AllowedKinds> & (WithAggregations extends true ? {
     /**
-     * The data to update the record with.
+     * Filters against the count of records.
      */
-    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<{
+    _count?: NumberFilter<'Int', false, false, AllowedKinds>;
     /**
-     * Unique filter to select the record to update.
+     * Filters against the minimum value.
      */
-    where: WhereUniqueInput<Schema, RelationFieldType<Schema, Model, Field>>;
+    _min?: DateTimeFilter<false, false, AllowedKinds>;
     /**
-     * The data to create the record if it doesn't exist.
+     * Filters against the maximum value.
      */
-    create: CreateInput<Schema, RelationFieldType<Schema, Model, Field>, OppositeRelationAndFK<Schema, Model, Field>>;
+    _max?: DateTimeFilter<false, false, AllowedKinds>;
+} : {}));
+type BytesFilter<Nullable extends boolean, WithAggregations extends boolean, AllowedKinds extends FilterKind = FilterKind> = ('Equality' extends AllowedKinds ? NullableIf<Uint8Array | Buffer, Nullable> : never) | (('Equality' extends AllowedKinds ? {
     /**
-     * The data to update the record with if it exists.
+     * Checks for equality with the specified value.
      */
-    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;
-type ProviderSupportsDistinct<Schema extends SchemaDef> = Schema['provider']['type'] extends 'postgresql' ? true : false;
-
-declare abstract class BaseCrudDialect<Schema extends SchemaDef> {
-    protected readonly schema: Schema;
-    protected readonly options: ClientOptions<Schema>;
-    protected eb: ExpressionBuilder<any, any>;
-    constructor(schema: Schema, options: ClientOptions<Schema>);
+    equals?: NullableIf<Uint8Array, Nullable>;
     /**
-     * Whether the dialect supports updating with a limit on the number of updated rows.
+     * Checks if the value is in the specified list of values.
      */
-    abstract get supportsUpdateWithLimit(): boolean;
+    in?: Uint8Array[];
     /**
-     * Whether the dialect supports deleting with a limit on the number of deleted rows.
+     * Checks if the value is not in the specified list of values.
      */
-    abstract get supportsDeleteWithLimit(): boolean;
+    notIn?: Uint8Array[];
+} : {}) & {
     /**
-     * Whether the dialect supports DISTINCT ON.
+     * Builds a negated filter.
      */
-    abstract get supportsDistinctOn(): boolean;
+    not?: BytesFilter<Nullable, WithAggregations, AllowedKinds>;
+} & (WithAggregations extends true ? {
     /**
-     * Whether the dialect support inserting with `DEFAULT` as field value.
+     * Filters against the count of records.
      */
-    abstract get supportsDefaultAsFieldValue(): boolean;
+    _count?: NumberFilter<'Int', false, false, AllowedKinds>;
     /**
-     * Whether the dialect supports the RETURNING clause in INSERT/UPDATE/DELETE statements.
+     * Filters against the minimum value.
      */
-    abstract get supportsReturning(): boolean;
+    _min?: BytesFilter<false, false, AllowedKinds>;
     /**
-     * Whether the dialect supports `INSERT INTO ... DEFAULT VALUES` syntax.
+     * Filters against the maximum value.
      */
-    abstract get supportsInsertDefaultValues(): boolean;
+    _max?: BytesFilter<false, false, AllowedKinds>;
+} : {}));
+type BooleanFilter<Nullable extends boolean, WithAggregations extends boolean, AllowedKinds extends FilterKind = FilterKind> = ('Equality' extends AllowedKinds ? NullableIf<boolean, Nullable> : never) | (('Equality' extends AllowedKinds ? {
     /**
-     * How to perform insert ignore operation.
+     * Checks for equality with the specified value.
      */
-    abstract get insertIgnoreMethod(): 'onConflict' | 'ignore';
+    equals?: NullableIf<boolean, Nullable>;
+} : {}) & {
     /**
-     * Transforms input value before sending to database.
+     * Builds a negated filter.
      */
-    transformInput(value: unknown, _type: BuiltinType, _forArrayField: boolean): unknown;
+    not?: BooleanFilter<Nullable, WithAggregations, AllowedKinds>;
+} & (WithAggregations extends true ? {
     /**
-     * Transforms output value received from database.
+     * Filters against the count of records.
      */
-    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;
-    protected buildJsonEqualityFilter(lhs: Expression<any>, rhs: unknown): ExpressionWrapper<any, any, SqlBool>;
-    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, take: number | undefined): 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): AliasableExpression<unknown>;
-    protected negateSort(sort: SortOrder, negated: boolean): SortOrder;
-    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;
+    _count?: NumberFilter<'Int', false, false, AllowedKinds>;
     /**
-     * Builds selection for a relation field.
+     * Filters against the minimum value.
      */
-    abstract buildRelationSelection(query: SelectQueryBuilder<any, any, any>, model: string, relationField: string, parentAlias: string, payload: true | FindArgs<Schema, GetModels<Schema>, true>): SelectQueryBuilder<any, any, any>;
+    _min?: BooleanFilter<false, false, AllowedKinds>;
     /**
-     * Builds skip and take clauses.
+     * Filters against the maximum value.
      */
-    abstract buildSkipTake(query: SelectQueryBuilder<any, any, any>, skip: number | undefined, take: number | undefined): SelectQueryBuilder<any, any, any>;
+    _max?: BooleanFilter<false, false, AllowedKinds>;
+} : {}));
+type JsonFilter<AllowedKinds extends FilterKind = FilterKind> = ('Equality' extends AllowedKinds ? {
     /**
-     * Builds an Kysely expression that returns a JSON object for the given key-value pairs.
+     * Checks for equality with the specified value.
      */
-    abstract buildJsonObject(value: Record<string, Expression<unknown>>): AliasableExpression<unknown>;
+    equals?: JsonValue | JsonNullValues;
     /**
-     * Builds an Kysely expression that returns the length of an array.
+     * Builds a negated filter.
      */
-    abstract buildArrayLength(array: Expression<unknown>): AliasableExpression<number>;
+    not?: JsonValue | JsonNullValues;
+} : {}) & ('Json' extends AllowedKinds ? {
     /**
-     * Builds an array value expression.
+     * JSON path to select the value to filter on. If omitted, the whole JSON value is used.
      */
-    abstract buildArrayValue(values: Expression<unknown>[], elemType: string): AliasableExpression<unknown>;
+    path?: string;
     /**
-     * Builds an expression that checks if an array contains a single value.
+     * Checks if the value is a string and contains the specified substring.
      */
-    abstract buildArrayContains(field: Expression<unknown>, value: Expression<unknown>, elemType?: string): AliasableExpression<SqlBool>;
+    string_contains?: string;
     /**
-     * Builds an expression that checks if an array contains all values from another array.
+     * Checks if the value is a string and starts with the specified substring.
      */
-    abstract buildArrayHasEvery(field: Expression<unknown>, values: Expression<unknown>): AliasableExpression<SqlBool>;
+    string_starts_with?: string;
     /**
-     * Builds an expression that checks if an array overlaps with another array.
+     * Checks if the value is a string and ends with the specified substring.
      */
-    abstract buildArrayHasSome(field: Expression<unknown>, values: Expression<unknown>): AliasableExpression<SqlBool>;
+    string_ends_with?: string;
     /**
-     * Casts the given expression to an integer type.
+     * String comparison mode. Not effective for "sqlite" provider
      */
-    abstract castInt<T extends Expression<any>>(expression: T): T;
+    mode?: 'default' | 'insensitive';
     /**
-     * Casts the given expression to a text type.
+     * Checks if the value is an array and contains the specified value.
      */
-    abstract castText<T extends Expression<any>>(expression: T): T;
+    array_contains?: JsonValue;
     /**
-     * Trims double quotes from the start and end of a text expression.
+     * Checks if the value is an array and starts with the specified value.
      */
-    abstract trimTextQuotes<T extends Expression<string>>(expression: T): T;
-    abstract getStringCasingBehavior(): {
-        supportsILike: boolean;
-        likeCaseSensitive: boolean;
-    };
+    array_starts_with?: JsonValue;
     /**
-     * Builds a VALUES table and select all fields from it.
+     * Checks if the value is an array and ends with the specified value.
      */
-    abstract buildValuesTableSelect(fields: FieldDef[], rows: unknown[][]): SelectQueryBuilder<any, any, any>;
+    array_ends_with?: JsonValue;
+} : {});
+type TypedJsonFilter<Schema extends SchemaDef, TypeDefName extends GetTypeDefs<Schema>, Array extends boolean, Optional extends boolean, AllowedKinds extends FilterKind> = XOR<JsonFilter<AllowedKinds>, TypedJsonTypedFilter<Schema, TypeDefName, Array, Optional, AllowedKinds>>;
+type TypedJsonTypedFilter<Schema extends SchemaDef, TypeDefName extends GetTypeDefs<Schema>, Array extends boolean, Optional extends boolean, AllowedKinds extends FilterKind> = 'Json' extends AllowedKinds ? (Array extends true ? ArrayTypedJsonFilter<Schema, TypeDefName, AllowedKinds> : NonArrayTypedJsonFilter<Schema, TypeDefName, AllowedKinds>) | (Optional extends true ? null : never) : {};
+type ArrayTypedJsonFilter<Schema extends SchemaDef, TypeDefName extends GetTypeDefs<Schema>, AllowedKinds extends FilterKind> = {
+    some?: TypedJsonFieldsFilter<Schema, TypeDefName, AllowedKinds>;
+    every?: TypedJsonFieldsFilter<Schema, TypeDefName, AllowedKinds>;
+    none?: TypedJsonFieldsFilter<Schema, TypeDefName, AllowedKinds>;
+};
+type NonArrayTypedJsonFilter<Schema extends SchemaDef, TypeDefName extends GetTypeDefs<Schema>, AllowedKinds extends FilterKind> = {
+    is?: TypedJsonFieldsFilter<Schema, TypeDefName, AllowedKinds>;
+    isNot?: TypedJsonFieldsFilter<Schema, TypeDefName, AllowedKinds>;
+} | TypedJsonFieldsFilter<Schema, TypeDefName, AllowedKinds>;
+type TypedJsonFieldsFilter<Schema extends SchemaDef, TypeDefName extends GetTypeDefs<Schema>, AllowedKinds extends FilterKind> = {
+    [Key in GetTypeDefFields<Schema, TypeDefName>]?: GetTypeDefFieldType<Schema, TypeDefName, Key> extends GetTypeDefs<Schema> ? TypedJsonFilter<Schema, GetTypeDefFieldType<Schema, TypeDefName, Key>, TypeDefFieldIsArray<Schema, TypeDefName, Key>, TypeDefFieldIsOptional<Schema, TypeDefName, Key>, AllowedKinds> : TypeDefFieldIsArray<Schema, TypeDefName, Key> extends true ? ArrayFilter<Schema, GetTypeDefFieldType<Schema, TypeDefName, Key>, AllowedKinds> : GetTypeDefFieldType<Schema, TypeDefName, Key> extends GetEnums<Schema> ? EnumFilter<Schema, GetTypeDefFieldType<Schema, TypeDefName, Key>, TypeDefFieldIsOptional<Schema, TypeDefName, Key>, false, AllowedKinds> : PrimitiveFilter<GetTypeDefFieldType<Schema, TypeDefName, Key>, TypeDefFieldIsOptional<Schema, TypeDefName, Key>, false, AllowedKinds>;
+};
+type SortOrder = 'asc' | 'desc';
+type NullsOrder = 'first' | 'last';
+type OrderBy<Schema extends SchemaDef, Model extends GetModels<Schema>, WithRelation extends boolean, WithAggregation extends boolean> = {
+    [Key in NonRelationFields<Schema, Model>]?: ModelFieldIsOptional<Schema, Model, Key> extends true ? SortOrder | {
+        /**
+         * Sort order
+         */
+        sort: SortOrder;
+        /**
+         * Treatment of null values
+         */
+        nulls?: NullsOrder;
+    } : SortOrder;
+} & (WithRelation extends true ? {
+    [Key in RelationFields<Schema, Model>]?: FieldIsArray<Schema, Model, Key> extends true ? {
+        /**
+         * Sorts by the count of related records.
+         */
+        _count?: SortOrder;
+    } : OrderBy<Schema, RelationFieldType<Schema, Model, Key>, WithRelation, WithAggregation>;
+} : {}) & (WithAggregation extends true ? {
     /**
-     * Builds a JSON path selection expression.
+     * Sorts by the count of records.
      */
-    protected abstract buildJsonPathSelection(receiver: Expression<any>, path: string | undefined): Expression<any>;
+    _count?: OrderBy<Schema, Model, false, false>;
     /**
-     * Builds a JSON array filter expression.
+     * Sorts by the minimum value.
      */
-    protected abstract buildJsonArrayFilter(receiver: Expression<any>, operation: 'array_contains' | 'array_starts_with' | 'array_ends_with', value: unknown): Expression<SqlBool>;
+    _min?: MinMaxInput<Schema, Model, SortOrder>;
     /**
-     * Builds a JSON array exists predicate (returning if any element matches the filter).
+     * Sorts by the maximum value.
      */
-    protected abstract buildJsonArrayExistsPredicate(receiver: Expression<any>, buildFilter: (elem: Expression<any>) => Expression<SqlBool>): Expression<SqlBool>;
+    _max?: MinMaxInput<Schema, Model, SortOrder>;
+} & (NumericFields<Schema, Model> extends never ? {} : {
     /**
-     * Builds an ORDER BY clause for a field with NULLS FIRST/LAST support.
+     * Sorts by the average value.
      */
-    protected abstract buildOrderByField(query: SelectQueryBuilder<any, any, any>, field: Expression<unknown>, sort: SortOrder, nulls: 'first' | 'last'): SelectQueryBuilder<any, any, any>;
-}
-
-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();
-    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>>;
-    validateProcedureInput(proc: string, input: unknown): unknown;
-    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: string): z.ZodOptional<z.ZodObject<z.core.$ZodLooseShape, z.core.$strict>>;
-    private makeCountAggregateInputSchema;
-    makeAggregateSchema(model: string): z.ZodOptional<z.ZodObject<z.core.$ZodLooseShape, z.core.$strict>>;
-    makeSumAvgInputSchema(model: string): z.ZodObject<Record<string, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>, z.core.$strict>;
-    makeMinMaxInputSchema(model: string): z.ZodObject<Record<string, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>, z.core.$strict>;
-    private makeGroupBySchema;
-    private onlyAggregationFields;
-    private makeHavingSchema;
-    private makeProcedureParamSchema;
-    getCache(cacheKey: string): z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>> | undefined;
-    setCache(cacheKey: string, schema: ZodType): Map<string, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
-    private printCacheStats;
-    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;
+    _avg?: SumAvgInput<Schema, Model, SortOrder>;
+    /**
+     * Sorts by the sum value.
+     */
+    _sum?: SumAvgInput<Schema, Model, SortOrder>;
+}) : {});
+type WhereUniqueInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema>> = AtLeast<{
+    [Key in keyof GetModel<Schema, Model>['uniqueFields']]?: GetModel<Schema, Model>['uniqueFields'][Key] extends Pick<FieldDef, 'type'> ? MapFieldDefType<Schema, GetModel<Schema, Model>['uniqueFields'][Key]> : {
+        [Key1 in keyof GetModel<Schema, Model>['uniqueFields'][Key]]: GetModel<Schema, Model>['uniqueFields'][Key][Key1] extends Pick<FieldDef, 'type'> ? MapFieldDefType<Schema, GetModel<Schema, Model>['uniqueFields'][Key][Key1]> : never;
+    };
+} & WhereInput<Schema, Model, Options>, Extract<keyof GetModel<Schema, Model>['uniqueFields'], string>>;
+type OmitInput<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
+    [Key in NonRelationFields<Schema, Model>]?: boolean;
 };
-/**
- * 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>> {
+type SelectIncludeOmit<Schema extends SchemaDef, Model extends GetModels<Schema>, AllowCount extends boolean, Options extends QueryOptions<Schema> = QueryOptions<Schema>, AllowRelation extends boolean = true> = {
+    /**
+     * Explicitly select fields and relations to be returned by the query.
+     */
+    select?: SelectInput<Schema, Model, Options, AllowCount, AllowRelation> | null;
+    /**
+     * Explicitly omit fields from the query result.
+     */
+    omit?: OmitInput<Schema, Model> | null;
+} & (AllowRelation extends true ? {
+    /**
+     * Specifies relations to be included in the query result. All scalar fields are included.
+     */
+    include?: IncludeInput<Schema, Model, Options, AllowCount> | null;
+} : {});
+type SelectInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>, AllowCount extends boolean = true, AllowRelation extends boolean = true> = {
+    [Key in NonRelationFields<Schema, Model>]?: boolean;
+} & (AllowRelation extends true ? IncludeInput<Schema, Model, Options, AllowCount> : {});
+type SelectCount<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema>> = boolean | {
+    /**
+     * Selects specific relations to count.
+     */
+    select: {
+        [Key in RelationFields<Schema, Model> as FieldIsArray<Schema, Model, Key> extends true ? Key : never]?: boolean | {
+            where: WhereInput<Schema, RelationFieldType<Schema, Model, Key>, Options, false>;
+        };
+    };
+};
+type IncludeInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>, AllowCount extends boolean = true> = {
+    [Key in RelationFields<Schema, Model> as RelationFieldType<Schema, Model, Key> extends GetSlicedModels<Schema, Options> ? Key : never]?: boolean | FindArgs<Schema, RelationFieldType<Schema, Model, Key>, Options, FieldIsArray<Schema, Model, Key>, FieldIsArray<Schema, Model, Key> extends true ? true : ModelFieldIsOptional<Schema, Model, Key> extends true ? true : false>;
+} & (AllowCount extends true ? HasToManyRelations<Schema, Model> extends true ? {
+    _count?: SelectCount<Schema, Model, Options>;
+} : {} : {});
+type Subset<T, U> = {
+    [key in keyof T]: key extends keyof U ? T[key] : never;
+};
+type SelectSubset<T, U> = {
+    [key in keyof T]: key extends keyof U ? T[key] : never;
+} & (T extends {
+    select: any;
+    include: any;
+} ? 'Please either choose `select` or `include`.' : T extends {
+    select: any;
+    omit: any;
+} ? 'Please either choose `select` or `omit`.' : {});
+type ToManyRelationFilter<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>, Options extends QueryOptions<Schema>> = {
+    every?: WhereInput<Schema, RelationFieldType<Schema, Model, Field>, Options>;
+    some?: WhereInput<Schema, RelationFieldType<Schema, Model, Field>, Options>;
+    none?: WhereInput<Schema, RelationFieldType<Schema, Model, Field>, Options>;
+};
+type ToOneRelationFilter<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>, Options extends QueryOptions<Schema>> = NullableIf<WhereInput<Schema, RelationFieldType<Schema, Model, Field>, Options> & {
+    /**
+     * Checks if the related record matches the specified filter.
+     */
+    is?: NullableIf<WhereInput<Schema, RelationFieldType<Schema, Model, Field>, Options>, ModelFieldIsOptional<Schema, Model, Field>>;
+    /**
+     * Checks if the related record does not match the specified filter.
+     */
+    isNot?: NullableIf<WhereInput<Schema, RelationFieldType<Schema, Model, Field>, Options>, ModelFieldIsOptional<Schema, Model, Field>>;
+}, ModelFieldIsOptional<Schema, Model, Field>>;
+type RelationFilter<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>, Options extends QueryOptions<Schema>, AllowedKinds extends FilterKind> = 'Relation' extends AllowedKinds ? FieldIsArray<Schema, Model, Field> extends true ? ToManyRelationFilter<Schema, Model, Field, Options> : ToOneRelationFilter<Schema, Model, Field, Options> : never;
+type MapModelFieldType<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends GetModelFields<Schema, Model>> = MapFieldDefType<Schema, GetModelField<Schema, Model, Field>>;
+type MapFieldDefType<Schema extends SchemaDef, T extends Pick<FieldDef, 'type' | 'optional' | 'array'>, Partial extends boolean = false> = WrapType<T['type'] extends GetEnums<Schema> ? keyof GetEnum<Schema, T['type']> : T['type'] extends GetTypeDefs<Schema> ? TypeDefResult<Schema, T['type'], Partial> & Record<string, unknown> : MapBaseType$1<T['type']>, T['optional'], T['array']>;
+type OptionalFieldsForCreate<Schema extends SchemaDef, Model extends GetModels<Schema>> = keyof {
+    [Key in GetModelFields<Schema, Model> as ModelFieldIsOptional<Schema, Model, Key> extends true ? Key : FieldHasDefault<Schema, Model, Key> extends true ? Key : FieldIsArray<Schema, Model, Key> extends true ? Key : GetModelField<Schema, Model, Key>['updatedAt'] extends true | UpdatedAtInfo ? Key : never]: GetModelField<Schema, Model, Key>;
+};
+type GetRelation<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends GetModelFields<Schema, Model>> = GetModelField<Schema, Model, Field>['relation'];
+type OppositeRelation<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends GetModelFields<Schema, Model>, FT = FieldType<Schema, Model, Field>> = FT extends GetModels<Schema> ? GetRelation<Schema, Model, Field> extends RelationInfo ? GetRelation<Schema, Model, Field>['opposite'] extends GetModelFields<Schema, FT> ? Schema['models'][FT]['fields'][GetRelation<Schema, Model, Field>['opposite']]['relation'] : never : never : never;
+type OppositeRelationFields<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends GetModelFields<Schema, Model>, Opposite = OppositeRelation<Schema, Model, Field>> = Opposite extends RelationInfo ? (Opposite['fields'] extends readonly string[] ? Opposite['fields'] : []) : [];
+type OppositeRelationAndFK<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends GetModelFields<Schema, Model>, FT = FieldType<Schema, Model, Field>, Relation = GetModelField<Schema, Model, Field>['relation'], Opposite = Relation extends RelationInfo ? Relation['opposite'] : never> = FT extends GetModels<Schema> ? Opposite extends GetModelFields<Schema, FT> ? Opposite | OppositeRelationFields<Schema, Model, Field>[number] : never : never;
+type FilterArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema>> = {
+    /**
+     * Filter conditions
+     */
+    where?: WhereInput<Schema, Model, Options>;
+};
+type SortAndTakeArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema>> = {
+    /**
+     * Number of records to skip
+     */
+    skip?: number;
+    /**
+     * Number of records to take
+     */
+    take?: number;
+    /**
+     * Order by clauses
+     */
+    orderBy?: OrArray<OrderBy<Schema, Model, true, false>>;
+    /**
+     * Cursor for pagination
+     */
+    cursor?: WhereUniqueInput<Schema, Model, Options>;
+};
+type FindArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema>, Collection extends boolean, AllowFilter extends boolean = true> = (Collection extends true ? SortAndTakeArgs<Schema, Model, Options> & (ProviderSupportsDistinct<Schema> extends true ? {
+    /**
+     * Distinct fields. Only supported by providers that natively support SQL "DISTINCT ON".
+     */
+    distinct?: OrArray<NonRelationFields<Schema, Model>>;
+} : {}) : {}) & (AllowFilter extends true ? FilterArgs<Schema, Model, Options> : {}) & SelectIncludeOmit<Schema, Model, Collection, Options>;
+type FindManyArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>> = FindArgs<Schema, Model, Options, true>;
+type FindFirstArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>> = FindArgs<Schema, Model, Options, true>;
+type ExistsArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>> = FilterArgs<Schema, Model, Options>;
+type FindUniqueArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>> = {
+    where: WhereUniqueInput<Schema, Model, Options>;
+} & SelectIncludeOmit<Schema, Model, true, Options>;
+type CreateArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>> = {
+    data: CreateInput<Schema, Model, Options>;
+} & SelectIncludeOmit<Schema, Model, true, Options>;
+type CreateManyArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = CreateManyInput<Schema, Model>;
+type CreateManyAndReturnArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>> = CreateManyInput<Schema, Model> & SelectIncludeOmit<Schema, Model, false, Options, false>;
+type OptionalWrap<Schema extends SchemaDef, Model extends GetModels<Schema>, T extends object> = Optional<T, keyof T & OptionalFieldsForCreate<Schema, Model>>;
+type CreateScalarPayload<Schema extends SchemaDef, Model extends GetModels<Schema>> = OptionalWrap<Schema, Model, {
+    [Key in ScalarFields<Schema, Model, false> as FieldIsDelegateDiscriminator<Schema, Model, Key> extends true ? never : Key]: ScalarCreatePayload<Schema, Model, Key>;
+}>;
+type ScalarCreatePayload<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends ScalarFields<Schema, Model, false>> = ScalarFieldMutationPayload<Schema, Model, Field> | (FieldIsArray<Schema, Model, Field> extends true ? {
+    set?: MapModelFieldType<Schema, Model, Field>;
+} : never);
+type ScalarFieldMutationPayload<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends GetModelFields<Schema, Model>> = IsJsonField<Schema, Model, Field> extends true ? ModelFieldIsOptional<Schema, Model, Field> extends true ? JsonValue | JsonNull | DbNull : JsonValue | JsonNull : MapModelFieldType<Schema, Model, Field>;
+type IsJsonField<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends GetModelFields<Schema, Model>> = GetModelFieldType<Schema, Model, Field> extends 'Json' ? true : false;
+type CreateFKPayload<Schema extends SchemaDef, Model extends GetModels<Schema>> = OptionalWrap<Schema, Model, {
+    [Key in ForeignKeyFields<Schema, Model>]: MapModelFieldType<Schema, Model, Key>;
+}>;
+type CreateRelationFieldPayload<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>, Options extends QueryOptions<Schema>> = Omit<{
+    /**
+     * Connects or create a related record.
+     */
+    connectOrCreate?: ConnectOrCreateInput<Schema, Model, Field, Options>;
+    /**
+     * Creates a related record.
+     */
+    create?: NestedCreateInput<Schema, Model, Field, Options>;
+    /**
+     * Creates a batch of related records.
+     */
+    createMany?: NestedCreateManyInput<Schema, Model, Field>;
+    /**
+     * Connects an existing record.
+     */
+    connect?: ConnectInput<Schema, Model, Field, Options>;
+}, (FieldIsArray<Schema, Model, Field> extends true ? never : 'createMany') | (FieldIsDelegateRelation<Schema, Model, Field> extends true ? 'create' | 'createMany' | 'connectOrCreate' : never)>;
+type CreateRelationPayload<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema>> = OptionalWrap<Schema, Model, {
+    [Key in RelationFields<Schema, Model> as RelationFieldType<Schema, Model, Key> extends GetSlicedModels<Schema, Options> ? Key : never]: CreateRelationFieldPayload<Schema, Model, Key, Options>;
+}>;
+type CreateWithFKInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema>> = CreateScalarPayload<Schema, Model> & CreateFKPayload<Schema, Model> & CreateWithNonOwnedRelationPayload<Schema, Model, Options>;
+type CreateWithRelationInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema>> = CreateScalarPayload<Schema, Model> & CreateRelationPayload<Schema, Model, Options>;
+type CreateWithNonOwnedRelationPayload<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema>> = OptionalWrap<Schema, Model, {
+    [Key in NonOwnedRelationFields<Schema, Model> as RelationFieldType<Schema, Model, Key> extends GetSlicedModels<Schema, Options> ? Key : never]: CreateRelationFieldPayload<Schema, Model, Key, Options>;
+}>;
+type ConnectOrCreatePayload<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema>, Without extends string = never> = {
+    /**
+     * The unique filter to find an existing record to connect.
+     */
+    where: WhereUniqueInput<Schema, Model, Options>;
+    /**
+     * The data to create a new record if no existing record is found.
+     */
+    create: CreateInput<Schema, Model, Options, Without>;
+};
+type CreateManyInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Without extends string = never> = {
+    /**
+     * The data for the records to create.
+     */
+    data: OrArray<Omit<CreateScalarPayload<Schema, Model>, Without> & Omit<CreateFKPayload<Schema, Model>, Without>>;
+    /**
+     * Specifies whether to skip creating records that would violate unique constraints.
+     */
+    skipDuplicates?: boolean;
+};
+type CreateInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema>, Without extends string = never> = XOR<Omit<CreateWithFKInput<Schema, Model, Options>, Without>, Omit<CreateWithRelationInput<Schema, Model, Options>, Without>>;
+type NestedCreateInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>, Options extends QueryOptions<Schema>> = OrArray<CreateInput<Schema, RelationFieldType<Schema, Model, Field>, Options, OppositeRelationAndFK<Schema, Model, Field>>, FieldIsArray<Schema, Model, Field>>;
+type NestedCreateManyInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>> = CreateManyInput<Schema, RelationFieldType<Schema, Model, Field>, OppositeRelationAndFK<Schema, Model, Field>>;
+type UpdateArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>> = {
+    /**
+     * The data to update the record with.
+     */
+    data: UpdateInput<Schema, Model, Options>;
+    /**
+     * The unique filter to find the record to update.
+     */
+    where: WhereUniqueInput<Schema, Model, Options>;
+} & SelectIncludeOmit<Schema, Model, true, Options>;
+type UpdateManyArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>> = UpdateManyPayload<Schema, Model, Options>;
+type UpdateManyAndReturnArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>> = UpdateManyPayload<Schema, Model, Options> & SelectIncludeOmit<Schema, Model, false, Options, false>;
+type UpdateManyPayload<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>, Without extends string = never> = {
+    /**
+     * The data to update the records with.
+     */
+    data: OrArray<UpdateScalarInput<Schema, Model, Without>>;
+    /**
+     * The filter to select records to update.
+     */
+    where?: WhereInput<Schema, Model, Options>;
+    /**
+     * Limit the number of records to update.
+     */
+    limit?: number;
+};
+type UpsertArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>> = {
+    /**
+     * The data to create the record if it doesn't exist.
+     */
+    create: CreateInput<Schema, Model, Options>;
+    /**
+     * The data to update the record with if it exists.
+     */
+    update: UpdateInput<Schema, Model, Options>;
+    /**
+     * The unique filter to find the record to update.
+     */
+    where: WhereUniqueInput<Schema, Model, Options>;
+} & SelectIncludeOmit<Schema, Model, true, Options>;
+type UpdateScalarInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Without extends string = never> = Omit<{
+    [Key in NonRelationFields<Schema, Model> as FieldIsDelegateDiscriminator<Schema, Model, Key> extends true ? never : Key]?: ScalarUpdatePayload<Schema, Model, Key>;
+}, Without>;
+type ScalarUpdatePayload<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends NonRelationFields<Schema, Model>> = ScalarFieldMutationPayload<Schema, Model, Field> | (Field extends NumericFields<Schema, Model> ? {
+    /**
+     * Sets the field to the specified value.
+     */
+    set?: NullableIf<number, ModelFieldIsOptional<Schema, Model, Field>>;
+    /**
+     * Increments the field by the specified value.
+     */
+    increment?: number;
+    /**
+     * Decrements the field by the specified value.
+     */
+    decrement?: number;
     /**
-     * Plugin ID.
+     * Multiplies the field by the specified value.
      */
-    id: string;
+    multiply?: number;
     /**
-     * Plugin display name.
+     * Divides the field by the specified value.
      */
-    name?: string;
+    divide?: number;
+} : never) | (FieldIsArray<Schema, Model, Field> extends true ? {
     /**
-     * Plugin description.
+     * Sets the field to the specified array.
      */
-    description?: string;
+    set?: MapModelFieldType<Schema, Model, Field>[];
     /**
-     * Custom function implementations.
-     * @private
+     * Appends the specified values to the array field.
      */
-    functions?: Record<string, ZModelFunction<Schema>>;
+    push?: OrArray<MapModelFieldType<Schema, Model, Field>, true>;
+} : never);
+type UpdateRelationInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema>, Without extends string = never> = Omit<{
+    [Key in RelationFields<Schema, Model> as RelationFieldType<Schema, Model, Key> extends GetSlicedModels<Schema, Options> ? Key : never]?: UpdateRelationFieldPayload<Schema, Model, Key, Options>;
+}, Without>;
+type UpdateInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema>, Without extends string = never> = UpdateScalarInput<Schema, Model, Without> & UpdateRelationInput<Schema, Model, Options, Without>;
+type UpdateRelationFieldPayload<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>, Options extends QueryOptions<Schema>> = FieldIsArray<Schema, Model, Field> extends true ? ToManyRelationUpdateInput<Schema, Model, Field, Options> : ToOneRelationUpdateInput<Schema, Model, Field, Options>;
+type ToManyRelationUpdateInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>, Options extends QueryOptions<Schema>> = Omit<{
     /**
-     * Intercepts an ORM query.
+     * Creates related records.
      */
-    onQuery?: OnQueryCallback<Schema>;
+    create?: NestedCreateInput<Schema, Model, Field, Options>;
     /**
-     * Intercepts a procedure invocation.
+     * Creates a batch of related records.
      */
-    onProcedure?: OnProcedureCallback<Schema>;
+    createMany?: NestedCreateManyInput<Schema, Model, Field>;
     /**
-     * Intercepts an entity mutation.
+     * Connects existing records.
      */
-    onEntityMutation?: EntityMutationHooksDef<Schema>;
+    connect?: ConnectInput<Schema, Model, Field, Options>;
     /**
-     * Intercepts a Kysely query.
+     * Connects or create related records.
      */
-    onKyselyQuery?: OnKyselyQueryCallback<Schema>;
+    connectOrCreate?: ConnectOrCreateInput<Schema, Model, Field, Options>;
     /**
-     * Extended query args configuration.
+     * Disconnects related records.
      */
-    queryArgs?: {
-        [K in keyof ExtQueryArgs]: ZodType<ExtQueryArgs[K]>;
-    };
+    disconnect?: DisconnectInput<Schema, Model, Field, Options>;
     /**
-     * Extended client members (methods and properties).
+     * Updates related records.
      */
-    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> = {
+    update?: NestedUpdateInput<Schema, Model, Field, Options>;
     /**
-     * The procedure name.
+     * Upserts related records.
      */
-    name: string;
+    upsert?: NestedUpsertInput<Schema, Model, Field, Options>;
     /**
-     * Whether the procedure is a mutation.
+     * Updates a batch of related records.
      */
-    mutation: boolean;
+    updateMany?: NestedUpdateManyInput<Schema, Model, Field, Options>;
     /**
-     * Procedure invocation input (envelope).
-     *
-     * The canonical shape is `{ args?: Record<string, unknown> }`.
-     * When a procedure has required params, `args` is required.
+     * Deletes related records.
      */
-    input: unknown;
+    delete?: NestedDeleteInput<Schema, Model, Field, Options>;
     /**
-     * Continues the invocation. The input passed here is forwarded to the next handler.
+     * Deletes a batch of related records.
      */
-    proceed: (input: unknown) => Promise<unknown>;
+    deleteMany?: NestedDeleteManyInput<Schema, Model, Field, Options>;
     /**
-     * The ZenStack client that is invoking the procedure.
+     * Sets the related records to the specified ones.
      */
-    client: ClientContract<Schema>;
+    set?: SetRelationInput<Schema, Model, Field, Options>;
+}, 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>, Options extends QueryOptions<Schema>> = Omit<{
+    /**
+     * Creates a related record.
+     */
+    create?: NestedCreateInput<Schema, Model, Field, Options>;
+    /**
+     * Connects an existing record.
+     */
+    connect?: ConnectInput<Schema, Model, Field, Options>;
+    /**
+     * Connects or create a related record.
+     */
+    connectOrCreate?: ConnectOrCreateInput<Schema, Model, Field, Options>;
+    /**
+     * Updates the related record.
+     */
+    update?: NestedUpdateInput<Schema, Model, Field, Options>;
+    /**
+     * Upserts the related record.
+     */
+    upsert?: NestedUpsertInput<Schema, Model, Field, Options>;
+} & (ModelFieldIsOptional<Schema, Model, Field> extends true ? {
+    /**
+     * Disconnects the related record.
+     */
+    disconnect?: DisconnectInput<Schema, Model, Field, Options>;
+    /**
+     * Deletes the related record.
+     */
+    delete?: NestedDeleteInput<Schema, Model, Field, Options>;
+} : {}), FieldIsDelegateRelation<Schema, Model, Field> extends true ? 'create' | 'connectOrCreate' | 'upsert' : never>;
+type DeleteArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>> = {
+    /**
+     * The unique filter to find the record to delete.
+     */
+    where: WhereUniqueInput<Schema, Model, Options>;
+} & SelectIncludeOmit<Schema, Model, true, Options>;
+type DeleteManyArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>> = {
+    /**
+     * Filter to select records to delete.
+     */
+    where?: WhereInput<Schema, Model, Options>;
+    /**
+     * Limits the number of records to delete.
+     */
+    limit?: number;
 };
-type OnQueryCallback<Schema extends SchemaDef> = (ctx: OnQueryHookContext<Schema>) => Promise<unknown>;
-type OnQueryHookContext<Schema extends SchemaDef> = {
+type CountArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>> = Omit<FindArgs<Schema, Model, Options, true>, 'select' | 'include' | 'distinct' | 'omit'> & {
     /**
-     * The model that is being queried.
+     * Selects fields to count
      */
-    model: GetModels<Schema>;
+    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>, Options extends QueryOptions<Schema> = QueryOptions<Schema>> = {
     /**
-     * The operation that is being performed.
+     * Filter conditions
      */
-    operation: AllCrudOperations;
+    where?: WhereInput<Schema, Model, Options>;
     /**
-     * The query arguments.
+     * Number of records to skip for the aggregation
      */
-    args: Record<string, unknown> | undefined;
+    skip?: number;
     /**
-     * The function to proceed with the original query.
-     * It takes the same arguments as the operation method.
-     *
-     * @param args The query arguments.
+     * Number of records to take for the aggregation
      */
-    proceed: (args: Record<string, unknown> | undefined) => Promise<unknown>;
+    take?: number;
     /**
-     * The ZenStack client that is performing the operation.
+     * Order by clauses
      */
-    client: ClientContract<Schema>;
+    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 EntityMutationHooksDef<Schema extends SchemaDef> = {
+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>, Options extends QueryOptions<Schema> = QueryOptions<Schema>> = Omit<WhereInput<Schema, Model, Options, true, true>, '$expr'>;
+type GroupByArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>> = {
+    /**
+     * Filter conditions
+     */
+    where?: WhereInput<Schema, Model, Options>;
+    /**
+     * 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, Options>;
+    /**
+     * 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;
+} ? {
     /**
-     * Called before entities are mutated.
+     * Count aggregation result
      */
-    beforeEntityMutation?: BeforeEntityMutationCallback<Schema>;
+    _count: AggCommonOutput<Count>;
+} : {}) & (Args extends {
+    _avg: infer Avg;
+} ? {
     /**
-     * Called after entities are mutated.
+     * Average aggregation result
      */
-    afterEntityMutation?: AfterEntityMutationCallback<Schema>;
+    _avg: AggCommonOutput<Avg>;
+} : {}) & (Args extends {
+    _sum: infer Sum;
+} ? {
     /**
-     * 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`.
+     * Sum aggregation result
      */
-    runAfterMutationWithinTransaction?: boolean;
-};
-type MutationHooksArgs<Schema extends SchemaDef> = {
+    _sum: AggCommonOutput<Sum>;
+} : {}) & (Args extends {
+    _min: infer Min;
+} ? {
     /**
-     * The model that is being mutated.
+     * Minimum aggregation result
      */
-    model: GetModels<Schema>;
+    _min: AggCommonOutput<Min>;
+} : {}) & (Args extends {
+    _max: infer Max;
+} ? {
     /**
-     * The mutation action that is being performed.
+     * Maximum aggregation result
      */
-    action: 'create' | 'update' | 'delete';
+    _max: AggCommonOutput<Max>;
+} : {})>;
+type ConnectInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>, Options extends QueryOptions<Schema>> = FieldIsArray<Schema, Model, Field> extends true ? OrArray<WhereUniqueInput<Schema, RelationFieldType<Schema, Model, Field>, Options>> : WhereUniqueInput<Schema, RelationFieldType<Schema, Model, Field>, Options>;
+type ConnectOrCreateInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>, Options extends QueryOptions<Schema>> = FieldIsArray<Schema, Model, Field> extends true ? OrArray<ConnectOrCreatePayload<Schema, RelationFieldType<Schema, Model, Field>, Options, OppositeRelationAndFK<Schema, Model, Field>>> : ConnectOrCreatePayload<Schema, RelationFieldType<Schema, Model, Field>, Options, OppositeRelationAndFK<Schema, Model, Field>>;
+type DisconnectInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>, Options extends QueryOptions<Schema>> = FieldIsArray<Schema, Model, Field> extends true ? OrArray<WhereUniqueInput<Schema, RelationFieldType<Schema, Model, Field>, Options>, true> : boolean | WhereInput<Schema, RelationFieldType<Schema, Model, Field>, Options>;
+type SetRelationInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>, Options extends QueryOptions<Schema>> = OrArray<WhereUniqueInput<Schema, RelationFieldType<Schema, Model, Field>, Options>>;
+type NestedUpdateInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>, Options extends QueryOptions<Schema>> = FieldIsArray<Schema, Model, Field> extends true ? OrArray<{
     /**
-     * The mutation data. Only available for create and update actions.
+     * Unique filter to select the record to update.
      */
-    queryNode: OperationNode;
+    where: WhereUniqueInput<Schema, RelationFieldType<Schema, Model, Field>, Options>;
     /**
-     * A query ID that uniquely identifies the mutation operation. You can use it to correlate
-     * data between the before and after mutation hooks.
+     * The data to update the record with.
      */
-    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> & {
+    data: UpdateInput<Schema, RelationFieldType<Schema, Model, Field>, Options, OppositeRelationAndFK<Schema, Model, Field>>;
+}, true> : XOR<{
     /**
-     * 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.
+     * Filter to select the record to update.
      */
-    loadBeforeMutationEntities(): Promise<Record<string, unknown>[] | undefined>;
+    where?: WhereInput<Schema, RelationFieldType<Schema, Model, Field>, Options>;
     /**
-     * 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.
+     * The data to update the record with.
      */
-    client: ClientContract<Schema>;
-};
-type PluginAfterEntityMutationArgs<Schema extends SchemaDef> = MutationHooksArgs<Schema> & {
+    data: UpdateInput<Schema, RelationFieldType<Schema, Model, Field>, Options, OppositeRelationAndFK<Schema, Model, Field>>;
+}, UpdateInput<Schema, RelationFieldType<Schema, Model, Field>, Options, OppositeRelationAndFK<Schema, Model, Field>>>;
+type NestedUpsertInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>, Options extends QueryOptions<Schema>> = OrArray<{
     /**
-     * Loads the entities that have been mutated.
+     * Unique filter to select the record to update.
      */
-    loadAfterMutationEntities(): Promise<Record<string, unknown>[] | undefined>;
+    where: WhereUniqueInput<Schema, RelationFieldType<Schema, Model, Field>, Options>;
     /**
-     * The entities before mutation. Only available if `beforeEntityMutation` hook is provided and
-     * the `loadBeforeMutationEntities` function is called in that hook.
+     * The data to create the record if it doesn't exist.
      */
-    beforeMutationEntities?: Record<string, unknown>[];
+    create: CreateInput<Schema, RelationFieldType<Schema, Model, Field>, Options, OppositeRelationAndFK<Schema, Model, Field>>;
     /**
-     * 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.
+     * The data to update the record with if it exists.
      */
-    client: ClientContract<Schema>;
+    update: UpdateInput<Schema, RelationFieldType<Schema, Model, Field>, Options, OppositeRelationAndFK<Schema, Model, Field>>;
+}, FieldIsArray<Schema, Model, Field>>;
+type NestedUpdateManyInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>, Options extends QueryOptions<Schema>> = OrArray<UpdateManyPayload<Schema, RelationFieldType<Schema, Model, Field>, Options, OppositeRelationAndFK<Schema, Model, Field>>>;
+type NestedDeleteInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>, Options extends QueryOptions<Schema>> = FieldIsArray<Schema, Model, Field> extends true ? OrArray<WhereUniqueInput<Schema, RelationFieldType<Schema, Model, Field>, Options>, true> : boolean | WhereInput<Schema, RelationFieldType<Schema, Model, Field>, Options>;
+type NestedDeleteManyInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>, Options extends QueryOptions<Schema>> = OrArray<WhereInput<Schema, RelationFieldType<Schema, Model, Field>, Options, 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 OnKyselyQueryArgs<Schema extends SchemaDef> = {
-    schema: SchemaDef;
+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>;
-    query: RootOperationNode;
-    proceed: ProceedKyselyQueryFunction;
+} & 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 ProceedKyselyQueryFunction = (query: RootOperationNode) => Promise<QueryResult<any>>;
-type OnKyselyQueryCallback<Schema extends SchemaDef> = (args: OnKyselyQueryArgs<Schema>) => Promise<QueryResult<UnknownRow>>;
+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 ProviderSupportsDistinct<Schema extends SchemaDef> = Schema['provider']['type'] extends 'postgresql' ? true : false;
 
 /**
  * A promise that only executes when it's awaited or .then() is called.
@@ -1884,18 +2213,18 @@ type ClientContract<Schema extends SchemaDef, Options extends ClientOptions<Sche
      */
     $pushSchema(): Promise<void>;
 } & {
-    [Key in GetModels<Schema> as Uncapitalize<Key>]: ModelOperations<Schema, Key, ToQueryOptions<Options>, ExtQueryArgs>;
-} & ProcedureOperations<Schema> & ExtClientMembers;
+    [Key in GetSlicedModels<Schema, Options> as Uncapitalize<Key>]: ModelOperations<Schema, Key, Options, ExtQueryArgs>;
+} & ProcedureOperations<Schema, Options> & ExtClientMembers;
 /**
  * The contract for a client in a transaction.
  */
 type TransactionClientContract<Schema extends SchemaDef, Options extends ClientOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase, ExtClientMembers extends ExtClientMembersBase> = Omit<ClientContract<Schema, Options, ExtQueryArgs, ExtClientMembers>, TransactionUnsupportedMethods>;
-type ProcedureOperations<Schema extends SchemaDef> = Schema['procedures'] extends Record<string, ProcedureDef> ? {
+type ProcedureOperations<Schema extends SchemaDef, Options extends ClientOptions<Schema> = ClientOptions<Schema>> = Schema['procedures'] extends Record<string, ProcedureDef> ? {
     /**
      * Custom procedures.
      */
     $procs: {
-        [Key in GetProcedureNames<Schema>]: ProcedureFunc<Schema, Key>;
+        [Key in GetSlicedProcedures<Schema, Options>]: ProcedureFunc<Schema, Key>;
     };
 } : {};
 /**
@@ -1920,6 +2249,9 @@ type CRUD_EXT = CRUD | 'post-update';
  * Extended CRUD operations including 'post-update'.
  */
 declare const CRUD_EXT: readonly ["create", "read", "update", "delete", "post-update"];
+type SliceOperations<T extends Record<string, unknown>, Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends ClientOptions<Schema>> = Omit<{
+    [Key in keyof T as Key extends GetSlicedOperations<Schema, Model, Options> ? Key : never]: T[Key];
+}, IsDelegateModel<Schema, Model> extends true ? OperationsIneligibleForDelegateModels : never>;
 type AllModelOperations<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema>, ExtQueryArgs> = CommonModelOperations<Schema, Model, Options, ExtQueryArgs> & (Schema['provider']['type'] extends 'mysql' ? {} : {
     /**
      * Creates multiple entities and returns them.
@@ -1939,7 +2271,7 @@ type AllModelOperations<Schema extends SchemaDef, Model extends GetModels<Schema
      * });
      * ```
      */
-    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>[]>;
+    createManyAndReturn<T extends CreateManyAndReturnArgs<Schema, Model, Options> & ExtractExtQueryArgs<ExtQueryArgs, 'createManyAndReturn'>>(args?: SelectSubset<T, CreateManyAndReturnArgs<Schema, Model, Options> & ExtractExtQueryArgs<ExtQueryArgs, 'createManyAndReturn'>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options>[]>;
     /**
      * Updates multiple entities and returns them.
      * @param args - update args. Only scalar fields are allowed for data.
@@ -1962,7 +2294,7 @@ type AllModelOperations<Schema extends SchemaDef, Model extends GetModels<Schema
      * });
      * ```
      */
-    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>[]>;
+    updateManyAndReturn<T extends UpdateManyAndReturnArgs<Schema, Model, Options> & ExtractExtQueryArgs<ExtQueryArgs, 'updateManyAndReturn'>>(args: Subset<T, UpdateManyAndReturnArgs<Schema, Model, Options> & ExtractExtQueryArgs<ExtQueryArgs, 'updateManyAndReturn'>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options>[]>;
 });
 type CommonModelOperations<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema>, ExtQueryArgs> = {
     /**
@@ -2046,35 +2378,35 @@ type CommonModelOperations<Schema extends SchemaDef, Model extends GetModels<Sch
      * }); // result: `{ _count: { posts: number } }`
      * ```
      */
-    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>[]>;
+    findMany<T extends FindManyArgs<Schema, Model, Options> & ExtractExtQueryArgs<ExtQueryArgs, 'findMany'>>(args?: SelectSubset<T, FindManyArgs<Schema, Model, Options> & 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> & ExtractExtQueryArgs<ExtQueryArgs, 'findUnique'>>(args: SelectSubset<T, FindUniqueArgs<Schema, Model> & ExtractExtQueryArgs<ExtQueryArgs, 'findUnique'>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options> | null>;
+    findUnique<T extends FindUniqueArgs<Schema, Model, Options> & ExtractExtQueryArgs<ExtQueryArgs, 'findUnique'>>(args: SelectSubset<T, FindUniqueArgs<Schema, Model, Options> & 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> & ExtractExtQueryArgs<ExtQueryArgs, 'findUnique'>>(args: SelectSubset<T, FindUniqueArgs<Schema, Model> & ExtractExtQueryArgs<ExtQueryArgs, 'findUnique'>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options>>;
+    findUniqueOrThrow<T extends FindUniqueArgs<Schema, Model, Options> & ExtractExtQueryArgs<ExtQueryArgs, 'findUnique'>>(args: SelectSubset<T, FindUniqueArgs<Schema, Model, Options> & 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> & ExtractExtQueryArgs<ExtQueryArgs, 'findFirst'>>(args?: SelectSubset<T, FindFirstArgs<Schema, Model> & ExtractExtQueryArgs<ExtQueryArgs, 'findFirst'>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options> | null>;
+    findFirst<T extends FindFirstArgs<Schema, Model, Options> & ExtractExtQueryArgs<ExtQueryArgs, 'findFirst'>>(args?: SelectSubset<T, FindFirstArgs<Schema, Model, Options> & 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> & ExtractExtQueryArgs<ExtQueryArgs, 'findFirst'>>(args?: SelectSubset<T, FindFirstArgs<Schema, Model> & ExtractExtQueryArgs<ExtQueryArgs, 'findFirst'>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options>>;
+    findFirstOrThrow<T extends FindFirstArgs<Schema, Model, Options> & ExtractExtQueryArgs<ExtQueryArgs, 'findFirst'>>(args?: SelectSubset<T, FindFirstArgs<Schema, Model, Options> & ExtractExtQueryArgs<ExtQueryArgs, 'findFirst'>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options>>;
     /**
      * Creates a new entity.
      * @param args - create args
@@ -2127,7 +2459,7 @@ type CommonModelOperations<Schema extends SchemaDef, Model extends GetModels<Sch
      * });
      * ```
      */
-    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>>;
+    create<T extends CreateArgs<Schema, Model, Options> & ExtractExtQueryArgs<ExtQueryArgs, 'create'>>(args: SelectSubset<T, CreateArgs<Schema, Model, Options> & ExtractExtQueryArgs<ExtQueryArgs, 'create'>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options>>;
     /**
      * Creates multiple entities. Only scalar fields are allowed.
      * @param args - create args
@@ -2271,7 +2603,7 @@ type CommonModelOperations<Schema extends SchemaDef, Model extends GetModels<Sch
      * });
      * ```
      */
-    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>>;
+    update<T extends UpdateArgs<Schema, Model, Options> & ExtractExtQueryArgs<ExtQueryArgs, 'update'>>(args: SelectSubset<T, UpdateArgs<Schema, Model, Options> & ExtractExtQueryArgs<ExtQueryArgs, 'update'>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options>>;
     /**
      * Updates multiple entities.
      * @param args - update args. Only scalar fields are allowed for data.
@@ -2292,7 +2624,7 @@ type CommonModelOperations<Schema extends SchemaDef, Model extends GetModels<Sch
      *     limit: 10
      * });
      */
-    updateMany<T extends UpdateManyArgs<Schema, Model> & ExtractExtQueryArgs<ExtQueryArgs, 'updateMany'>>(args: Subset<T, UpdateManyArgs<Schema, Model> & ExtractExtQueryArgs<ExtQueryArgs, 'updateMany'>>): ZenStackPromise<Schema, BatchResult>;
+    updateMany<T extends UpdateManyArgs<Schema, Model, Options> & ExtractExtQueryArgs<ExtQueryArgs, 'updateMany'>>(args: Subset<T, UpdateManyArgs<Schema, Model, Options> & ExtractExtQueryArgs<ExtQueryArgs, 'updateMany'>>): ZenStackPromise<Schema, BatchResult>;
     /**
      * Creates or updates an entity.
      * @param args - upsert args
@@ -2313,7 +2645,7 @@ type CommonModelOperations<Schema extends SchemaDef, Model extends GetModels<Sch
      * });
      * ```
      */
-    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>>;
+    upsert<T extends UpsertArgs<Schema, Model, Options> & ExtractExtQueryArgs<ExtQueryArgs, 'upsert'>>(args: SelectSubset<T, UpsertArgs<Schema, Model, Options> & ExtractExtQueryArgs<ExtQueryArgs, 'upsert'>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options>>;
     /**
      * Deletes a uniquely identifiable entity.
      * @param args - delete args
@@ -2333,7 +2665,7 @@ type CommonModelOperations<Schema extends SchemaDef, Model extends GetModels<Sch
      * }); // result: `{ id: string; email: string }`
      * ```
      */
-    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>>;
+    delete<T extends DeleteArgs<Schema, Model, Options> & ExtractExtQueryArgs<ExtQueryArgs, 'delete'>>(args: SelectSubset<T, DeleteArgs<Schema, Model, Options> & ExtractExtQueryArgs<ExtQueryArgs, 'delete'>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options>>;
     /**
      * Deletes multiple entities.
      * @param args - delete args
@@ -2353,7 +2685,7 @@ type CommonModelOperations<Schema extends SchemaDef, Model extends GetModels<Sch
      * });
      * ```
      */
-    deleteMany<T extends DeleteManyArgs<Schema, Model> & ExtractExtQueryArgs<ExtQueryArgs, 'deleteMany'>>(args?: Subset<T, DeleteManyArgs<Schema, Model> & ExtractExtQueryArgs<ExtQueryArgs, 'deleteMany'>>): ZenStackPromise<Schema, BatchResult>;
+    deleteMany<T extends DeleteManyArgs<Schema, Model, Options> & ExtractExtQueryArgs<ExtQueryArgs, 'deleteMany'>>(args?: Subset<T, DeleteManyArgs<Schema, Model, Options> & ExtractExtQueryArgs<ExtQueryArgs, 'deleteMany'>>): ZenStackPromise<Schema, BatchResult>;
     /**
      * Counts rows or field values.
      * @param args - count args
@@ -2372,7 +2704,7 @@ type CommonModelOperations<Schema extends SchemaDef, Model extends GetModels<Sch
      *     select: { _all: true, email: true }
      * }); // result: `{ _all: number, email: number }`
      */
-    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>>>;
+    count<T extends CountArgs<Schema, Model, Options> & ExtractExtQueryArgs<ExtQueryArgs, 'count'>>(args?: Subset<T, CountArgs<Schema, Model, Options> & ExtractExtQueryArgs<ExtQueryArgs, 'count'>>): ZenStackPromise<Schema, Simplify<CountResult<Schema, Model, T>>>;
     /**
      * Aggregates rows.
      * @param args - aggregation args
@@ -2390,7 +2722,7 @@ type CommonModelOperations<Schema extends SchemaDef, Model extends GetModels<Sch
      *     _max: { age: true }
      * }); // result: `{ _count: number, _avg: { age: number }, ... }`
      */
-    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>>>;
+    aggregate<T extends AggregateArgs<Schema, Model, Options> & ExtractExtQueryArgs<ExtQueryArgs, 'aggregate'>>(args: Subset<T, AggregateArgs<Schema, Model, Options> & ExtractExtQueryArgs<ExtQueryArgs, 'aggregate'>>): ZenStackPromise<Schema, Simplify<AggregateResult<Schema, Model, T>>>;
     /**
      * Groups rows by columns.
      * @param args - groupBy args
@@ -2424,7 +2756,7 @@ type CommonModelOperations<Schema extends SchemaDef, Model extends GetModels<Sch
      *     having: { country: 'US', age: { _avg: { gte: 18 } } }
      * });
      */
-    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>>>;
+    groupBy<T extends GroupByArgs<Schema, Model, Options> & ExtractExtQueryArgs<ExtQueryArgs, 'groupBy'>>(args: Subset<T, GroupByArgs<Schema, Model, Options> & ExtractExtQueryArgs<ExtQueryArgs, 'groupBy'>>): ZenStackPromise<Schema, Simplify<GroupByResult<Schema, Model, T>>>;
     /**
      * Checks if an entity exists.
      * @param args - exists args
@@ -2442,10 +2774,10 @@ type CommonModelOperations<Schema extends SchemaDef, Model extends GetModels<Sch
      *     where: { posts: { some: { published: true } } },
      * }); // result: `boolean`
      */
-    exists<T extends ExistsArgs<Schema, Model> & ExtractExtQueryArgs<ExtQueryArgs, 'exists'>>(args?: Subset<T, ExistsArgs<Schema, Model> & ExtractExtQueryArgs<ExtQueryArgs, 'exists'>>): ZenStackPromise<Schema, boolean>;
+    exists<T extends ExistsArgs<Schema, Model, Options> & ExtractExtQueryArgs<ExtQueryArgs, 'exists'>>(args?: Subset<T, ExistsArgs<Schema, Model, Options> & 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>, ExtQueryArgs = {}> = Omit<AllModelOperations<Schema, Model, Options, ExtQueryArgs>, IsDelegateModel<Schema, Model> extends true ? OperationsIneligibleForDelegateModels : never>;
+type ModelOperations<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends ClientOptions<Schema> = ClientOptions<Schema>, ExtQueryArgs = {}> = SliceOperations<AllModelOperations<Schema, Model, Options, ExtQueryArgs>, Schema, Model, Options>;
 /**
  * Type for auth context that includes both scalar and relation fields.
  * Relations are recursively included to allow nested auth data like { user: { profile: { ... } } }
@@ -2455,117 +2787,6 @@ 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.
  */
@@ -2718,7 +2939,7 @@ declare function extractIdFields(entity: any, schema: SchemaDef, model: string):
 };
 declare function getDiscriminatorField(schema: SchemaDef, model: string): string | undefined;
 declare function getDelegateDescendantModels(schema: SchemaDef, model: string, collected?: Set<ModelDef>): ModelDef[];
-declare function aggregate(eb: ExpressionBuilder<any, any>, expr: Expression<any>, op: AGGREGATE_OPERATORS): kysely.AggregateFunctionBuilder<any, any, string | number | bigint>;
+declare function aggregate(eb: ExpressionBuilder<any, any>, expr: Expression<any>, op: AggregateOperators): kysely.AggregateFunctionBuilder<any, any, string | number | bigint>;
 /**
  * Strips alias from the node if it exists.
  */
@@ -2810,4 +3031,4 @@ declare namespace schemaUtils {
   export { schemaUtils_ExpressionVisitor as ExpressionVisitor, schemaUtils_MatchingExpressionVisitor as MatchingExpressionVisitor, type schemaUtils_VisitResult as VisitResult };
 }
 
-export { type AfterEntityMutationCallback, type AggregateArgs, type AggregateResult, AllCrudOperations, type AllModelOperations, AllReadOperations, AnyNull, AnyNullClass, type AnyPlugin, type AuthType, BaseCrudDialect, type BatchResult, type BeforeEntityMutationCallback, type BooleanFilter, type BytesFilter, CRUD, CRUD_EXT, type ClientConstructor, type ClientContract, type ClientOptions, type ComputedFieldsOptions, CoreCreateOperations, CoreCrudOperations, CoreDeleteOperations, CoreReadOperations, CoreUpdateOperations, CoreWriteOperations, type CountArgs, type CountResult, type CreateArgs, type CreateInput, type CreateManyAndReturnArgs, type CreateManyArgs, type CreateManyInput, type DateTimeFilter, DbNull, DbNullClass, type DefaultModelResult, type DeleteArgs, type DeleteManyArgs, type EntityMutationHooksDef, type ExistsArgs, type ExtClientMembersBase, type ExtQueryArgsBase, type 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 };
+export { type AfterEntityMutationCallback, type AggregateArgs, type AggregateResult, AllCrudOperations, type AllModelOperations, AllReadOperations, AnyNull, AnyNullClass, type AnyPlugin, type AuthType, BaseCrudDialect, type BatchResult, type BeforeEntityMutationCallback, type BooleanFilter, type BytesFilter, CRUD, CRUD_EXT, type ClientConstructor, type ClientContract, type ClientOptions, type ComputedFieldsOptions, CoreCreateOperations, CoreCrudOperations, CoreDeleteOperations, CoreReadOperations, CoreUpdateOperations, CoreWriteOperations, type CountArgs, type CountResult, type CreateArgs, type CreateInput, type CreateManyAndReturnArgs, type CreateManyArgs, type CreateManyInput, type DateTimeFilter, DbNull, DbNullClass, type DefaultModelResult, type DeleteArgs, type DeleteManyArgs, type EntityMutationHooksDef, type ExistsArgs, type ExtClientMembersBase, type ExtQueryArgsBase, type FilterKind, type FindArgs, type FindFirstArgs, type FindManyArgs, type FindUniqueArgs, type GetAllIncludedOperations, type GetIncludedOperations, type GetProcedure, type GetProcedureNames, type GetProcedureParams, type GetQueryOptions, type GetSlicedFilterKindsForField, type GetSlicedModels, type GetSlicedOperations, type GetSlicedProcedures, type GroupByArgs, type GroupByResult, type HasComputedFields, type HasProcedures, type IncludeInput, InputValidator, type JsonArray, type JsonFilter, JsonNull, JsonNullClass, type JsonNullValues, type JsonObject, type JsonValue, kyselyUtils as KyselyUtils, type ModelOperations, type ModelResult, type ModelSlicingOptions, type NullsOrder, type NumberFilter, ORMError, ORMErrorReason, type OmitConfig, type OmitInput, type OnKyselyQueryArgs, type OnKyselyQueryCallback, type OnProcedureHookContext, type OperationsIneligibleForDelegateModels, type OrderBy, type PluginAfterEntityMutationArgs, type PluginBeforeEntityMutationArgs, type ProcedureEnvelope, type ProcedureFunc, type ProcedureHandlerFunc, type ProcedureOperations, type ProceduresOptions, type ProceedKyselyQueryFunction, type QueryOptions, queryUtils as QueryUtils, RejectedByPolicyReason, type RuntimePlugin, schemaUtils as SchemaUtils, type SelectIncludeOmit, type SelectInput, type SelectSubset, type SimplifiedPlainResult, type SimplifiedResult, type SlicingOptions, type SortOrder, type StringFilter, type Subset, type ToKysely, type TransactionClientContract, TransactionIsolationLevel, type TypeDefResult, type TypedJsonFilter, type UpdateArgs, type UpdateInput, type UpdateManyAndReturnArgs, type UpdateManyArgs, type UpsertArgs, type WhereInput, type WhereUniqueInput, type ZModelFunction, type ZModelFunctionContext, ZenStackClient, type ZenStackPromise, definePlugin, getCrudDialect };