@zenstackhq/orm 3.4.0-beta.4 → 3.4.1

package/dist/index.d.cts

@@ -1,9 +1,9 @@
 import * as _zenstackhq_schema from '@zenstackhq/schema';
-import { SchemaDef, BuiltinType, GetModels, FieldDef, ModelDef, DataSourceProviderType, ScalarFields, ForeignKeyFields, GetModelFields, FieldHasDefault, GetModelFieldType, ModelFieldIsOptional, GetModelField, GetModel, ProcedureDef, NonRelationFields, GetEnums, GetEnum, GetTypeDefs, GetTypeDefFields, GetTypeDefField, TypeDefFieldIsOptional, RelationFields, FieldIsArray, RelationFieldType, FieldIsRelation, GetTypeDefFieldType, TypeDefFieldIsArray, UpdatedAtInfo, FieldIsDelegateDiscriminator, FieldType, RelationInfo, FieldIsDelegateRelation, IsDelegateModel, Expression as Expression$1, LiteralExpression, ArrayExpression, FieldExpression, MemberExpression, BinaryExpression, UnaryExpression, CallExpression, BindingExpression, ThisExpression, NullExpression } from '@zenstackhq/schema';
+import { SchemaDef, GetModels, ScalarFields, ForeignKeyFields, GetModelFields, FieldHasDefault, GetModelFieldType, ModelFieldIsOptional, GetModelField, GetModel, ProcedureDef, BuiltinType, FieldDef, ModelDef, DataSourceProviderType, NonRelationFields, RelationFields, FieldIsArray, RelationFieldType, FieldIsRelation, GetEnums, GetEnum, GetTypeDefs, GetTypeDefFields, GetTypeDefField, TypeDefFieldIsOptional, 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, ExpressionBuilder, SelectQueryBuilder, Expression, SqlBool, ExpressionWrapper, AliasableExpression, Generated, QueryId, RootOperationNode, QueryResult, UnknownRow, Dialect, KyselyConfig, OperandExpression } from 'kysely';
+import { Kysely, 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, Generated, QueryId, RootOperationNode, QueryResult, UnknownRow, Dialect, ExpressionBuilder, Expression, KyselyConfig, OperandExpression, SelectQueryBuilder, SqlBool, ExpressionWrapper, AliasableExpression } from 'kysely';
 import Decimal from 'decimal.js';
-import { z, ZodType } from 'zod';
+import { ZodType } from 'zod';
 
 declare class DefaultOperationNodeVisitor extends OperationNodeVisitor {
     protected defaultVisit(node: OperationNode): void;
@@ -177,7 +177,6 @@ type Without<T, U> = {
 };
 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]>;
@@ -235,165 +234,6 @@ declare const FILTER_PROPERTY_TO_KIND: {
  */
 type FilterPropertyToKind = typeof FILTER_PROPERTY_TO_KIND;
 
-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>);
-    /**
-     * Whether the dialect supports updating with a limit on the number of updated rows.
-     */
-    abstract get supportsUpdateWithLimit(): boolean;
-    /**
-     * Whether the dialect supports deleting with a limit on the number of deleted rows.
-     */
-    abstract get supportsDeleteWithLimit(): boolean;
-    /**
-     * Whether the dialect supports DISTINCT ON.
-     */
-    abstract get supportsDistinctOn(): boolean;
-    /**
-     * Whether the dialect support inserting with `DEFAULT` as field value.
-     */
-    abstract get supportsDefaultAsFieldValue(): boolean;
-    /**
-     * Whether the dialect supports the RETURNING clause in INSERT/UPDATE/DELETE statements.
-     */
-    abstract get supportsReturning(): boolean;
-    /**
-     * Whether the dialect supports `INSERT INTO ... DEFAULT VALUES` syntax.
-     */
-    abstract get supportsInsertDefaultValues(): boolean;
-    /**
-     * How to perform insert ignore operation.
-     */
-    abstract get insertIgnoreMethod(): 'onConflict' | 'ignore';
-    /**
-     * Transforms input value before sending to database.
-     */
-    transformInput(value: unknown, _type: BuiltinType, _forArrayField: boolean): unknown;
-    /**
-     * Transforms output value received from database.
-     */
-    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;
-    /**
-     * Builds selection for a relation field.
-     */
-    abstract buildRelationSelection(query: SelectQueryBuilder<any, any, any>, model: string, relationField: string, parentAlias: string, payload: true | FindArgs<Schema, GetModels<Schema>, any, true>): SelectQueryBuilder<any, any, any>;
-    /**
-     * Builds skip and take clauses.
-     */
-    abstract buildSkipTake(query: SelectQueryBuilder<any, any, any>, skip: number | undefined, take: number | undefined): SelectQueryBuilder<any, any, any>;
-    /**
-     * Builds an Kysely expression that returns a JSON object for the given key-value pairs.
-     */
-    abstract buildJsonObject(value: Record<string, Expression<unknown>>): AliasableExpression<unknown>;
-    /**
-     * Builds an Kysely expression that returns the length of an array.
-     */
-    abstract buildArrayLength(array: Expression<unknown>): AliasableExpression<number>;
-    /**
-     * Builds an array value expression.
-     */
-    abstract buildArrayValue(values: Expression<unknown>[], elemType: string): AliasableExpression<unknown>;
-    /**
-     * Builds an expression that checks if an array contains a single value.
-     */
-    abstract buildArrayContains(field: Expression<unknown>, value: Expression<unknown>, elemType?: string): AliasableExpression<SqlBool>;
-    /**
-     * Builds an expression that checks if an array contains all values from another array.
-     */
-    abstract buildArrayHasEvery(field: Expression<unknown>, values: Expression<unknown>): AliasableExpression<SqlBool>;
-    /**
-     * Builds an expression that checks if an array overlaps with another array.
-     */
-    abstract buildArrayHasSome(field: Expression<unknown>, values: Expression<unknown>): AliasableExpression<SqlBool>;
-    /**
-     * Casts the given expression to an integer type.
-     */
-    abstract castInt<T extends Expression<any>>(expression: T): T;
-    /**
-     * Casts the given expression to a text type.
-     */
-    abstract castText<T extends Expression<any>>(expression: T): T;
-    /**
-     * Trims double quotes from the start and end of a text expression.
-     */
-    abstract trimTextQuotes<T extends Expression<string>>(expression: T): T;
-    abstract getStringCasingBehavior(): {
-        supportsILike: boolean;
-        likeCaseSensitive: boolean;
-    };
-    /**
-     * Builds a VALUES table and select all fields from it.
-     */
-    abstract buildValuesTableSelect(fields: FieldDef[], rows: unknown[][]): SelectQueryBuilder<any, any, any>;
-    /**
-     * Builds a JSON path selection expression.
-     */
-    protected abstract buildJsonPathSelection(receiver: Expression<any>, path: string | undefined): Expression<any>;
-    /**
-     * Builds a JSON array filter expression.
-     */
-    protected abstract buildJsonArrayFilter(receiver: Expression<any>, operation: 'array_contains' | 'array_starts_with' | 'array_ends_with', value: unknown): Expression<SqlBool>;
-    /**
-     * Builds a JSON array exists predicate (returning if any element matches the filter).
-     */
-    protected abstract buildJsonArrayExistsPredicate(receiver: Expression<any>, buildFilter: (elem: Expression<any>) => Expression<SqlBool>): Expression<SqlBool>;
-    /**
-     * Builds an ORDER BY clause for a field with NULLS FIRST/LAST support.
-     */
-    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>;
 };
@@ -406,187 +246,6 @@ 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();
-    /**
-     * Gets the effective set of allowed FilterKind values for a specific model and field.
-     * Respects the precedence: model[field] > model.$all > $all[field] > $all.$all.
-     */
-    private getEffectiveFilterKinds;
-    /**
-     * Computes the effective set of filter kinds based on inclusion and exclusion lists.
-     */
-    private computeFilterKinds;
-    /**
-     * Filters operators based on allowed filter kinds.
-     */
-    private trimFilterOperators;
-    private createUnionFilterSchema;
-    /**
-     * Checks if a model is included in the slicing configuration.
-     * Returns true if the model is allowed, false if it's excluded.
-     */
-    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.
@@ -913,76 +572,327 @@ type QueryOptions<Schema extends SchemaDef> = {
  */
 type ClientOptions<Schema extends SchemaDef> = QueryOptions<Schema> & {
     /**
-     * Kysely dialect.
+     * 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;
+    /**
+     * Whether to use compact alias names (e.g., "$t1", "$t2") when transforming ORM queries to SQL.
+     * Defaults to `true`.
+     */
+    useCompactAliasNames?: 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']]: Schema['models'][Model]['computedFields'][Field] extends infer Func ? Func extends (...args: any[]) => infer R ? (p: ExpressionBuilder<ToKyselySchema<Schema>, Model>, ...args: Parameters<Func>) => OperandExpression<R> : never : never;
+    };
+};
+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'];
+
+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>);
+    /**
+     * Whether the dialect supports updating with a limit on the number of updated rows.
+     */
+    abstract get supportsUpdateWithLimit(): boolean;
+    /**
+     * Whether the dialect supports deleting with a limit on the number of deleted rows.
+     */
+    abstract get supportsDeleteWithLimit(): boolean;
+    /**
+     * Whether the dialect supports DISTINCT ON.
+     */
+    abstract get supportsDistinctOn(): boolean;
+    /**
+     * Whether the dialect support inserting with `DEFAULT` as field value.
+     */
+    abstract get supportsDefaultAsFieldValue(): boolean;
+    /**
+     * Whether the dialect supports the RETURNING clause in INSERT/UPDATE/DELETE statements.
+     */
+    abstract get supportsReturning(): boolean;
+    /**
+     * Whether the dialect supports `INSERT INTO ... DEFAULT VALUES` syntax.
+     */
+    abstract get supportsInsertDefaultValues(): boolean;
+    /**
+     * How to perform insert ignore operation.
+     */
+    abstract get insertIgnoreMethod(): 'onConflict' | 'ignore';
+    /**
+     * Transforms input value before sending to database.
+     */
+    transformInput(value: unknown, _type: BuiltinType, _forArrayField: boolean): unknown;
+    /**
+     * Transforms output value received from database.
+     */
+    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;
+    /**
+     * Builds selection for a relation field.
+     */
+    abstract buildRelationSelection(query: SelectQueryBuilder<any, any, any>, model: string, relationField: string, parentAlias: string, payload: true | FindArgs<Schema, GetModels<Schema>, any, true>): SelectQueryBuilder<any, any, any>;
+    /**
+     * Builds skip and take clauses.
+     */
+    abstract buildSkipTake(query: SelectQueryBuilder<any, any, any>, skip: number | undefined, take: number | undefined): SelectQueryBuilder<any, any, any>;
+    /**
+     * Builds an Kysely expression that returns a JSON object for the given key-value pairs.
+     */
+    abstract buildJsonObject(value: Record<string, Expression<unknown>>): AliasableExpression<unknown>;
+    /**
+     * Builds an Kysely expression that returns the length of an array.
+     */
+    abstract buildArrayLength(array: Expression<unknown>): AliasableExpression<number>;
+    /**
+     * Builds an array value expression.
+     */
+    abstract buildArrayValue(values: Expression<unknown>[], elemType: string): AliasableExpression<unknown>;
+    /**
+     * Builds an expression that checks if an array contains a single value.
+     */
+    abstract buildArrayContains(field: Expression<unknown>, value: Expression<unknown>, elemType?: string): AliasableExpression<SqlBool>;
+    /**
+     * Builds an expression that checks if an array contains all values from another array.
+     */
+    abstract buildArrayHasEvery(field: Expression<unknown>, values: Expression<unknown>): AliasableExpression<SqlBool>;
+    /**
+     * Builds an expression that checks if an array overlaps with another array.
+     */
+    abstract buildArrayHasSome(field: Expression<unknown>, values: Expression<unknown>): AliasableExpression<SqlBool>;
+    /**
+     * Casts the given expression to an integer type.
      */
-    dialect: Dialect;
+    abstract castInt<T extends Expression<any>>(expression: T): T;
     /**
-     * Custom function definitions.
-     *
-     * @private
+     * Casts the given expression to a text type.
      */
-    functions?: Record<string, ZModelFunction<Schema>>;
+    abstract castText<T extends Expression<any>>(expression: T): T;
     /**
-     * Plugins.
+     * Trims double quotes from the start and end of a text expression.
      */
-    plugins?: AnyPlugin[];
+    abstract trimTextQuotes<T extends Expression<string>>(expression: T): T;
+    abstract getStringCasingBehavior(): {
+        supportsILike: boolean;
+        likeCaseSensitive: boolean;
+    };
     /**
-     * Logging configuration.
+     * Builds a VALUES table and select all fields from it.
      */
-    log?: KyselyConfig['log'];
+    abstract buildValuesTableSelect(fields: FieldDef[], rows: unknown[][]): SelectQueryBuilder<any, any, any>;
     /**
-     * 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
+     * Builds a JSON path selection expression.
      */
-    fixPostgresTimezone?: boolean;
+    protected abstract buildJsonPathSelection(receiver: Expression<any>, path: string | undefined): Expression<any>;
     /**
-     * Whether to enable input validations expressed with attributes like `@email`, `@regex`,
-     * `@@validate`, etc. Defaults to `true`.
+     * Builds a JSON array filter expression.
      */
-    validateInput?: boolean;
-} & (HasComputedFields<Schema> extends true ? {
+    protected abstract buildJsonArrayFilter(receiver: Expression<any>, operation: 'array_contains' | 'array_starts_with' | 'array_ends_with', value: unknown): Expression<SqlBool>;
     /**
-     * Computed field definitions.
+     * Builds a JSON array exists predicate (returning if any element matches the filter).
      */
-    computedFields: ComputedFieldsOptions<Schema>;
-} : {}) & (HasProcedures<Schema> extends true ? {
+    protected abstract buildJsonArrayExistsPredicate(receiver: Expression<any>, buildFilter: (elem: Expression<any>) => Expression<SqlBool>): Expression<SqlBool>;
     /**
-     * Custom procedure definitions.
+     * Builds an ORDER BY clause for a field with NULLS FIRST/LAST support.
      */
-    procedures: ProceduresOptions<Schema>;
-} : {});
+    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;
+    readonly zodFactory: ZodSchemaFactory<Schema>;
+    constructor(client: ClientContract<Schema>);
+    validateFindArgs(model: GetModels<Schema>, args: unknown, operation: 'findFirst' | 'findUnique' | 'findMany'): 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;
+}
+
 /**
- * Config for omitting fields in ORM query results.
+ * List of core CRUD operations. It excludes the 'orThrow' variants.
  */
-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;
+declare const CoreCrudOperations: readonly ["findMany", "findUnique", "findFirst", "create", "createMany", "createManyAndReturn", "update", "updateMany", "updateManyAndReturn", "upsert", "delete", "deleteMany", "count", "aggregate", "groupBy", "exists"];
 /**
- * Extracts QueryOptions from an object with '$options' property.
+ * List of core CRUD operations. It excludes the 'orThrow' variants.
  */
-type GetQueryOptions<T extends {
-    $options: any;
-}> = T['$options'];
+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 IsNever<T> = [T] extends [never] ? true : false;
 /**
@@ -1530,18 +1440,18 @@ type FindArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, Options
      * 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>> = {
+} : {}) : {}) & (AllowFilter extends true ? FilterArgs<Schema, Model, Options> : {}) & SelectIncludeOmit<Schema, Model, true, Options>;
+type FindManyArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase = {}> = FindArgs<Schema, Model, Options, true> & ExtractExtQueryArgs<ExtQueryArgs, 'findMany'>;
+type FindFirstArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase = {}> = FindArgs<Schema, Model, Options, true> & ExtractExtQueryArgs<ExtQueryArgs, 'findFirst'>;
+type ExistsArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase = {}> = FilterArgs<Schema, Model, Options> & ExtractExtQueryArgs<ExtQueryArgs, 'exists'>;
+type FindUniqueArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase = {}> = {
     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>> = {
+} & SelectIncludeOmit<Schema, Model, true, Options> & ExtractExtQueryArgs<ExtQueryArgs, 'findUnique'>;
+type CreateArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase = {}> = {
     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>;
+} & SelectIncludeOmit<Schema, Model, true, Options> & ExtractExtQueryArgs<ExtQueryArgs, 'create'>;
+type CreateManyArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, _Options extends QueryOptions<Schema> = QueryOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase = {}> = CreateManyInput<Schema, Model> & ExtractExtQueryArgs<ExtQueryArgs, 'createMany'>;
+type CreateManyAndReturnArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase = {}> = CreateManyInput<Schema, Model> & SelectIncludeOmit<Schema, Model, false, Options, false> & ExtractExtQueryArgs<ExtQueryArgs, 'createManyAndReturn'>;
 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>;
@@ -1603,7 +1513,7 @@ type CreateManyInput<Schema extends SchemaDef, Model extends GetModels<Schema>,
 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>> = {
+type UpdateArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase = {}> = {
     /**
      * The data to update the record with.
      */
@@ -1612,9 +1522,9 @@ type UpdateArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, Optio
      * 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>;
+} & SelectIncludeOmit<Schema, Model, true, Options> & ExtractExtQueryArgs<ExtQueryArgs, 'update'>;
+type UpdateManyArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase = {}> = UpdateManyPayload<Schema, Model, Options> & ExtractExtQueryArgs<ExtQueryArgs, 'updateMany'>;
+type UpdateManyAndReturnArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase = {}> = UpdateManyPayload<Schema, Model, Options> & SelectIncludeOmit<Schema, Model, false, Options, false> & ExtractExtQueryArgs<ExtQueryArgs, 'updateManyAndReturn'>;
 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.
@@ -1629,7 +1539,7 @@ type UpdateManyPayload<Schema extends SchemaDef, Model extends GetModels<Schema>
      */
     limit?: number;
 };
-type UpsertArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>> = {
+type UpsertArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase = {}> = {
     /**
      * The data to create the record if it doesn't exist.
      */
@@ -1642,7 +1552,7 @@ type UpsertArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, Optio
      * The unique filter to find the record to update.
      */
     where: WhereUniqueInput<Schema, Model, Options>;
-} & SelectIncludeOmit<Schema, Model, true, Options>;
+} & SelectIncludeOmit<Schema, Model, true, Options> & ExtractExtQueryArgs<ExtQueryArgs, 'upsert'>;
 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>;
@@ -1759,13 +1669,13 @@ type ToOneRelationUpdateInput<Schema extends SchemaDef, Model extends GetModels<
      */
     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>> = {
+type DeleteArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase = {}> = {
     /**
      * 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>> = {
+} & SelectIncludeOmit<Schema, Model, true, Options> & ExtractExtQueryArgs<ExtQueryArgs, 'delete'>;
+type DeleteManyArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase = {}> = {
     /**
      * Filter to select records to delete.
      */
@@ -1774,13 +1684,13 @@ type DeleteManyArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, O
      * Limits the number of records to delete.
      */
     limit?: number;
-};
-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'> & {
+} & ExtractExtQueryArgs<ExtQueryArgs, 'deleteMany'>;
+type CountArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase = {}> = Omit<FindArgs<Schema, Model, Options, true>, 'select' | 'include' | 'distinct' | 'omit'> & {
     /**
      * Selects fields to count
      */
     select?: CountAggregateInput<Schema, Model> | true;
-};
+} & ExtractExtQueryArgs<ExtQueryArgs, 'count'>;
 type CountAggregateInput<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
     [Key in NonRelationFields<Schema, Model>]?: true;
 } & {
@@ -1791,7 +1701,7 @@ type CountResult<Schema extends SchemaDef, _Model extends GetModels<Schema>, Arg
 } ? 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>> = {
+type AggregateArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase = {}> = {
     /**
      * Filter conditions
      */
@@ -1830,7 +1740,7 @@ type AggregateArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, Op
      * Performs sum value aggregation.
      */
     _sum?: SumAvgInput<Schema, Model, true>;
-});
+}) & ExtractExtQueryArgs<ExtQueryArgs, 'aggregate'>;
 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>;
 };
@@ -1880,7 +1790,7 @@ 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>> = {
+type GroupByArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase = {}> = {
     /**
      * Filter conditions
      */
@@ -1926,7 +1836,7 @@ type GroupByArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, Opti
      * Performs sum value aggregation.
      */
     _sum?: SumAvgInput<Schema, Model, true>;
-});
+}) & ExtractExtQueryArgs<ExtQueryArgs, 'groupBy'>;
 type GroupByResult<Schema extends SchemaDef, Model extends GetModels<Schema>, Args extends {
     by: unknown;
 }> = Array<{
@@ -2071,6 +1981,10 @@ type HasToManyRelations<Schema extends SchemaDef, Model extends GetModels<Schema
 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;
+/**
+ * Extracts extended query args for a specific operation.
+ */
+type ExtractExtQueryArgs<ExtQueryArgs, Operation extends CoreCrudOperations> = (Operation extends keyof ExtQueryArgs ? ExtQueryArgs[Operation] : {}) & ('$create' extends keyof ExtQueryArgs ? Operation extends CoreCreateOperations ? ExtQueryArgs['$create'] : {} : {}) & ('$read' extends keyof ExtQueryArgs ? (Operation extends CoreReadOperations ? ExtQueryArgs['$read'] : {}) : {}) & ('$update' extends keyof ExtQueryArgs ? Operation extends CoreUpdateOperations ? ExtQueryArgs['$update'] : {} : {}) & ('$delete' extends keyof ExtQueryArgs ? Operation extends CoreDeleteOperations ? ExtQueryArgs['$delete'] : {} : {}) & ('$all' extends keyof ExtQueryArgs ? ExtQueryArgs['$all'] : {});
 
 /**
  * A promise that only executes when it's awaited or .then() is called.
@@ -2084,10 +1998,6 @@ type ZenStackPromise<Schema extends SchemaDef, T> = Promise<T> & {
 };
 
 type TransactionUnsupportedMethods = (typeof TRANSACTION_UNSUPPORTED_METHODS)[number];
-/**
- * Extracts extended query args for a specific operation.
- */
-type ExtractExtQueryArgs<ExtQueryArgs, Operation extends CoreCrudOperations> = (Operation extends keyof ExtQueryArgs ? ExtQueryArgs[Operation] : {}) & ('$create' extends keyof ExtQueryArgs ? Operation extends CoreCreateOperations ? ExtQueryArgs['$create'] : {} : {}) & ('$read' extends keyof ExtQueryArgs ? (Operation extends CoreReadOperations ? ExtQueryArgs['$read'] : {}) : {}) & ('$update' extends keyof ExtQueryArgs ? Operation extends CoreUpdateOperations ? ExtQueryArgs['$update'] : {} : {}) & ('$delete' extends keyof ExtQueryArgs ? Operation extends CoreDeleteOperations ? ExtQueryArgs['$delete'] : {} : {}) & ('$all' extends keyof ExtQueryArgs ? ExtQueryArgs['$all'] : {});
 /**
  * Transaction isolation levels.
  */
@@ -2207,6 +2117,10 @@ type ClientContract<Schema extends SchemaDef, Options extends ClientOptions<Sche
      * Explicitly disconnects from the database.
      */
     $disconnect(): Promise<void>;
+    /**
+     * Factory for creating zod schemas to validate query args.
+     */
+    get $zod(): ZodSchemaFactory<Schema, Options, ExtQueryArgs>;
     /**
      * Pushes the schema to the database. For testing purposes only.
      * @private
@@ -2252,7 +2166,7 @@ declare const CRUD_EXT: readonly ["create", "read", "update", "delete", "post-up
 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' ? {} : {
+type AllModelOperations<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase> = CommonModelOperations<Schema, Model, Options, ExtQueryArgs> & (Schema['provider']['type'] extends 'mysql' ? {} : {
     /**
      * Creates multiple entities and returns them.
      * @param args - create args. See {@link createMany} for input. Use
@@ -2271,7 +2185,7 @@ type AllModelOperations<Schema extends SchemaDef, Model extends GetModels<Schema
      * });
      * ```
      */
-    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>[]>;
+    createManyAndReturn<T extends CreateManyAndReturnArgs<Schema, Model, Options, ExtQueryArgs>>(args?: SelectSubset<T, CreateManyAndReturnArgs<Schema, Model, Options, ExtQueryArgs>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options>[]>;
     /**
      * Updates multiple entities and returns them.
      * @param args - update args. Only scalar fields are allowed for data.
@@ -2294,9 +2208,9 @@ type AllModelOperations<Schema extends SchemaDef, Model extends GetModels<Schema
      * });
      * ```
      */
-    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>[]>;
+    updateManyAndReturn<T extends UpdateManyAndReturnArgs<Schema, Model, Options, ExtQueryArgs>>(args: Subset<T, UpdateManyAndReturnArgs<Schema, Model, Options, ExtQueryArgs>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options>[]>;
 });
-type CommonModelOperations<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema>, ExtQueryArgs> = {
+type CommonModelOperations<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase> = {
     /**
      * Returns a list of entities.
      * @param args - query args
@@ -2378,35 +2292,35 @@ type CommonModelOperations<Schema extends SchemaDef, Model extends GetModels<Sch
      * }); // result: `{ _count: { posts: number } }`
      * ```
      */
-    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>[]>;
+    findMany<T extends FindManyArgs<Schema, Model, Options, ExtQueryArgs>>(args?: SelectSubset<T, FindManyArgs<Schema, Model, Options, ExtQueryArgs>>): 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, Options> & ExtractExtQueryArgs<ExtQueryArgs, 'findUnique'>>(args: SelectSubset<T, FindUniqueArgs<Schema, Model, Options> & ExtractExtQueryArgs<ExtQueryArgs, 'findUnique'>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options> | null>;
+    findUnique<T extends FindUniqueArgs<Schema, Model, Options, ExtQueryArgs>>(args: SelectSubset<T, FindUniqueArgs<Schema, Model, Options, ExtQueryArgs>>): 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, Options> & ExtractExtQueryArgs<ExtQueryArgs, 'findUnique'>>(args: SelectSubset<T, FindUniqueArgs<Schema, Model, Options> & ExtractExtQueryArgs<ExtQueryArgs, 'findUnique'>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options>>;
+    findUniqueOrThrow<T extends FindUniqueArgs<Schema, Model, Options, ExtQueryArgs>>(args: SelectSubset<T, FindUniqueArgs<Schema, Model, Options, ExtQueryArgs>>): 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, Options> & ExtractExtQueryArgs<ExtQueryArgs, 'findFirst'>>(args?: SelectSubset<T, FindFirstArgs<Schema, Model, Options> & ExtractExtQueryArgs<ExtQueryArgs, 'findFirst'>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options> | null>;
+    findFirst<T extends FindFirstArgs<Schema, Model, Options, ExtQueryArgs>>(args?: SelectSubset<T, FindFirstArgs<Schema, Model, Options, ExtQueryArgs>>): 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, Options> & ExtractExtQueryArgs<ExtQueryArgs, 'findFirst'>>(args?: SelectSubset<T, FindFirstArgs<Schema, Model, Options> & ExtractExtQueryArgs<ExtQueryArgs, 'findFirst'>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options>>;
+    findFirstOrThrow<T extends FindFirstArgs<Schema, Model, Options, ExtQueryArgs>>(args?: SelectSubset<T, FindFirstArgs<Schema, Model, Options, ExtQueryArgs>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options>>;
     /**
      * Creates a new entity.
      * @param args - create args
@@ -2459,7 +2373,7 @@ type CommonModelOperations<Schema extends SchemaDef, Model extends GetModels<Sch
      * });
      * ```
      */
-    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>>;
+    create<T extends CreateArgs<Schema, Model, Options, ExtQueryArgs>>(args: SelectSubset<T, CreateArgs<Schema, Model, Options, ExtQueryArgs>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options>>;
     /**
      * Creates multiple entities. Only scalar fields are allowed.
      * @param args - create args
@@ -2485,7 +2399,7 @@ type CommonModelOperations<Schema extends SchemaDef, Model extends GetModels<Sch
      * });
      * ```
      */
-    createMany<T extends CreateManyArgs<Schema, Model> & ExtractExtQueryArgs<ExtQueryArgs, 'createMany'>>(args?: SelectSubset<T, CreateManyArgs<Schema, Model> & ExtractExtQueryArgs<ExtQueryArgs, 'createMany'>>): ZenStackPromise<Schema, BatchResult>;
+    createMany<T extends CreateManyArgs<Schema, Model, Options, ExtQueryArgs>>(args?: SelectSubset<T, CreateManyArgs<Schema, Model, Options, ExtQueryArgs>>): ZenStackPromise<Schema, BatchResult>;
     /**
      * Updates a uniquely identified entity.
      * @param args - update args. See {@link findMany} for how to control
@@ -2603,7 +2517,7 @@ type CommonModelOperations<Schema extends SchemaDef, Model extends GetModels<Sch
      * });
      * ```
      */
-    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>>;
+    update<T extends UpdateArgs<Schema, Model, Options, ExtQueryArgs>>(args: SelectSubset<T, UpdateArgs<Schema, Model, Options, ExtQueryArgs>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options>>;
     /**
      * Updates multiple entities.
      * @param args - update args. Only scalar fields are allowed for data.
@@ -2624,7 +2538,7 @@ type CommonModelOperations<Schema extends SchemaDef, Model extends GetModels<Sch
      *     limit: 10
      * });
      */
-    updateMany<T extends UpdateManyArgs<Schema, Model, Options> & ExtractExtQueryArgs<ExtQueryArgs, 'updateMany'>>(args: Subset<T, UpdateManyArgs<Schema, Model, Options> & ExtractExtQueryArgs<ExtQueryArgs, 'updateMany'>>): ZenStackPromise<Schema, BatchResult>;
+    updateMany<T extends UpdateManyArgs<Schema, Model, Options, ExtQueryArgs>>(args: Subset<T, UpdateManyArgs<Schema, Model, Options, ExtQueryArgs>>): ZenStackPromise<Schema, BatchResult>;
     /**
      * Creates or updates an entity.
      * @param args - upsert args
@@ -2645,7 +2559,7 @@ type CommonModelOperations<Schema extends SchemaDef, Model extends GetModels<Sch
      * });
      * ```
      */
-    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>>;
+    upsert<T extends UpsertArgs<Schema, Model, Options, ExtQueryArgs>>(args: SelectSubset<T, UpsertArgs<Schema, Model, Options, ExtQueryArgs>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options>>;
     /**
      * Deletes a uniquely identifiable entity.
      * @param args - delete args
@@ -2665,7 +2579,7 @@ type CommonModelOperations<Schema extends SchemaDef, Model extends GetModels<Sch
      * }); // result: `{ id: string; email: string }`
      * ```
      */
-    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>>;
+    delete<T extends DeleteArgs<Schema, Model, Options, ExtQueryArgs>>(args: SelectSubset<T, DeleteArgs<Schema, Model, Options, ExtQueryArgs>>): ZenStackPromise<Schema, SimplifiedPlainResult<Schema, Model, T, Options>>;
     /**
      * Deletes multiple entities.
      * @param args - delete args
@@ -2685,7 +2599,7 @@ type CommonModelOperations<Schema extends SchemaDef, Model extends GetModels<Sch
      * });
      * ```
      */
-    deleteMany<T extends DeleteManyArgs<Schema, Model, Options> & ExtractExtQueryArgs<ExtQueryArgs, 'deleteMany'>>(args?: Subset<T, DeleteManyArgs<Schema, Model, Options> & ExtractExtQueryArgs<ExtQueryArgs, 'deleteMany'>>): ZenStackPromise<Schema, BatchResult>;
+    deleteMany<T extends DeleteManyArgs<Schema, Model, Options, ExtQueryArgs>>(args?: Subset<T, DeleteManyArgs<Schema, Model, Options, ExtQueryArgs>>): ZenStackPromise<Schema, BatchResult>;
     /**
      * Counts rows or field values.
      * @param args - count args
@@ -2704,7 +2618,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, Options> & ExtractExtQueryArgs<ExtQueryArgs, 'count'>>(args?: Subset<T, CountArgs<Schema, Model, Options> & ExtractExtQueryArgs<ExtQueryArgs, 'count'>>): ZenStackPromise<Schema, Simplify<CountResult<Schema, Model, T>>>;
+    count<T extends CountArgs<Schema, Model, Options, ExtQueryArgs>>(args?: Subset<T, CountArgs<Schema, Model, Options, ExtQueryArgs>>): ZenStackPromise<Schema, Simplify<CountResult<Schema, Model, T>>>;
     /**
      * Aggregates rows.
      * @param args - aggregation args
@@ -2722,7 +2636,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, Options> & ExtractExtQueryArgs<ExtQueryArgs, 'aggregate'>>(args: Subset<T, AggregateArgs<Schema, Model, Options> & ExtractExtQueryArgs<ExtQueryArgs, 'aggregate'>>): ZenStackPromise<Schema, Simplify<AggregateResult<Schema, Model, T>>>;
+    aggregate<T extends AggregateArgs<Schema, Model, Options, ExtQueryArgs>>(args: Subset<T, AggregateArgs<Schema, Model, Options, ExtQueryArgs>>): ZenStackPromise<Schema, Simplify<AggregateResult<Schema, Model, T>>>;
     /**
      * Groups rows by columns.
      * @param args - groupBy args
@@ -2756,7 +2670,7 @@ type CommonModelOperations<Schema extends SchemaDef, Model extends GetModels<Sch
      *     having: { country: 'US', age: { _avg: { gte: 18 } } }
      * });
      */
-    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>>>;
+    groupBy<T extends GroupByArgs<Schema, Model, Options, ExtQueryArgs>>(args: Subset<T, GroupByArgs<Schema, Model, Options, ExtQueryArgs>>): ZenStackPromise<Schema, Simplify<GroupByResult<Schema, Model, T>>>;
     /**
      * Checks if an entity exists.
      * @param args - exists args
@@ -2774,10 +2688,10 @@ type CommonModelOperations<Schema extends SchemaDef, Model extends GetModels<Sch
      *     where: { posts: { some: { published: true } } },
      * }); // result: `boolean`
      */
-    exists<T extends ExistsArgs<Schema, Model, Options> & ExtractExtQueryArgs<ExtQueryArgs, 'exists'>>(args?: Subset<T, ExistsArgs<Schema, Model, Options> & ExtractExtQueryArgs<ExtQueryArgs, 'exists'>>): ZenStackPromise<Schema, boolean>;
+    exists<T extends ExistsArgs<Schema, Model, Options, ExtQueryArgs>>(args?: Subset<T, ExistsArgs<Schema, Model, Options, ExtQueryArgs>>): ZenStackPromise<Schema, boolean>;
 };
 type OperationsIneligibleForDelegateModels = 'create' | 'createMany' | 'createManyAndReturn' | 'upsert';
-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 ModelOperations<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends ClientOptions<Schema> = ClientOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase = {}> = 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: { ... } } }
@@ -2787,6 +2701,136 @@ 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>;
 
+/**
+ * Create a factory for generating Zod schemas to validate ORM query inputs.
+ */
+declare function createQuerySchemaFactory<Schema extends SchemaDef, Options extends ClientOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase = {}>(client: ClientContract<Schema, Options, ExtQueryArgs>): ZodSchemaFactory<Schema, Options, ExtQueryArgs>;
+/**
+ * Create a factory for generating Zod schemas to validate ORM query inputs.
+ */
+declare function createQuerySchemaFactory<Schema extends SchemaDef, Options extends ClientOptions<Schema> = ClientOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase = {}>(schema: Schema, options?: Options): ZodSchemaFactory<Schema, Options, ExtQueryArgs>;
+/**
+ * Options for creating Zod schemas.
+ */
+type CreateSchemaOptions = {
+    /**
+     * Controls the depth of relation nesting in the generated schema. Default is unlimited.
+     */
+    relationDepth?: number;
+};
+/**
+ * Factory class responsible for creating and caching Zod schemas for ORM input validation.
+ */
+declare class ZodSchemaFactory<Schema extends SchemaDef, Options extends ClientOptions<Schema> = ClientOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase = {}> {
+    private readonly schemaCache;
+    private readonly allFilterKinds;
+    private readonly schema;
+    private readonly options;
+    constructor(client: ClientContract<Schema, Options, ExtQueryArgs, any>);
+    constructor(schema: Schema, options?: Options);
+    private get plugins();
+    private get extraValidationsEnabled();
+    private shouldIncludeRelations;
+    private nextOptions;
+    private getCache;
+    private setCache;
+    private printCacheStats;
+    makeFindUniqueSchema<Model extends GetModels<Schema>>(model: Model, options?: CreateSchemaOptions): ZodType<FindUniqueArgs<Schema, Model, Options, ExtQueryArgs>>;
+    makeFindFirstSchema<Model extends GetModels<Schema>>(model: Model, options?: CreateSchemaOptions): ZodType<FindFirstArgs<Schema, Model, Options, ExtQueryArgs> | undefined>;
+    makeFindManySchema<Model extends GetModels<Schema>>(model: Model, options?: CreateSchemaOptions): ZodType<FindManyArgs<Schema, Model, Options, ExtQueryArgs> | undefined>;
+    private makeFindSchema;
+    makeExistsSchema<Model extends GetModels<Schema>>(model: Model, options?: CreateSchemaOptions): ZodType<ExistsArgs<Schema, Model, Options, ExtQueryArgs> | undefined>;
+    private makeScalarSchema;
+    private makeEnumSchema;
+    private makeTypeDefSchema;
+    makeWhereSchema(model: string, unique: boolean, withoutRelationFields?: boolean, withAggregations?: boolean, options?: CreateSchemaOptions): ZodType;
+    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;
+    makeCreateSchema<Model extends GetModels<Schema>>(model: Model, options?: CreateSchemaOptions): ZodType<CreateArgs<Schema, Model, Options, ExtQueryArgs>>;
+    makeCreateManySchema<Model extends GetModels<Schema>>(model: Model, options?: CreateSchemaOptions): ZodType<CreateManyArgs<Schema, Model, Options, ExtQueryArgs>>;
+    makeCreateManyAndReturnSchema<Model extends GetModels<Schema>>(model: Model, options?: CreateSchemaOptions): ZodType<CreateManyAndReturnArgs<Schema, Model, Options, ExtQueryArgs>>;
+    private makeCreateDataSchema;
+    private makeRelationManipulationSchema;
+    private makeSetDataSchema;
+    private makeConnectDataSchema;
+    private makeDisconnectDataSchema;
+    private makeDeleteRelationDataSchema;
+    private makeConnectOrCreateDataSchema;
+    private makeCreateManyPayloadSchema;
+    makeUpdateSchema<Model extends GetModels<Schema>>(model: Model, options?: CreateSchemaOptions): ZodType<UpdateArgs<Schema, Model, Options, ExtQueryArgs>>;
+    makeUpdateManySchema<Model extends GetModels<Schema>>(model: Model, options?: CreateSchemaOptions): ZodType<UpdateManyArgs<Schema, Model, Options, ExtQueryArgs>>;
+    makeUpdateManyAndReturnSchema<Model extends GetModels<Schema>>(model: Model, options?: CreateSchemaOptions): ZodType<UpdateManyAndReturnArgs<Schema, Model, Options, ExtQueryArgs>>;
+    makeUpsertSchema<Model extends GetModels<Schema>>(model: Model, options?: CreateSchemaOptions): ZodType<UpsertArgs<Schema, Model, Options, ExtQueryArgs>>;
+    private makeUpdateDataSchema;
+    makeDeleteSchema<Model extends GetModels<Schema>>(model: Model, options?: CreateSchemaOptions): ZodType<DeleteArgs<Schema, Model, Options, ExtQueryArgs>>;
+    makeDeleteManySchema<Model extends GetModels<Schema>>(model: Model, options?: CreateSchemaOptions): ZodType<DeleteManyArgs<Schema, Model, Options, ExtQueryArgs> | undefined>;
+    makeCountSchema<Model extends GetModels<Schema>>(model: Model, options?: CreateSchemaOptions): ZodType<CountArgs<Schema, Model, Options, ExtQueryArgs> | undefined>;
+    private makeCountAggregateInputSchema;
+    makeAggregateSchema<Model extends GetModels<Schema>>(model: Model, options?: CreateSchemaOptions): ZodType<AggregateArgs<Schema, Model, Options, ExtQueryArgs> | undefined>;
+    private makeSumAvgInputSchema;
+    private makeMinMaxInputSchema;
+    makeGroupBySchema<Model extends GetModels<Schema>>(model: Model, options?: CreateSchemaOptions): ZodType<GroupByArgs<Schema, Model, Options, ExtQueryArgs>>;
+    private onlyAggregationFields;
+    private makeHavingSchema;
+    makeProcedureParamSchema(param: {
+        type: string;
+        array?: boolean;
+        optional?: boolean;
+    }, _options?: CreateSchemaOptions): ZodType;
+    private mergePluginArgsSchema;
+    private getPluginExtQueryArgsSchema;
+    private makeSkipSchema;
+    private makeTakeSchema;
+    private refineForSelectIncludeMutuallyExclusive;
+    private refineForSelectOmitMutuallyExclusive;
+    private refineForSelectHasTruthyField;
+    private nullableIf;
+    private orArray;
+    private isNumericField;
+    private get providerSupportsCaseSensitivity();
+    /**
+     * Gets the effective set of allowed FilterKind values for a specific model and field.
+     * Respects the precedence: model[field] > model.$all > $all[field] > $all.$all.
+     */
+    private getEffectiveFilterKinds;
+    /**
+     * Computes the effective set of filter kinds based on inclusion and exclusion lists.
+     */
+    private computeFilterKinds;
+    /**
+     * Filters operators based on allowed filter kinds.
+     */
+    private trimFilterOperators;
+    private createUnionFilterSchema;
+    /**
+     * Checks if a model is included in the slicing configuration.
+     * Returns true if the model is allowed, false if it's excluded.
+     */
+    private isModelAllowed;
+}
+
 /**
  * ZenStack ORM client.
  */
@@ -2958,7 +3002,13 @@ declare function extractModelName(node: OperationNode): string | undefined;
  * Extracts field name from an OperationNode.
  */
 declare function extractFieldName(node: OperationNode): string | undefined;
+declare const TEMP_ALIAS_PREFIX = "$$_";
+/**
+ * Create an alias name for a temporary table or column name.
+ */
+declare function tmpAlias(name: string): string;
 
+declare const queryUtils_TEMP_ALIAS_PREFIX: typeof TEMP_ALIAS_PREFIX;
 declare const queryUtils_aggregate: typeof aggregate;
 declare const queryUtils_buildJoinPairs: typeof buildJoinPairs;
 declare const queryUtils_ensureArray: typeof ensureArray;
@@ -2992,8 +3042,9 @@ declare const queryUtils_requireIdFields: typeof requireIdFields;
 declare const queryUtils_requireModel: typeof requireModel;
 declare const queryUtils_requireTypeDef: typeof requireTypeDef;
 declare const queryUtils_stripAlias: typeof stripAlias;
+declare const queryUtils_tmpAlias: typeof tmpAlias;
 declare namespace queryUtils {
-  export { queryUtils_aggregate as aggregate, queryUtils_buildJoinPairs as buildJoinPairs, queryUtils_ensureArray as ensureArray, queryUtils_extractFieldName as extractFieldName, queryUtils_extractIdFields as extractIdFields, queryUtils_extractModelName as extractModelName, queryUtils_fieldHasDefaultValue as fieldHasDefaultValue, queryUtils_flattenCompoundUniqueFilters as flattenCompoundUniqueFilters, queryUtils_getDelegateDescendantModels as getDelegateDescendantModels, queryUtils_getDiscriminatorField as getDiscriminatorField, queryUtils_getEnum as getEnum, queryUtils_getField as getField, queryUtils_getIdFields as getIdFields, queryUtils_getIdValues as getIdValues, queryUtils_getManyToManyRelation as getManyToManyRelation, queryUtils_getModel as getModel, queryUtils_getModelFields as getModelFields, queryUtils_getRelationForeignKeyFieldPairs as getRelationForeignKeyFieldPairs, queryUtils_getTypeDef as getTypeDef, queryUtils_getUniqueFields as getUniqueFields, queryUtils_hasModel as hasModel, queryUtils_isEnum as isEnum, queryUtils_isForeignKeyField as isForeignKeyField, queryUtils_isInheritedField as isInheritedField, queryUtils_isRelationField as isRelationField, queryUtils_isScalarField as isScalarField, queryUtils_isTypeDef as isTypeDef, queryUtils_makeDefaultOrderBy as makeDefaultOrderBy, queryUtils_requireField as requireField, queryUtils_requireIdFields as requireIdFields, queryUtils_requireModel as requireModel, queryUtils_requireTypeDef as requireTypeDef, queryUtils_stripAlias as stripAlias };
+  export { queryUtils_TEMP_ALIAS_PREFIX as TEMP_ALIAS_PREFIX, queryUtils_aggregate as aggregate, queryUtils_buildJoinPairs as buildJoinPairs, queryUtils_ensureArray as ensureArray, queryUtils_extractFieldName as extractFieldName, queryUtils_extractIdFields as extractIdFields, queryUtils_extractModelName as extractModelName, queryUtils_fieldHasDefaultValue as fieldHasDefaultValue, queryUtils_flattenCompoundUniqueFilters as flattenCompoundUniqueFilters, queryUtils_getDelegateDescendantModels as getDelegateDescendantModels, queryUtils_getDiscriminatorField as getDiscriminatorField, queryUtils_getEnum as getEnum, queryUtils_getField as getField, queryUtils_getIdFields as getIdFields, queryUtils_getIdValues as getIdValues, queryUtils_getManyToManyRelation as getManyToManyRelation, queryUtils_getModel as getModel, queryUtils_getModelFields as getModelFields, queryUtils_getRelationForeignKeyFieldPairs as getRelationForeignKeyFieldPairs, queryUtils_getTypeDef as getTypeDef, queryUtils_getUniqueFields as getUniqueFields, queryUtils_hasModel as hasModel, queryUtils_isEnum as isEnum, queryUtils_isForeignKeyField as isForeignKeyField, queryUtils_isInheritedField as isInheritedField, queryUtils_isRelationField as isRelationField, queryUtils_isScalarField as isScalarField, queryUtils_isTypeDef as isTypeDef, queryUtils_makeDefaultOrderBy as makeDefaultOrderBy, queryUtils_requireField as requireField, queryUtils_requireIdFields as requireIdFields, queryUtils_requireModel as requireModel, queryUtils_requireTypeDef as requireTypeDef, queryUtils_stripAlias as stripAlias, queryUtils_tmpAlias as tmpAlias };
 }
 
 type VisitResult = void | {
@@ -3031,4 +3082,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 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 };
+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, createQuerySchemaFactory, definePlugin, getCrudDialect };