@zenstackhq/runtime 3.0.0-beta.1 → 3.0.0-beta.11

package/dist/index.d.ts

@@ -1,36 +1,1315 @@
-import { C as ClientConstructor } from './contract-CusA0mQO.js';
-export { K as AggregateArgs, L as AggregateResult, B as BatchResult, i as BooleanFilter, h as BytesFilter, c as ClientContract, d as ClientOptions, G as CountArgs, H as CountResult, u as CreateArgs, w as CreateManyAndReturnArgs, v as CreateManyArgs, D as DateTimeFilter, A as DeleteArgs, E as DeleteManyArgs, F as FindArgs, s as FindFirstArgs, r as FindManyArgs, t as FindUniqueArgs, P as GroupByArgs, Q as GroupByResult, I as IncludeInput, J as JsonArray, a as JsonObject, b as JsonValue, M as ModelResult, k as NullsOrder, N as NumberFilter, m as OmitInput, O as OrderBy, n as SelectIncludeOmit, o as SelectInput, q as SelectSubset, S as SimplifiedModelResult, j as SortOrder, g as StringFilter, p as Subset, T as ToKysely, f as TypeDefResult, U as UpdateArgs, y as UpdateManyAndReturnArgs, x as UpdateManyArgs, z as UpsertArgs, W as WhereInput, l as WhereUniqueInput, Z as ZenStackPromise, e as definePlugin } from './contract-CusA0mQO.js';
-export { sql } from 'kysely';
-import 'decimal.js';
-import '@zenstackhq/sdk/schema';
+import Decimal from 'decimal.js';
+import * as _zenstackhq_sdk_schema from '@zenstackhq/sdk/schema';
+import { SchemaDef, BuiltinType, GetModels, FieldDef, ModelDef, DataSourceProviderType, GetModel, ProcedureDef, IsDelegateModel, Expression as Expression$1, LiteralExpression, ArrayExpression, FieldExpression, MemberExpression, BinaryExpression, UnaryExpression, CallExpression, ThisExpression, NullExpression } from '@zenstackhq/sdk/schema';
+import { F as FindArgs, O as OrArray, a as OrderBy, M as MaybePromise, T as ToKyselySchema, P as PrependParameter, A as AuthType, b as ToKysely, U as UnwrapTuplePromises, S as SelectSubset, c as Simplify, d as ModelResult, e as FindUniqueArgs, C as CreateArgs, f as CreateManyArgs, B as BatchResult, g as CreateManyAndReturnArgs, h as UpdateArgs, i as UpdateManyArgs, j as Subset, k as UpdateManyAndReturnArgs, l as UpsertArgs, D as DeleteArgs, m as DeleteManyArgs, n as CountArgs, o as CountResult, p as AggregateArgs, q as AggregateResult, G as GroupByArgs, r as GroupByResult, s as OrUndefinedIf } from './auth-CzM6GLw6.js';
+export { E as BooleanFilter, z as BytesFilter, y as DateTimeFilter, Y as FindFirstArgs, X as FindManyArgs, V as IncludeInput, J as JsonArray, t as JsonObject, u as JsonValue, I as NullsOrder, N as NumberFilter, L as OmitInput, Q as SelectIncludeOmit, R as SelectInput, v as SimplifiedModelResult, H as SortOrder, x as StringFilter, w as TypeDefResult, W as WhereInput, K as WhereUniqueInput } from './auth-CzM6GLw6.js';
+import * as kysely from 'kysely';
+import { ExpressionBuilder, SelectQueryBuilder, Expression, SqlBool, ExpressionWrapper, OperationNode, RootOperationNode, QueryResult, UnknownRow, Dialect, KyselyConfig, OperationNodeVisitor, 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 } from 'kysely';
+
+/**
+ * Client API methods that are not supported in transactions.
+ */
+declare const TRANSACTION_UNSUPPORTED_METHODS: readonly ["$transaction", "$connect", "$disconnect", "$use"];
+/**
+ * Logical combinators used in filters.
+ */
+declare const LOGICAL_COMBINATORS: readonly ["AND", "OR", "NOT"];
+/**
+ * Aggregation operators.
+ */
+declare const AGGREGATE_OPERATORS: readonly ["_count", "_sum", "_avg", "_min", "_max"];
+type AGGREGATE_OPERATORS = (typeof AGGREGATE_OPERATORS)[number];
+
+declare abstract class BaseCrudDialect<Schema extends SchemaDef> {
+    protected readonly schema: Schema;
+    protected readonly options: ClientOptions<Schema>;
+    protected eb: ExpressionBuilder<any, any>;
+    constructor(schema: Schema, options: ClientOptions<Schema>);
+    transformPrimitive(value: unknown, _type: BuiltinType, _forArrayField: boolean): unknown;
+    transformOutput(value: unknown, _type: BuiltinType): unknown;
+    buildSelectModel(model: string, modelAlias: string): SelectQueryBuilder<any, any, {}>;
+    buildFilterSortTake(model: GetModels<Schema>, args: FindArgs<Schema, GetModels<Schema>, true>, query: SelectQueryBuilder<any, any, {}>, modelAlias: string): SelectQueryBuilder<any, any, {}>;
+    buildFilter(model: string, modelAlias: string, where: boolean | object | undefined): Expression<SqlBool>;
+    private buildCursorFilter;
+    private isLogicalCombinator;
+    protected buildCompositeFilter(model: string, modelAlias: string, key: (typeof LOGICAL_COMBINATORS)[number], payload: any): Expression<SqlBool>;
+    private buildRelationFilter;
+    private buildToOneRelationFilter;
+    private buildToManyRelationFilter;
+    private buildArrayFilter;
+    buildPrimitiveFilter(fieldRef: Expression<any>, fieldDef: FieldDef, payload: any): Expression<SqlBool>;
+    private buildLiteralFilter;
+    private buildStandardFilter;
+    private buildStringFilter;
+    private prepStringCasing;
+    private buildNumberFilter;
+    private buildBooleanFilter;
+    private buildDateTimeFilter;
+    private buildBytesFilter;
+    private buildEnumFilter;
+    buildOrderBy(query: SelectQueryBuilder<any, any, any>, model: string, modelAlias: string, orderBy: OrArray<OrderBy<Schema, GetModels<Schema>, boolean, boolean>> | undefined, negated: boolean): SelectQueryBuilder<any, any, any>;
+    buildSelectAllFields(model: string, query: SelectQueryBuilder<any, any, any>, omit: Record<string, boolean | undefined> | undefined, modelAlias: string): SelectQueryBuilder<any, any, any>;
+    protected buildModelSelect(model: GetModels<Schema>, subQueryAlias: string, payload: true | FindArgs<Schema, GetModels<Schema>, true>, selectAllFields: boolean): SelectQueryBuilder<any, any, {}>;
+    buildSelectField(query: SelectQueryBuilder<any, any, any>, model: string, modelAlias: string, field: string): SelectQueryBuilder<any, any, any>;
+    buildDelegateJoin(thisModel: string, thisModelAlias: string, otherModelAlias: string, query: SelectQueryBuilder<any, any, any>): SelectQueryBuilder<any, any, any>;
+    buildCountJson(model: string, eb: ExpressionBuilder<any, any>, parentAlias: string, payload: any): ExpressionWrapper<any, any, unknown>;
+    private negateSort;
+    true(): Expression<SqlBool>;
+    false(): Expression<SqlBool>;
+    isTrue(expression: Expression<SqlBool>): boolean;
+    isFalse(expression: Expression<SqlBool>): boolean;
+    and(...args: Expression<SqlBool>[]): Expression<SqlBool>;
+    or(...args: Expression<SqlBool>[]): Expression<SqlBool>;
+    not(...args: Expression<SqlBool>[]): ExpressionWrapper<any, any, SqlBool>;
+    fieldRef(model: string, field: string, modelAlias?: string, inlineComputedField?: boolean): any;
+    protected canJoinWithoutNestedSelect(modelDef: ModelDef, payload: boolean | FindArgs<Schema, GetModels<Schema>, true>): boolean;
+    abstract get provider(): DataSourceProviderType;
+    /**
+     * Builds selection for a relation field.
+     */
+    abstract buildRelationSelection(query: SelectQueryBuilder<any, any, any>, model: string, relationField: string, parentAlias: string, payload: true | FindArgs<Schema, GetModels<Schema>, true>): SelectQueryBuilder<any, any, any>;
+    /**
+     * Builds skip and take clauses.
+     */
+    abstract buildSkipTake(query: SelectQueryBuilder<any, any, any>, skip: number | undefined, take: number | undefined): SelectQueryBuilder<any, any, any>;
+    /**
+     * Builds an Kysely expression that returns a JSON object for the given key-value pairs.
+     */
+    abstract buildJsonObject(value: Record<string, Expression<unknown>>): ExpressionWrapper<any, any, unknown>;
+    /**
+     * Builds an Kysely expression that returns the length of an array.
+     */
+    abstract buildArrayLength(array: Expression<unknown>): ExpressionWrapper<any, any, number>;
+    /**
+     * Builds an array literal SQL string for the given values.
+     */
+    abstract buildArrayLiteralSQL(values: unknown[]): string;
+    /**
+     * Whether the dialect supports updating with a limit on the number of updated rows.
+     */
+    abstract get supportsUpdateWithLimit(): boolean;
+    /**
+     * Whether the dialect supports deleting with a limit on the number of deleted rows.
+     */
+    abstract get supportsDeleteWithLimit(): boolean;
+    /**
+     * Whether the dialect supports DISTINCT ON.
+     */
+    abstract get supportsDistinctOn(): boolean;
+    /**
+     * Whether the dialect support inserting with `DEFAULT` as field value.
+     */
+    abstract get supportInsertWithDefault(): boolean;
+    /**
+     * Gets the SQL column type for the given field definition.
+     */
+    abstract getFieldSqlType(fieldDef: FieldDef): string;
+    abstract getStringCasingBehavior(): {
+        supportsILike: boolean;
+        likeCaseSensitive: boolean;
+    };
+}
+
+type CoreCrudOperation = 'findMany' | 'findUnique' | 'findFirst' | 'create' | 'createMany' | 'createManyAndReturn' | 'update' | 'updateMany' | 'updateManyAndReturn' | 'upsert' | 'delete' | 'deleteMany' | 'count' | 'aggregate' | 'groupBy';
+type AllCrudOperation = CoreCrudOperation | 'findUniqueOrThrow' | 'findFirstOrThrow';
+
+/**
+ * ZenStack runtime plugin.
+ */
+interface RuntimePlugin<Schema extends SchemaDef = SchemaDef> {
+    /**
+     * Plugin ID.
+     */
+    id: string;
+    /**
+     * Plugin display name.
+     */
+    name?: string;
+    /**
+     * Plugin description.
+     */
+    description?: string;
+    /**
+     * Custom function implementations.
+     */
+    functions?: Record<string, ZModelFunction<Schema>>;
+    /**
+     * Intercepts an ORM query.
+     */
+    onQuery?: OnQueryCallback<Schema>;
+    /**
+     * Intercepts an entity mutation.
+     */
+    onEntityMutation?: EntityMutationHooksDef<Schema>;
+    /**
+     * Intercepts a Kysely query.
+     */
+    onKyselyQuery?: OnKyselyQueryCallback<Schema>;
+}
+/**
+ * Defines a ZenStack runtime plugin.
+ */
+declare function definePlugin<Schema extends SchemaDef>(plugin: RuntimePlugin<Schema>): RuntimePlugin<Schema>;
+
+type OnQueryCallback<Schema extends SchemaDef> = (ctx: OnQueryHookContext<Schema>) => Promise<unknown>;
+type OnQueryHookContext<Schema extends SchemaDef> = {
+    /**
+     * The model that is being queried.
+     */
+    model: GetModels<Schema>;
+    /**
+     * The operation that is being performed.
+     */
+    operation: AllCrudOperation;
+    /**
+     * The query arguments.
+     */
+    args: unknown;
+    /**
+     * The function to proceed with the original query.
+     * It takes the same arguments as the operation method.
+     *
+     * @param args The query arguments.
+     */
+    proceed: (args: unknown) => Promise<unknown>;
+    /**
+     * The ZenStack client that is performing the operation.
+     */
+    client: ClientContract<Schema>;
+};
+type EntityMutationHooksDef<Schema extends SchemaDef> = {
+    /**
+     * Called before entities are mutated.
+     */
+    beforeEntityMutation?: BeforeEntityMutationCallback<Schema>;
+    /**
+     * Called after entities are mutated.
+     */
+    afterEntityMutation?: AfterEntityMutationCallback<Schema>;
+    /**
+     * Whether to run after-mutation hooks within the transaction that performs the mutation.
+     *
+     * If set to `true`, if the mutation already runs inside a transaction, the callbacks are
+     * executed immediately after the mutation within the transaction boundary. If the mutation
+     * is not running inside a transaction, a new transaction is created to run both the mutation
+     * and the callbacks.
+     *
+     * If set to `false`, the callbacks are executed after the mutation transaction is committed.
+     *
+     * Defaults to `false`.
+     */
+    runAfterMutationWithinTransaction?: boolean;
+};
+type MutationHooksArgs<Schema extends SchemaDef> = {
+    /**
+     * The model that is being mutated.
+     */
+    model: GetModels<Schema>;
+    /**
+     * The mutation action that is being performed.
+     */
+    action: 'create' | 'update' | 'delete';
+    /**
+     * The mutation data. Only available for create and update actions.
+     */
+    queryNode: OperationNode;
+    /**
+     * A query ID that uniquely identifies the mutation operation. You can use it to correlate
+     * data between the before and after mutation hooks.
+     */
+    queryId: string;
+};
+type BeforeEntityMutationCallback<Schema extends SchemaDef> = (args: PluginBeforeEntityMutationArgs<Schema>) => MaybePromise<void>;
+type AfterEntityMutationCallback<Schema extends SchemaDef> = (args: PluginAfterEntityMutationArgs<Schema>) => MaybePromise<void>;
+type PluginBeforeEntityMutationArgs<Schema extends SchemaDef> = MutationHooksArgs<Schema> & {
+    /**
+     * Loads the entities that are about to be mutated. The db operation that loads the entities is executed
+     * within the same transaction context as the mutation.
+     */
+    loadBeforeMutationEntities(): Promise<Record<string, unknown>[] | undefined>;
+    /**
+     * The ZenStack client you can use to perform additional operations. The database operations initiated
+     * from this client are executed within the same transaction as the mutation if the mutation is running
+     * inside a transaction.
+     *
+     * Mutations initiated from this client will NOT trigger entity mutation hooks to avoid infinite loops.
+     */
+    client: ClientContract<Schema>;
+};
+type PluginAfterEntityMutationArgs<Schema extends SchemaDef> = MutationHooksArgs<Schema> & {
+    /**
+     * Loads the entities that have been mutated.
+     */
+    loadAfterMutationEntities(): Promise<Record<string, unknown>[] | undefined>;
+    /**
+     * The ZenStack client you can use to perform additional operations.
+     * See {@link EntityMutationHooksDef.runAfterMutationWithinTransaction} for detailed transaction behavior.
+     *
+     * Mutations initiated from this client will NOT trigger entity mutation hooks to avoid infinite loops.
+     */
+    client: ClientContract<Schema>;
+};
+type OnKyselyQueryArgs<Schema extends SchemaDef> = {
+    schema: SchemaDef;
+    client: ClientContract<Schema>;
+    query: RootOperationNode;
+    proceed: ProceedKyselyQueryFunction;
+};
+type ProceedKyselyQueryFunction = (query: RootOperationNode) => Promise<QueryResult<any>>;
+type OnKyselyQueryCallback<Schema extends SchemaDef> = (args: OnKyselyQueryArgs<Schema>) => Promise<QueryResult<UnknownRow>>;
+
+type ZModelFunctionContext<Schema extends SchemaDef> = {
+    /**
+     * ZenStack client instance
+     */
+    client: ClientContract<Schema>;
+    /**
+     * Database dialect
+     */
+    dialect: BaseCrudDialect<Schema>;
+    /**
+     * The containing model name
+     */
+    model: GetModels<Schema>;
+    /**
+     * The alias name that can be used to refer to the containing model
+     */
+    modelAlias: string;
+    /**
+     * The CRUD operation being performed
+     */
+    operation: CRUD_EXT;
+};
+type ZModelFunction<Schema extends SchemaDef> = (eb: ExpressionBuilder<ToKyselySchema<Schema>, keyof ToKyselySchema<Schema>>, args: Expression<any>[], context: ZModelFunctionContext<Schema>) => Expression<unknown>;
+/**
+ * ZenStack client options.
+ */
+type ClientOptions<Schema extends SchemaDef> = {
+    /**
+     * Kysely dialect.
+     */
+    dialect: Dialect;
+    /**
+     * Custom function definitions.
+     */
+    functions?: Record<string, ZModelFunction<Schema>>;
+    /**
+     * Plugins.
+     */
+    plugins?: RuntimePlugin<Schema>[];
+    /**
+     * Logging configuration.
+     */
+    log?: KyselyConfig['log'];
+    /**
+     * Whether to automatically fix timezone for `DateTime` fields returned by node-pg. Defaults
+     * to `true`.
+     *
+     * Node-pg has a terrible quirk that it interprets the date value as local timezone (as a
+     * `Date` object) although for `DateTime` field the data in DB is stored in UTC.
+     * @see https://github.com/brianc/node-postgres/issues/429
+     */
+    fixPostgresTimezone?: boolean;
+    /**
+     * Whether to enable input validations expressed with attributes like `@email`, `@regex`,
+     * `@@validate`, etc. Defaults to `true`.
+     */
+    validateInput?: boolean;
+} & (HasComputedFields<Schema> extends true ? {
+    /**
+     * Computed field definitions.
+     */
+    computedFields: ComputedFieldsOptions<Schema>;
+} : {}) & (HasProcedures<Schema> extends true ? {
+    /**
+     * Custom procedure definitions.
+     */
+    procedures: ProceduresOptions<Schema>;
+} : {});
+type ComputedFieldsOptions<Schema extends SchemaDef> = {
+    [Model in GetModels<Schema> as 'computedFields' extends keyof GetModel<Schema, Model> ? Model : never]: {
+        [Field in keyof Schema['models'][Model]['computedFields']]: PrependParameter<ExpressionBuilder<ToKyselySchema<Schema>, Model>, Schema['models'][Model]['computedFields'][Field]>;
+    };
+};
+type HasComputedFields<Schema extends SchemaDef> = string extends GetModels<Schema> ? false : keyof ComputedFieldsOptions<Schema> extends never ? false : true;
+type ProceduresOptions<Schema extends SchemaDef> = Schema extends {
+    procedures: Record<string, ProcedureDef>;
+} ? {
+    [Key in keyof Schema['procedures']]: PrependParameter<ClientContract<Schema>, ProcedureFunc<Schema, Schema['procedures'][Key]>>;
+} : {};
+type HasProcedures<Schema extends SchemaDef> = Schema extends {
+    procedures: Record<string, ProcedureDef>;
+} ? true : false;
+
+/**
+ * A promise that only executes when it's awaited or .then() is called.
+ */
+type ZenStackPromise<Schema extends SchemaDef, T> = Promise<T> & {
+    /**
+     * @private
+     * Callable to get a plain promise.
+     */
+    cb: (txClient?: ClientContract<Schema>) => Promise<T>;
+};
+
+type TransactionUnsupportedMethods = (typeof TRANSACTION_UNSUPPORTED_METHODS)[number];
+/**
+ * Transaction isolation levels.
+ */
+declare enum TransactionIsolationLevel {
+    ReadUncommitted = "read uncommitted",
+    ReadCommitted = "read committed",
+    RepeatableRead = "repeatable read",
+    Serializable = "serializable",
+    Snapshot = "snapshot"
+}
+/**
+ * ZenStack client interface.
+ */
+type ClientContract<Schema extends SchemaDef> = {
+    readonly $schema: Schema;
+    /**
+     * The client options.
+     */
+    readonly $options: ClientOptions<Schema>;
+    /**
+     * Executes a prepared raw query and returns the number of affected rows.
+     * @example
+     * ```
+     * const result = await db.$executeRaw`UPDATE User SET cool = ${true} WHERE email = ${'user@email.com'};`
+     * ```
+     */
+    $executeRaw(query: TemplateStringsArray, ...values: any[]): ZenStackPromise<Schema, number>;
+    /**
+     * Executes a raw query and returns the number of affected rows.
+     * This method is susceptible to SQL injections.
+     * @example
+     * ```
+     * const result = await db.$executeRawUnsafe('UPDATE User SET cool = $1 WHERE email = $2 ;', true, 'user@email.com')
+     * ```
+     */
+    $executeRawUnsafe(query: string, ...values: any[]): ZenStackPromise<Schema, number>;
+    /**
+     * Performs a prepared raw query and returns the `SELECT` data.
+     * @example
+     * ```
+     * const result = await db.$queryRaw`SELECT * FROM User WHERE id = ${1} OR email = ${'user@email.com'};`
+     * ```
+     */
+    $queryRaw<T = unknown>(query: TemplateStringsArray, ...values: any[]): ZenStackPromise<Schema, T>;
+    /**
+     * Performs a raw query and returns the `SELECT` data.
+     * This method is susceptible to SQL injections.
+     * @example
+     * ```
+     * const result = await db.$queryRawUnsafe('SELECT * FROM User WHERE id = $1 OR email = $2;', 1, 'user@email.com')
+     * ```
+     */
+    $queryRawUnsafe<T = unknown>(query: string, ...values: any[]): ZenStackPromise<Schema, T>;
+    /**
+     * The current user identity.
+     */
+    get $auth(): AuthType<Schema> | undefined;
+    /**
+     * Sets the current user identity.
+     */
+    $setAuth(auth: AuthType<Schema> | undefined): ClientContract<Schema>;
+    /**
+     * Returns a new client enabling/disabling input validations expressed with attributes like
+     * `@email`, `@regex`, `@@validate`, etc.
+     */
+    $setInputValidation(enable: boolean): ClientContract<Schema>;
+    /**
+     * The Kysely query builder instance.
+     */
+    readonly $qb: ToKysely<Schema>;
+    /**
+     * The raw Kysely query builder without any ZenStack enhancements.
+     */
+    readonly $qbRaw: ToKysely<any>;
+    /**
+     * Starts an interactive transaction.
+     */
+    $transaction<T>(callback: (tx: Omit<ClientContract<Schema>, TransactionUnsupportedMethods>) => Promise<T>, options?: {
+        isolationLevel?: TransactionIsolationLevel;
+    }): Promise<T>;
+    /**
+     * Starts a sequential transaction.
+     */
+    $transaction<P extends ZenStackPromise<Schema, any>[]>(arg: [...P], options?: {
+        isolationLevel?: TransactionIsolationLevel;
+    }): Promise<UnwrapTuplePromises<P>>;
+    /**
+     * Returns a new client with the specified plugin installed.
+     */
+    $use(plugin: RuntimePlugin<Schema>): ClientContract<Schema>;
+    /**
+     * Returns a new client with the specified plugin removed.
+     */
+    $unuse(pluginId: string): ClientContract<Schema>;
+    /**
+     * Returns a new client with all plugins removed.
+     */
+    $unuseAll(): ClientContract<Schema>;
+    /**
+     * Eagerly connects to the database.
+     */
+    $connect(): Promise<void>;
+    /**
+     * Explicitly disconnects from the database.
+     */
+    $disconnect(): Promise<void>;
+    /**
+     * Pushes the schema to the database. For testing purposes only.
+     * @private
+     */
+    $pushSchema(): Promise<void>;
+} & {
+    [Key in GetModels<Schema> as Uncapitalize<Key>]: ModelOperations<Schema, Key>;
+} & Procedures<Schema>;
+/**
+ * The contract for a client in a transaction.
+ */
+type TransactionClientContract<Schema extends SchemaDef> = Omit<ClientContract<Schema>, TransactionUnsupportedMethods>;
+type _TypeMap = {
+    String: string;
+    Int: number;
+    Float: number;
+    BigInt: bigint;
+    Decimal: Decimal;
+    Boolean: boolean;
+    DateTime: Date;
+};
+type MapType<Schema extends SchemaDef, T extends string> = T extends keyof _TypeMap ? _TypeMap[T] : T extends GetModels<Schema> ? ModelResult<Schema, T> : unknown;
+type Procedures<Schema extends SchemaDef> = Schema['procedures'] extends Record<string, ProcedureDef> ? {
+    $procedures: {
+        [Key in keyof Schema['procedures']]: ProcedureFunc<Schema, Schema['procedures'][Key]>;
+    };
+} : {};
+type ProcedureFunc<Schema extends SchemaDef, Proc extends ProcedureDef> = (...args: MapProcedureParams<Schema, Proc['params']>) => Promise<MapType<Schema, Proc['returnType']>>;
+type MapProcedureParams<Schema extends SchemaDef, Params> = {
+    [P in keyof Params]: Params[P] extends {
+        type: infer U;
+    } ? OrUndefinedIf<MapType<Schema, U & string>, Params[P] extends {
+        optional: true;
+    } ? true : false> : never;
+};
+/**
+ * Creates a new ZenStack client instance.
+ */
+interface ClientConstructor {
+    new <Schema extends SchemaDef>(schema: Schema, options: ClientOptions<Schema>): ClientContract<Schema>;
+}
+/**
+ * CRUD operations.
+ */
+type CRUD = 'create' | 'read' | 'update' | 'delete';
+/**
+ * CRUD operations.
+ */
+declare const CRUD: readonly ["create", "read", "update", "delete"];
+/**
+ * Extended CRUD operations including 'post-update'.
+ */
+type CRUD_EXT = CRUD | 'post-update';
+/**
+ * Extended CRUD operations including 'post-update'.
+ */
+declare const CRUD_EXT: readonly ["create", "read", "update", "delete", "post-update"];
+type AllModelOperations<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
+    /**
+     * Returns a list of entities.
+     * @param args - query args
+     * @returns a list of entities
+     *
+     * @example
+     * ```ts
+     * // find all users and return all scalar fields
+     * await db.user.findMany();
+     *
+     * // find all users with name 'Alex'
+     * await db.user.findMany({
+     *     where: {
+     *         name: 'Alex'
+     *     }
+     * });
+     *
+     * // select fields
+     * await db.user.findMany({
+     *     select: {
+     *         name: true,
+     *         email: true,
+     *     }
+     * }); // result: `Array<{ name: string, email: string }>`
+     *
+     * // omit fields
+     * await db.user.findMany({
+     *     omit: {
+     *         name: true,
+     *     }
+     * }); // result: `Array<{ id: number; email: string; ... }>`
+     *
+     * // include relations (and all scalar fields)
+     * await db.user.findMany({
+     *     include: {
+     *         posts: true,
+     *     }
+     * }); // result: `Array<{ ...; posts: Post[] }>`
+     *
+     * // include relations with filter
+     * await db.user.findMany({
+     *     include: {
+     *         posts: {
+     *             where: {
+     *                 published: true
+     *             }
+     *         }
+     *     }
+     * });
+     *
+     * // pagination and sorting
+     * await db.user.findMany({
+     *     skip: 10,
+     *     take: 10,
+     *     orderBy: [{ name: 'asc' }, { email: 'desc' }],
+     * });
+     *
+     * // pagination with cursor (https://www.prisma.io/docs/orm/prisma-client/queries/pagination#cursor-based-pagination)
+     * await db.user.findMany({
+     *     cursor: { id: 10 },
+     *     skip: 1,
+     *     take: 10,
+     *     orderBy: { id: 'asc' },
+     * });
+     *
+     * // distinct
+     * await db.user.findMany({
+     *     distinct: ['name']
+     * });
+     *
+     * // count all relations
+     * await db.user.findMany({
+     *     _count: true,
+     * }); // result: `{ _count: { posts: number; ... } }`
+     *
+     * // count selected relations
+     * await db.user.findMany({
+     *     _count: { select: { posts: true } },
+     * }); // result: `{ _count: { posts: number } }`
+     * ```
+     */
+    findMany<T extends FindArgs<Schema, Model, true>>(args?: SelectSubset<T, FindArgs<Schema, Model, true>>): ZenStackPromise<Schema, Simplify<ModelResult<Schema, Model, T>>[]>;
+    /**
+     * Returns a uniquely identified entity.
+     * @param args - query args
+     * @returns a single entity or null if not found
+     * @see {@link findMany}
+     */
+    findUnique<T extends FindUniqueArgs<Schema, Model>>(args: SelectSubset<T, FindUniqueArgs<Schema, Model>>): ZenStackPromise<Schema, Simplify<ModelResult<Schema, Model, T>> | null>;
+    /**
+     * Returns a uniquely identified entity or throws `NotFoundError` if not found.
+     * @param args - query args
+     * @returns a single entity
+     * @see {@link findMany}
+     */
+    findUniqueOrThrow<T extends FindUniqueArgs<Schema, Model>>(args: SelectSubset<T, FindUniqueArgs<Schema, Model>>): ZenStackPromise<Schema, Simplify<ModelResult<Schema, Model, T>>>;
+    /**
+     * Returns the first entity.
+     * @param args - query args
+     * @returns a single entity or null if not found
+     * @see {@link findMany}
+     */
+    findFirst<T extends FindArgs<Schema, Model, true>>(args?: SelectSubset<T, FindArgs<Schema, Model, true>>): ZenStackPromise<Schema, Simplify<ModelResult<Schema, Model, T>> | null>;
+    /**
+     * Returns the first entity or throws `NotFoundError` if not found.
+     * @param args - query args
+     * @returns a single entity
+     * @see {@link findMany}
+     */
+    findFirstOrThrow<T extends FindArgs<Schema, Model, true>>(args?: SelectSubset<T, FindArgs<Schema, Model, true>>): ZenStackPromise<Schema, Simplify<ModelResult<Schema, Model, T>>>;
+    /**
+     * Creates a new entity.
+     * @param args - create args
+     * @returns the created entity
+     *
+     * @example
+     * ```ts
+     * // simple create
+     * await db.user.create({
+     *    data: { name: 'Alex', email: 'alex@zenstack.dev' }
+     * });
+     *
+     * // nested create with relation
+     * await db.user.create({
+     *    data: {
+     *        email: 'alex@zenstack.dev',
+     *        posts: { create: { title: 'Hello World' } }
+     *    }
+     * });
+     *
+     * // you can use `select`, `omit`, and `include` to control
+     * // the fields returned by the query, as with `findMany`
+     * await db.user.create({
+     *    data: {
+     *        email: 'alex@zenstack.dev',
+     *        posts: { create: { title: 'Hello World' } }
+     *    },
+     *    include: { posts: true }
+     * }); // result: `{ id: number; posts: Post[] }`
+     *
+     * // connect relations
+     * await db.user.create({
+     *    data: {
+     *        email: 'alex@zenstack.dev',
+     *        posts: { connect: { id: 1 } }
+     *    }
+     * });
+     *
+     * // connect relations, and create if not found
+     * await db.user.create({
+     *    data: {
+     *        email: 'alex@zenstack.dev',
+     *        posts: {
+     *            connectOrCreate: {
+     *                where: { id: 1 },
+     *                create: { title: 'Hello World' }
+     *            }
+     *        }
+     *    }
+     * });
+     * ```
+     */
+    create<T extends CreateArgs<Schema, Model>>(args: SelectSubset<T, CreateArgs<Schema, Model>>): ZenStackPromise<Schema, Simplify<ModelResult<Schema, Model, T>>>;
+    /**
+     * Creates multiple entities. Only scalar fields are allowed.
+     * @param args - create args
+     * @returns count of created entities: `{ count: number }`
+     *
+     * @example
+     * ```ts
+     * // create multiple entities
+     * await db.user.createMany({
+     *     data: [
+     *         { name: 'Alex', email: 'alex@zenstack.dev' },
+     *         { name: 'John', email: 'john@zenstack.dev' }
+     *     ]
+     * });
+     *
+     * // skip items that cause unique constraint violation
+     * await db.user.createMany({
+     *     data: [
+     *         { name: 'Alex', email: 'alex@zenstack.dev' },
+     *         { name: 'John', email: 'john@zenstack.dev' }
+     *     ],
+     *     skipDuplicates: true
+     * });
+     * ```
+     */
+    createMany<T extends CreateManyArgs<Schema, Model>>(args?: SelectSubset<T, CreateManyArgs<Schema, Model>>): ZenStackPromise<Schema, BatchResult>;
+    /**
+     * Creates multiple entities and returns them.
+     * @param args - create args. See {@link createMany} for input. Use
+     * `select` and `omit` to control the fields returned.
+     * @returns the created entities
+     *
+     * @example
+     * ```ts
+     * // create multiple entities and return selected fields
+     * await db.user.createManyAndReturn({
+     *     data: [
+     *         { name: 'Alex', email: 'alex@zenstack.dev' },
+     *         { name: 'John', email: 'john@zenstack.dev' }
+     *     ],
+     *     select: { id: true, email: true }
+     * });
+     * ```
+     */
+    createManyAndReturn<T extends CreateManyAndReturnArgs<Schema, Model>>(args?: SelectSubset<T, CreateManyAndReturnArgs<Schema, Model>>): ZenStackPromise<Schema, Simplify<ModelResult<Schema, Model, T>>[]>;
+    /**
+     * Updates a uniquely identified entity.
+     * @param args - update args. See {@link findMany} for how to control
+     * fields and relations returned.
+     * @returns the updated entity. Throws `NotFoundError` if the entity is not found.
+     *
+     * @example
+     * ```ts
+     * // update fields
+     * await db.user.update({
+     *     where: { id: 1 },
+     *     data: { name: 'Alex' }
+     * });
+     *
+     * // connect a relation
+     * await db.user.update({
+     *     where: { id: 1 },
+     *     data: { posts: { connect: { id: 1 } } }
+     * });
+     *
+     * // connect relation, and create if not found
+     * await db.user.update({
+     *     where: { id: 1 },
+     *     data: {
+     *         posts: {
+     *            connectOrCreate: {
+     *                where: { id: 1 },
+     *                create: { title: 'Hello World' }
+     *            }
+     *         }
+     *     }
+     * });
+     *
+     * // create many related entities (only available for one-to-many relations)
+     * await db.user.update({
+     *     where: { id: 1 },
+     *     data: {
+     *         posts: {
+     *             createMany: {
+     *                 data: [{ title: 'Hello World' }, { title: 'Hello World 2' }],
+     *             }
+     *         }
+     *     }
+     * });
+     *
+     * // disconnect a one-to-many relation
+     * await db.user.update({
+     *     where: { id: 1 },
+     *     data: { posts: { disconnect: { id: 1 } } }
+     * });
+     *
+     * // disconnect a one-to-one relation
+     * await db.user.update({
+     *     where: { id: 1 },
+     *     data: { profile: { disconnect: true } }
+     * });
+     *
+     * // replace a relation (only available for one-to-many relations)
+     * await db.user.update({
+     *     where: { id: 1 },
+     *     data: {
+     *         posts: {
+     *             set: [{ id: 1 }, { id: 2 }]
+     *         }
+     *     }
+     * });
+     *
+     * // update a relation
+     * await db.user.update({
+     *     where: { id: 1 },
+     *     data: {
+     *         posts: {
+     *             update: { where: { id: 1 }, data: { title: 'Hello World' } }
+     *         }
+     *     }
+     * });
+     *
+     * // upsert a relation
+     * await db.user.update({
+     *     where: { id: 1 },
+     *     data: {
+     *         posts: {
+     *             upsert: {
+     *                 where: { id: 1 },
+     *                 create: { title: 'Hello World' },
+     *                 update: { title: 'Hello World' }
+     *             }
+     *         }
+     *     }
+     * });
+     *
+     * // update many related entities (only available for one-to-many relations)
+     * await db.user.update({
+     *     where: { id: 1 },
+     *     data: {
+     *         posts: {
+     *             updateMany: {
+     *                 where: { published: true },
+     *                 data: { title: 'Hello World' }
+     *             }
+     *         }
+     *     }
+     * });
+     *
+     * // delete a one-to-many relation
+     * await db.user.update({
+     *     where: { id: 1 },
+     *     data: { posts: { delete: { id: 1 } } }
+     * });
+     *
+     * // delete a one-to-one relation
+     * await db.user.update({
+     *     where: { id: 1 },
+     *     data: { profile: { delete: true } }
+     * });
+     * ```
+     */
+    update<T extends UpdateArgs<Schema, Model>>(args: SelectSubset<T, UpdateArgs<Schema, Model>>): ZenStackPromise<Schema, Simplify<ModelResult<Schema, Model, T>>>;
+    /**
+     * Updates multiple entities.
+     * @param args - update args. Only scalar fields are allowed for data.
+     * @returns count of updated entities: `{ count: number }`
+     *
+     * @example
+     * ```ts
+     * // update many entities
+     * await db.user.updateMany({
+     *     where: { email: { endsWith: '@zenstack.dev' } },
+     *     data: { role: 'ADMIN' }
+     * });
+     *
+     * // limit the number of updated entities
+     * await db.user.updateMany({
+     *     where: { email: { endsWith: '@zenstack.dev' } },
+     *     data: { role: 'ADMIN' },
+     *     limit: 10
+     * });
+     */
+    updateMany<T extends UpdateManyArgs<Schema, Model>>(args: Subset<T, UpdateManyArgs<Schema, Model>>): ZenStackPromise<Schema, BatchResult>;
+    /**
+     * Updates multiple entities and returns them.
+     * @param args - update args. Only scalar fields are allowed for data.
+     * @returns the updated entities
+     *
+     * @example
+     * ```ts
+     * // update many entities and return selected fields
+     * await db.user.updateManyAndReturn({
+     *     where: { email: { endsWith: '@zenstack.dev' } },
+     *     data: { role: 'ADMIN' },
+     *     select: { id: true, email: true }
+     * }); // result: `Array<{ id: string; email: string }>`
+     *
+     * // limit the number of updated entities
+     * await db.user.updateManyAndReturn({
+     *     where: { email: { endsWith: '@zenstack.dev' } },
+     *     data: { role: 'ADMIN' },
+     *     limit: 10
+     * });
+     * ```
+     */
+    updateManyAndReturn<T extends UpdateManyAndReturnArgs<Schema, Model>>(args: Subset<T, UpdateManyAndReturnArgs<Schema, Model>>): ZenStackPromise<Schema, Simplify<ModelResult<Schema, Model, T>>[]>;
+    /**
+     * Creates or updates an entity.
+     * @param args - upsert args
+     * @returns the upserted entity
+     *
+     * @example
+     * ```ts
+     * // upsert an entity
+     * await db.user.upsert({
+     *     // `where` clause is used to find the entity
+     *     where: { id: 1 },
+     *     // `create` clause is used if the entity is not found
+     *     create: { email: 'alex@zenstack.dev', name: 'Alex' },
+     *     // `update` clause is used if the entity is found
+     *     update: { name: 'Alex-new' },
+     *     // `select` and `omit` can be used to control the returned fields
+     *     ...
+     * });
+     * ```
+     */
+    upsert<T extends UpsertArgs<Schema, Model>>(args: SelectSubset<T, UpsertArgs<Schema, Model>>): ZenStackPromise<Schema, Simplify<ModelResult<Schema, Model, T>>>;
+    /**
+     * Deletes a uniquely identifiable entity.
+     * @param args - delete args
+     * @returns the deleted entity. Throws `NotFoundError` if the entity is not found.
+     *
+     * @example
+     * ```ts
+     * // delete an entity
+     * await db.user.delete({
+     *     where: { id: 1 }
+     * });
+     *
+     * // delete an entity and return selected fields
+     * await db.user.delete({
+     *     where: { id: 1 },
+     *     select: { id: true, email: true }
+     * }); // result: `{ id: string; email: string }`
+     * ```
+     */
+    delete<T extends DeleteArgs<Schema, Model>>(args: SelectSubset<T, DeleteArgs<Schema, Model>>): ZenStackPromise<Schema, Simplify<ModelResult<Schema, Model, T>>>;
+    /**
+     * Deletes multiple entities.
+     * @param args - delete args
+     * @returns count of deleted entities: `{ count: number }`
+     *
+     * @example
+     * ```ts
+     * // delete many entities
+     * await db.user.deleteMany({
+     *     where: { email: { endsWith: '@zenstack.dev' } }
+     * });
+     *
+     * // limit the number of deleted entities
+     * await db.user.deleteMany({
+     *     where: { email: { endsWith: '@zenstack.dev' } },
+     *     limit: 10
+     * });
+     * ```
+     */
+    deleteMany<T extends DeleteManyArgs<Schema, Model>>(args?: Subset<T, DeleteManyArgs<Schema, Model>>): ZenStackPromise<Schema, BatchResult>;
+    /**
+     * Counts rows or field values.
+     * @param args - count args
+     * @returns `number`, or an object containing count of selected relations
+     *
+     * @example
+     * ```ts
+     * // count all
+     * await db.user.count();
+     *
+     * // count with a filter
+     * await db.user.count({ where: { email: { endsWith: '@zenstack.dev' } } });
+     *
+     * // count rows and field values
+     * await db.user.count({
+     *     select: { _all: true, email: true }
+     * }); // result: `{ _all: number, email: number }`
+     */
+    count<T extends CountArgs<Schema, Model>>(args?: Subset<T, CountArgs<Schema, Model>>): ZenStackPromise<Schema, Simplify<CountResult<Schema, Model, T>>>;
+    /**
+     * Aggregates rows.
+     * @param args - aggregation args
+     * @returns an object containing aggregated values
+     *
+     * @example
+     * ```ts
+     * // aggregate rows
+     * await db.profile.aggregate({
+     *     where: { email: { endsWith: '@zenstack.dev' } },
+     *     _count: true,
+     *     _avg: { age: true },
+     *     _sum: { age: true },
+     *     _min: { age: true },
+     *     _max: { age: true }
+     * }); // result: `{ _count: number, _avg: { age: number }, ... }`
+     */
+    aggregate<T extends AggregateArgs<Schema, Model>>(args: Subset<T, AggregateArgs<Schema, Model>>): ZenStackPromise<Schema, Simplify<AggregateResult<Schema, Model, T>>>;
+    /**
+     * Groups rows by columns.
+     * @param args - groupBy args
+     * @returns an object containing grouped values
+     *
+     * @example
+     * ```ts
+     * // group by a field
+     * await db.profile.groupBy({
+     *     by: 'country',
+     *     _count: true
+     * }); // result: `Array<{ country: string, _count: number }>`
+     *
+     * // group by multiple fields
+     * await db.profile.groupBy({
+     *     by: ['country', 'city'],
+     *     _count: true
+     * }); // result: `Array<{ country: string, city: string, _count: number }>`
+     *
+     * // group by with sorting, the `orderBy` fields must be either an aggregation
+     * // or a field used in the `by` list
+     * await db.profile.groupBy({
+     *     by: 'country',
+     *     orderBy: { country: 'desc' }
+     * });
+     *
+     * // group by with having (post-aggregation filter), the fields used in `having` must
+     * // be either an aggregation, or a field used in the `by` list
+     * await db.profile.groupBy({
+     *     by: 'country',
+     *     having: { country: 'US', age: { _avg: { gte: 18 } } }
+     * });
+     */
+    groupBy<T extends GroupByArgs<Schema, Model>>(args: Subset<T, GroupByArgs<Schema, Model>>): ZenStackPromise<Schema, Simplify<GroupByResult<Schema, Model, T>>>;
+};
+type ModelOperations<Schema extends SchemaDef, Model extends GetModels<Schema>> = Omit<AllModelOperations<Schema, Model>, IsDelegateModel<Schema, Model> extends true ? 'create' | 'createMany' | 'createManyAndReturn' | 'upsert' : never>;
 
 /**
  * ZenStack ORM client.
  */
 declare const ZenStackClient: ClientConstructor;
 
+declare function getCrudDialect<Schema extends SchemaDef>(schema: Schema, options: ClientOptions<Schema>): BaseCrudDialect<Schema>;
+
+/**
+ * Base for all ZenStack runtime errors.
+ */
+declare class ZenStackError extends Error {
+}
 /**
  * Error thrown when input validation fails.
  */
-declare class InputValidationError extends Error {
+declare class InputValidationError extends ZenStackError {
     constructor(message: string, cause?: unknown);
 }
 /**
  * Error thrown when a query fails.
  */
-declare class QueryError extends Error {
+declare class QueryError extends ZenStackError {
     constructor(message: string, cause?: unknown);
 }
 /**
  * Error thrown when an internal error occurs.
  */
-declare class InternalError extends Error {
+declare class InternalError extends ZenStackError {
 }
 /**
  * Error thrown when an entity is not found.
  */
-declare class NotFoundError extends Error {
-    constructor(model: string);
+declare class NotFoundError extends ZenStackError {
+    constructor(model: string, details?: string);
+}
+/**
+ * Reason code for policy rejection.
+ */
+declare enum RejectedByPolicyReason {
+    /**
+     * Rejected because the operation is not allowed by policy.
+     */
+    NO_ACCESS = "no-access",
+    /**
+     * Rejected because the result cannot be read back after mutation due to policy.
+     */
+    CANNOT_READ_BACK = "cannot-read-back",
+    /**
+     * Other reasons.
+     */
+    OTHER = "other"
+}
+/**
+ * Error thrown when an operation is rejected by access policy.
+ */
+declare class RejectedByPolicyError extends ZenStackError {
+    readonly model: string | undefined;
+    readonly reason: RejectedByPolicyReason;
+    constructor(model: string | undefined, reason?: RejectedByPolicyReason, message?: string);
+}
+
+declare function hasModel(schema: SchemaDef, model: string): boolean;
+declare function getModel(schema: SchemaDef, model: string): ModelDef | undefined;
+declare function getTypeDef(schema: SchemaDef, type: string): _zenstackhq_sdk_schema.TypeDefDef | undefined;
+declare function requireModel(schema: SchemaDef, model: string): ModelDef;
+declare function getField(schema: SchemaDef, model: string, field: string): FieldDef | undefined;
+declare function requireField(schema: SchemaDef, modelOrType: string, field: string): FieldDef;
+declare function getIdFields<Schema extends SchemaDef>(schema: SchemaDef, model: GetModels<Schema>): string[] | undefined;
+declare function requireIdFields(schema: SchemaDef, model: string): string[];
+declare function getRelationForeignKeyFieldPairs(schema: SchemaDef, model: string, relationField: string): {
+    keyPairs: {
+        fk: string;
+        pk: string;
+    }[];
+    ownedByModel: boolean;
+};
+declare function isScalarField(schema: SchemaDef, model: string, field: string): boolean;
+declare function isForeignKeyField(schema: SchemaDef, model: string, field: string): boolean;
+declare function isRelationField(schema: SchemaDef, model: string, field: string): boolean;
+declare function isInheritedField(schema: SchemaDef, model: string, field: string): boolean;
+declare function getUniqueFields(schema: SchemaDef, model: string): ({
+    name: string;
+    def: FieldDef;
+} | {
+    name: string;
+    defs: Record<string, FieldDef>;
+})[];
+declare function getIdValues(schema: SchemaDef, model: string, data: any): Record<string, any>;
+declare function fieldHasDefaultValue(fieldDef: FieldDef): boolean | undefined;
+declare function isEnum(schema: SchemaDef, type: string): boolean;
+declare function getEnum(schema: SchemaDef, type: string): _zenstackhq_sdk_schema.EnumDef | undefined;
+declare function buildJoinPairs(schema: SchemaDef, model: string, modelAlias: string, relationField: string, relationModelAlias: string): [string, string][];
+declare function makeDefaultOrderBy<Schema extends SchemaDef>(schema: SchemaDef, model: string): OrderBy<Schema, Extract<keyof Schema["models"], string>, true, false>[];
+declare function getManyToManyRelation(schema: SchemaDef, model: string, field: string): {
+    parentFkName: string;
+    parentPKName: string;
+    otherModel: string;
+    otherField: string;
+    otherFkName: string;
+    otherPKName: string;
+    joinTable: string;
+} | undefined;
+/**
+ * Convert filter like `{ id1_id2: { id1: 1, id2: 1 } }` to `{ id1: 1, id2: 1 }`
+ */
+declare function flattenCompoundUniqueFilters(schema: SchemaDef, model: string, filter: unknown): any;
+declare function ensureArray<T>(value: T | T[]): T[];
+declare function safeJSONStringify(value: unknown): string;
+declare function extractIdFields(entity: any, schema: SchemaDef, model: string): {
+    [k: string]: unknown;
+};
+declare function getDiscriminatorField(schema: SchemaDef, model: string): string | undefined;
+declare function getDelegateDescendantModels(schema: SchemaDef, model: string, collected?: Set<ModelDef>): ModelDef[];
+declare function aggregate(eb: ExpressionBuilder<any, any>, expr: Expression<any>, op: AGGREGATE_OPERATORS): kysely.AggregateFunctionBuilder<any, any, string | number | bigint>;
+/**
+ * Strips alias from the node if it exists.
+ */
+declare function stripAlias(node: OperationNode): {
+    alias: OperationNode;
+    node: OperationNode;
+} | {
+    alias: undefined;
+    node: OperationNode;
+};
+/**
+ * Extracts model name from an OperationNode.
+ */
+declare function extractModelName(node: OperationNode): string | undefined;
+/**
+ * Extracts field name from an OperationNode.
+ */
+declare function extractFieldName(node: OperationNode): string | undefined;
+
+declare const queryUtils_aggregate: typeof aggregate;
+declare const queryUtils_buildJoinPairs: typeof buildJoinPairs;
+declare const queryUtils_ensureArray: typeof ensureArray;
+declare const queryUtils_extractFieldName: typeof extractFieldName;
+declare const queryUtils_extractIdFields: typeof extractIdFields;
+declare const queryUtils_extractModelName: typeof extractModelName;
+declare const queryUtils_fieldHasDefaultValue: typeof fieldHasDefaultValue;
+declare const queryUtils_flattenCompoundUniqueFilters: typeof flattenCompoundUniqueFilters;
+declare const queryUtils_getDelegateDescendantModels: typeof getDelegateDescendantModels;
+declare const queryUtils_getDiscriminatorField: typeof getDiscriminatorField;
+declare const queryUtils_getEnum: typeof getEnum;
+declare const queryUtils_getField: typeof getField;
+declare const queryUtils_getIdFields: typeof getIdFields;
+declare const queryUtils_getIdValues: typeof getIdValues;
+declare const queryUtils_getManyToManyRelation: typeof getManyToManyRelation;
+declare const queryUtils_getModel: typeof getModel;
+declare const queryUtils_getRelationForeignKeyFieldPairs: typeof getRelationForeignKeyFieldPairs;
+declare const queryUtils_getTypeDef: typeof getTypeDef;
+declare const queryUtils_getUniqueFields: typeof getUniqueFields;
+declare const queryUtils_hasModel: typeof hasModel;
+declare const queryUtils_isEnum: typeof isEnum;
+declare const queryUtils_isForeignKeyField: typeof isForeignKeyField;
+declare const queryUtils_isInheritedField: typeof isInheritedField;
+declare const queryUtils_isRelationField: typeof isRelationField;
+declare const queryUtils_isScalarField: typeof isScalarField;
+declare const queryUtils_makeDefaultOrderBy: typeof makeDefaultOrderBy;
+declare const queryUtils_requireField: typeof requireField;
+declare const queryUtils_requireIdFields: typeof requireIdFields;
+declare const queryUtils_requireModel: typeof requireModel;
+declare const queryUtils_safeJSONStringify: typeof safeJSONStringify;
+declare const queryUtils_stripAlias: typeof stripAlias;
+declare namespace queryUtils {
+  export { queryUtils_aggregate as aggregate, queryUtils_buildJoinPairs as buildJoinPairs, queryUtils_ensureArray as ensureArray, queryUtils_extractFieldName as extractFieldName, queryUtils_extractIdFields as extractIdFields, queryUtils_extractModelName as extractModelName, queryUtils_fieldHasDefaultValue as fieldHasDefaultValue, queryUtils_flattenCompoundUniqueFilters as flattenCompoundUniqueFilters, queryUtils_getDelegateDescendantModels as getDelegateDescendantModels, queryUtils_getDiscriminatorField as getDiscriminatorField, queryUtils_getEnum as getEnum, queryUtils_getField as getField, queryUtils_getIdFields as getIdFields, queryUtils_getIdValues as getIdValues, queryUtils_getManyToManyRelation as getManyToManyRelation, queryUtils_getModel as getModel, queryUtils_getRelationForeignKeyFieldPairs as getRelationForeignKeyFieldPairs, queryUtils_getTypeDef as getTypeDef, queryUtils_getUniqueFields as getUniqueFields, queryUtils_hasModel as hasModel, queryUtils_isEnum as isEnum, queryUtils_isForeignKeyField as isForeignKeyField, queryUtils_isInheritedField as isInheritedField, queryUtils_isRelationField as isRelationField, queryUtils_isScalarField as isScalarField, queryUtils_makeDefaultOrderBy as makeDefaultOrderBy, queryUtils_requireField as requireField, queryUtils_requireIdFields as requireIdFields, queryUtils_requireModel as requireModel, queryUtils_safeJSONStringify as safeJSONStringify, queryUtils_stripAlias as stripAlias };
+}
+
+declare class DefaultOperationNodeVisitor extends OperationNodeVisitor {
+    protected defaultVisit(node: OperationNode): void;
+    protected visitSelectQuery(node: SelectQueryNode): void;
+    protected visitSelection(node: SelectionNode): void;
+    protected visitColumn(node: ColumnNode): void;
+    protected visitAlias(node: AliasNode): void;
+    protected visitTable(node: TableNode): void;
+    protected visitFrom(node: FromNode): void;
+    protected visitReference(node: ReferenceNode): void;
+    protected visitAnd(node: AndNode): void;
+    protected visitOr(node: OrNode): void;
+    protected visitValueList(node: ValueListNode): void;
+    protected visitParens(node: ParensNode): void;
+    protected visitJoin(node: JoinNode): void;
+    protected visitRaw(node: RawNode): void;
+    protected visitWhere(node: WhereNode): void;
+    protected visitInsertQuery(node: InsertQueryNode): void;
+    protected visitDeleteQuery(node: DeleteQueryNode): void;
+    protected visitReturning(node: ReturningNode): void;
+    protected visitCreateTable(node: CreateTableNode): void;
+    protected visitAddColumn(node: AddColumnNode): void;
+    protected visitColumnDefinition(node: ColumnDefinitionNode): void;
+    protected visitDropTable(node: DropTableNode): void;
+    protected visitOrderBy(node: OrderByNode): void;
+    protected visitOrderByItem(node: OrderByItemNode): void;
+    protected visitGroupBy(node: GroupByNode): void;
+    protected visitGroupByItem(node: GroupByItemNode): void;
+    protected visitUpdateQuery(node: UpdateQueryNode): void;
+    protected visitColumnUpdate(node: ColumnUpdateNode): void;
+    protected visitLimit(node: LimitNode): void;
+    protected visitOffset(node: OffsetNode): void;
+    protected visitOnConflict(node: OnConflictNode): void;
+    protected visitOnDuplicateKey(node: OnDuplicateKeyNode): void;
+    protected visitCheckConstraint(node: CheckConstraintNode): void;
+    protected visitDataType(node: DataTypeNode): void;
+    protected visitSelectAll(node: SelectAllNode): void;
+    protected visitIdentifier(node: IdentifierNode): void;
+    protected visitSchemableIdentifier(node: SchemableIdentifierNode): void;
+    protected visitValue(node: ValueNode): void;
+    protected visitPrimitiveValueList(node: PrimitiveValueListNode): void;
+    protected visitOperator(node: OperatorNode): void;
+    protected visitCreateIndex(node: CreateIndexNode): void;
+    protected visitDropIndex(node: DropIndexNode): void;
+    protected visitList(node: ListNode): void;
+    protected visitPrimaryKeyConstraint(node: PrimaryKeyConstraintNode): void;
+    protected visitUniqueConstraint(node: UniqueConstraintNode): void;
+    protected visitReferences(node: ReferencesNode): void;
+    protected visitWith(node: WithNode): void;
+    protected visitCommonTableExpression(node: CommonTableExpressionNode): void;
+    protected visitCommonTableExpressionName(node: CommonTableExpressionNameNode): void;
+    protected visitHaving(node: HavingNode): void;
+    protected visitCreateSchema(node: CreateSchemaNode): void;
+    protected visitDropSchema(node: DropSchemaNode): void;
+    protected visitAlterTable(node: AlterTableNode): void;
+    protected visitDropColumn(node: DropColumnNode): void;
+    protected visitRenameColumn(node: RenameColumnNode): void;
+    protected visitAlterColumn(node: AlterColumnNode): void;
+    protected visitModifyColumn(node: ModifyColumnNode): void;
+    protected visitAddConstraint(node: AddConstraintNode): void;
+    protected visitDropConstraint(node: DropConstraintNode): void;
+    protected visitForeignKeyConstraint(node: ForeignKeyConstraintNode): void;
+    protected visitCreateView(node: CreateViewNode): void;
+    protected visitDropView(node: DropViewNode): void;
+    protected visitGenerated(node: GeneratedNode): void;
+    protected visitDefaultValue(node: DefaultValueNode): void;
+    protected visitOn(node: OnNode): void;
+    protected visitValues(node: ValuesNode): void;
+    protected visitSelectModifier(node: SelectModifierNode): void;
+    protected visitCreateType(node: CreateTypeNode): void;
+    protected visitDropType(node: DropTypeNode): void;
+    protected visitExplain(node: ExplainNode): void;
+    protected visitDefaultInsertValue(node: DefaultInsertValueNode): void;
+    protected visitAggregateFunction(node: AggregateFunctionNode): void;
+    protected visitOver(node: OverNode): void;
+    protected visitPartitionBy(node: PartitionByNode): void;
+    protected visitPartitionByItem(node: PartitionByItemNode): void;
+    protected visitSetOperation(node: SetOperationNode): void;
+    protected visitBinaryOperation(node: BinaryOperationNode): void;
+    protected visitUnaryOperation(node: UnaryOperationNode): void;
+    protected visitUsing(node: UsingNode): void;
+    protected visitFunction(node: FunctionNode): void;
+    protected visitCase(node: CaseNode): void;
+    protected visitWhen(node: WhenNode): void;
+    protected visitJSONReference(node: JSONReferenceNode): void;
+    protected visitJSONPath(node: JSONPathNode): void;
+    protected visitJSONPathLeg(node: JSONPathLegNode): void;
+    protected visitJSONOperatorChain(node: JSONOperatorChainNode): void;
+    protected visitTuple(node: TupleNode): void;
+    protected visitMergeQuery(node: MergeQueryNode): void;
+    protected visitMatched(node: MatchedNode): void;
+    protected visitAddIndex(node: AddIndexNode): void;
+    protected visitCast(node: CastNode): void;
+    protected visitFetch(node: FetchNode): void;
+    protected visitTop(node: TopNode): void;
+    protected visitOutput(node: OutputNode): void;
+}
+
+type kyselyUtils_DefaultOperationNodeVisitor = DefaultOperationNodeVisitor;
+declare const kyselyUtils_DefaultOperationNodeVisitor: typeof DefaultOperationNodeVisitor;
+declare namespace kyselyUtils {
+  export { kyselyUtils_DefaultOperationNodeVisitor as DefaultOperationNodeVisitor };
+}
+
+declare class ExpressionVisitor {
+    visit(expr: Expression$1): void;
+    protected visitLiteral(_e: LiteralExpression): void;
+    protected visitArray(e: ArrayExpression): void;
+    protected visitField(_e: FieldExpression): void;
+    protected visitMember(e: MemberExpression): void;
+    protected visitBinary(e: BinaryExpression): void;
+    protected visitUnary(e: UnaryExpression): void;
+    protected visitCall(e: CallExpression): void;
+    protected visitThis(_e: ThisExpression): void;
+    protected visitNull(_e: NullExpression): void;
+}
+
+type schemaUtils_ExpressionVisitor = ExpressionVisitor;
+declare const schemaUtils_ExpressionVisitor: typeof ExpressionVisitor;
+declare namespace schemaUtils {
+  export { schemaUtils_ExpressionVisitor as ExpressionVisitor };
 }
 
-export { ClientConstructor, InputValidationError, InternalError, NotFoundError, QueryError, ZenStackClient };
+export { type AfterEntityMutationCallback, AggregateArgs, AggregateResult, type AllModelOperations, BaseCrudDialect, BatchResult, type BeforeEntityMutationCallback, CRUD, CRUD_EXT, type ClientConstructor, type ClientContract, type ClientOptions, type ComputedFieldsOptions, CountArgs, CountResult, CreateArgs, CreateManyAndReturnArgs, CreateManyArgs, type CoreCrudOperation as CrudOperation, DeleteArgs, DeleteManyArgs, type EntityMutationHooksDef, FindArgs, FindUniqueArgs, GroupByArgs, GroupByResult, type HasComputedFields, type HasProcedures, InputValidationError, InternalError, kyselyUtils as KyselyUtils, type ModelOperations, ModelResult, NotFoundError, type OnKyselyQueryArgs, type OnKyselyQueryCallback, OrderBy, type PluginAfterEntityMutationArgs, type PluginBeforeEntityMutationArgs, type ProcedureFunc, type Procedures, type ProceduresOptions, type ProceedKyselyQueryFunction, QueryError, queryUtils as QueryUtils, RejectedByPolicyError, RejectedByPolicyReason, type RuntimePlugin, schemaUtils as SchemaUtils, SelectSubset, Subset, ToKysely, type TransactionClientContract, TransactionIsolationLevel, UpdateArgs, UpdateManyAndReturnArgs, UpdateManyArgs, UpsertArgs, type ZModelFunction, type ZModelFunctionContext, ZenStackClient, ZenStackError, type ZenStackPromise, definePlugin, getCrudDialect };