@zenstackhq/orm 3.1.0 → 3.2.0

package/dist/index.d.cts

@@ -1,8 +1,9 @@
-import Decimal from 'decimal.js';
 import * as _zenstackhq_schema from '@zenstackhq/schema';
 import { SchemaDef, BuiltinType, GetModels, FieldDef, ModelDef, DataSourceProviderType, ScalarFields, ForeignKeyFields, GetModelFields, FieldHasDefault, GetModelFieldType, ModelFieldIsOptional, GetModelField, GetModel, ProcedureDef, NonRelationFields, GetEnums, GetEnum, GetTypeDefs, GetTypeDefFields, GetTypeDefField, TypeDefFieldIsOptional, RelationFields, FieldIsArray, RelationFieldType, FieldIsRelation, GetTypeDefFieldType, TypeDefFieldIsArray, FieldIsDelegateDiscriminator, FieldType, RelationInfo, FieldIsDelegateRelation, IsDelegateModel, Expression as Expression$1, LiteralExpression, ArrayExpression, FieldExpression, MemberExpression, BinaryExpression, UnaryExpression, CallExpression, ThisExpression, NullExpression } from '@zenstackhq/schema';
 import * as kysely from 'kysely';
 import { OperationNodeVisitor, OperationNode, SelectQueryNode, SelectionNode, ColumnNode, AliasNode, TableNode, FromNode, ReferenceNode, AndNode, OrNode, ValueListNode, ParensNode, JoinNode, RawNode, WhereNode, InsertQueryNode, DeleteQueryNode, ReturningNode, CreateTableNode, AddColumnNode, ColumnDefinitionNode, DropTableNode, OrderByNode, OrderByItemNode, GroupByNode, GroupByItemNode, UpdateQueryNode, ColumnUpdateNode, LimitNode, OffsetNode, OnConflictNode, OnDuplicateKeyNode, CheckConstraintNode, DataTypeNode, SelectAllNode, IdentifierNode, SchemableIdentifierNode, ValueNode, PrimitiveValueListNode, OperatorNode, CreateIndexNode, DropIndexNode, ListNode, PrimaryKeyConstraintNode, UniqueConstraintNode, ReferencesNode, WithNode, CommonTableExpressionNode, CommonTableExpressionNameNode, HavingNode, CreateSchemaNode, DropSchemaNode, AlterTableNode, DropColumnNode, RenameColumnNode, AlterColumnNode, ModifyColumnNode, AddConstraintNode, DropConstraintNode, ForeignKeyConstraintNode, CreateViewNode, DropViewNode, GeneratedNode, DefaultValueNode, OnNode, ValuesNode, SelectModifierNode, CreateTypeNode, DropTypeNode, ExplainNode, DefaultInsertValueNode, AggregateFunctionNode, OverNode, PartitionByNode, PartitionByItemNode, SetOperationNode, BinaryOperationNode, UnaryOperationNode, UsingNode, FunctionNode, CaseNode, WhenNode, JSONReferenceNode, JSONPathNode, JSONPathLegNode, JSONOperatorChainNode, TupleNode, MergeQueryNode, MatchedNode, AddIndexNode, CastNode, FetchNode, TopNode, OutputNode, RenameConstraintNode, RefreshMaterializedViewNode, OrActionNode, CollateNode, Kysely, ExpressionBuilder, SelectQueryBuilder, Expression, SqlBool, ExpressionWrapper, Generated, QueryId, RootOperationNode, QueryResult, UnknownRow, Dialect, KyselyConfig, OperandExpression } from 'kysely';
+import Decimal from 'decimal.js';
+import { z } from 'zod';
 
 declare class DefaultOperationNodeVisitor extends OperationNodeVisitor {
     protected defaultVisit(node: OperationNode): void;
@@ -154,6 +155,12 @@ type TypeMap = {
     DateTime: Date;
     Bytes: Uint8Array;
     Json: JsonValue;
+    Null: null;
+    Object: Record<string, unknown>;
+    Any: unknown;
+    Unsupported: unknown;
+    Void: void;
+    Undefined: undefined;
 };
 type MapBaseType$1<T extends string> = T extends keyof TypeMap ? TypeMap[T] : unknown;
 type OrArray<T, IF extends boolean = true> = IF extends true ? T | T[] : T;
@@ -196,7 +203,7 @@ declare abstract class BaseCrudDialect<Schema extends SchemaDef> {
     protected eb: ExpressionBuilder<any, any>;
     constructor(schema: Schema, options: ClientOptions<Schema>);
     transformPrimitive(value: unknown, _type: BuiltinType, _forArrayField: boolean): unknown;
-    transformOutput(value: unknown, _type: BuiltinType): unknown;
+    transformOutput(value: unknown, _type: BuiltinType, _array: boolean): unknown;
     buildSelectModel(model: string, modelAlias: string): SelectQueryBuilder<any, any, {}>;
     buildFilterSortTake(model: string, args: FindArgs<Schema, GetModels<Schema>, true>, query: SelectQueryBuilder<any, any, {}>, modelAlias: string): SelectQueryBuilder<any, any, {}>;
     buildFilter(model: string, modelAlias: string, where: boolean | object | undefined): Expression<SqlBool>;
@@ -314,7 +321,122 @@ 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>;
 
-type CoreCrudOperation = 'findMany' | 'findUnique' | 'findFirst' | 'create' | 'createMany' | 'createManyAndReturn' | 'update' | 'updateMany' | 'updateManyAndReturn' | 'upsert' | 'delete' | 'deleteMany' | 'count' | 'aggregate' | 'groupBy';
+declare class InputValidator<Schema extends SchemaDef> {
+    private readonly client;
+    constructor(client: ClientContract<Schema>);
+    private get schema();
+    private get options();
+    private get extraValidationsEnabled();
+    validateProcedureInput(proc: string, input: unknown): unknown;
+    private makeProcedureParamSchema;
+    validateFindArgs(model: GetModels<Schema>, args: unknown, options: {
+        unique: boolean;
+        findOne: boolean;
+    }): FindArgs<Schema, GetModels<Schema>, true> | undefined;
+    validateExistsArgs(model: GetModels<Schema>, args: unknown): ExistsArgs<Schema, GetModels<Schema>> | undefined;
+    validateCreateArgs(model: GetModels<Schema>, args: unknown): CreateArgs<Schema, GetModels<Schema>>;
+    validateCreateManyArgs(model: GetModels<Schema>, args: unknown): CreateManyArgs<Schema, GetModels<Schema>>;
+    validateCreateManyAndReturnArgs(model: GetModels<Schema>, args: unknown): CreateManyAndReturnArgs<Schema, GetModels<Schema>> | undefined;
+    validateUpdateArgs(model: GetModels<Schema>, args: unknown): UpdateArgs<Schema, GetModels<Schema>>;
+    validateUpdateManyArgs(model: GetModels<Schema>, args: unknown): UpdateManyArgs<Schema, GetModels<Schema>>;
+    validateUpdateManyAndReturnArgs(model: GetModels<Schema>, args: unknown): UpdateManyAndReturnArgs<Schema, GetModels<Schema>>;
+    validateUpsertArgs(model: GetModels<Schema>, args: unknown): UpsertArgs<Schema, GetModels<Schema>>;
+    validateDeleteArgs(model: GetModels<Schema>, args: unknown): DeleteArgs<Schema, GetModels<Schema>>;
+    validateDeleteManyArgs(model: GetModels<Schema>, args: unknown): DeleteManyArgs<Schema, GetModels<Schema>> | undefined;
+    validateCountArgs(model: GetModels<Schema>, args: unknown): CountArgs<Schema, GetModels<Schema>> | undefined;
+    validateAggregateArgs(model: GetModels<Schema>, args: unknown): AggregateArgs<Schema, GetModels<Schema>>;
+    validateGroupByArgs(model: GetModels<Schema>, args: unknown): GroupByArgs<Schema, GetModels<Schema>>;
+    private getSchemaCache;
+    private setSchemaCache;
+    private validate;
+    private makeFindSchema;
+    private makeExistsSchema;
+    private makeScalarSchema;
+    private makeEnumSchema;
+    private makeTypeDefSchema;
+    private makeWhereSchema;
+    private makeTypedJsonFilterSchema;
+    private isTypeDefType;
+    private makeEnumFilterSchema;
+    private makeArrayFilterSchema;
+    private internalMakeArrayFilterSchema;
+    private makePrimitiveFilterSchema;
+    private makeJsonValueSchema;
+    private makeJsonFilterSchema;
+    private makeDateTimeFilterSchema;
+    private makeBooleanFilterSchema;
+    private makeBytesFilterSchema;
+    private makeCommonPrimitiveFilterComponents;
+    private makeCommonPrimitiveFilterSchema;
+    private makeNumberFilterSchema;
+    private makeStringFilterSchema;
+    private makeStringModeSchema;
+    private makeSelectSchema;
+    private makeCountSelectionSchema;
+    private makeRelationSelectIncludeSchema;
+    private makeOmitSchema;
+    private makeIncludeSchema;
+    private makeOrderBySchema;
+    private makeDistinctSchema;
+    private makeCursorSchema;
+    private makeCreateSchema;
+    private makeCreateManySchema;
+    private makeCreateManyAndReturnSchema;
+    private makeCreateDataSchema;
+    private isDelegateDiscriminator;
+    private makeRelationManipulationSchema;
+    private makeSetDataSchema;
+    private makeConnectDataSchema;
+    private makeDisconnectDataSchema;
+    private makeDeleteRelationDataSchema;
+    private makeConnectOrCreateDataSchema;
+    private makeCreateManyDataSchema;
+    private makeUpdateSchema;
+    private makeUpdateManySchema;
+    private makeUpdateManyAndReturnSchema;
+    private makeUpsertSchema;
+    private makeUpdateDataSchema;
+    private makeDeleteSchema;
+    private makeDeleteManySchema;
+    makeCountSchema(model: GetModels<Schema>): z.ZodOptional<z.ZodObject<{
+        where: z.ZodOptional<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        skip: z.ZodOptional<z.ZodNumber>;
+        take: z.ZodOptional<z.ZodNumber>;
+        orderBy: z.ZodOptional<z.ZodObject<Record<string, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>, z.core.$strict>> | z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<Record<string, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>, z.core.$strict>, z.ZodArray<z.ZodObject<Record<string, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>, z.core.$strict>>]>>;
+        select: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodObject<{
+            _all: z.ZodOptional<z.ZodLiteral<true>>;
+        }, z.core.$strict>]>>;
+    }, z.core.$strip>>;
+    private makeCountAggregateInputSchema;
+    makeAggregateSchema(model: GetModels<Schema>): z.ZodOptional<z.ZodObject<{
+        where: z.ZodOptional<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        skip: z.ZodOptional<z.ZodNumber>;
+        take: z.ZodOptional<z.ZodNumber>;
+        orderBy: z.ZodOptional<z.ZodObject<Record<string, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>, z.core.$strict>> | z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<Record<string, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>, z.core.$strict>, z.ZodArray<z.ZodObject<Record<string, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>, z.core.$strict>>]>>;
+        _count: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodObject<{
+            _all: z.ZodOptional<z.ZodLiteral<true>>;
+        }, z.core.$strict>]>>;
+        _avg: z.ZodOptional<z.ZodObject<Record<string, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>, z.core.$strict>>;
+        _sum: z.ZodOptional<z.ZodObject<Record<string, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>, z.core.$strict>>;
+        _min: z.ZodOptional<z.ZodObject<Record<string, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>, z.core.$strict>>;
+        _max: z.ZodOptional<z.ZodObject<Record<string, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>, z.core.$strict>>;
+    }, z.core.$strip>>;
+    makeSumAvgInputSchema(model: GetModels<Schema>): z.ZodObject<Record<string, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>, z.core.$strict>;
+    makeMinMaxInputSchema(model: GetModels<Schema>): z.ZodObject<Record<string, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>, z.core.$strict>;
+    private makeGroupBySchema;
+    private onlyAggregationFields;
+    private makeHavingSchema;
+    private makeSkipSchema;
+    private makeTakeSchema;
+    private refineForSelectIncludeMutuallyExclusive;
+    private refineForSelectOmitMutuallyExclusive;
+    private nullableIf;
+    private orArray;
+    private isNumericField;
+    private get providerSupportsCaseSensitivity();
+}
+
+type CoreCrudOperation = 'findMany' | 'findUnique' | 'findFirst' | 'create' | 'createMany' | 'createManyAndReturn' | 'update' | 'updateMany' | 'updateManyAndReturn' | 'upsert' | 'delete' | 'deleteMany' | 'count' | 'aggregate' | 'groupBy' | 'exists';
 type AllCrudOperation = CoreCrudOperation | 'findUniqueOrThrow' | 'findFirstOrThrow';
 
 /**
@@ -342,6 +464,10 @@ interface RuntimePlugin<Schema extends SchemaDef = SchemaDef> {
      * Intercepts an ORM query.
      */
     onQuery?: OnQueryCallback<Schema>;
+    /**
+     * Intercepts a procedure invocation.
+     */
+    onProcedure?: OnProcedureCallback<Schema>;
     /**
      * Intercepts an entity mutation.
      */
@@ -356,6 +482,32 @@ interface RuntimePlugin<Schema extends SchemaDef = SchemaDef> {
  */
 declare function definePlugin<Schema extends SchemaDef>(plugin: RuntimePlugin<Schema>): RuntimePlugin<Schema>;
 
+type OnProcedureCallback<Schema extends SchemaDef> = (ctx: OnProcedureHookContext<Schema>) => Promise<unknown>;
+type OnProcedureHookContext<Schema extends SchemaDef> = {
+    /**
+     * 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> = {
     /**
@@ -560,7 +712,7 @@ type HasComputedFields<Schema extends SchemaDef> = string extends GetModels<Sche
 type ProceduresOptions<Schema extends SchemaDef> = Schema extends {
     procedures: Record<string, ProcedureDef>;
 } ? {
-    [Key in keyof Schema['procedures']]: PrependParameter<ClientContract<Schema>, ProcedureFunc<Schema, Schema['procedures'][Key]>>;
+    [Key in GetProcedureNames<Schema>]: ProcedureHandlerFunc<Schema, Key>;
 } : {};
 type HasProcedures<Schema extends SchemaDef> = Schema extends {
     procedures: Record<string, ProcedureDef>;
@@ -1040,6 +1192,7 @@ type FindArgs<Schema extends SchemaDef, Model extends GetModels<Schema>, Collect
 } : {}) & (AllowFilter extends true ? FilterArgs<Schema, Model> : {}) & SelectIncludeOmit<Schema, Model, Collection>;
 type FindManyArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = FindArgs<Schema, Model, true>;
 type FindFirstArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = FindArgs<Schema, Model, true>;
+type ExistsArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = FilterArgs<Schema, Model>;
 type FindUniqueArgs<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
     where: WhereUniqueInput<Schema, Model>;
 } & SelectIncludeOmit<Schema, Model, true>;
@@ -1513,6 +1666,59 @@ type NestedUpsertInput<Schema extends SchemaDef, Model extends GetModels<Schema>
 type NestedUpdateManyInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>> = OrArray<UpdateManyPayload<Schema, RelationFieldType<Schema, Model, Field>, OppositeRelationAndFK<Schema, Model, Field>>>;
 type NestedDeleteInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>> = FieldIsArray<Schema, Model, Field> extends true ? OrArray<WhereUniqueInput<Schema, RelationFieldType<Schema, Model, Field>>, true> : boolean | WhereInput<Schema, RelationFieldType<Schema, Model, Field>>;
 type NestedDeleteManyInput<Schema extends SchemaDef, Model extends GetModels<Schema>, Field extends RelationFields<Schema, Model>> = OrArray<WhereInput<Schema, RelationFieldType<Schema, Model, Field>, true>>;
+type GetProcedureNames<Schema extends SchemaDef> = Schema extends {
+    procedures: Record<string, ProcedureDef>;
+} ? keyof Schema['procedures'] : never;
+type GetProcedureParams<Schema extends SchemaDef, ProcName extends GetProcedureNames<Schema>> = Schema extends {
+    procedures: Record<string, ProcedureDef>;
+} ? Schema['procedures'][ProcName]['params'] : never;
+type GetProcedure<Schema extends SchemaDef, ProcName extends GetProcedureNames<Schema>> = Schema extends {
+    procedures: Record<string, ProcedureDef>;
+} ? Schema['procedures'][ProcName] : never;
+type _OptionalProcedureParamNames<Params> = keyof {
+    [K in keyof Params as Params[K] extends {
+        optional: true;
+    } ? K : never]: K;
+};
+type _RequiredProcedureParamNames<Params> = keyof {
+    [K in keyof Params as Params[K] extends {
+        optional: true;
+    } ? never : K]: K;
+};
+type _HasRequiredProcedureParams<Params> = _RequiredProcedureParamNames<Params> extends never ? false : true;
+type MapProcedureArgsObject<Schema extends SchemaDef, Params> = Simplify<Optional<{
+    [K in keyof Params]: MapProcedureParam<Schema, Params[K]>;
+}, _OptionalProcedureParamNames<Params>>>;
+type ProcedureEnvelope<Schema extends SchemaDef, ProcName extends GetProcedureNames<Schema>, Params = GetProcedureParams<Schema, ProcName>> = keyof Params extends never ? {
+    args?: Record<string, never>;
+} : _HasRequiredProcedureParams<Params> extends true ? {
+    args: MapProcedureArgsObject<Schema, Params>;
+} : {
+    args?: MapProcedureArgsObject<Schema, Params>;
+};
+type ProcedureHandlerCtx<Schema extends SchemaDef, ProcName extends GetProcedureNames<Schema>> = {
+    client: ClientContract<Schema>;
+} & ProcedureEnvelope<Schema, ProcName>;
+/**
+ * Shape of a procedure's runtime function.
+ */
+type ProcedureFunc<Schema extends SchemaDef, ProcName extends GetProcedureNames<Schema>> = (...args: _HasRequiredProcedureParams<GetProcedureParams<Schema, ProcName>> extends true ? [input: ProcedureEnvelope<Schema, ProcName>] : [input?: ProcedureEnvelope<Schema, ProcName>]) => MaybePromise<MapProcedureReturn<Schema, GetProcedure<Schema, ProcName>>>;
+/**
+ * Signature for procedure handlers configured via client options.
+ */
+type ProcedureHandlerFunc<Schema extends SchemaDef, ProcName extends GetProcedureNames<Schema>> = (ctx: ProcedureHandlerCtx<Schema, ProcName>) => MaybePromise<MapProcedureReturn<Schema, GetProcedure<Schema, ProcName>>>;
+type MapProcedureReturn<Schema extends SchemaDef, Proc> = Proc extends {
+    returnType: infer R;
+} ? Proc extends {
+    returnArray: true;
+} ? Array<MapType<Schema, R & string>> : MapType<Schema, R & string> : never;
+type MapProcedureParam<Schema extends SchemaDef, P> = P extends {
+    type: infer U;
+} ? OrUndefinedIf<P extends {
+    array: true;
+} ? Array<MapType<Schema, U & string>> : MapType<Schema, U & string>, P extends {
+    optional: true;
+} ? true : false> : never;
 type NonOwnedRelationFields<Schema extends SchemaDef, Model extends GetModels<Schema>> = keyof {
     [Key in RelationFields<Schema, Model> as GetModelField<Schema, Model, Key>['relation'] extends {
         references: readonly unknown[];
@@ -1521,6 +1727,8 @@ type NonOwnedRelationFields<Schema extends SchemaDef, Model extends GetModels<Sc
 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;
 
 /**
  * A promise that only executes when it's awaited or .then() is called.
@@ -1660,34 +1868,19 @@ type ClientContract<Schema extends SchemaDef, Options extends ClientOptions<Sche
     $pushSchema(): Promise<void>;
 } & {
     [Key in GetModels<Schema> as Uncapitalize<Key>]: ModelOperations<Schema, Key, ToQueryOptions<Options>>;
-} & Procedures<Schema>;
+} & ProcedureOperations<Schema>;
 /**
  * The contract for a client in a transaction.
  */
 type TransactionClientContract<Schema extends SchemaDef, Options extends ClientOptions<Schema>> = Omit<ClientContract<Schema, Options>, TransactionUnsupportedMethods>;
-type _TypeMap = {
-    String: string;
-    Int: number;
-    Float: number;
-    BigInt: bigint;
-    Decimal: Decimal;
-    Boolean: boolean;
-    DateTime: Date;
-};
-type MapType<Schema extends SchemaDef, T extends string> = T extends keyof _TypeMap ? _TypeMap[T] : T extends GetModels<Schema> ? ModelResult<Schema, T> : unknown;
-type Procedures<Schema extends SchemaDef> = Schema['procedures'] extends Record<string, ProcedureDef> ? {
-    $procedures: {
-        [Key in keyof Schema['procedures']]: ProcedureFunc<Schema, Schema['procedures'][Key]>;
+type ProcedureOperations<Schema extends SchemaDef> = Schema['procedures'] extends Record<string, ProcedureDef> ? {
+    /**
+     * Custom procedures.
+     */
+    $procs: {
+        [Key in GetProcedureNames<Schema>]: ProcedureFunc<Schema, Key>;
     };
 } : {};
-type ProcedureFunc<Schema extends SchemaDef, Proc extends ProcedureDef> = (...args: MapProcedureParams<Schema, Proc['params']>) => Promise<MapType<Schema, Proc['returnType']>>;
-type MapProcedureParams<Schema extends SchemaDef, Params> = {
-    [P in keyof Params]: Params[P] extends {
-        type: infer U;
-    } ? OrUndefinedIf<MapType<Schema, U & string>, Params[P] extends {
-        optional: true;
-    } ? true : false> : never;
-};
 /**
  * Creates a new ZenStack client instance.
  */
@@ -2213,6 +2406,24 @@ type AllModelOperations<Schema extends SchemaDef, Model extends GetModels<Schema
      * });
      */
     groupBy<T extends GroupByArgs<Schema, Model>>(args: Subset<T, GroupByArgs<Schema, Model>>): ZenStackPromise<Schema, Simplify<GroupByResult<Schema, Model, T>>>;
+    /**
+     * 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 ExistsArgs<Schema, Model>>(args?: Subset<T, ExistsArgs<Schema, Model>>): ZenStackPromise<Schema, boolean>;
 };
 type OperationsIneligibleForDelegateModels = 'create' | 'createMany' | 'createManyAndReturn' | 'upsert';
 type ModelOperations<Schema extends SchemaDef, Model extends GetModels<Schema>, Options extends QueryOptions<Schema> = QueryOptions<Schema>> = Omit<AllModelOperations<Schema, Model, Options>, IsDelegateModel<Schema, Model> extends true ? OperationsIneligibleForDelegateModels : never>;
@@ -2457,4 +2668,4 @@ declare namespace schemaUtils {
   export { schemaUtils_ExpressionVisitor as ExpressionVisitor, schemaUtils_MatchingExpressionVisitor as MatchingExpressionVisitor, type schemaUtils_VisitResult as VisitResult };
 }
 
-export { type AfterEntityMutationCallback, type AggregateArgs, type AggregateResult, type AllModelOperations, AnyNull, AnyNullClass, type AuthType, BaseCrudDialect, type BatchResult, type BeforeEntityMutationCallback, type BooleanFilter, type BytesFilter, CRUD, CRUD_EXT, type ClientConstructor, type ClientContract, type ClientOptions, type ComputedFieldsOptions, type CountArgs, type CountResult, type CreateArgs, type CreateInput, type CreateManyAndReturnArgs, type CreateManyArgs, type CreateManyInput, type CoreCrudOperation as CrudOperation, type DateTimeFilter, DbNull, DbNullClass, type DefaultModelResult, type DeleteArgs, type DeleteManyArgs, type EntityMutationHooksDef, type FindArgs, type FindFirstArgs, type FindManyArgs, type FindUniqueArgs, type GroupByArgs, type GroupByResult, type HasComputedFields, type HasProcedures, type IncludeInput, type JsonArray, type JsonFilter, JsonNull, JsonNullClass, type JsonNullValues, type JsonObject, type JsonValue, kyselyUtils as KyselyUtils, type ModelOperations, type ModelResult, type NullsOrder, type NumberFilter, ORMError, ORMErrorReason, type OmitInput, type OmitOptions, type OnKyselyQueryArgs, type OnKyselyQueryCallback, type OperationsIneligibleForDelegateModels, type OrderBy, type PluginAfterEntityMutationArgs, type PluginBeforeEntityMutationArgs, type ProcedureFunc, type Procedures, type ProceduresOptions, type ProceedKyselyQueryFunction, type QueryOptions, queryUtils as QueryUtils, RejectedByPolicyReason, type RuntimePlugin, schemaUtils as SchemaUtils, type SelectIncludeOmit, type SelectInput, type SelectSubset, type SimplifiedPlainResult, type SimplifiedResult, type SortOrder, type StringFilter, type Subset, type ToKysely, type ToQueryOptions, type TransactionClientContract, TransactionIsolationLevel, type TypeDefResult, type TypedJsonFilter, type UpdateArgs, type UpdateInput, type UpdateManyAndReturnArgs, type UpdateManyArgs, type UpsertArgs, type WhereInput, type WhereUniqueInput, type ZModelFunction, type ZModelFunctionContext, ZenStackClient, type ZenStackPromise, definePlugin, getCrudDialect };
+export { type AfterEntityMutationCallback, type AggregateArgs, type AggregateResult, type AllModelOperations, AnyNull, AnyNullClass, type AuthType, BaseCrudDialect, type BatchResult, type BeforeEntityMutationCallback, type BooleanFilter, type BytesFilter, CRUD, CRUD_EXT, type ClientConstructor, type ClientContract, type ClientOptions, type ComputedFieldsOptions, type CountArgs, type CountResult, type CreateArgs, type CreateInput, type CreateManyAndReturnArgs, type CreateManyArgs, type CreateManyInput, type CoreCrudOperation as CrudOperation, type DateTimeFilter, DbNull, DbNullClass, type DefaultModelResult, type DeleteArgs, type DeleteManyArgs, type EntityMutationHooksDef, type ExistsArgs, type FindArgs, type FindFirstArgs, type FindManyArgs, type FindUniqueArgs, type GetProcedure, type GetProcedureNames, type GetProcedureParams, type GroupByArgs, type GroupByResult, type HasComputedFields, type HasProcedures, type IncludeInput, InputValidator, type JsonArray, type JsonFilter, JsonNull, JsonNullClass, type JsonNullValues, type JsonObject, type JsonValue, kyselyUtils as KyselyUtils, type ModelOperations, type ModelResult, type NullsOrder, type NumberFilter, ORMError, ORMErrorReason, type OmitInput, type OmitOptions, type OnKyselyQueryArgs, type OnKyselyQueryCallback, type OnProcedureHookContext, type OperationsIneligibleForDelegateModels, type OrderBy, type PluginAfterEntityMutationArgs, type PluginBeforeEntityMutationArgs, type ProcedureEnvelope, type ProcedureFunc, type ProcedureHandlerFunc, type ProcedureOperations, type ProceduresOptions, type ProceedKyselyQueryFunction, type QueryOptions, queryUtils as QueryUtils, RejectedByPolicyReason, type RuntimePlugin, schemaUtils as SchemaUtils, type SelectIncludeOmit, type SelectInput, type SelectSubset, type SimplifiedPlainResult, type SimplifiedResult, type SortOrder, type StringFilter, type Subset, type ToKysely, type ToQueryOptions, type TransactionClientContract, TransactionIsolationLevel, type TypeDefResult, type TypedJsonFilter, type UpdateArgs, type UpdateInput, type UpdateManyAndReturnArgs, type UpdateManyArgs, type UpsertArgs, type WhereInput, type WhereUniqueInput, type ZModelFunction, type ZModelFunctionContext, ZenStackClient, type ZenStackPromise, definePlugin, getCrudDialect };