import { AnyNull, AnyNullClass, DbNull, DbNullClass, JsonArray, JsonNull, JsonNullClass, JsonNullValues, JsonObject, JsonValue } from "./common-types.cjs";
import * as _$kysely from "kysely";
import { AddColumnNode, AddConstraintNode, AddIndexNode, AddValueNode, AggregateFunctionNode, AliasNode, AliasableExpression, AlterColumnNode, AlterTableNode, AlterTypeNode, AndNode, BinaryOperationNode, CaseNode, CastNode, CheckConstraintNode, CollateNode, ColumnDefinitionNode, ColumnNode, ColumnUpdateNode, CommonTableExpressionNameNode, CommonTableExpressionNode, CreateIndexNode, CreateSchemaNode, CreateTableNode, CreateTypeNode, CreateViewNode, DataTypeNode, DefaultInsertValueNode, DefaultValueNode, DeleteQueryNode, Dialect, DropColumnNode, DropConstraintNode, DropIndexNode, DropSchemaNode, DropTableNode, DropTypeNode, DropViewNode, ExplainNode, Expression, ExpressionBuilder, ExpressionWrapper, FetchNode, ForeignKeyConstraintNode, FromNode, FunctionNode, Generated, GeneratedNode, GroupByItemNode, GroupByNode, HavingNode, IdentifierNode, InsertQueryNode, JSONOperatorChainNode, JSONPathLegNode, JSONPathNode, JSONReferenceNode, JoinNode, Kysely, KyselyConfig, LimitNode, ListNode, MatchedNode, MergeQueryNode, ModifyColumnNode, OffsetNode, OnConflictNode, OnDuplicateKeyNode, OnNode, OperandExpression, OperationNode, OperationNodeVisitor, OperatorNode, OrActionNode, OrNode, OrderByItemNode, OrderByNode, OutputNode, OverNode, ParensNode, PartitionByItemNode, PartitionByNode, PrimaryKeyConstraintNode, PrimitiveValueListNode, QueryId, QueryResult, RawNode, ReferenceNode, ReferencesNode, RefreshMaterializedViewNode, RenameColumnNode, RenameConstraintNode, RenameValueNode, ReturningNode, RootOperationNode, SchemableIdentifierNode, SelectAllNode, SelectModifierNode, SelectQueryBuilder, SelectQueryNode, SelectionNode, SetOperationNode, SqlBool, TableNode, TopNode, TupleNode, UnaryOperationNode, UniqueConstraintNode, UnknownRow, UpdateQueryNode, UsingNode, ValueListNode, ValueNode, ValuesNode, WhenNode, WhereNode, WithNode } from "kysely";
import * as _$_zenstackhq_schema0 from "@zenstackhq/schema";
import { ArrayExpression, BinaryExpression, BindingExpression, BuiltinType, CallExpression, DataSourceProviderType, Expression as Expression$1, FieldDef, FieldExpression, FieldHasDefault, FieldIsArray, FieldIsDelegateDiscriminator, FieldIsRelation, FieldType, ForeignKeyFields, GetEnum, GetEnums, GetModel, GetModelDelegateMapValue, GetModelDiscriminator, GetModelField, GetModelFieldType, GetModelFields, GetModels, GetSubModels, GetTypeDefField, GetTypeDefFieldType, GetTypeDefFields, GetTypeDefs, IsDelegateModel, LiteralExpression, MemberExpression, ModelDef, ModelFieldIsOptional, NonRelationFields, NullExpression, ProcedureDef, RelationFieldType, RelationFields, RelationInfo, ScalarFields, SchemaDef, ThisExpression, TypeDefFieldIsArray, TypeDefFieldIsOptional, UnaryExpression, UpdatedAtInfo } from "@zenstackhq/schema";
import { ZodType, z } from "zod";
import Decimal from "decimal.js";

//#region \0rolldown/runtime.js
declare namespace kysely_utils_d_exports {
  export { AnyKysely, DefaultOperationNodeVisitor };
}
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;
  protected visitRenameConstraint(node: RenameConstraintNode): void;
  protected visitRefreshMaterializedView(node: RefreshMaterializedViewNode): void;
  protected visitOrAction(node: OrActionNode): void;
  protected visitCollate(node: CollateNode): void;
  protected visitAlterType(node: AlterTypeNode): void;
  protected visitAddValue(node: AddValueNode): void;
  protected visitRenameValue(node: RenameValueNode): void;
}
type AnyKysely = Kysely<any>;
//#endregion
//#region src/utils/type-utils.d.ts
type Optional<T extends object, K extends keyof T = keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
type PartialIf<T, Condition extends boolean> = Condition extends true ? Partial<T> : T;
type NullableIf<T, Condition extends boolean> = Condition extends true ? T | null : T;
type _Preserve = Date | Function | Decimal | Uint8Array | JsonObject | JsonValue;
type _Depth = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
type Simplify<T, D extends number = 6> = D extends 0 ? T : T extends object ? T extends _Preserve ? T : { [K in keyof T]: Simplify<T[K], _Depth[D]> } & {} : T;
type WrapType<T, Optional = false, Array = false> = Array extends true ? Optional extends true ? T[] | null : T[] : Optional extends true ? T | null : T;
type TypeMap = {
  String: string;
  Boolean: boolean;
  Int: number;
  Float: number;
  BigInt: bigint;
  Decimal: Decimal;
  DateTime: Date;
  Bytes: Uint8Array;
  Json: JsonValue | null;
  Null: null;
  Object: Record<string, unknown>;
  Any: unknown;
  Unsupported: unknown;
  Void: void;
  Undefined: undefined;
};
type MapBaseType$1<T extends string> = T extends keyof TypeMap ? TypeMap[T] : unknown;
type OrArray<T, IF extends boolean = true> = IF extends true ? T | T[] : T;
type NonEmptyArray<T> = [T, ...T[]];
type ValueOfPotentialTuple<T> = T extends unknown[] ? T[number] : T;
type NoExpand<T> = T extends unknown ? T : never;
type AtLeast<O extends object, K extends string> = NoExpand<O extends unknown ? (K extends keyof O ? { [P in K]: O[P] } & O : O) | ({ [P in keyof O as P extends K ? K : never]-?: O[P] } & O) : never>;
type Without<T, U> = { [P in Exclude<keyof T, keyof U>]?: never };
type XOR<T, U> = T extends object ? (U extends object ? (Without<T, U> & U) | (Without<U, T> & T) : U) : T;
type MaybePromise<T> = T | Promise<T>;
type OrUndefinedIf<T, Condition extends boolean> = Condition extends true ? T | undefined : T;
type UnwrapTuplePromises<T extends readonly unknown[]> = { [K in keyof T]: Awaited<T[K]> };
//#endregion
//#region src/client/constants.d.ts
/**
 * 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 AggregateOperators: readonly ["_count", "_sum", "_avg", "_min", "_max"];
type AggregateOperators = (typeof AggregateOperators)[number];
/**
 * Mapping of filter operators to their corresponding filter kind categories.
 */
declare const FILTER_PROPERTY_TO_KIND: {
  readonly equals: "Equality";
  readonly not: "Equality";
  readonly in: "Equality";
  readonly notIn: "Equality";
  readonly lt: "Range";
  readonly lte: "Range";
  readonly gt: "Range";
  readonly gte: "Range";
  readonly between: "Range";
  readonly contains: "Like";
  readonly startsWith: "Like";
  readonly endsWith: "Like";
  readonly mode: "Like";
  readonly is: "Relation";
  readonly isNot: "Relation";
  readonly some: "Relation";
  readonly every: "Relation";
  readonly none: "Relation";
  readonly path: "Json";
  readonly string_contains: "Json";
  readonly string_starts_with: "Json";
  readonly string_ends_with: "Json";
  readonly array_contains: "Json";
  readonly array_starts_with: "Json";
  readonly array_ends_with: "Json";
  readonly fuzzy: "Fuzzy";
  readonly fts: "FullText";
  readonly has: "List";
  readonly hasEvery: "List";
  readonly hasSome: "List";
  readonly isEmpty: "List";
};
/**
 * Mapping of filter operators to their corresponding filter kind categories.
 */
type FilterPropertyToKind = typeof FILTER_PROPERTY_TO_KIND;
//#endregion
//#region src/client/query-builder.d.ts
type ToKyselySchema<Schema extends SchemaDef> = { [Model in GetModels<Schema>]: ToKyselyTable<Schema, Model> };
type ToKysely<Schema extends SchemaDef> = Kysely<ToKyselySchema<Schema>>;
type ToKyselyTable<Schema extends SchemaDef, Model extends GetModels<Schema>> = { [Field in ScalarFields<Schema, Model, false> | ForeignKeyFields<Schema, Model> as GetModelField<Schema, Model, Field>['originModel'] extends string ? never : Field]: toKyselyFieldType<Schema, Model, Field> };
type MapBaseType<T> = T extends 'String' ? string : T extends 'Boolean' ? boolean : T extends 'Int' | 'Float' ? number : T extends 'BigInt' ? bigint : T extends 'Decimal' ? Decimal : T extends 'DateTime' ? string : unknown;
type WrapNull<T, Null> = Null extends true ? T | null : T;
type MapType$1<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends GetModelFields<Schema, Model>> = WrapNull<MapBaseType<GetModelFieldType<Schema, Model, Field>>, ModelFieldIsOptional<Schema, Model, Field>>;
type toKyselyFieldType<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends GetModelFields<Schema, Model>> = FieldHasDefault<Schema, Model, Field> extends true ? Generated<MapType$1<Schema, Model, Field>> : MapType$1<Schema, Model, Field>;
//#endregion
//#region src/client/plugin.d.ts
type AllowedExtQueryArgKeys = CoreCrudOperations | '$create' | '$read' | '$update' | '$delete' | '$all';
/**
 * Base shape of plugin-extended query args.
 */
type ExtQueryArgsBase = { [K in AllowedExtQueryArgKeys]?: object };
/**
 * Base type for plugin-extended client members (methods and properties).
 * Member names should start with '$' to avoid model name conflicts.
 */
type ExtClientMembersBase = Record<string, unknown>;
/**
 * Base shape of plugin-extended result fields.
 * Keyed by model name, each value maps field names to their definitions.
 * `needs` keys are constrained to non-relation fields of the corresponding model.
 */
type ExtResultBase<Schema extends SchemaDef = SchemaDef> = { [M in GetModels<Schema> as Uncapitalize<M>]?: Record<string, {
  needs: Partial<Record<NonRelationFields<Schema, M>, true>>;
  compute: (...args: any[]) => any;
}> };
/**
 * Mapped type that provides per-field contextual typing for `compute` callbacks
 * based on the `needs` declaration. Uses a separate type parameter `R_` that captures
 * the needs shape (model → field → { neededField: true }), then links each field's
 * `compute` parameter to exactly the keys declared in its `needs`.
 */
type ExtResultInferenceArgs<Schema extends SchemaDef, R_> = { [K in keyof R_ & string]: { [P in keyof R_[K]]?: {
  needs?: { [F in keyof R_[K][P]]: F extends NonRelationFields<Schema, ModelNameFromKey<Schema, K>> ? true : never } & Partial<Record<NonRelationFields<Schema, ModelNameFromKey<Schema, K>>, true>>;
  compute: (data: ExtResultComputeData<Schema, ModelNameFromKey<Schema, K>, R_[K][P]>) => unknown;
} } };
/**
 * Reverse-maps an uncapitalized key back to the original model name in the schema.
 * E.g., for a schema with model `myModel`, the key `myModel` maps back to `myModel`
 * (not `MyModel` as `Capitalize` would produce).
 */
type ModelNameFromKey<Schema extends SchemaDef, K extends string> = { [M in GetModels<Schema>]: Uncapitalize<M> extends K ? M : never }[GetModels<Schema>];
/**
 * Maps the needs shape `S` to an object with actual schema field types.
 * For each key in `S` that is a valid non-relation field of model `M`,
 * resolves the TypeScript type from the schema field definition.
 */
type ExtResultComputeData<Schema extends SchemaDef, M extends GetModels<Schema>, S> = { [F in keyof S & GetModelFields<Schema, M>]: MapModelFieldType<Schema, M, F> };
/**
 * ZenStack runtime plugin.
 */
interface RuntimePlugin<Schema extends SchemaDef, ExtQueryArgs extends ExtQueryArgsBase, ExtClientMembers extends Record<string, unknown>, ExtResult extends ExtResultBase<Schema>> {
  /**
   * Plugin ID.
   */
  id: string;
  /**
   * Plugin display name.
   */
  name?: string;
  /**
   * Plugin description.
   */
  description?: string;
  /**
   * Custom function implementations.
   * @private
   */
  functions?: Record<string, ZModelFunction<Schema>>;
  /**
   * Intercepts an ORM query.
   */
  onQuery?: OnQueryCallback<Schema>;
  /**
   * Intercepts a procedure invocation.
   */
  onProcedure?: OnProcedureCallback<Schema>;
  /**
   * Intercepts an entity mutation.
   */
  onEntityMutation?: EntityMutationHooksDef<Schema>;
  /**
   * Intercepts a Kysely query.
   */
  onKyselyQuery?: OnKyselyQueryCallback<Schema>;
  /**
   * Extended query args configuration.
   */
  queryArgs?: { [K in keyof ExtQueryArgs]: ZodType<ExtQueryArgs[K]> };
  /**
   * Extended client members (methods and properties).
   */
  client?: ExtClientMembers;
  /**
   * Extended result fields on query results.
   * Keyed by model name, each value defines computed fields with `needs` and `compute`.
   */
  result?: ExtResult;
}
type AnyPlugin = RuntimePlugin<SchemaDef, any, any, any>;
/**
 * Defines a ZenStack runtime plugin based on type of the given schema.
 *
 * @see {@link https://zenstack.dev/docs/orm/plugins/|Plugin Documentation}
 *
 * @example
 * ```typescript
 * definePlugin(schema, {
 *     id: 'my-plugin',
 *     result: {
 *         user: {
 *             fullName: {
 *                 needs: { firstName: true, lastName: true },
 *                 compute: (user) => `${user.firstName} ${user.lastName}`,
 *             },
 *         },
 *     },
 * });
 * ```
 */
declare function definePlugin<Schema extends SchemaDef, const ExtQueryArgs extends ExtQueryArgsBase = {}, const ExtClientMembers extends Record<string, unknown> = {}, const ExtResult extends ExtResultBase<Schema> = {}, R_ = {}>(schema: Schema, plugin: RuntimePlugin<Schema, ExtQueryArgs, ExtClientMembers, ExtResult> & {
  result?: ExtResultInferenceArgs<Schema, R_>;
}): RuntimePlugin<Schema, ExtQueryArgs, ExtClientMembers, ExtResult>;
/**
 * Defines a ZenStack runtime plugin.
 *
 * @see {@link https://zenstack.dev/docs/orm/plugins/|Plugin Documentation}
 *
 * @example
 * ```typescript
 * definePlugin(schema, {
 *     id: 'my-plugin',
 *     result: {
 *         user: {
 *             fullName: {
 *                 needs: { firstName: true, lastName: true },
 *                 compute: (user) => `${user.firstName} ${user.lastName}`,
 *             },
 *         },
 *     },
 * });
 * ```
 *  */
declare function definePlugin<Schema extends SchemaDef, const ExtQueryArgs extends ExtQueryArgsBase = {}, const ExtClientMembers extends Record<string, unknown> = {}, const ExtResult extends ExtResultBase<Schema> = {}>(plugin: RuntimePlugin<Schema, ExtQueryArgs, ExtClientMembers, ExtResult>): RuntimePlugin<Schema, ExtQueryArgs, ExtClientMembers, ExtResult>;
type OnProcedureCallback<Schema extends SchemaDef> = (ctx: OnProcedureHookContext<Schema>) => Promise<unknown>;
type OnProcedureHookContext<Schema extends SchemaDef> = {
  /**
   * The procedure name.
   */
  name: string;
  /**
   * Whether the procedure is a mutation.
   */
  mutation: boolean;
  /**
   * Procedure invocation input (envelope).
   *
   * The canonical shape is `{ args?: Record<string, unknown> }`.
   * When a procedure has required params, `args` is required.
   */
  input: unknown;
  /**
   * Continues the invocation. The input passed here is forwarded to the next handler.
   */
  proceed: (input: unknown) => Promise<unknown>;
  /**
   * The ZenStack client that is invoking the procedure.
   */
  client: ClientContract<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: AllCrudOperations;
  /**
   * The query arguments.
   */
  args: Record<string, unknown> | undefined;
  /**
   * The function to proceed with the original query.
   * It takes the same arguments as the operation method.
   *
   * @param args The query arguments.
   */
  proceed: (args: Record<string, unknown> | undefined) => Promise<unknown>;
  /**
   * The ZenStack client that is performing the operation.
   */
  client: ClientContract<Schema>;
};
type EntityMutationHooksDef<Schema extends SchemaDef> = {
  /**
   * Called before entities are mutated.
   */
  beforeEntityMutation?: BeforeEntityMutationCallback<Schema>;
  /**
   * Called after entities are mutated.
   */
  afterEntityMutation?: AfterEntityMutationCallback<Schema>;
  /**
   * Whether to run after-mutation hooks within the transaction that performs the mutation.
   *
   * If set to `true`, if the mutation already runs inside a transaction, the callbacks are
   * executed immediately after the mutation within the transaction boundary. If the mutation
   * is not running inside a transaction, a new transaction is created to run both the mutation
   * and the callbacks.
   *
   * If set to `false`, the callbacks are executed after the mutation transaction is committed.
   *
   * Defaults to `false`.
   */
  runAfterMutationWithinTransaction?: boolean;
};
type MutationHooksArgs<Schema extends SchemaDef> = {
  /**
   * The model that is being mutated.
   */
  model: GetModels<Schema>;
  /**
   * The mutation action that is being performed.
   */
  action: 'create' | 'update' | 'delete';
  /**
   * The mutation data. Only available for create and update actions.
   */
  queryNode: OperationNode;
  /**
   * A query ID that uniquely identifies the mutation operation. You can use it to correlate
   * data between the before and after mutation hooks.
   */
  queryId: QueryId;
};
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 entities before mutation. Only available if `beforeEntityMutation` hook is provided and
   * the `loadBeforeMutationEntities` function is called in that hook.
   */
  beforeMutationEntities?: Record<string, unknown>[];
  /**
   * 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>>;
//#endregion
//#region src/client/options.d.ts
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>;
/**
 * Options for slicing ORM client's capabilities by including/excluding certain models, operations,
 * filters, etc.
 */
type SlicingOptions<Schema extends SchemaDef> = {
  /**
   * Models to include in the client. If not specified, all models are included by default.
   */
  includedModels?: readonly GetModels<Schema>[];
  /**
   * Models to exclude from the client. Exclusion takes precedence over inclusion.
   */
  excludedModels?: readonly GetModels<Schema>[];
  /**
   * Model slicing options.
   */
  models?: { [Model in GetModels<Schema> as Uncapitalize<Model>]?: ModelSlicingOptions<Schema, Model> } & {
    /**
     * Slicing options that apply to all models. Model-specific options will override these general
     * options if both are specified.
     */
    $all?: ModelSlicingOptions<Schema, GetModels<Schema>>;
  };
  /**
   * Procedures to include in the client. If not specified, all procedures are included by default.
   */
  includedProcedures?: readonly GetProcedureNames<Schema>[];
  /**
   * Procedures to exclude from the client. Exclusion takes precedence over inclusion.
   */
  excludedProcedures?: readonly GetProcedureNames<Schema>[];
};
/**
 * Kinds of filter operations.
 */
type FilterKind = FilterPropertyToKind[keyof FilterPropertyToKind];
/**
 * Model slicing options.
 */
type ModelSlicingOptions<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
  /**
   * ORM query operations to include for the model. If not specified, all operations are included
   * by default.
   */
  includedOperations?: readonly AllCrudOperations[];
  /**
   * ORM query operations to exclude for the model. Exclusion takes precedence over inclusion.
   */
  excludedOperations?: readonly AllCrudOperations[];
  /**
   * Field-level slicing options.
   */
  fields?: { [Field in GetModelFields<Schema, Model>]?: FieldSlicingOptions } & {
    /**
     * Field slicing options that apply to all fields. Field-specific options will override these
     * general options if both are specified.
     */
    $all?: FieldSlicingOptions;
  };
};
/**
 * Field slicing options.
 */
type FieldSlicingOptions = {
  /**
   * Filter kinds to include for the field. If not specified, all filter kinds are included by default.
   */
  includedFilterKinds?: readonly FilterKind[];
  /**
   * Filter kinds to exclude for the field. Exclusion takes precedence over inclusion.
   */
  excludedFilterKinds?: readonly FilterKind[];
};
/**
 * Partial ORM client options that defines customizable behaviors.
 */
type QueryOptions<Schema extends SchemaDef> = {
  /**
   * Options for omitting fields in ORM query results.
   */
  omit?: OmitConfig<Schema>;
  /**
   * Whether to allow overriding omit settings at query time. Defaults to `true`. When set to `false`, a
   * query-time `omit` clause that sets the field to `false` (not omitting) will trigger a validation error.
   */
  allowQueryTimeOmitOverride?: boolean;
  /**
   * Options for slicing ORM client's capabilities by including/excluding certain models, operations, filters, etc.
   */
  slicing?: SlicingOptions<Schema>;
};
/**
 * Projects a (typically inferred) client options type down to only the members that influence
 * ORM typing - the {@link QueryOptions} fields (`omit`, `allowQueryTimeOmitOverride`, `slicing`).
 *
 * The full options object inferred at `new ZenStackClient(...)` carries heavy function types for
 * `computedFields` and `procedures`. Those are never read by the model/operation types, but if the
 * raw options type is fanned out across every model's `ModelOperations` instantiation (30+ for a
 * typical schema) it inflates type checking dramatically. Projecting to the query-relevant subset
 * before the fan-out keeps the per-model types cheap while preserving full options on `$options`.
 */
type QueryRelevantOptions<Schema extends SchemaDef, Options> = Pick<Options, Extract<keyof Options, keyof QueryOptions<Schema>>>;
/**
 * ZenStack client options.
 */
type ClientOptions<Schema extends SchemaDef> = QueryOptions<Schema> & {
  /**
   * Kysely dialect.
   */
  dialect: Dialect;
  /**
   * Custom function definitions.
   *
   * @private
   */
  functions?: Record<string, ZModelFunction<Schema>>;
  /**
   * Plugins.
   */
  plugins?: AnyPlugin[];
  /**
   * Logging configuration. Extends Kysely's log config with a `'warning'` level
   * for ZenStack-specific diagnostics (e.g., slow query warnings).
   */
  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 query args validation. Defaults to `true`.
   *
   * **USE WITH CAUTION**, as setting it to `false` will allow malformed input to pass through, causing
   * incorrect SQL generation or runtime errors. If you use validation attributes like `@email`, `@regex`,
   * etc., in ZModel, they will be ignored too.
   */
  validateInput?: boolean;
  /**
   * Whether to use compact alias names (e.g., "$$t1", "$$t2") when transforming ORM queries to SQL.
   * Defaults to `true`.
   *
   * When set to `false`, original aliases are kept unless temporary aliases become too long for
   * safe SQL identifier handling, in which case compact aliases are used as a fallback.
   */
  useCompactAliasNames?: boolean;
  /**
   * Whether to skip validation for whether all computed fields are properly defined.
   */
  skipValidationForComputedFields?: boolean;
  /**
   * Diagnostics related options.
   */
  diagnostics?: {
    /**
     * Threshold in milliseconds for determining slow queries. If not specified, no query will be considered slow.
     */
    slowQueryThresholdMs?: number;
    /**
     * Maximum number of slow query records to keep in memory. Defaults to `100`. When the number is exceeded, the
     * entry with the lowest duration will be removed. Set to `Infinity` to keep unlimited records.
     */
    slowQueryMaxRecords?: number;
  };
} & (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> as Uncapitalize<Model>]?: { [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> ? Uncapitalize<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'];
//#endregion
//#region src/client/crud/dialects/base-dialect.d.ts
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.
   *
   * `fieldDef` is optional so existing callers that don't have it stay
   * source-compatible. Dialects can use it to inspect `@db.*` native-type
   * attributes (e.g. to format `@db.Time` values as `HH:MM:SS` rather than
   * full ISO timestamps).
   */
  transformInput(value: unknown, _type: BuiltinType, _forArrayField: boolean, _fieldDef?: FieldDef): 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): Expression<SqlBool>;
  private buildValueFilter;
  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>;
  private applyRelationOrderBy;
  private applyScalarOrderBy;
  private applyAggregationOrderBy;
  private applyFuzzyRelevanceOrderBy;
  private applyFtsRelevanceOrderBy;
  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;
  /**
   * Builds an EXISTS expression from an inner SELECT query.
   * Can be overridden by dialects that need special handling (e.g., MySQL wraps
   * in a derived table to avoid "can't specify target table for update in FROM clause").
   */
  protected buildExistsExpression(innerQuery: SelectQueryBuilder<any, any, any>): Expression<SqlBool>;
  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 binary comparison expression between two operands.
   */
  buildComparison(left: Expression<unknown>, _leftFieldDef: FieldDef | undefined, op: string, right: Expression<unknown>, _rightFieldDef: FieldDef | undefined): Expression<SqlBool>;
  /**
   * 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>;
  /**
   * Builds a fuzzy search filter for a string field using PostgreSQL `pg_trgm`.
   * The selected SQL form (operator vs. function, with/without `unaccent`) depends
   * on the resolved options.
   */
  abstract buildFuzzyFilter(fieldRef: Expression<any>, options: FuzzyFilterOptions): Expression<SqlBool>;
  /**
   * Builds an ORDER BY clause that sorts by fuzzy relevance to a search term.
   */
  abstract buildFuzzyRelevanceOrderBy(query: SelectQueryBuilder<any, any, any>, fieldRefs: Expression<any>[], search: string, sort: SortOrder, mode: FuzzyFilterOptions['mode'], unaccent: boolean): SelectQueryBuilder<any, any, any>;
  /**
   * Validate the user-provided fuzzy filter payload and apply defaults so dialects
   * always receive a fully-resolved {@link FuzzyFilterOptions} value.
   */
  protected normalizeFuzzyOptions(value: unknown): FuzzyFilterOptions;
  /**
   * Builds a full-text-search filter for a string field. Receives the raw
   * user-supplied filter payload — dialects validate/normalize it themselves
   * (the shape is provider-specific; only Postgres supports this filter).
   */
  abstract buildFullTextFilter(fieldRef: Expression<any>, payload: unknown): Expression<SqlBool>;
  /**
   * Builds an ORDER BY clause that sorts by full-text-search relevance to a search term.
   */
  abstract buildFtsRelevanceOrderBy(query: SelectQueryBuilder<any, any, any>, fieldRefs: Expression<any>[], search: string, config: string | undefined, sort: SortOrder): SelectQueryBuilder<any, any, any>;
}
/**
 * Resolved options for a fuzzy filter passed to a dialect. `mode` and `unaccent`
 * are always populated (defaults: `mode='simple'`, `unaccent=false`, applied by
 * `normalizeFuzzyOptions`); `threshold` is optional and switches the SQL from
 * operator form (`%`, `<%`, `<<%`) to function form (`similarity() > threshold`).
 */
type FuzzyFilterOptions = {
  search: string;
  mode: 'simple' | 'word' | 'strictWord';
  threshold?: number;
  unaccent: boolean;
};
//#endregion
//#region src/client/crud/validator/validator.d.ts
type InputValidatorOptions = {
  /**
   * Whether validation is enabled. Defaults to `true`.
   */
  enabled?: boolean;
};
declare class InputValidator<Schema extends SchemaDef> {
  private readonly client;
  readonly zodFactory: ZodSchemaFactory<Schema>;
  private readonly enabled;
  constructor(client: ClientContract<Schema>, options?: InputValidatorOptions);
  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;
}
//#endregion
//#region src/client/crud/operations/base.d.ts
/**
 * 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];
/**
 * List of all write operations - simply an alias of CoreWriteOperations.
 */
declare const AllWriteOperations: readonly ["create", "createMany", "createManyAndReturn", "update", "updateMany", "updateManyAndReturn", "upsert", "delete", "deleteMany"];
/**
 * List of all write operations - simply an alias of CoreWriteOperations.
 */
type AllWriteOperations = CoreWriteOperations;
//#endregion
//#region src/client/type-utils.d.ts
/**
 * Checks if a model has any required Unsupported fields (non-optional, no default).
 * Uses raw field access since `GetModelFields` excludes Unsupported fields.
 */
type ModelHasRequiredUnsupportedField<Schema extends SchemaDef, Model extends GetModels<Schema>> = true extends { [Key in Extract<keyof GetModel<Schema, Model>['fields'], string>]: GetModel<Schema, Model>['fields'][Key] extends infer F extends FieldDef ? F['type'] extends 'Unsupported' ? F['optional'] extends true ? false : 'default' extends keyof F ? false : true : false : false }[Extract<keyof GetModel<Schema, Model>['fields'], string>] ? true : false;
/**
 * Checks if a model allows create operations (not a delegate model and has no required Unsupported fields).
 */
type ModelAllowsCreate<Schema extends SchemaDef, Model extends GetModels<Schema>> = IsDelegateModel<Schema, Model> extends true ? false : ModelHasRequiredUnsupportedField<Schema, Model> extends true ? false : true;
type IsNever<T> = [T] extends [never] ? true : false;
/**
 * Filters models based on slicing configuration.
 */
type GetSlicedModels<Schema extends SchemaDef, Options extends QueryOptions<Schema>> = Options['slicing'] extends infer S ? S extends SlicingOptions<Schema> ? S['includedModels'] extends readonly GetModels<Schema>[] ? Exclude<Extract<S['includedModels'][number], GetModels<Schema>>, S['excludedModels'] extends readonly GetModels<Schema>[] ? S['excludedModels'][number] : never> : Exclude<GetModels<Schema>, S['excludedModels'] extends readonly GetModels<Schema>[] ? S['excludedModels'][number] : never> : GetModels<Schema> : GetModels<Schema>;
/**
 * Filters query operations based on slicing configuration for a specific model.
 */
type GetSlicedOperations<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema>> = Options['slicing'] extends infer Slicing ? Slicing extends SlicingOptions<Schema> ? GetIncludedOperations<Slicing, Model> extends infer IO ? GetExcludedOperations<Slicing, Model> extends infer EO ? IO extends '_none_' ? never : IsNever<IO> extends false ? Exclude<IO, EO> : Exclude<AllCrudOperations, EO> : AllCrudOperations : AllCrudOperations : AllCrudOperations : AllCrudOperations;
type GetIncludedOperations<Slicing extends SlicingOptions<any>, Model extends string> = 'models' extends keyof Slicing ? Slicing extends {
  models: infer Config;
} ? Uncapitalize<Model> extends keyof Config ? 'includedOperations' extends keyof Config[Uncapitalize<Model>] ? Config[Uncapitalize<Model>] extends {
  includedOperations: readonly [];
} ? '_none_' : Config[Uncapitalize<Model>] extends {
  includedOperations: readonly (infer IO)[];
} ? IO : never : GetAllIncludedOperations<Slicing> : GetAllIncludedOperations<Slicing> : AllCrudOperations : AllCrudOperations;
type GetAllIncludedOperations<Slicing extends SlicingOptions<any>> = 'models' extends keyof Slicing ? Slicing extends {
  models: infer Config;
} ? '$all' extends keyof Config ? Config['$all'] extends {
  includedOperations: readonly [];
} ? '_none_' : Config['$all'] extends {
  includedOperations: readonly (infer IO)[];
} ? IO : AllCrudOperations : AllCrudOperations : AllCrudOperations : AllCrudOperations;
type GetExcludedOperations<Slicing extends SlicingOptions<any>, Model extends string> = 'models' extends keyof Slicing ? Slicing extends {
  models: infer Config;
} ? Uncapitalize<Model> extends keyof Config ? Config[Uncapitalize<Model>] extends {
  excludedOperations: readonly (infer EO)[];
} ? EO : GetAllExcludedOperations<Slicing> : GetAllExcludedOperations<Slicing> : never : never;
type GetAllExcludedOperations<Slicing extends SlicingOptions<any>> = 'models' extends keyof Slicing ? Slicing extends {
  models: infer M;
} ? '$all' extends keyof M ? M['$all'] extends {
  excludedOperations: readonly (infer EO)[];
} ? EO : never : never : never : never;
/**
 * Filters procedures based on slicing configuration.
 */
type GetSlicedProcedures<Schema extends SchemaDef, Options extends QueryOptions<Schema>> = Options['slicing'] extends infer S ? S extends SlicingOptions<Schema> ? S['includedProcedures'] extends readonly (infer IncludedProc)[] ? Exclude<Extract<IncludedProc, GetProcedureNames<Schema>>, S['excludedProcedures'] extends readonly (infer ExcludedProc)[] ? Extract<ExcludedProc, GetProcedureNames<Schema>> : never> : Exclude<GetProcedureNames<Schema>, S['excludedProcedures'] extends readonly (infer ExcludedProc)[] ? Extract<ExcludedProc, GetProcedureNames<Schema>> : never> : GetProcedureNames<Schema> : GetProcedureNames<Schema>;
/**
 * Filters filter kinds for a specific field, considering field-level slicing configuration with $all fallback.
 */
type GetSlicedFilterKindsForField<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends string, Options extends QueryOptions<Schema>> = Options extends {
  slicing: infer S;
} ? S extends SlicingOptions<Schema> ? GetFieldIncludedFilterKinds<S, Model, Field> extends infer IFK ? GetFieldExcludedFilterKinds<S, Model, Field> extends infer EFK ? '_none_' extends IFK ? never : IsNever<IFK> extends true ? IsNever<EFK> extends true ? FilterKind : Exclude<FilterKind, EFK> : Exclude<IFK, EFK> : FilterKind : FilterKind : FilterKind : FilterKind;
type GetIncludedFilterKindsFromModelConfig<ModelConfig, Field extends string> = ModelConfig extends {
  includedFilterKinds: readonly [];
} ? '_none_' : 'fields' extends keyof ModelConfig ? ModelConfig['fields'] extends infer FieldsConfig ? Field extends keyof FieldsConfig ? 'includedFilterKinds' extends keyof FieldsConfig[Field] ? FieldsConfig[Field] extends {
  includedFilterKinds: readonly [];
} ? '_none_' : FieldsConfig[Field] extends {
  includedFilterKinds: readonly (infer IFK)[];
} ? IFK : never : GetAllFieldsIncludedFilterKinds<FieldsConfig> : GetAllFieldsIncludedFilterKinds<FieldsConfig> : never : never;
type GetFieldIncludedFilterKinds<S extends SlicingOptions<any>, Model extends string, Field extends string> = S extends {
  models?: infer Config;
} ? Uncapitalize<Model> extends keyof Config ? GetIncludedFilterKindsFromModelConfig<Config[Uncapitalize<Model>], Field> : '$all' extends keyof Config ? GetIncludedFilterKindsFromModelConfig<Config['$all'], Field> : never : never;
type GetAllFieldsIncludedFilterKinds<FieldsConfig> = '$all' extends keyof FieldsConfig ? FieldsConfig['$all'] extends {
  includedFilterKinds: readonly [];
} ? '_none_' : FieldsConfig['$all'] extends {
  includedFilterKinds: readonly (infer IFK)[];
} ? IFK : never : never;
type GetExcludedFilterKindsFromModelConfig<ModelConfig, Field extends string> = 'fields' extends keyof ModelConfig ? ModelConfig['fields'] extends infer FieldsConfig ? Field extends keyof FieldsConfig ? FieldsConfig[Field] extends {
  excludedFilterKinds: readonly (infer EFK)[];
} ? EFK : GetAllFieldsExcludedFilterKinds<FieldsConfig> : GetAllFieldsExcludedFilterKinds<FieldsConfig> : never : never;
type GetFieldExcludedFilterKinds<S extends SlicingOptions<any>, Model extends string, Field extends string> = S extends {
  models?: infer Config;
} ? Uncapitalize<Model> extends keyof Config ? GetExcludedFilterKindsFromModelConfig<Config[Uncapitalize<Model>], Field> : '$all' extends keyof Config ? GetExcludedFilterKindsFromModelConfig<Config['$all'], Field> : never : never;
type GetAllFieldsExcludedFilterKinds<FieldsConfig> = '$all' extends keyof FieldsConfig ? FieldsConfig['$all'] extends {
  excludedFilterKinds: readonly (infer EFK)[];
} ? EFK : never : never;
//#endregion
//#region src/client/crud-types.d.ts
type DefaultModelResult<Schema extends SchemaDef, Model extends GetModels<Schema>, Omit = undefined, Options extends QueryOptions<Schema> = QueryOptions<Schema>, Optional = false, Array = false, IsGenericModel = ([string] extends [Model] ? true : false)> = WrapType<IsGenericModel extends true ? FlatModelResult<Schema, Model, Omit, Options> : IsDelegateModel<Schema, Model> extends true ? DelegateUnionResult<Schema, Model, Options, GetSubModels<Schema, Model>, Omit> : FlatModelResult<Schema, Model, Omit, Options>, Optional, Array>;
type ShouldOmitField<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema>, Field extends GetModelFields<Schema, Model>, Omit> = QueryLevelOmit<Schema, Model, Field, Omit> extends boolean ? QueryLevelOmit<Schema, Model, Field, Omit> : OptionsLevelOmit<Schema, Model, Field, Options> extends boolean ? OptionsLevelOmit<Schema, Model, Field, Options> : SchemaLevelOmit<Schema, Model, Field>;
type QueryLevelOmit<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends GetModelFields<Schema, Model>, Omit> = Field extends keyof Omit ? (Omit[Field] extends boolean ? Omit[Field] : undefined) : undefined;
type OptionsLevelOmit<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends GetModelFields<Schema, Model>, Options extends QueryOptions<Schema>> = Uncapitalize<Model> extends keyof Options['omit'] ? Field extends keyof Options['omit'][Uncapitalize<Model>] ? Options['omit'][Uncapitalize<Model>][Field] extends boolean ? Options['omit'][Uncapitalize<Model>][Field] : undefined : undefined : undefined;
type SchemaLevelOmit<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends GetModelFields<Schema, Model>> = GetModelField<Schema, Model, Field>['omit'] extends true ? true : false;
type FlatModelResult<Schema extends SchemaDef, Model extends GetModels<Schema>, Omit, Options extends QueryOptions<Schema>> = { [Key in NonRelationFields<Schema, Model> as ShouldOmitField<Schema, Model, Options, Key, Omit> extends true ? never : Key]: MapModelFieldType<Schema, Model, Key> };
type DelegateUnionResult<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema>, SubModel extends GetModels<Schema>, Omit = undefined, Depth extends readonly 0[] = []> = Depth['length'] extends 10 ? SubModel extends string ? FlatModelResult<Schema, SubModel, Omit, Options> & { [K in GetModelDiscriminator<Schema, Model>]: GetModelDelegateMapValue<Schema, SubModel> } : never : SubModel extends string ? IsDelegateModel<Schema, SubModel> extends true ? // sub-model is itself a delegate — recurse into its own sub-models so all
DelegateUnionResult<Schema, SubModel, Options, GetSubModels<Schema, SubModel>, Omit, [...Depth, 0]> & { [K in GetModelDiscriminator<Schema, Model>]: GetModelDelegateMapValue<Schema, SubModel> } : // leaf model — produce a flat scalar result and fix the discriminator
FlatModelResult<Schema, SubModel, Omit, Options> & { [K in GetModelDiscriminator<Schema, Model>]: GetModelDelegateMapValue<Schema, SubModel> } : never;
type ModelSelectResult<Schema extends SchemaDef, Model extends GetModels<Schema>, Select, Omit, Options extends QueryOptions<Schema>, ExtResult extends ExtResultBase<Schema> = {}> = { [Key in keyof Select as Select[Key] extends false | undefined ? never : Key extends keyof ExtractExtResult<ExtResult, Model & string> ? never : Key extends '_count' ? Select[Key] extends SelectCount<Schema, Model, Options> ? Key : never : Key extends keyof Omit ? Omit[Key] extends true ? never : Key : Key]: Key extends '_count' ? SelectCountResult<Schema, Model, Select[Key]> : Key extends NonRelationFields<Schema, Model> ? MapModelFieldType<Schema, Model, Key> : Key extends RelationFields<Schema, Model> ? ModelResult<Schema, RelationFieldType<Schema, Model, Key>, Select[Key], Options, ModelFieldIsOptional<Schema, Model, Key>, FieldIsArray<Schema, Model, Key>, ExtResult> : never };
type SelectCountResult<Schema extends SchemaDef, Model extends GetModels<Schema>, C> = C extends true ? { [Key in RelationFields<Schema, Model> as FieldIsArray<Schema, Model, Key> extends true ? Key : never]: number } : C extends {
  select: infer S;
} ? { [Key in keyof S]: number } : never;
type ModelResult<Schema extends SchemaDef, Model extends GetModels<Schema>, Args = {}, Options extends QueryOptions<Schema> = QueryOptions<Schema>, Optional = false, Array = false, ExtResult extends ExtResultBase<Schema> = {}> = WrapType<(Args extends {
  select: infer S extends object;
  omit?: infer O extends object;
} & Record<string, unknown> ? ModelSelectResult<Schema, Model, S, O, Options, ExtResult> : Args extends {
  include: infer I extends object;
  omit?: infer O extends object;
} & Record<string, unknown> ? // select all non-omitted scalar fields
DefaultModelResult<Schema, Model, O, Options, false, false> & { [Key in keyof I & RelationFields<Schema, Model> as I[Key] extends false | undefined ? never : Key]: ModelResult<Schema, RelationFieldType<Schema, Model, Key>, I[Key], Options, ModelFieldIsOptional<Schema, Model, Key>, FieldIsArray<Schema, Model, Key>, ExtResult> } & ('_count' extends keyof I ? I['_count'] extends false | undefined ? {} : {
  _count: SelectCountResult<Schema, Model, I['_count']>;
} : {}) : Args extends {
  omit: infer O;
} & Record<string, unknown> ? DefaultModelResult<Schema, Model, O, Options, false, false> : DefaultModelResult<Schema, Model, undefined, Options, false, false>) & SelectAwareExtResult<ExtResult, Model & string, Args>, Optional, Array>;
type SimplifiedResult<Schema extends SchemaDef, Model extends GetModels<Schema>, Args = {}, Options extends QueryOptions<Schema> = QueryOptions<Schema>, Optional = false, Array = false, ExtResult extends ExtResultBase<Schema> = {}> = Simplify<ModelResult<Schema, Model, Args, Options, Optional, Array, ExtResult>>;
type SimplifiedPlainResult<Schema extends SchemaDef, Model extends GetModels<Schema>, Args = {}, Options extends QueryOptions<Schema> = QueryOptions<Schema>, ExtResult extends ExtResultBase<Schema> = {}> = Simplify<ModelResult<Schema, Model, Args, Options, false, false, ExtResult>>;
type TypeDefResult<Schema extends SchemaDef, TypeDef extends GetTypeDefs<Schema>, Partial extends boolean = false> = PartialIf<Optional<{ [Key in GetTypeDefFields<Schema, TypeDef>]: MapFieldDefType<Schema, GetTypeDefField<Schema, TypeDef, Key>, Partial> }, Partial extends true ? never : keyof { [Key in GetTypeDefFields<Schema, TypeDef> as TypeDefFieldIsOptional<Schema, TypeDef, Key> extends true ? Key : never]: true }>, Partial> & Record<string, unknown>;
type BatchResult = {
  count: number;
};
type WhereInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>, ScalarOnly extends boolean = false, WithAggregations extends boolean = false> = { [Key in GetModelFields<Schema, Model> as ScalarOnly extends true ? Key extends RelationFields<Schema, Model> ? never : Key : Key]?: FieldFilter<Schema, Model, Key, Options, WithAggregations> } & {
  $expr?: (eb: ExpressionBuilder<ToKyselySchema<Schema>, Model>) => OperandExpression<SqlBool>;
} & {
  AND?: OrArray<WhereInput<Schema, Model, Options, ScalarOnly>>;
  OR?: WhereInput<Schema, Model, Options, ScalarOnly>[];
  NOT?: OrArray<WhereInput<Schema, Model, Options, ScalarOnly>>;
};
type FieldFilter<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends GetModelFields<Schema, Model>, Options extends QueryOptions<Schema>, WithAggregations extends boolean, AllowedKinds extends FilterKind = GetSlicedFilterKindsForField<Schema, Model, Field, Options>> = Field extends RelationFields<Schema, Model> ? RelationFilter<Schema, Model, Field, Options, AllowedKinds> : FieldIsArray<Schema, Model, Field> extends true ? ArrayFilter<Schema, GetModelFieldType<Schema, Model, Field>, AllowedKinds> : GetModelFieldType<Schema, Model, Field> extends GetEnums<Schema> ? EnumFilter<Schema, GetModelFieldType<Schema, Model, Field>, ModelFieldIsOptional<Schema, Model, Field>, WithAggregations, AllowedKinds> : GetModelFieldType<Schema, Model, Field> extends GetTypeDefs<Schema> ? TypedJsonFilter<Schema, GetModelFieldType<Schema, Model, Field>, FieldIsArray<Schema, Model, Field>, ModelFieldIsOptional<Schema, Model, Field>, AllowedKinds> : GetModelFieldType<Schema, Model, Field> extends 'String' ? AddFullTextFilterIfSupported<Schema, Model, Field, AllowedKinds, AddFuzzyFilterIfSupported<Schema, Model, Field, AllowedKinds, PrimitiveFilter<GetModelFieldType<Schema, Model, Field>, ModelFieldIsOptional<Schema, Model, Field>, WithAggregations, AllowedKinds>>> : PrimitiveFilter<GetModelFieldType<Schema, Model, Field>, ModelFieldIsOptional<Schema, Model, Field>, WithAggregations, AllowedKinds>;
/**
 * Conditionally augments a string-field filter with the `fuzzy` operator when:
 * 1. The `Fuzzy` filter kind is allowed for this field, AND
 * 2. The schema's provider supports fuzzy search (postgres only), AND
 * 3. The field is annotated with `@fuzzy` in the ZModel schema.
 *
 * Caller is responsible for only invoking this on String-typed fields
 * (the gate lives in `FieldFilter`).
 */
type AddFuzzyFilterIfSupported<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends GetModelFields<Schema, Model>, AllowedKinds extends FilterKind, Base> = 'Fuzzy' extends AllowedKinds ? ProviderSupportsFuzzy<Schema> extends true ? GetModelField<Schema, Model, Field>['fuzzy'] extends true ? Base & {
  /**
   * Performs a fuzzy search on the string field. Only available when
   * the schema's provider is `postgresql` (requires `pg_trgm` extension)
   * and the field is annotated with `@fuzzy` in the ZModel schema.
   * See {@link FuzzyFilterPayload} for the full options reference.
   */
  fuzzy?: FuzzyFilterPayload;
} : Base : Base : Base;
/**
 * Conditionally augments a string-field filter with the `fts` operator when:
 * 1. The `FullText` filter kind is allowed for this field, AND
 * 2. The schema's provider supports full-text search (postgres only), AND
 * 3. The field is annotated with `@fullText` in the ZModel schema.
 *
 * Caller is responsible for only invoking this on String-typed fields
 * (the gate lives in `FieldFilter`).
 */
type AddFullTextFilterIfSupported<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends GetModelFields<Schema, Model>, AllowedKinds extends FilterKind, Base> = 'FullText' extends AllowedKinds ? ProviderSupportsFullText<Schema> extends true ? GetModelField<Schema, Model, Field>['fullText'] extends true ? Base & {
  /**
   * Performs a full-text search on the string field. Only available when
   * the schema's provider is `postgresql` and the field is annotated with
   * `@fullText` in the ZModel schema.
   * See {@link FullTextFilterPayload} for the full options reference.
   */
  fts?: FullTextFilterPayload;
} : Base : Base : Base;
type EnumFilter<Schema extends SchemaDef, T extends GetEnums<Schema>, Nullable extends boolean, WithAggregations extends boolean, AllowedKinds extends FilterKind> = ('Equality' extends AllowedKinds ? NullableIf<keyof GetEnum<Schema, T>, Nullable> : never) | (('Equality' extends AllowedKinds ? {
  /**
   * Checks for equality with the specified enum value.
   */
  equals?: NullableIf<keyof GetEnum<Schema, T>, Nullable>;
  /**
   * Checks if the enum value is in the specified list of values.
   */
  in?: (keyof GetEnum<Schema, T>)[];
  /**
   * Checks if the enum value is not in the specified list of values.
   */
  notIn?: (keyof GetEnum<Schema, T>)[];
} : {}) & {
  /**
   * Builds a negated filter.
   */
  not?: EnumFilter<Schema, T, Nullable, WithAggregations, AllowedKinds>;
} & (WithAggregations extends true ? {
  /**
   * Filters against the count of records.
   */
  _count?: NumberFilter<'Int', false, false, AllowedKinds>;
  /**
   * Filters against the minimum value.
   */
  _min?: EnumFilter<Schema, T, false, false, AllowedKinds>;
  /**
   * Filters against the maximum value.
   */
  _max?: EnumFilter<Schema, T, false, false, AllowedKinds>;
} : {}));
type ArrayFilter<Schema extends SchemaDef, Type extends string, AllowedKinds extends FilterKind> = ('Equality' extends AllowedKinds ? {
  /**
   * Checks if the array equals the specified array.
   */
  equals?: MapScalarType<Schema, Type>[] | null;
} : {}) & ('List' extends AllowedKinds ? {
  /**
   * Checks if the array contains all elements of the specified array.
   */
  has?: MapScalarType<Schema, Type> | null;
  /**
   * Checks if the array contains any of the elements of the specified array.
   */
  hasEvery?: MapScalarType<Schema, Type>[];
  /**
   * Checks if the array contains some of the elements of the specified array.
   */
  hasSome?: MapScalarType<Schema, Type>[];
  /**
   * Checks if the array is empty.
   */
  isEmpty?: boolean;
} : {});
type MapScalarType<Schema extends SchemaDef, Type extends string> = Type extends GetEnums<Schema> ? keyof GetEnum<Schema, Type> : MapBaseType$1<Type>;
type PrimitiveFilter<T extends string, Nullable extends boolean, WithAggregations extends boolean, AllowedKinds extends FilterKind> = T extends 'String' ? StringFilter<Nullable, WithAggregations, AllowedKinds> : T extends 'Int' | 'Float' | 'Decimal' | 'BigInt' ? NumberFilter<T, Nullable, WithAggregations, AllowedKinds> : T extends 'Boolean' ? BooleanFilter<Nullable, WithAggregations, AllowedKinds> : T extends 'DateTime' ? DateTimeFilter<Nullable, WithAggregations, AllowedKinds> : T extends 'Bytes' ? BytesFilter<Nullable, WithAggregations, AllowedKinds> : T extends 'Json' ? JsonFilter<AllowedKinds> : never;
type CommonPrimitiveFilter<DataType, T extends BuiltinType, Nullable extends boolean, WithAggregations extends boolean, AllowedKinds extends FilterKind> = ('Equality' extends AllowedKinds ? {
  /**
   * Checks for equality with the specified value.
   */
  equals?: NullableIf<DataType, Nullable>;
  /**
   * Checks if the value is in the specified list of values.
   */
  in?: DataType[];
  /**
   * Checks if the value is not in the specified list of values.
   */
  notIn?: DataType[];
} : {}) & ('Range' extends AllowedKinds ? {
  /**
   * Checks if the value is less than the specified value.
   */
  lt?: DataType;
  /**
   * Checks if the value is less than or equal to the specified value.
   */
  lte?: DataType;
  /**
   * Checks if the value is greater than the specified value.
   */
  gt?: DataType;
  /**
   * Checks if the value is greater than or equal to the specified value.
   */
  gte?: DataType;
  /**
   * Checks if the value is between the specified values (inclusive).
   */
  between?: [start: DataType, end: DataType];
} : {}) & {
  /**
   * Builds a negated filter.
   */
  not?: PrimitiveFilter<T, Nullable, WithAggregations, AllowedKinds>;
};
type StringFilter<Nullable extends boolean, WithAggregations extends boolean, AllowedKinds extends FilterKind = FilterKind> = ('Equality' extends AllowedKinds ? NullableIf<string, Nullable> : never) | (CommonPrimitiveFilter<string, 'String', Nullable, WithAggregations, AllowedKinds> & ('Like' extends AllowedKinds ? {
  /**
   * Checks if the string contains the specified substring.
   */
  contains?: string;
  /**
   * Checks if the string starts with the specified substring.
   */
  startsWith?: string;
  /**
   * Checks if the string ends with the specified substring.
   */
  endsWith?: string;
  /**
   * Specifies the string comparison mode. Not effective for "sqlite" provider
   */
  mode?: 'default' | 'insensitive';
} : {}) & (WithAggregations extends true ? {
  /**
   * Filters against the count of records.
   */
  _count?: NumberFilter<'Int', false, false, AllowedKinds>;
  /**
   * Filters against the minimum value.
   */
  _min?: StringFilter<false, false, AllowedKinds>;
  /**
   * Filters against the maximum value.
   */
  _max?: StringFilter<false, false, AllowedKinds>;
} : {}));
type NumberFilter<T extends 'Int' | 'Float' | 'Decimal' | 'BigInt', Nullable extends boolean, WithAggregations extends boolean, AllowedKinds extends FilterKind = FilterKind> = ('Equality' extends AllowedKinds ? NullableIf<number | bigint, Nullable> : never) | (CommonPrimitiveFilter<number, T, Nullable, WithAggregations, AllowedKinds> & (WithAggregations extends true ? {
  /**
   * Filters against the count of records.
   */
  _count?: NumberFilter<'Int', false, false, AllowedKinds>;
  /**
   * Filters against the average value.
   */
  _avg?: NumberFilter<T, false, false, AllowedKinds>;
  /**
   * Filters against the sum value.
   */
  _sum?: NumberFilter<T, false, false, AllowedKinds>;
  /**
   * Filters against the minimum value.
   */
  _min?: NumberFilter<T, false, false, AllowedKinds>;
  /**
   * Filters against the maximum value.
   */
  _max?: NumberFilter<T, false, false, AllowedKinds>;
} : {}));
type DateTimeFilter<Nullable extends boolean, WithAggregations extends boolean, AllowedKinds extends FilterKind = FilterKind> = ('Equality' extends AllowedKinds ? NullableIf<Date | string, Nullable> : never) | (CommonPrimitiveFilter<Date | string, 'DateTime', Nullable, WithAggregations, AllowedKinds> & (WithAggregations extends true ? {
  /**
   * Filters against the count of records.
   */
  _count?: NumberFilter<'Int', false, false, AllowedKinds>;
  /**
   * Filters against the minimum value.
   */
  _min?: DateTimeFilter<false, false, AllowedKinds>;
  /**
   * Filters against the maximum value.
   */
  _max?: DateTimeFilter<false, false, AllowedKinds>;
} : {}));
type BytesFilter<Nullable extends boolean, WithAggregations extends boolean, AllowedKinds extends FilterKind = FilterKind> = ('Equality' extends AllowedKinds ? NullableIf<Uint8Array | Buffer, Nullable> : never) | (('Equality' extends AllowedKinds ? {
  /**
   * Checks for equality with the specified value.
   */
  equals?: NullableIf<Uint8Array, Nullable>;
  /**
   * Checks if the value is in the specified list of values.
   */
  in?: Uint8Array[];
  /**
   * Checks if the value is not in the specified list of values.
   */
  notIn?: Uint8Array[];
} : {}) & {
  /**
   * Builds a negated filter.
   */
  not?: BytesFilter<Nullable, WithAggregations, AllowedKinds>;
} & (WithAggregations extends true ? {
  /**
   * Filters against the count of records.
   */
  _count?: NumberFilter<'Int', false, false, AllowedKinds>;
  /**
   * Filters against the minimum value.
   */
  _min?: BytesFilter<false, false, AllowedKinds>;
  /**
   * Filters against the maximum value.
   */
  _max?: BytesFilter<false, false, AllowedKinds>;
} : {}));
type BooleanFilter<Nullable extends boolean, WithAggregations extends boolean, AllowedKinds extends FilterKind = FilterKind> = ('Equality' extends AllowedKinds ? NullableIf<boolean, Nullable> : never) | (('Equality' extends AllowedKinds ? {
  /**
   * Checks for equality with the specified value.
   */
  equals?: NullableIf<boolean, Nullable>;
} : {}) & {
  /**
   * Builds a negated filter.
   */
  not?: BooleanFilter<Nullable, WithAggregations, AllowedKinds>;
} & (WithAggregations extends true ? {
  /**
   * Filters against the count of records.
   */
  _count?: NumberFilter<'Int', false, false, AllowedKinds>;
  /**
   * Filters against the minimum value.
   */
  _min?: BooleanFilter<false, false, AllowedKinds>;
  /**
   * Filters against the maximum value.
   */
  _max?: BooleanFilter<false, false, AllowedKinds>;
} : {}));
type JsonFilter<AllowedKinds extends FilterKind = FilterKind> = ('Equality' extends AllowedKinds ? {
  /**
   * Checks for equality with the specified value.
   */
  equals?: JsonValue | JsonNullValues;
  /**
   * Builds a negated filter.
   */
  not?: JsonValue | JsonNullValues;
} : {}) & ('Json' extends AllowedKinds ? {
  /**
   * JSON path to select the value to filter on. If omitted, the whole JSON value is used.
   */
  path?: string;
  /**
   * Checks if the value is a string and contains the specified substring.
   */
  string_contains?: string;
  /**
   * Checks if the value is a string and starts with the specified substring.
   */
  string_starts_with?: string;
  /**
   * Checks if the value is a string and ends with the specified substring.
   */
  string_ends_with?: string;
  /**
   * String comparison mode. Not effective for "sqlite" provider
   */
  mode?: 'default' | 'insensitive';
  /**
   * Checks if the value is an array and contains the specified value.
   */
  array_contains?: JsonValue;
  /**
   * Checks if the value is an array and starts with the specified value.
   */
  array_starts_with?: JsonValue;
  /**
   * Checks if the value is an array and ends with the specified value.
   */
  array_ends_with?: JsonValue;
} : {});
type TypedJsonFilter<Schema extends SchemaDef, TypeDefName extends GetTypeDefs<Schema>, Array extends boolean, Optional extends boolean, AllowedKinds extends FilterKind> = (JsonFilter<AllowedKinds> & { [Key in GetTypeDefFields<Schema, TypeDefName>]?: never }) | (TypedJsonTypedFilter<Schema, TypeDefName, Array, AllowedKinds> & { [Key in keyof JsonFilter<AllowedKinds>]?: never }) | (Optional extends true ? null | JsonNullValues : never);
type TypedJsonTypedFilter<Schema extends SchemaDef, TypeDefName extends GetTypeDefs<Schema>, Array extends boolean, AllowedKinds extends FilterKind> = 'Json' extends AllowedKinds ? Array extends true ? ArrayTypedJsonFilter<Schema, TypeDefName, AllowedKinds> : NonArrayTypedJsonFilter<Schema, TypeDefName, AllowedKinds> : {};
type ArrayTypedJsonFilter<Schema extends SchemaDef, TypeDefName extends GetTypeDefs<Schema>, AllowedKinds extends FilterKind> = {
  some?: TypedJsonFieldsFilter<Schema, TypeDefName, AllowedKinds>;
  every?: TypedJsonFieldsFilter<Schema, TypeDefName, AllowedKinds>;
  none?: TypedJsonFieldsFilter<Schema, TypeDefName, AllowedKinds>;
};
type NonArrayTypedJsonFilter<Schema extends SchemaDef, TypeDefName extends GetTypeDefs<Schema>, AllowedKinds extends FilterKind> = {
  is?: TypedJsonFieldsFilter<Schema, TypeDefName, AllowedKinds>;
  isNot?: TypedJsonFieldsFilter<Schema, TypeDefName, AllowedKinds>;
} | TypedJsonFieldsFilter<Schema, TypeDefName, AllowedKinds>;
type TypedJsonFieldsFilter<Schema extends SchemaDef, TypeDefName extends GetTypeDefs<Schema>, AllowedKinds extends FilterKind> = { [Key in GetTypeDefFields<Schema, TypeDefName>]?: GetTypeDefFieldType<Schema, TypeDefName, Key> extends GetTypeDefs<Schema> ? TypedJsonFilter<Schema, GetTypeDefFieldType<Schema, TypeDefName, Key>, TypeDefFieldIsArray<Schema, TypeDefName, Key>, TypeDefFieldIsOptional<Schema, TypeDefName, Key>, AllowedKinds> : TypeDefFieldIsArray<Schema, TypeDefName, Key> extends true ? ArrayFilter<Schema, GetTypeDefFieldType<Schema, TypeDefName, Key>, AllowedKinds> : GetTypeDefFieldType<Schema, TypeDefName, Key> extends GetEnums<Schema> ? EnumFilter<Schema, GetTypeDefFieldType<Schema, TypeDefName, Key>, TypeDefFieldIsOptional<Schema, TypeDefName, Key>, false, AllowedKinds> : PrimitiveFilter<GetTypeDefFieldType<Schema, TypeDefName, Key>, TypeDefFieldIsOptional<Schema, TypeDefName, Key>, false, AllowedKinds> };
type SortOrder = 'asc' | 'desc';
type NullsOrder = 'first' | 'last';
type StringFields<Schema extends SchemaDef, Model extends GetModels<Schema>> = { [Key in NonRelationFields<Schema, Model>]: MapModelFieldType<Schema, Model, Key> extends string | null ? Key : never }[NonRelationFields<Schema, Model>];
/**
 * String fields that have been annotated with `@fuzzy` and are therefore eligible
 * for `_fuzzyRelevance` ordering.
 */
type FuzzyFields<Schema extends SchemaDef, Model extends GetModels<Schema>> = { [Key in StringFields<Schema, Model>]: GetModelField<Schema, Model, Key>['fuzzy'] extends true ? Key : never }[StringFields<Schema, Model>];
/**
 * Payload for the `fuzzy` string filter operator. Performs a fuzzy search using
 * PostgreSQL `pg_trgm` (only available when the schema's provider is `postgresql`).
 * Not supported on MySQL or SQLite (throws `NotSupported` at runtime).
 *
 * Modes:
 * - `'simple'` (default): trigram similarity on the whole value (operator `%`,
 *   function `similarity()`).
 * - `'word'`: word similarity — checks if the search term is approximately
 *   contained as a word inside the value (operator `<%`,
 *   function `word_similarity()`).
 * - `'strictWord'`: stricter variant of `'word'` (operator `<<%`,
 *   function `strict_word_similarity()`).
 *
 * When `threshold` is provided the function form is used
 * (`similarity() > threshold`) instead of the operator form, so the
 * `pg_trgm.*_threshold` session settings are bypassed.
 *
 * `unaccent` is opt-in (defaults to `false`) — set it to `true` to make the
 * comparison accent-insensitive. Enabling it requires the `unaccent` extension
 * to be installed on the database.
 */
type FuzzyFilterPayload = {
  /**
   * Search term to match against (must be a non-empty string).
   */
  search: string;
  /**
   * Matching mode. Defaults to `'simple'`.
   */
  mode?: 'simple' | 'word' | 'strictWord';
  /**
   * Optional similarity threshold in `[0, 1]`. When provided, the function
   * form is used and matches require `similarity > threshold`.
   */
  threshold?: number;
  /**
   * Whether to apply `unaccent()` to both sides. Defaults to `false`.
   * Set to `true` to enable accent-insensitive matching (requires the
   * `unaccent` extension on PostgreSQL).
   */
  unaccent?: boolean;
};
type FuzzyRelevanceOrderBy<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
  /**
   * Sorts by fuzzy search relevance using PostgreSQL `pg_trgm` similarity functions.
   * Not supported on MySQL or SQLite (throws `NotSupported` at runtime).
   * Cannot be combined with cursor-based pagination.
   */
  _fuzzyRelevance?: {
    /**
     * String fields annotated with `@fuzzy` to compute relevance against (must be non-empty).
     *
     * When multiple fields are provided, the row's relevance score is the
     * greatest per-field similarity, i.e. `GREATEST(similarity(field1, search), similarity(field2, search), ...)`.
     */
    fields: [FuzzyFields<Schema, Model>, ...FuzzyFields<Schema, Model>[]];
    /**
     * The search term to compute relevance for.
     */
    search: string;
    /**
     * Fuzzy matching mode used to compute relevance.
     */
    mode?: 'simple' | 'word' | 'strictWord';
    /**
     * Whether to remove accents before computing relevance.
     */
    unaccent?: boolean;
    /**
     * Sort direction.
     */
    sort: SortOrder;
  };
};
/**
 * String fields that have been annotated with `@fullText` and are therefore eligible
 * for `_ftsRelevance` ordering.
 */
type FullTextFields<Schema extends SchemaDef, Model extends GetModels<Schema>> = { [Key in StringFields<Schema, Model>]: GetModelField<Schema, Model, Key>['fullText'] extends true ? Key : never }[StringFields<Schema, Model>];
/**
 * Payload for the `fts` string filter operator. Performs full-text search using
 * PostgreSQL `to_tsvector` / `to_tsquery` (postgresql provider only).
 *
 * Query syntax follows `to_tsquery`: callers write raw `&` (AND), `|` (OR),
 * `!` (NOT), `<->` (FOLLOWED BY). Malformed queries throw at SQL execution time.
 */
type FullTextFilterPayload = {
  /**
   * Search query in `to_tsquery` syntax (must be a non-empty string).
   */
  search: string;
  /**
   * Postgres text-search configuration (e.g. `'english'`, `'simple'`). When
   * omitted, the database's `default_text_search_config` setting is used —
   * the SQL is emitted as `to_tsvector(field) @@ to_tsquery(query)` without
   * an explicit regconfig argument.
   */
  config?: string;
};
type FtsRelevanceOrderBy<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
  /**
   * Sorts by full-text-search relevance using PostgreSQL `ts_rank`.
   */
  _ftsRelevance?: {
    /**
     * String fields annotated with `@fullText` to compute relevance against (must be non-empty).
     *
     * When multiple fields are provided, the fields are concatenated with a
     * space separator and a single `ts_rank` is computed over the combined
     * document — i.e. `ts_rank(to_tsvector(concat_ws(' ', f1, f2, ...)), q)`.
     * This means an AND query (e.g. `'cat & dog'`) matches rows where the
     * terms appear across different fields, not just within the same field.
     */
    fields: [FullTextFields<Schema, Model>, ...FullTextFields<Schema, Model>[]];
    /**
     * The search term to compute relevance for (in `to_tsquery` syntax).
     */
    search: string;
    /**
     * Postgres text-search configuration. When omitted, the database's
     * `default_text_search_config` setting is used.
     */
    config?: string;
    /**
     * Sort direction.
     */
    sort: SortOrder;
  };
};
type OrderBy<Schema extends SchemaDef, Model extends GetModels<Schema>, WithRelation extends boolean, WithAggregation extends boolean> = { [Key in NonRelationFields<Schema, Model>]?: ModelFieldIsOptional<Schema, Model, Key> extends true ? SortOrder | {
  /**
   * Sort order
   */
  sort: SortOrder;
  /**
   * Treatment of null values
   */
  nulls?: NullsOrder;
} : SortOrder } & (WithRelation extends true ? { [Key in RelationFields<Schema, Model>]?: FieldIsArray<Schema, Model, Key> extends true ? {
  /**
   * Sorts by the count of related records.
   */
  _count?: SortOrder;
} : OrderBy<Schema, RelationFieldType<Schema, Model, Key>, WithRelation, WithAggregation> } : {}) & (WithAggregation extends true ? {
  /**
   * Sorts by the count of records.
   */
  _count?: OrderBy<Schema, Model, false, false>;
  /**
   * Sorts by the minimum value.
   */
  _min?: MinMaxInput<Schema, Model, SortOrder>;
  /**
   * Sorts by the maximum value.
   */
  _max?: MinMaxInput<Schema, Model, SortOrder>;
} & (NumericFields<Schema, Model> extends never ? {} : {
  /**
   * Sorts by the average value.
   */
  _avg?: SumAvgInput<Schema, Model, SortOrder>;
  /**
   * Sorts by the sum value.
   */
  _sum?: SumAvgInput<Schema, Model, SortOrder>;
}) : {});
type WhereUniqueInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema>> = AtLeast<{ [Key in keyof GetModel<Schema, Model>['uniqueFields']]?: GetModel<Schema, Model>['uniqueFields'][Key] extends Pick<FieldDef, 'type'> ? MapFieldDefType<Schema, GetModel<Schema, Model>['uniqueFields'][Key]> : { [Key1 in keyof GetModel<Schema, Model>['uniqueFields'][Key]]: GetModel<Schema, Model>['uniqueFields'][Key][Key1] extends Pick<FieldDef, 'type'> ? MapFieldDefType<Schema, GetModel<Schema, Model>['uniqueFields'][Key][Key1]> : never } } & WhereInput<Schema, Model, Options>, Extract<keyof GetModel<Schema, Model>['uniqueFields'], string>>;
type OmitInput<Schema extends SchemaDef, Model extends GetModels<Schema>> = { [Key in NonRelationFields<Schema, Model>]?: boolean };
type SelectIncludeOmit<Schema extends SchemaDef, Model extends GetModels<Schema>, AllowCount extends boolean, Options extends QueryOptions<Schema> = QueryOptions<Schema>, AllowRelation extends boolean = true, ExtResult extends ExtResultBase<Schema> = {}> = {
  /**
   * Explicitly select fields and relations to be returned by the query.
   */
  select?: (SelectInput<Schema, Model, Options, AllowCount, AllowRelation, ExtResult> & ExtResultSelectOmitFields<ExtResult, Model & string>) | null;
  /**
   * Explicitly omit fields from the query result.
   */
  omit?: (OmitInput<Schema, Model> & ExtResultSelectOmitFields<ExtResult, Model & string>) | null;
} & { [K in AllowRelation extends true ? RelationFields<Schema, Model> extends never ? never : 'include' : never]?: IncludeInput<Schema, Model, Options, AllowCount, ExtResult> | null };
type SelectInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>, AllowCount extends boolean = true, AllowRelation extends boolean = true, ExtResult extends ExtResultBase<Schema> = {}> = { [Key in NonRelationFields<Schema, Model>]?: boolean } & (AllowRelation extends true ? IncludeInput<Schema, Model, Options, AllowCount, ExtResult> : {});
type SelectCount<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema>> = boolean | {
  /**
   * Selects specific relations to count.
   */
  select: { [Key in RelationFields<Schema, Model> as FieldIsArray<Schema, Model, Key> extends true ? Key : never]?: boolean | {
    where: WhereInput<Schema, RelationFieldType<Schema, Model, Key>, Options, false>;
  } };
};
type IncludeInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>, AllowCount extends boolean = true, ExtResult extends ExtResultBase<Schema> = {}> = { [Key in RelationFields<Schema, Model> as RelationFieldType<Schema, Model, Key> extends GetSlicedModels<Schema, Options> ? Key : never]?: boolean | FindArgs<Schema, RelationFieldType<Schema, Model, Key>, Options, FieldIsArray<Schema, Model, Key>, FieldIsArray<Schema, Model, Key> extends true ? true : ModelFieldIsOptional<Schema, Model, Key> extends true ? true : false, ExtResult> } & (AllowCount extends true ? HasToManyRelations<Schema, Model> extends true ? {
  _count?: SelectCount<Schema, Model, Options>;
} : {} : {});
type Subset<T, U> = { [key in keyof T]: key extends keyof U ? T[key] : never };
type SelectSubset<T, U> = { [key in keyof T]: key extends keyof U ? T[key] : never } & (T extends {
  select: any;
  include: any;
} ? 'Please either choose `select` or `include`.' : T extends {
  select: any;
  omit: any;
} ? 'Please either choose `select` or `omit`.' : {});
type ToManyRelationFilter<in out Schema extends SchemaDef, in out Model extends GetModels<Schema>, in out Field extends RelationFields<Schema, Model>, Options extends QueryOptions<Schema>> = {
  every?: WhereInput<Schema, RelationFieldType<Schema, Model, Field>, Options>;
  some?: WhereInput<Schema, RelationFieldType<Schema, Model, Field>, Options>;
  none?: WhereInput<Schema, RelationFieldType<Schema, Model, Field>, Options>;
};
type ToOneRelationFilter<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>, Options extends QueryOptions<Schema>> = NullableIf<WhereInput<Schema, RelationFieldType<Schema, Model, Field>, Options> & {
  /**
   * Checks if the related record matches the specified filter.
   */
  is?: NullableIf<WhereInput<Schema, RelationFieldType<Schema, Model, Field>, Options>, ModelFieldIsOptional<Schema, Model, Field>>;
  /**
   * Checks if the related record does not match the specified filter.
   */
  isNot?: NullableIf<WhereInput<Schema, RelationFieldType<Schema, Model, Field>, Options>, ModelFieldIsOptional<Schema, Model, Field>>;
}, ModelFieldIsOptional<Schema, Model, Field>>;
type RelationFilter<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>, Options extends QueryOptions<Schema>, AllowedKinds extends FilterKind> = 'Relation' extends AllowedKinds ? FieldIsArray<Schema, Model, Field> extends true ? ToManyRelationFilter<Schema, Model, Field, Options> : ToOneRelationFilter<Schema, Model, Field, Options> : never;
type MapModelFieldType<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends GetModelFields<Schema, Model>> = MapFieldDefType<Schema, GetModelField<Schema, Model, Field>>;
type MapFieldDefType<Schema extends SchemaDef, T extends Pick<FieldDef, 'type' | 'optional' | 'array'>, Partial extends boolean = false> = WrapType<T['type'] extends GetEnums<Schema> ? keyof GetEnum<Schema, T['type']> : T['type'] extends GetTypeDefs<Schema> ? TypeDefResult<Schema, T['type'], Partial> & Record<string, unknown> : MapBaseType$1<T['type']>, T['optional'], T['array']>;
type OptionalFieldsForCreate<Schema extends SchemaDef, Model extends GetModels<Schema>> = keyof { [Key in GetModelFields<Schema, Model> as ModelFieldIsOptional<Schema, Model, Key> extends true ? Key : FieldHasDefault<Schema, Model, Key> extends true ? Key : FieldIsArray<Schema, Model, Key> extends true ? Key : GetModelField<Schema, Model, Key>['updatedAt'] extends true | UpdatedAtInfo ? Key : never]: GetModelField<Schema, Model, Key> };
type GetRelation<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends GetModelFields<Schema, Model>> = GetModelField<Schema, Model, Field>['relation'];
type OppositeRelation<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends GetModelFields<Schema, Model>, FT = FieldType<Schema, Model, Field>> = FT extends GetModels<Schema> ? GetRelation<Schema, Model, Field> extends RelationInfo ? GetRelation<Schema, Model, Field>['opposite'] extends GetModelFields<Schema, FT> ? Schema['models'][FT]['fields'][GetRelation<Schema, Model, Field>['opposite']]['relation'] : never : never : never;
type OppositeRelationFields<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends GetModelFields<Schema, Model>, Opposite = OppositeRelation<Schema, Model, Field>> = Opposite extends RelationInfo ? (Opposite['fields'] extends readonly string[] ? Opposite['fields'] : []) : [];
type OppositeRelationAndFK<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends GetModelFields<Schema, Model>, FT = FieldType<Schema, Model, Field>, Relation = GetModelField<Schema, Model, Field>['relation'], Opposite = (Relation extends RelationInfo ? Relation['opposite'] : never)> = FT extends GetModels<Schema> ? Opposite extends GetModelFields<Schema, FT> ? Opposite | OppositeRelationFields<Schema, Model, Field>[number] : never : never;
type FilterArgs<in out Schema extends SchemaDef, in out Model extends GetModels<Schema>, in out Options extends QueryOptions<Schema>> = {
  /**
   * Filter conditions
   */
  where?: WhereInput<Schema, Model, Options>;
};
type SortAndTakeArgs<in out Schema extends SchemaDef, in out Model extends GetModels<Schema>, in out Options extends QueryOptions<Schema>> = {
  /**
   * Number of records to skip
   */
  skip?: number;
  /**
   * Number of records to take
   */
  take?: number;
  /**
   * Order by clauses
   */
  orderBy?: OrArray<OrderBy<Schema, Model, true, false> & (ProviderSupportsFuzzy<Schema> extends true ? FuzzyRelevanceOrderBy<Schema, Model> : {}) & (ProviderSupportsFullText<Schema> extends true ? FtsRelevanceOrderBy<Schema, Model> : {})>;
  /**
   * Cursor for pagination
   */
  cursor?: WhereUniqueInput<Schema, Model, Options>;
};
type FindArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema>, Collection extends boolean, AllowFilter extends boolean = true, ExtResult extends ExtResultBase<Schema> = {}> = (Collection extends true ? SortAndTakeArgs<Schema, Model, Options> & (ProviderSupportsDistinct<Schema> extends true ? {
  /**
   * Distinct fields. Only supported by providers that natively support SQL "DISTINCT ON".
   */
  distinct?: OrArray<NonRelationFields<Schema, Model>>;
} : {}) : {}) & (AllowFilter extends true ? FilterArgs<Schema, Model, Options> : {}) & SelectIncludeOmit<Schema, Model, true, Options, true, ExtResult>;
type FindManyArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase = {}, ExtResult extends ExtResultBase<Schema> = {}> = FindArgs<Schema, Model, Options, true, true, ExtResult> & ExtractExtQueryArgs<ExtQueryArgs, 'findMany'>;
type FindFirstArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase = {}, ExtResult extends ExtResultBase<Schema> = {}> = FindArgs<Schema, Model, Options, true, true, ExtResult> & 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 = {}, ExtResult extends ExtResultBase<Schema> = {}> = {
  where: WhereUniqueInput<Schema, Model, Options>;
} & SelectIncludeOmit<Schema, Model, true, Options, true, ExtResult> & ExtractExtQueryArgs<ExtQueryArgs, 'findUnique'>;
type CreateArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase = {}, ExtResult extends ExtResultBase<Schema> = {}> = {
  data: CreateInput<Schema, Model, Options>;
} & SelectIncludeOmit<Schema, Model, true, Options, true, ExtResult> & 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 = {}, ExtResult extends ExtResultBase<Schema> = {}> = CreateManyInput<Schema, Model> & SelectIncludeOmit<Schema, Model, false, Options, false, ExtResult> & 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> }>;
type ScalarCreatePayload<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends ScalarFields<Schema, Model, false>> = ScalarFieldMutationPayload<Schema, Model, Field> | (FieldIsArray<Schema, Model, Field> extends true ? {
  set?: MapModelFieldType<Schema, Model, Field>;
} : never);
type ScalarFieldMutationPayload<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends GetModelFields<Schema, Model>> = IsJsonField<Schema, Model, Field> extends true ? ModelFieldIsOptional<Schema, Model, Field> extends true ? JsonValue | JsonNull | DbNull : JsonValue | JsonNull : IsTypedJsonField<Schema, Model, Field> extends true ? ModelFieldIsOptional<Schema, Model, Field> extends true ? MapModelFieldType<Schema, Model, Field> | JsonNull | DbNull : MapModelFieldType<Schema, Model, Field> : MapModelFieldType<Schema, Model, Field>;
type IsJsonField<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends GetModelFields<Schema, Model>> = GetModelFieldType<Schema, Model, Field> extends 'Json' ? true : false;
type IsTypedJsonField<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends GetModelFields<Schema, Model>> = GetModelFieldType<Schema, Model, Field> extends GetTypeDefs<Schema> ? true : false;
type CreateFKPayload<Schema extends SchemaDef, Model extends GetModels<Schema>> = OptionalWrap<Schema, Model, { [Key in ForeignKeyFields<Schema, Model>]: MapModelFieldType<Schema, Model, Key> }>;
type RelationModelAllowsCreate<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>> = GetModelFieldType<Schema, Model, Field> extends GetModels<Schema> ? ModelAllowsCreate<Schema, GetModelFieldType<Schema, Model, Field>> : false;
type CreateRelationFieldPayload<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>, Options extends QueryOptions<Schema>> = Omit<{
  /**
   * Connects or create a related record.
   */
  connectOrCreate?: ConnectOrCreateInput<Schema, Model, Field, Options>;
  /**
   * Creates a related record.
   */
  create?: NestedCreateInput<Schema, Model, Field, Options>;
  /**
   * Creates a batch of related records.
   */
  createMany?: NestedCreateManyInput<Schema, Model, Field>;
  /**
   * Connects an existing record.
   */
  connect?: ConnectInput<Schema, Model, Field, Options>;
}, (FieldIsArray<Schema, Model, Field> extends true ? never : 'createMany') | (RelationModelAllowsCreate<Schema, Model, Field> extends true ? never : 'create' | 'createMany' | 'connectOrCreate')>;
type CreateRelationPayload<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema>> = OptionalWrap<Schema, Model, { [Key in RelationFields<Schema, Model> as RelationFieldType<Schema, Model, Key> extends GetSlicedModels<Schema, Options> ? Key : never]: CreateRelationFieldPayload<Schema, Model, Key, Options> }>;
/**
 * Create input type that uses FK scalar fields (e.g., `authorId`) instead of
 * relation objects.
 */
type UncheckedCreateInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>> = CreateScalarPayload<Schema, Model> & CreateFKPayload<Schema, Model> & CreateWithNonOwnedRelationPayload<Schema, Model, Options>;
/**
 * Create input type that uses relation objects (e.g., `author: { connect: … }`)
 * instead of FK scalar fields.
 */
type CheckedCreateInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>> = CreateScalarPayload<Schema, Model> & CreateRelationPayload<Schema, Model, Options>;
type CreateWithNonOwnedRelationPayload<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema>> = OptionalWrap<Schema, Model, { [Key in NonOwnedRelationFields<Schema, Model> as RelationFieldType<Schema, Model, Key> extends GetSlicedModels<Schema, Options> ? Key : never]: CreateRelationFieldPayload<Schema, Model, Key, Options> }>;
type ConnectOrCreatePayload<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema>, Without extends string = never> = {
  /**
   * The unique filter to find an existing record to connect.
   */
  where: WhereUniqueInput<Schema, Model, Options>;
  /**
   * The data to create a new record if no existing record is found.
   */
  create: CreateInput<Schema, Model, Options, Without>;
};
type CreateManyInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Without extends string = never> = {
  /**
   * The data for the records to create.
   */
  data: OrArray<Omit<CreateScalarPayload<Schema, Model>, Without> & Omit<CreateFKPayload<Schema, Model>, Without>>;
  /**
   * Specifies whether to skip creating records that would violate unique constraints.
   */
  skipDuplicates?: boolean;
};
type CreateInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema>, Without extends string = never> = XOR<Omit<UncheckedCreateInput<Schema, Model, Options>, Without>, Omit<CheckedCreateInput<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>, ExtQueryArgs extends ExtQueryArgsBase = {}, ExtResult extends ExtResultBase<Schema> = {}> = {
  /**
   * The data to update the record with.
   */
  data: UpdateInput<Schema, Model, Options>;
  /**
   * The unique filter to find the record to update.
   */
  where: WhereUniqueInput<Schema, Model, Options>;
} & SelectIncludeOmit<Schema, Model, true, Options, true, ExtResult> & 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 = {}, ExtResult extends ExtResultBase<Schema> = {}> = UpdateManyPayload<Schema, Model, Options> & SelectIncludeOmit<Schema, Model, false, Options, false, ExtResult> & ExtractExtQueryArgs<ExtQueryArgs, 'updateManyAndReturn'>;
type UpdateManyPayload<in out Schema extends SchemaDef, in out Model extends GetModels<Schema>, out Options extends QueryOptions<Schema> = QueryOptions<Schema>, Without extends string = never> = {
  /**
   * The data to update the records with.
   */
  data: OrArray<UpdateScalarInput<Schema, Model, Without> & UpdateFKPayload<Schema, Model, Without>>;
  /**
   * The filter to select records to update.
   */
  where?: WhereInput<Schema, Model, Options>;
  /**
   * Limit the number of records to update.
   */
  limit?: number;
};
type UpsertArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase = {}, ExtResult extends ExtResultBase<Schema> = {}> = {
  /**
   * The data to create the record if it doesn't exist.
   */
  create: CreateInput<Schema, Model, Options>;
  /**
   * The data to update the record with if it exists.
   */
  update: UpdateInput<Schema, Model, Options>;
  /**
   * The unique filter to find the record to update.
   */
  where: WhereUniqueInput<Schema, Model, Options>;
} & SelectIncludeOmit<Schema, Model, true, Options, true, ExtResult> & ExtractExtQueryArgs<ExtQueryArgs, 'upsert'>;
type UpdateScalarInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Without extends string = never> = Omit<{ [Key in Exclude<NonRelationFields<Schema, Model>, ForeignKeyFields<Schema, Model>> as FieldIsDelegateDiscriminator<Schema, Model, Key> extends true ? never : Key]?: ScalarUpdatePayload<Schema, Model, Key> }, Without>;
type UpdateFKPayload<Schema extends SchemaDef, Model extends GetModels<Schema>, Without extends string = never> = Omit<{ [Key in ForeignKeyFields<Schema, Model>]?: MapModelFieldType<Schema, Model, Key> }, Without>;
type ScalarUpdatePayload<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends NonRelationFields<Schema, Model>> = ScalarFieldMutationPayload<Schema, Model, Field> | (Field extends NumericFields<Schema, Model> ? {
  /**
   * Sets the field to the specified value.
   */
  set?: NullableIf<number, ModelFieldIsOptional<Schema, Model, Field>>;
  /**
   * Increments the field by the specified value.
   */
  increment?: number;
  /**
   * Decrements the field by the specified value.
   */
  decrement?: number;
  /**
   * Multiplies the field by the specified value.
   */
  multiply?: number;
  /**
   * Divides the field by the specified value.
   */
  divide?: number;
} : never) | (FieldIsArray<Schema, Model, Field> extends true ? {
  /**
   * Sets the field to the specified array.
   */
  set?: MapModelFieldType<Schema, Model, Field>[];
  /**
   * Appends the specified values to the array field.
   */
  push?: OrArray<MapModelFieldType<Schema, Model, Field>, true>;
} : never);
type UpdateRelationInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema>, Without extends string = never> = Omit<{ [Key in RelationFields<Schema, Model> as RelationFieldType<Schema, Model, Key> extends GetSlicedModels<Schema, Options> ? Key : never]?: UpdateRelationFieldPayload<Schema, Model, Key, Options> }, Without>;
type UpdateNonOwnedRelationInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>> = { [Key in NonOwnedRelationFields<Schema, Model> as RelationFieldType<Schema, Model, Key> extends GetSlicedModels<Schema, Options> ? Key : never]?: UpdateRelationFieldPayload<Schema, Model, Key, Options> };
/**
 * Update input type that uses FK scalar fields (e.g., `authorId`) instead of
 * relation objects.
 */
type UncheckedUpdateInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>> = UpdateScalarInput<Schema, Model> & UpdateFKPayload<Schema, Model> & UpdateNonOwnedRelationInput<Schema, Model, Options>;
/**
 * Update input type that uses relation objects (e.g., `author: { connect: … }`)
 * instead of FK scalar fields.
 */
type CheckedUpdateInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>> = UpdateScalarInput<Schema, Model> & UpdateRelationInput<Schema, Model, Options>;
type UpdateInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema>, Without extends string = never> = XOR<Omit<UncheckedUpdateInput<Schema, Model, Options>, Without>, Omit<CheckedUpdateInput<Schema, Model, Options>, Without>>;
type UpdateRelationFieldPayload<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>, Options extends QueryOptions<Schema>> = FieldIsArray<Schema, Model, Field> extends true ? ToManyRelationUpdateInput<Schema, Model, Field, Options> : ToOneRelationUpdateInput<Schema, Model, Field, Options>;
type ToManyRelationUpdateInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>, Options extends QueryOptions<Schema>> = Omit<{
  /**
   * Creates related records.
   */
  create?: NestedCreateInput<Schema, Model, Field, Options>;
  /**
   * Creates a batch of related records.
   */
  createMany?: NestedCreateManyInput<Schema, Model, Field>;
  /**
   * Connects existing records.
   */
  connect?: ConnectInput<Schema, Model, Field, Options>;
  /**
   * Connects or create related records.
   */
  connectOrCreate?: ConnectOrCreateInput<Schema, Model, Field, Options>;
  /**
   * Disconnects related records.
   */
  disconnect?: DisconnectInput<Schema, Model, Field, Options>;
  /**
   * Updates related records.
   */
  update?: NestedUpdateInput<Schema, Model, Field, Options>;
  /**
   * Upserts related records.
   */
  upsert?: NestedUpsertInput<Schema, Model, Field, Options>;
  /**
   * Updates a batch of related records.
   */
  updateMany?: NestedUpdateManyInput<Schema, Model, Field, Options>;
  /**
   * Deletes related records.
   */
  delete?: NestedDeleteInput<Schema, Model, Field, Options>;
  /**
   * Deletes a batch of related records.
   */
  deleteMany?: NestedDeleteManyInput<Schema, Model, Field, Options>;
  /**
   * Sets the related records to the specified ones.
   */
  set?: SetRelationInput<Schema, Model, Field, Options>;
}, RelationModelAllowsCreate<Schema, Model, Field> extends true ? never : 'create' | 'createMany' | 'connectOrCreate' | 'upsert'>;
type ToOneRelationUpdateInput<in out Schema extends SchemaDef, in out Model extends GetModels<Schema>, in out Field extends RelationFields<Schema, Model>, in out Options extends QueryOptions<Schema>> = Omit<{
  /**
   * Creates a related record.
   */
  create?: NestedCreateInput<Schema, Model, Field, Options>;
  /**
   * Connects an existing record.
   */
  connect?: ConnectInput<Schema, Model, Field, Options>;
  /**
   * Connects or create a related record.
   */
  connectOrCreate?: ConnectOrCreateInput<Schema, Model, Field, Options>;
  /**
   * Updates the related record.
   */
  update?: NestedUpdateInput<Schema, Model, Field, Options>;
  /**
   * Upserts the related record.
   */
  upsert?: NestedUpsertInput<Schema, Model, Field, Options>;
} & (ModelFieldIsOptional<Schema, Model, Field> extends true ? {
  /**
   * Disconnects the related record.
   */
  disconnect?: DisconnectInput<Schema, Model, Field, Options>;
  /**
   * Deletes the related record.
   */
  delete?: NestedDeleteInput<Schema, Model, Field, Options>;
} : {}), RelationModelAllowsCreate<Schema, Model, Field> extends true ? never : 'create' | 'connectOrCreate' | 'upsert'>;
type DeleteArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase = {}, ExtResult extends ExtResultBase<Schema> = {}> = {
  /**
   * The unique filter to find the record to delete.
   */
  where: WhereUniqueInput<Schema, Model, Options>;
} & SelectIncludeOmit<Schema, Model, true, Options, true, ExtResult> & 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.
   */
  where?: WhereInput<Schema, Model, Options>;
  /**
   * Limits the number of records to delete.
   */
  limit?: number;
} & 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 } & {
  _all?: true;
};
type CountResult<Schema extends SchemaDef, _Model extends GetModels<Schema>, Args> = Args extends {
  select: infer S;
} ? S extends true ? number : { [Key in keyof S]: number } : number;
type AggregateArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase = {}> = {
  /**
   * Filter conditions
   */
  where?: WhereInput<Schema, Model, Options>;
  /**
   * Number of records to skip for the aggregation
   */
  skip?: number;
  /**
   * Number of records to take for the aggregation
   */
  take?: number;
  /**
   * Order by clauses
   */
  orderBy?: OrArray<OrderBy<Schema, Model, true, false>>;
} & {
  /**
   * Performs count aggregation.
   */
  _count?: true | CountAggregateInput<Schema, Model>;
  /**
   * Performs minimum value aggregation.
   */
  _min?: MinMaxInput<Schema, Model, true>;
  /**
   * Performs maximum value aggregation.
   */
  _max?: MinMaxInput<Schema, Model, true>;
} & (NumericFields<Schema, Model> extends never ? {} : {
  /**
   * Performs average value aggregation.
   */
  _avg?: SumAvgInput<Schema, Model, true>;
  /**
   * Performs sum value aggregation.
   */
  _sum?: SumAvgInput<Schema, Model, true>;
}) & 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> };
type SumAvgInput<Schema extends SchemaDef, Model extends GetModels<Schema>, ValueType> = { [Key in NumericFields<Schema, Model>]?: ValueType };
type MinMaxInput<Schema extends SchemaDef, Model extends GetModels<Schema>, ValueType> = { [Key in GetModelFields<Schema, Model> as FieldIsArray<Schema, Model, Key> extends true ? never : FieldIsRelation<Schema, Model, Key> extends true ? never : Key]?: ValueType };
type AggregateResult<Schema extends SchemaDef, _Model extends GetModels<Schema>, Args> = (Args extends {
  _count: infer Count;
} ? {
  /**
   * Count aggregation result
   */
  _count: AggCommonOutput<Count>;
} : {}) & (Args extends {
  _sum: infer Sum;
} ? {
  /**
   * Sum aggregation result
   */
  _sum: AggCommonOutput<Sum>;
} : {}) & (Args extends {
  _avg: infer Avg;
} ? {
  /**
   * Average aggregation result
   */
  _avg: AggCommonOutput<Avg>;
} : {}) & (Args extends {
  _min: infer Min;
} ? {
  /**
   * Minimum aggregation result
   */
  _min: AggCommonOutput<Min>;
} : {}) & (Args extends {
  _max: infer Max;
} ? {
  /**
   * Maximum aggregation result
   */
  _max: AggCommonOutput<Max>;
} : {});
type AggCommonOutput<Input> = Input extends true ? number : Input extends {} ? { [Key in keyof Input]: number } : never;
type GroupByHaving<in out Schema extends SchemaDef, in out Model extends GetModels<Schema>, out 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>, ExtQueryArgs extends ExtQueryArgsBase = {}> = {
  /**
   * Filter conditions
   */
  where?: WhereInput<Schema, Model, Options>;
  /**
   * Order by clauses
   */
  orderBy?: OrArray<OrderBy<Schema, Model, false, true>>;
  /**
   * Fields to group by
   */
  by: NonRelationFields<Schema, Model> | NonEmptyArray<NonRelationFields<Schema, Model>>;
  /**
   * Filter conditions for the grouped records
   */
  having?: GroupByHaving<Schema, Model, Options>;
  /**
   * Number of records to take for grouping
   */
  take?: number;
  /**
   * Number of records to skip for grouping
   */
  skip?: number;
  /**
   * Performs count aggregation.
   */
  _count?: true | CountAggregateInput<Schema, Model>;
  /**
   * Performs minimum value aggregation.
   */
  _min?: MinMaxInput<Schema, Model, true>;
  /**
   * Performs maximum value aggregation.
   */
  _max?: MinMaxInput<Schema, Model, true>;
} & (NumericFields<Schema, Model> extends never ? {} : {
  /**
   * Performs average value aggregation.
   */
  _avg?: SumAvgInput<Schema, Model, true>;
  /**
   * Performs sum value aggregation.
   */
  _sum?: SumAvgInput<Schema, Model, true>;
}) & ExtractExtQueryArgs<ExtQueryArgs, 'groupBy'>;
type GroupByResult<Schema extends SchemaDef, Model extends GetModels<Schema>, Args extends {
  by: unknown;
}> = Array<{ [Key in NonRelationFields<Schema, Model> as Key extends ValueOfPotentialTuple<Args['by']> ? Key : never]: MapModelFieldType<Schema, Model, Key> } & (Args extends {
  _count: infer Count;
} ? {
  /**
   * Count aggregation result
   */
  _count: AggCommonOutput<Count>;
} : {}) & (Args extends {
  _avg: infer Avg;
} ? {
  /**
   * Average aggregation result
   */
  _avg: AggCommonOutput<Avg>;
} : {}) & (Args extends {
  _sum: infer Sum;
} ? {
  /**
   * Sum aggregation result
   */
  _sum: AggCommonOutput<Sum>;
} : {}) & (Args extends {
  _min: infer Min;
} ? {
  /**
   * Minimum aggregation result
   */
  _min: AggCommonOutput<Min>;
} : {}) & (Args extends {
  _max: infer Max;
} ? {
  /**
   * Maximum aggregation result
   */
  _max: AggCommonOutput<Max>;
} : {})>;
/**
 * Maps each CRUD operation name to its argument type for a given model.
 */
type CrudArgsMap<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase = {}, ExtResult extends ExtResultBase<Schema> = {}> = {
  findMany: FindManyArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>;
  findUnique: FindUniqueArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>;
  findUniqueOrThrow: FindUniqueArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>;
  findFirst: FindFirstArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>;
  findFirstOrThrow: FindFirstArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>;
  create: CreateArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>;
  createMany: CreateManyArgs<Schema, Model, Options, ExtQueryArgs>;
  createManyAndReturn: CreateManyAndReturnArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>;
  update: UpdateArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>;
  updateMany: UpdateManyArgs<Schema, Model, Options, ExtQueryArgs>;
  updateManyAndReturn: UpdateManyAndReturnArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>;
  upsert: UpsertArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>;
  delete: DeleteArgs<Schema, Model, Options, ExtQueryArgs, ExtResult>;
  deleteMany: DeleteManyArgs<Schema, Model, Options, ExtQueryArgs>;
  count: CountArgs<Schema, Model, Options, ExtQueryArgs>;
  aggregate: AggregateArgs<Schema, Model, Options, ExtQueryArgs>;
  groupBy: GroupByArgs<Schema, Model, Options, ExtQueryArgs>;
  exists: ExistsArgs<Schema, Model, Options, ExtQueryArgs>;
};
/**
 * Maps a CRUD operation name to its argument type for a given model.
 */
type CrudArgsType<Schema extends SchemaDef, Model extends GetModels<Schema>, Op extends AllCrudOperations, Options extends QueryOptions<Schema> = QueryOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase = {}, ExtResult extends ExtResultBase<Schema> = {}> = CrudArgsMap<Schema, Model, Options, ExtQueryArgs, ExtResult>[Op];
/**
 * Maps each CRUD operation name to its return type for a given model + args.
 */
type CrudReturnMap<Schema extends SchemaDef, Model extends GetModels<Schema>, Args, Options extends QueryOptions<Schema> = QueryOptions<Schema>, ExtResult extends ExtResultBase<Schema> = {}> = {
  findMany: SimplifiedPlainResult<Schema, Model, Args, Options, ExtResult>[];
  findUnique: SimplifiedPlainResult<Schema, Model, Args, Options, ExtResult> | null;
  findUniqueOrThrow: SimplifiedPlainResult<Schema, Model, Args, Options, ExtResult>;
  findFirst: SimplifiedPlainResult<Schema, Model, Args, Options, ExtResult> | null;
  findFirstOrThrow: SimplifiedPlainResult<Schema, Model, Args, Options, ExtResult>;
  create: SimplifiedPlainResult<Schema, Model, Args, Options, ExtResult>;
  createMany: BatchResult;
  createManyAndReturn: SimplifiedPlainResult<Schema, Model, Args, Options, ExtResult>[];
  update: SimplifiedPlainResult<Schema, Model, Args, Options, ExtResult>;
  updateMany: BatchResult;
  updateManyAndReturn: SimplifiedPlainResult<Schema, Model, Args, Options, ExtResult>[];
  upsert: SimplifiedPlainResult<Schema, Model, Args, Options, ExtResult>;
  delete: SimplifiedPlainResult<Schema, Model, Args, Options, ExtResult>;
  deleteMany: BatchResult;
  count: CountResult<Schema, Model, Args>;
  aggregate: AggregateResult<Schema, Model, Args>;
  groupBy: Args extends {
    by: unknown;
  } ? GroupByResult<Schema, Model, Args> : never;
  exists: boolean;
};
/**
 * Maps a CRUD operation name to its return type for a given model + args.
 */
type CrudReturnType<Schema extends SchemaDef, Model extends GetModels<Schema>, Op extends AllCrudOperations, Args, Options extends QueryOptions<Schema> = QueryOptions<Schema>, ExtResult extends ExtResultBase<Schema> = {}> = CrudReturnMap<Schema, Model, Args, Options, ExtResult>[Op];
type ConnectInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>, Options extends QueryOptions<Schema>> = FieldIsArray<Schema, Model, Field> extends true ? OrArray<WhereUniqueInput<Schema, RelationFieldType<Schema, Model, Field>, Options>> : WhereUniqueInput<Schema, RelationFieldType<Schema, Model, Field>, Options>;
type ConnectOrCreateInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>, Options extends QueryOptions<Schema>> = FieldIsArray<Schema, Model, Field> extends true ? OrArray<ConnectOrCreatePayload<Schema, RelationFieldType<Schema, Model, Field>, Options, OppositeRelationAndFK<Schema, Model, Field>>> : ConnectOrCreatePayload<Schema, RelationFieldType<Schema, Model, Field>, Options, OppositeRelationAndFK<Schema, Model, Field>>;
type DisconnectInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>, Options extends QueryOptions<Schema>> = FieldIsArray<Schema, Model, Field> extends true ? OrArray<WhereUniqueInput<Schema, RelationFieldType<Schema, Model, Field>, Options>, true> : boolean | WhereInput<Schema, RelationFieldType<Schema, Model, Field>, Options>;
type SetRelationInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>, Options extends QueryOptions<Schema>> = OrArray<WhereUniqueInput<Schema, RelationFieldType<Schema, Model, Field>, Options>>;
type NestedUpdateInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>, Options extends QueryOptions<Schema>> = FieldIsArray<Schema, Model, Field> extends true ? OrArray<{
  /**
   * Unique filter to select the record to update.
   */
  where: WhereUniqueInput<Schema, RelationFieldType<Schema, Model, Field>, Options>;
  /**
   * The data to update the record with.
   */
  data: UpdateInput<Schema, RelationFieldType<Schema, Model, Field>, Options, OppositeRelationAndFK<Schema, Model, Field>>;
}, true> : XOR<{
  /**
   * Filter to select the record to update.
   */
  where?: WhereInput<Schema, RelationFieldType<Schema, Model, Field>, Options>;
  /**
   * The data to update the record with.
   */
  data: UpdateInput<Schema, RelationFieldType<Schema, Model, Field>, Options, OppositeRelationAndFK<Schema, Model, Field>>;
}, UpdateInput<Schema, RelationFieldType<Schema, Model, Field>, Options, OppositeRelationAndFK<Schema, Model, Field>>>;
type NestedUpsertInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>, Options extends QueryOptions<Schema>> = OrArray<{
  /**
   * Unique filter to select the record to update.
   */
  where: WhereUniqueInput<Schema, RelationFieldType<Schema, Model, Field>, Options>;
  /**
   * The data to create the record if it doesn't exist.
   */
  create: CreateInput<Schema, RelationFieldType<Schema, Model, Field>, Options, OppositeRelationAndFK<Schema, Model, Field>>;
  /**
   * The data to update the record with if it exists.
   */
  update: UpdateInput<Schema, RelationFieldType<Schema, Model, Field>, Options, OppositeRelationAndFK<Schema, Model, Field>>;
}, FieldIsArray<Schema, Model, Field>>;
type NestedUpdateManyInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>, Options extends QueryOptions<Schema>> = OrArray<UpdateManyPayload<Schema, RelationFieldType<Schema, Model, Field>, Options, OppositeRelationAndFK<Schema, Model, Field>>>;
type NestedDeleteInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>, Options extends QueryOptions<Schema>> = FieldIsArray<Schema, Model, Field> extends true ? OrArray<WhereUniqueInput<Schema, RelationFieldType<Schema, Model, Field>, Options>, true> : boolean | WhereInput<Schema, RelationFieldType<Schema, Model, Field>, Options>;
type NestedDeleteManyInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>, Options extends QueryOptions<Schema>> = OrArray<WhereInput<Schema, RelationFieldType<Schema, Model, Field>, Options, true>>;
type GetProcedureNames<Schema extends SchemaDef> = Schema extends {
  procedures: Record<string, ProcedureDef>;
} ? keyof Schema['procedures'] : never;
type GetProcedureParams<Schema extends SchemaDef, ProcName extends GetProcedureNames<Schema>> = Schema extends {
  procedures: Record<string, ProcedureDef>;
} ? Schema['procedures'][ProcName]['params'] : never;
type GetProcedure<Schema extends SchemaDef, ProcName extends GetProcedureNames<Schema>> = Schema extends {
  procedures: Record<string, ProcedureDef>;
} ? Schema['procedures'][ProcName] : never;
type _OptionalProcedureParamNames<Params> = keyof { [K in keyof Params as Params[K] extends {
  optional: true;
} ? K : never]: K };
type _RequiredProcedureParamNames<Params> = keyof { [K in keyof Params as Params[K] extends {
  optional: true;
} ? never : K]: K };
type _HasRequiredProcedureParams<Params> = _RequiredProcedureParamNames<Params> extends never ? false : true;
type MapProcedureArgsObject<Schema extends SchemaDef, Params> = Simplify<Optional<{ [K in keyof Params]: MapProcedureParam<Schema, Params[K]> }, _OptionalProcedureParamNames<Params>>>;
type ProcedureEnvelope<Schema extends SchemaDef, ProcName extends GetProcedureNames<Schema>, Params = GetProcedureParams<Schema, ProcName>> = keyof Params extends never ? {
  args?: Record<string, never>;
} : _HasRequiredProcedureParams<Params> extends true ? {
  args: MapProcedureArgsObject<Schema, Params>;
} : {
  args?: MapProcedureArgsObject<Schema, Params>;
};
type ProcedureHandlerCtx<Schema extends SchemaDef, ProcName extends GetProcedureNames<Schema>> = {
  client: ClientContract<Schema>;
} & ProcedureEnvelope<Schema, ProcName>;
/**
 * Shape of a procedure's runtime function.
 */
type ProcedureFunc<Schema extends SchemaDef, ProcName extends GetProcedureNames<Schema>> = (...args: _HasRequiredProcedureParams<GetProcedureParams<Schema, ProcName>> extends true ? [input: ProcedureEnvelope<Schema, ProcName>] : [input?: ProcedureEnvelope<Schema, ProcName>]) => MaybePromise<MapProcedureReturn<Schema, GetProcedure<Schema, ProcName>>>;
/**
 * Signature for procedure handlers configured via client options.
 */
type ProcedureHandlerFunc<Schema extends SchemaDef, ProcName extends GetProcedureNames<Schema>> = (ctx: ProcedureHandlerCtx<Schema, ProcName>) => MaybePromise<MapProcedureReturn<Schema, GetProcedure<Schema, ProcName>>>;
type MapProcedureReturn<Schema extends SchemaDef, Proc> = Proc extends {
  returnType: infer R;
} ? Proc extends {
  returnArray: true;
} ? Array<MapType<Schema, R & string>> : MapType<Schema, R & string> : never;
type MapProcedureParam<Schema extends SchemaDef, P> = P extends {
  type: infer U;
} ? OrUndefinedIf<P extends {
  array: true;
} ? Array<MapType<Schema, U & string>> : MapType<Schema, U & string>, P extends {
  optional: true;
} ? true : false> : never;
type NonOwnedRelationFields<Schema extends SchemaDef, Model extends GetModels<Schema>> = keyof { [Key in RelationFields<Schema, Model> as GetModelField<Schema, Model, Key>['relation'] extends {
  references: readonly unknown[];
} ? never : Key]: true };
type HasToManyRelations<Schema extends SchemaDef, Model extends GetModels<Schema>> = keyof { [Key in RelationFields<Schema, Model> as FieldIsArray<Schema, Model, Key> extends true ? Key : never]: true } extends never ? false : true;
type EnumValue<Schema extends SchemaDef, Enum extends GetEnums<Schema>> = GetEnum<Schema, Enum>[keyof GetEnum<Schema, Enum>];
type MapType<Schema extends SchemaDef, T extends string> = T extends keyof TypeMap ? TypeMap[T] : T extends GetModels<Schema> ? ModelResult<Schema, T> : T extends GetTypeDefs<Schema> ? TypeDefResult<Schema, T> : T extends GetEnums<Schema> ? EnumValue<Schema, T> : unknown;
type ProviderSupportsDistinct<Schema extends SchemaDef> = Schema['provider']['type'] extends 'postgresql' ? true : false;
type ProviderSupportsFuzzy<Schema extends SchemaDef> = Schema['provider']['type'] extends 'postgresql' ? true : false;
type ProviderSupportsFullText<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'] : {});
/**
 * Extracts extended result field types for a specific model from ExtResult.
 * Maps `{ needs, compute }` definitions to `{ fieldName: ReturnType<compute> }`.
 * When ExtResult is `{}`, this resolves to `{}` (no-op for intersection).
 */
type ExtractExtResult<ExtResult extends ExtResultBase, Model extends string> = Uncapitalize<Model> extends keyof ExtResult ? { [K in keyof ExtResult[Uncapitalize<Model>]]: ExtResult[Uncapitalize<Model>][K] extends {
  compute: (...args: any[]) => infer R;
} ? R : never } : {};
/**
 * Extracts extended result field names as optional boolean keys for use in select/omit inputs.
 * When ExtResult is `{}`, this resolves to `{}` (no-op for intersection).
 */
type ExtResultSelectOmitFields<ExtResult extends ExtResultBase, Model extends string> = keyof ExtResult extends never ? {} : Uncapitalize<Model> extends keyof ExtResult ? { [K in keyof ExtResult[Uncapitalize<Model>]]?: boolean } : {};
type TruthyKeys<S, Keys extends string> = { [K in Keys]: K extends keyof S ? (S[K] extends false | undefined ? never : K) : never }[Keys];
/**
 * Select/omit-aware version of ExtractExtResult.
 * - If T has `select`, only includes ext result fields that are explicitly selected.
 * - If T has `omit`, excludes ext result fields that are explicitly omitted.
 * - Otherwise, includes all ext result fields.
 */
type SelectAwareExtResult<ExtResult extends ExtResultBase, Model extends string, T> = keyof ExtResult extends never ? {} : T extends {
  select: infer S;
} ? S extends null | undefined ? ExtractExtResult<ExtResult, Model> : Pick<ExtractExtResult<ExtResult, Model>, TruthyKeys<S, Extract<keyof S & string, keyof ExtractExtResult<ExtResult, Model>>>> : T extends {
  omit: infer O;
} ? O extends null | undefined ? ExtractExtResult<ExtResult, Model> : Omit<ExtractExtResult<ExtResult, Model>, TruthyKeys<O, Extract<keyof O & string, keyof ExtractExtResult<ExtResult, Model>>>> : ExtractExtResult<ExtResult, Model>;
//#endregion
//#region src/client/diagnostics.d.ts
/**
 * Zod schema cache statistics.
 */
interface ZodCacheStats {
  /**
   * Number of cached Zod schemas.
   */
  size: number;
  /**
   * Keys of the cached Zod schemas.
   */
  keys: string[];
}
/**
 * Information about a query, used for diagnostics.
 */
interface QueryInfo {
  /**
   * Time when the query started.
   */
  startedAt: Date;
  /**
   * Duration of the query in milliseconds.
   */
  durationMs: number;
  /**
   * SQL statement of the query.
   */
  sql: string;
}
/**
 * ZenStackClient diagnostics.
 */
interface Diagnostics {
  /**
   * Statistics about the Zod schemas (used for query args validation) cache.
   */
  zodCache: ZodCacheStats;
  /**
   * Slow queries.
   */
  slowQueries: QueryInfo[];
}
//#endregion
//#region src/client/promise.d.ts
/**
 * A promise that only executes when it's awaited or .then() is called.
 */
interface ZenStackPromise<T> extends Promise<T> {
  [Symbol.toStringTag]: 'ZenStackPromise';
}
//#endregion
//#region src/client/contract.d.ts
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"
}
/**
 * Symbol used as a type-only key on `ClientContract` to brand the `ExtQueryArgs`
 * generic slot. Hidden from member-access autocomplete since symbol keys are
 * not surfaced. Consumed by `InferExtQueryArgs` to recover the slot.
 * @internal
 */
declare const ExtQueryArgsMarker: unique symbol;
/**
 * Symbol used as a type-only key on `ClientContract` to brand the `ExtResult`
 * generic slot. Consumed by `InferExtResult` to recover the slot.
 * @internal
 */
declare const ExtResultMarker: unique symbol;
/**
 * ZenStack client interface.
 *
 * Note: this alias resolves to an intersection, so it cannot carry variance annotations itself
 * (TS2637). It doesn't need them - measuring its variance recurses into {@link ModelOperations},
 * whose annotations short-circuit the expensive cascade. See {@link CommonModelOperations}.
 */
type ClientContract<Schema extends SchemaDef, Options extends ClientOptions<Schema> = ClientOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase = {}, ExtClientMembers extends ExtClientMembersBase = {}, ExtResult extends ExtResultBase<Schema> = {}> = {
  /**
   * The schema definition.
   */
  readonly $schema: Schema;
  /**
   * The client options.
   */
  readonly $options: Options; /** @internal type-only brand carrying the `ExtQueryArgs` slot for inference. */
  readonly [ExtQueryArgsMarker]?: ExtQueryArgs; /** @internal type-only brand carrying the `ExtResult` slot for inference. */
  readonly [ExtResultMarker]?: ExtResult;
  /**
   * 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<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<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<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<T>;
  /**
   * The current user identity. If the client is not bound to any user context, returns `undefined`.
   */
  get $auth(): AuthType<Schema> | undefined;
  /**
   * Returns a new client bound to the specified user identity. The original client remains unchanged.
   * Pass `undefined` to return a client without any user context.
   *
   * @example
   * ```
   * const userClient = db.$setAuth({ id: 'user-id' });
   * ```
   */
  $setAuth(auth: AuthType<Schema> | undefined): ClientContract<Schema, Options, ExtQueryArgs, ExtClientMembers, ExtResult>;
  /**
   * Returns a new client with new options applied. The original client remains unchanged.
   *
   * @example
   * ```
   * const dbNoValidation = db.$setOptions({ ...db.$options, validateInput: false });
   * ```
   */
  $setOptions<NewOptions extends ClientOptions<Schema>>(options: NewOptions): ClientContract<Schema, NewOptions, ExtQueryArgs, ExtClientMembers, ExtResult>;
  /**
   * Returns a new client enabling/disabling query args validation. The original client remains unchanged.
   *
   * @deprecated Use {@link $setOptions} instead.
   */
  $setInputValidation(enable: boolean): ClientContract<Schema, Options, ExtQueryArgs, ExtClientMembers, ExtResult>;
  /**
   * The Kysely query builder instance.
   *
   * @example
   * ```
   * db.$qb.selectFrom('User').selectAll().where('id', '=', 1).execute();
   * ```
   */
  readonly $qb: ToKysely<Schema>;
  /**
   * The raw Kysely query builder without any ZenStack enhancements.
   */
  readonly $qbRaw: AnyKysely;
  /**
   * Starts an interactive transaction.
   *
   * @example
   * ```
   * await db.$transaction(async (tx) => {
   *   const user = await tx.user.update({ where: { id: 1 }, data: { name: 'Alice' } });
   *   const post = await tx.post.create({ data: { title: 'Hello World', authorId: user.id } });
   *   return { user, posts: [post] };
   * ```
   */
  $transaction<T>(callback: (tx: TransactionClientContract<Schema, Options, ExtQueryArgs, ExtClientMembers, ExtResult>) => Promise<T>, options?: {
    isolationLevel?: TransactionIsolationLevel;
  }): Promise<T>;
  /**
   * Starts a sequential transaction that runs the provided operations in order.
   *
   * @example
   * ```
   * await db.$transaction([
   *   db.user.update({ where: { id: 1 }, data: { name: 'Alice' } }),
   *   db.post.create({ data: { title: 'Hello World', authorId: 1 } }),
   * ]);
   */
  $transaction<P extends ZenStackPromise<any>[]>(arg: [...P], options?: {
    isolationLevel?: TransactionIsolationLevel;
  }): Promise<UnwrapTuplePromises<P>>;
  /**
   * Returns a new client with the specified plugin installed. The original client remains unchanged.
   *
   * @see {@link https://zenstack.dev/docs/orm/plugins/|Plugin Documentation}
   */
  $use<PluginSchema extends SchemaDef = Schema, PluginExtQueryArgs extends ExtQueryArgsBase = {}, PluginExtClientMembers extends ExtClientMembersBase = {}, PluginExtResult extends ExtResultBase<PluginSchema> = {}, _R = {}>(plugin: RuntimePlugin<PluginSchema, PluginExtQueryArgs, PluginExtClientMembers, PluginExtResult> & {
    result?: ExtResultInferenceArgs<Schema, _R>;
  }): ClientContract<Schema, Options, ExtQueryArgs & PluginExtQueryArgs, ExtClientMembers & PluginExtClientMembers, ExtResult & PluginExtResult>;
  /**
   * Returns a new client with the specified plugin removed. The original client remains unchanged.
   */
  $unuse(pluginId: string): ClientContract<Schema, Options, ExtQueryArgs, ExtClientMembers, ExtResult>;
  /**
   * Returns a new client with all plugins removed. The original client remains unchanged.
   */
  $unuseAll(): ClientContract<Schema, Options>;
  /**
   * Eagerly connects to the database.
   */
  $connect(): Promise<void>;
  /**
   * Explicitly disconnects from the database.
   */
  $disconnect(): Promise<void>;
  /**
   * Factory for creating zod schemas to validate query args.
   */
  get $zod(): ZodSchemaFactory<Schema, QueryRelevantOptions<Schema, Options>, ExtQueryArgs>;
  /**
   * Pushes the schema to the database. For testing purposes only.
   * @private
   */
  $pushSchema(): Promise<void>;
  /**
   * Returns diagnostics information such as cache and slow query statistics.
   */
  get $diagnostics(): Promise<Diagnostics>;
} & { [Key in GetSlicedModels<Schema, QueryRelevantOptions<Schema, Options>> as Uncapitalize<Key>]: ModelOperations<Schema, Key, QueryRelevantOptions<Schema, Options>, ExtQueryArgs, ExtResult> } & ProcedureOperations<Schema, Options> & ExtClientMembers;
/**
 * The contract for a client in a transaction.
 */
type TransactionClientContract<Schema extends SchemaDef, Options extends ClientOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase, ExtClientMembers extends ExtClientMembersBase, ExtResult extends ExtResultBase<Schema> = {}> = Omit<ClientContract<Schema, Options, ExtQueryArgs, ExtClientMembers, ExtResult>, TransactionUnsupportedMethods>;
type ProcedureOperations<Schema extends SchemaDef, Options extends ClientOptions<Schema> = ClientOptions<Schema>> = Schema['procedures'] extends Record<string, ProcedureDef> ? {
  /**
   * Custom procedures.
   */
  $procs: { [Key in GetSlicedProcedures<Schema, Options>]: ProcedureFunc<Schema, Key> };
} : {};
/**
 * Creates a new ZenStack client instance.
 */
interface ClientConstructor {
  new <Schema extends SchemaDef, Options extends ClientOptions<Schema> = ClientOptions<Schema>>(schema: Schema, options: Options): ClientContract<Schema, Options>;
}
/**
 * CRUD operations.
 */
type CRUD = 'create' | 'read' | 'update' | 'delete';
/**
 * Extended CRUD operations including 'post-update'.
 */
type CRUD_EXT = CRUD | 'post-update';
/**
 * CRUD operations.
 */
declare const CRUD: readonly ["create", "read", "update", "delete"];
/**
 * Extended CRUD operations including 'post-update'.
 */
declare const CRUD_EXT: readonly ["create", "read", "update", "delete", "post-update"];
type SliceOperations<T extends Record<string, unknown>, Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema>> = Omit<{ [Key in keyof T as Key extends GetSlicedOperations<Schema, Model, Options> ? Key : never]: T[Key] }, ModelAllowsCreate<Schema, Model> extends true ? never : OperationsRequiringCreate>;
type AllModelOperations<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase, ExtResult extends ExtResultBase<Schema> = {}> = CommonModelOperations<Schema, Model, Options, ExtQueryArgs, ExtResult> & (Schema['provider']['type'] extends 'mysql' ? {} : {
  /**
   * 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 CrudArgsType<Schema, Model, 'createManyAndReturn', Options, ExtQueryArgs, ExtResult>>(args?: SelectSubset<T, CrudArgsType<Schema, Model, 'createManyAndReturn', Options, ExtQueryArgs, ExtResult>>): ZenStackPromise<CrudReturnType<Schema, Model, 'createManyAndReturn', T, Options, ExtResult>>;
  /**
   * 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 CrudArgsType<Schema, Model, 'updateManyAndReturn', Options, ExtQueryArgs, ExtResult>>(args: Subset<T, CrudArgsType<Schema, Model, 'updateManyAndReturn', Options, ExtQueryArgs, ExtResult>>): ZenStackPromise<CrudReturnType<Schema, Model, 'updateManyAndReturn', T, Options, ExtResult>>;
});
type CommonModelOperations<in out Schema extends SchemaDef, in out Model extends GetModels<Schema>, in out Options extends QueryOptions<Schema>, in out ExtQueryArgs extends ExtQueryArgsBase, out ExtResult extends ExtResultBase<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 CrudArgsType<Schema, Model, 'findMany', Options, ExtQueryArgs, ExtResult>>(args?: SelectSubset<T, CrudArgsType<Schema, Model, 'findMany', Options, ExtQueryArgs, ExtResult>>): ZenStackPromise<CrudReturnType<Schema, Model, 'findMany', T, Options, ExtResult>>;
  /**
   * Returns a uniquely identified entity.
   * @param args - query args
   * @returns a single entity or null if not found
   * @see {@link findMany}
   */
  findUnique<T extends CrudArgsType<Schema, Model, 'findUnique', Options, ExtQueryArgs, ExtResult>>(args: SelectSubset<T, CrudArgsType<Schema, Model, 'findUnique', Options, ExtQueryArgs, ExtResult>>): ZenStackPromise<CrudReturnType<Schema, Model, 'findUnique', T, Options, ExtResult>>;
  /**
   * 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 CrudArgsType<Schema, Model, 'findUniqueOrThrow', Options, ExtQueryArgs, ExtResult>>(args: SelectSubset<T, CrudArgsType<Schema, Model, 'findUniqueOrThrow', Options, ExtQueryArgs, ExtResult>>): ZenStackPromise<CrudReturnType<Schema, Model, 'findUniqueOrThrow', T, Options, ExtResult>>;
  /**
   * Returns the first entity.
   * @param args - query args
   * @returns a single entity or null if not found
   * @see {@link findMany}
   */
  findFirst<T extends CrudArgsType<Schema, Model, 'findFirst', Options, ExtQueryArgs, ExtResult>>(args?: SelectSubset<T, CrudArgsType<Schema, Model, 'findFirst', Options, ExtQueryArgs, ExtResult>>): ZenStackPromise<CrudReturnType<Schema, Model, 'findFirst', T, Options, ExtResult>>;
  /**
   * Returns the first entity or throws `NotFoundError` if not found.
   * @param args - query args
   * @returns a single entity
   * @see {@link findMany}
   */
  findFirstOrThrow<T extends CrudArgsType<Schema, Model, 'findFirstOrThrow', Options, ExtQueryArgs, ExtResult>>(args?: SelectSubset<T, CrudArgsType<Schema, Model, 'findFirstOrThrow', Options, ExtQueryArgs, ExtResult>>): ZenStackPromise<CrudReturnType<Schema, Model, 'findFirstOrThrow', T, Options, ExtResult>>;
  /**
   * 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 CrudArgsType<Schema, Model, 'create', Options, ExtQueryArgs, ExtResult>>(args: SelectSubset<T, CrudArgsType<Schema, Model, 'create', Options, ExtQueryArgs, ExtResult>>): ZenStackPromise<CrudReturnType<Schema, Model, 'create', T, Options, ExtResult>>;
  /**
   * 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 CrudArgsType<Schema, Model, 'createMany', Options, ExtQueryArgs, ExtResult>>(args?: SelectSubset<T, CrudArgsType<Schema, Model, 'createMany', Options, ExtQueryArgs, ExtResult>>): ZenStackPromise<CrudReturnType<Schema, Model, 'createMany', T, Options, ExtResult>>;
  /**
   * 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 CrudArgsType<Schema, Model, 'update', Options, ExtQueryArgs, ExtResult>>(args: SelectSubset<T, CrudArgsType<Schema, Model, 'update', Options, ExtQueryArgs, ExtResult>>): ZenStackPromise<CrudReturnType<Schema, Model, 'update', T, Options, ExtResult>>;
  /**
   * 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 CrudArgsType<Schema, Model, 'updateMany', Options, ExtQueryArgs, ExtResult>>(args: Subset<T, CrudArgsType<Schema, Model, 'updateMany', Options, ExtQueryArgs, ExtResult>>): ZenStackPromise<CrudReturnType<Schema, Model, 'updateMany', T, Options, ExtResult>>;
  /**
   * 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 CrudArgsType<Schema, Model, 'upsert', Options, ExtQueryArgs, ExtResult>>(args: SelectSubset<T, CrudArgsType<Schema, Model, 'upsert', Options, ExtQueryArgs, ExtResult>>): ZenStackPromise<CrudReturnType<Schema, Model, 'upsert', T, Options, ExtResult>>;
  /**
   * 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 CrudArgsType<Schema, Model, 'delete', Options, ExtQueryArgs, ExtResult>>(args: SelectSubset<T, CrudArgsType<Schema, Model, 'delete', Options, ExtQueryArgs, ExtResult>>): ZenStackPromise<CrudReturnType<Schema, Model, 'delete', T, Options, ExtResult>>;
  /**
   * 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 CrudArgsType<Schema, Model, 'deleteMany', Options, ExtQueryArgs, ExtResult>>(args?: Subset<T, CrudArgsType<Schema, Model, 'deleteMany', Options, ExtQueryArgs, ExtResult>>): ZenStackPromise<CrudReturnType<Schema, Model, 'deleteMany', T, Options, ExtResult>>;
  /**
   * 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 CrudArgsType<Schema, Model, 'count', Options, ExtQueryArgs, ExtResult>>(args?: Subset<T, CrudArgsType<Schema, Model, 'count', Options, ExtQueryArgs, ExtResult>>): ZenStackPromise<Simplify<CrudReturnType<Schema, Model, 'count', T, Options, ExtResult>>>;
  /**
   * 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 CrudArgsType<Schema, Model, 'aggregate', Options, ExtQueryArgs, ExtResult>>(args: Subset<T, CrudArgsType<Schema, Model, 'aggregate', Options, ExtQueryArgs, ExtResult>>): ZenStackPromise<Simplify<CrudReturnType<Schema, Model, 'aggregate', T, Options, ExtResult>>>;
  /**
   * 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 CrudArgsType<Schema, Model, 'groupBy', Options, ExtQueryArgs, ExtResult>>(args: Subset<T, CrudArgsType<Schema, Model, 'groupBy', Options, ExtQueryArgs, ExtResult>>): ZenStackPromise<Simplify<CrudReturnType<Schema, Model, 'groupBy', T, Options, ExtResult>>>;
  /**
   * Checks if an entity exists.
   * @param args - exists args
   * @returns whether a matching entity was found
   *
   * @example
   * ```ts
   * // check if a user exists
   * await db.user.exists({
   *     where: { id: 1 },
   * }); // result: `boolean`
   *
   * // check with a relation
   * await db.user.exists({
   *     where: { posts: { some: { published: true } } },
   * }); // result: `boolean`
   */
  exists<T extends CrudArgsType<Schema, Model, 'exists', Options, ExtQueryArgs, ExtResult>>(args?: Subset<T, CrudArgsType<Schema, Model, 'exists', Options, ExtQueryArgs, ExtResult>>): ZenStackPromise<CrudReturnType<Schema, Model, 'exists', T, Options, ExtResult>>;
};
type OperationsRequiringCreate = 'create' | 'createMany' | 'createManyAndReturn' | 'upsert';
type ModelOperations<in out Schema extends SchemaDef, in out Model extends GetModels<Schema>, in out Options extends QueryOptions<Schema> = ClientOptions<Schema>, in out ExtQueryArgs extends ExtQueryArgsBase = {}, out ExtResult extends ExtResultBase<Schema> = {}> = SliceOperations<AllModelOperations<Schema, Model, Options, ExtQueryArgs, ExtResult>, 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: { ... } } }
 */
type AuthModelType<Schema extends SchemaDef, Model extends GetModels<Schema>> = Partial<DefaultModelResult<Schema, Model>> & { [Key in RelationFields<Schema, Model>]?: FieldIsArray<Schema, Model, Key> extends true ? AuthModelType<Schema, RelationFieldType<Schema, Model, Key>>[] : AuthModelType<Schema, RelationFieldType<Schema, Model, Key>> };
type AuthType<Schema extends SchemaDef> = Schema['authType'] extends GetModels<Schema> ? AuthModelType<Schema, Schema['authType']> : Schema['authType'] extends GetTypeDefs<Schema> ? TypeDefResult<Schema, Schema['authType'], true> : Record<string, unknown>;
//#endregion
//#region src/client/zod/factory.d.ts
/**
 * 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>;
/**
 * Create a factory using only query options (e.g. slicing) without a full client config.
 */
declare function createQuerySchemaFactory<Schema extends SchemaDef>(schema: Schema, options?: QueryOptions<Schema>): ZodSchemaFactory<Schema>;
/**
 * 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<in out Schema extends SchemaDef, in out Options extends QueryOptions<Schema> = ClientOptions<Schema>, ExtQueryArgs extends ExtQueryArgsBase = {}> {
  private readonly schemaCache;
  private readonly schemaRegistry;
  private readonly allFilterKinds;
  private readonly schema;
  private readonly options;
  private readonly extraValidationsEnabled;
  constructor(client: ClientContract<Schema, any, ExtQueryArgs, any>);
  constructor(schema: Schema, options?: Options);
  private get plugins();
  /**
   * Returns model field entries, excluding Unsupported fields.
   */
  private getModelFields;
  private shouldIncludeRelations;
  private nextOptions;
  private getCache;
  private setCache;
  /**
   * Builds a suffix to append to schema IDs when filter variants differ from defaults.
   * Ensures different combinations of optional, array, and allowedFilterKinds produce distinct registry entries.
   */
  private filterSchemaSuffix;
  /**
   * Registers a schema in the registry under the given id.
   * Safe to call multiple times with the same id: first registration wins, subsequent ones are silently skipped.
   */
  private registerSchema;
  /**
   * Returns a JSON Schema document containing all registered Zod schemas as named definitions.
   * The returned object has the shape `{ schemas: { [id]: jsonSchema } }`.
   *
   * Eagerly builds all top-level schemas for every model so the registry is fully populated
   * before serialization.
   */
  toJSONSchema(): {
    schemas: Record<string, z.core.JSONSchema.BaseSchema>;
  };
  get cacheStats(): {
    size: number;
    keys: string[];
  };
  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 makeNullableTypedJsonMutationSchema;
  private isTypeDefType;
  private makeEnumFilterSchema;
  private makeArrayFilterSchema;
  private internalMakeArrayFilterSchema;
  private makePrimitiveFilterSchema;
  private makeJsonValueSchema;
  private makeJsonFilterSchema;
  private makeDateTimeValueSchema;
  private makeDateTimeFilterSchema;
  private makeBooleanFilterSchema;
  private makeBytesFilterSchema;
  private makeCommonPrimitiveFilterComponents;
  private makeCommonPrimitiveFilterSchema;
  private makeNumberFilterSchema;
  private makeStringFilterSchema;
  private makeStringModeSchema;
  private makeFuzzyFilterSchema;
  private makeFullTextFilterSchema;
  private makeSelectSchema;
  private makeCountSelectionSchema;
  private makeRelationSelectIncludeSchema;
  /**
   * Determines whether a field is configured to be omitted at the schema or client-options level
   * (query-level omit is excluded as it's mutually exclusive with `select`).
   */
  private isFieldOmittedByConfig;
  private makeOmitSchema;
  private addExtResultFields;
  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>>;
  private makeSumAvgInputSchema;
  private makeMinMaxInputSchema;
  makeGroupBySchema<Model extends GetModels<Schema>>(model: Model, options?: CreateSchemaOptions): ZodType<GroupByArgs<Schema, Model, Options, ExtQueryArgs>>;
  private onlyAggregationFields;
  private makeHavingSchema;
  makeProcedureArgsSchema(procName: string): ZodType;
  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();
  private get providerSupportsFullTextSearch();
  private get providerSupportsFuzzySearch();
  /**
   * 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;
  private canCreateModel;
  private isModelAllowed;
  private isProcedureAllowed;
}
//#endregion
//#region src/client/client-impl.d.ts
/**
 * ZenStack ORM client.
 */
declare const ZenStackClient: ClientConstructor;
//#endregion
//#region src/client/crud/dialects/index.d.ts
declare function getCrudDialect<Schema extends SchemaDef>(schema: Schema, options: ClientOptions<Schema>): BaseCrudDialect<Schema>;
//#endregion
//#region src/client/errors.d.ts
/**
 * Reason code for ORM errors.
 */
declare enum ORMErrorReason {
  /**
   * ORM client configuration error.
   */
  CONFIG_ERROR = "config-error",
  /**
   * Invalid input error.
   */
  INVALID_INPUT = "invalid-input",
  /**
   * The specified record was not found.
   */
  NOT_FOUND = "not-found",
  /**
   * Operation is rejected by access policy.
   */
  REJECTED_BY_POLICY = "rejected-by-policy",
  /**
   * Error was thrown by the underlying database driver.
   */
  DB_QUERY_ERROR = "db-query-error",
  /**
   * The requested operation is not supported.
   */
  NOT_SUPPORTED = "not-supported",
  /**
   * An internal error occurred.
   */
  INTERNAL_ERROR = "internal-error"
}
/**
 * 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"
}
/**
 * ZenStack ORM error.
 */
declare class ORMError extends Error {
  reason: ORMErrorReason;
  constructor(reason: ORMErrorReason, message?: string, options?: ErrorOptions);
  /**
   * The name of the model that the error pertains to.
   */
  model?: string;
  /**
   * The error code given by the underlying database driver.
   */
  dbErrorCode?: unknown;
  /**
   * The error message given by the underlying database driver.
   */
  dbErrorMessage?: string;
  /**
   * The reason code for policy rejection. Only available when `reason` is `REJECTED_BY_POLICY`.
   */
  rejectedByPolicyReason?: RejectedByPolicyReason;
  /**
   * The SQL query that was executed. Only available when `reason` is `DB_QUERY_ERROR`.
   */
  sql?: string;
  /**
   * The parameters used in the SQL query. Only available when `reason` is `DB_QUERY_ERROR`.
   */
  sqlParams?: readonly unknown[];
}
declare namespace query_utils_d_exports {
  export { ManyToManyJoinTableEndpoints, TEMP_ALIAS_PREFIX, aggregate, buildJoinPairs, ensureArray, extractFieldName, extractIdFields, extractModelName, fieldHasDefaultValue, flattenCompoundUniqueFilters, getDelegateDescendantModels, getDelegateDiscriminatorValue, getDiscriminatorField, getEnum, getField, getIdFields, getIdValues, getManyToManyJoinTable, getManyToManyRelation, getModel, getModelFields, getRelationForeignKeyFieldPairs, getTypeDef, getUniqueFields, hasModel, isEnum, isForeignKeyField, isInheritedField, isRelationField, isScalarField, isTypeDef, isUnsupportedField, makeDefaultOrderBy, requireField, requireIdFields, requireModel, requireTypeDef, stripAlias, tmpAlias };
}
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_schema0.TypeDefDef | undefined;
declare function requireModel(schema: SchemaDef, model: string): ModelDef;
declare function requireTypeDef(schema: SchemaDef, type: string): _$_zenstackhq_schema0.TypeDefDef;
declare function getField(schema: SchemaDef, model: string, field: string): FieldDef | undefined;
declare function requireField(schema: SchemaDef, modelOrType: string, field: string): FieldDef;
/**
 * Gets all model fields, by default non-relation, non-computed, non-inherited, non-unsupported fields only.
 */
declare function getModelFields(schema: SchemaDef, model: string, options?: {
  relations?: boolean;
  computed?: boolean;
  inherited?: boolean;
  unsupported?: boolean;
}): FieldDef[];
/**
 * Checks if a field is of `Unsupported` type.
 */
declare function isUnsupportedField(fieldDef: FieldDef): boolean;
declare function getIdFields<Schema extends SchemaDef>(schema: SchemaDef, model: GetModels<Schema>): readonly string[] | undefined;
declare function requireIdFields(schema: SchemaDef, model: string): readonly 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 | _$_zenstackhq_schema0.UpdatedAtInfo | undefined;
declare function isEnum(schema: SchemaDef, type: string): boolean;
declare function getEnum(schema: SchemaDef, type: string): _$_zenstackhq_schema0.EnumDef | undefined;
declare function isTypeDef(schema: SchemaDef, type: string): boolean;
declare function buildJoinPairs(schema: SchemaDef, model: string, modelAlias: string, relationField: string, relationModelAlias: string): [string, string][];
declare function makeDefaultOrderBy(schema: SchemaDef, model: string): {
  readonly [x: string]: "asc";
}[];
declare function getManyToManyRelation(schema: SchemaDef, model: string, field: string): {
  parentFkName: string;
  parentPKName: string;
  otherModel: string;
  otherField: string;
  otherFkName: string;
  otherPKName: string;
  joinTable: string;
} | undefined;
/**
 * Endpoints of an implicit many-to-many relation, identified by its join table name.
 */
interface ManyToManyJoinTableEndpoints {
  model: string;
  field: string;
  otherModel: string;
  otherField: string;
}
/**
 * Resolve the relation endpoints for an implicit many-to-many join table by its table
 * name, or `undefined` if the table is not an implicit m2m join table. The join-table
 * index is built once per schema (single pass) and reused, making this an O(1) lookup.
 * See issue #2715.
 */
declare function getManyToManyJoinTable(schema: SchemaDef, joinTableName: string): ManyToManyJoinTableEndpoints | 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 extractIdFields(entity: any, schema: SchemaDef, model: string): {
  [k: string]: unknown;
};
declare function getDiscriminatorField(schema: SchemaDef, model: string): string | undefined;
declare function getDelegateDiscriminatorValue(schema: SchemaDef, model: string): string;
declare function getDelegateDescendantModels(schema: SchemaDef, model: string, collected?: Set<ModelDef>): ModelDef[];
declare function aggregate(eb: ExpressionBuilder<any, any>, expr: Expression<any>, op: AggregateOperators): _$kysely.AggregateFunctionBuilder<any, any, string | number | bigint>;
/**
 * Strips alias from the node if it exists.
 */
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 TEMP_ALIAS_PREFIX = "$$_";
/**
 * Create an alias name for a temporary table or column name.
 */
declare function tmpAlias(name: string): string;
declare namespace schema_utils_d_exports {
  export { ExpressionVisitor, MatchingExpressionVisitor, VisitResult };
}
type VisitResult = void | {
  abort: true;
};
declare class ExpressionVisitor {
  visit(expr: Expression$1): VisitResult;
  protected visitLiteral(_e: LiteralExpression): VisitResult;
  protected visitArray(e: ArrayExpression): VisitResult;
  protected visitField(_e: FieldExpression): VisitResult;
  protected visitMember(e: MemberExpression): VisitResult;
  protected visitBinary(e: BinaryExpression): VisitResult;
  protected visitUnary(e: UnaryExpression): VisitResult;
  protected visitCall(e: CallExpression): VisitResult;
  protected visitBinding(_e: BindingExpression): VisitResult;
  protected visitThis(_e: ThisExpression): VisitResult;
  protected visitNull(_e: NullExpression): VisitResult;
}
declare class MatchingExpressionVisitor extends ExpressionVisitor {
  private predicate;
  private found;
  constructor(predicate: (expr: Expression$1) => boolean);
  find(expr: Expression$1): boolean;
  visit(expr: Expression$1): void | {
    readonly abort: true;
  };
}
//#endregion
export { AfterEntityMutationCallback, AggregateArgs, AggregateResult, AllCrudOperations, AllModelOperations, AllReadOperations, AllWriteOperations, AnyNull, AnyNullClass, AnyPlugin, AuthType, BaseCrudDialect, BatchResult, BeforeEntityMutationCallback, BooleanFilter, BytesFilter, CRUD, CRUD_EXT, CheckedCreateInput, CheckedUpdateInput, ClientConstructor, ClientContract, ClientOptions, ComputedFieldsOptions, CoreCreateOperations, CoreCrudOperations, CoreDeleteOperations, CoreReadOperations, CoreUpdateOperations, CoreWriteOperations, CountArgs, CountResult, CreateArgs, CreateInput, CreateManyAndReturnArgs, CreateManyArgs, CreateManyInput, CrudArgsMap, CrudArgsType, CrudReturnMap, CrudReturnType, DateTimeFilter, DbNull, DbNullClass, DefaultModelResult, DeleteArgs, DeleteManyArgs, EntityMutationHooksDef, ExistsArgs, ExtClientMembersBase, ExtQueryArgsBase, ExtQueryArgsMarker, ExtResultBase, ExtResultInferenceArgs, ExtResultMarker, ExtResultSelectOmitFields, ExtractExtResult, FilterKind, FindArgs, FindFirstArgs, FindManyArgs, FindUniqueArgs, FtsRelevanceOrderBy, FullTextFilterPayload, FuzzyFilterPayload, FuzzyRelevanceOrderBy, GetAllIncludedOperations, GetIncludedOperations, GetProcedure, GetProcedureNames, GetProcedureParams, GetQueryOptions, GetSlicedFilterKindsForField, GetSlicedModels, GetSlicedOperations, GetSlicedProcedures, GroupByArgs, GroupByResult, HasComputedFields, HasProcedures, IncludeInput, InputValidator, JsonArray, JsonFilter, JsonNull, JsonNullClass, JsonNullValues, JsonObject, JsonValue, kysely_utils_d_exports as KyselyUtils, MapModelFieldType, ModelAllowsCreate, ModelHasRequiredUnsupportedField, ModelOperations, ModelResult, ModelSlicingOptions, NullsOrder, NumberFilter, ORMError, ORMErrorReason, OmitConfig, OmitInput, OnKyselyQueryArgs, OnKyselyQueryCallback, OnProcedureHookContext, OperationsRequiringCreate, OrderBy, PluginAfterEntityMutationArgs, PluginBeforeEntityMutationArgs, ProcedureEnvelope, ProcedureFunc, ProcedureHandlerFunc, ProcedureOperations, ProceduresOptions, ProceedKyselyQueryFunction, QueryOptions, QueryRelevantOptions, query_utils_d_exports as QueryUtils, RejectedByPolicyReason, RuntimePlugin, schema_utils_d_exports as SchemaUtils, SelectAwareExtResult, SelectIncludeOmit, SelectInput, SelectSubset, SimplifiedPlainResult, SimplifiedResult, SlicingOptions, SortOrder, StringFilter, Subset, type ToKysely, TransactionClientContract, TransactionIsolationLevel, TypeDefResult, TypedJsonFilter, UncheckedCreateInput, UncheckedUpdateInput, UpdateArgs, UpdateInput, UpdateManyAndReturnArgs, UpdateManyArgs, UpsertArgs, WhereInput, WhereUniqueInput, ZModelFunction, ZModelFunctionContext, ZenStackClient, type ZenStackPromise, type ZodSchemaFactory, createQuerySchemaFactory, definePlugin, getCrudDialect };
//# sourceMappingURL=index.d.cts.map