arkos 2.0.0-next.2 → 2.0.0-next.21

package/dist/types/modules/auth/auth.service.d.ts

@@ -1,7 +1,9 @@
 import { User } from "../../types";
 import { ArkosRequest, ArkosRequestHandler } from "../../types";
-import { AuthJwtPayload, AccessAction, AccessControlConfig, AuthenticationControlConfig } from "../../types/auth";
+import { AuthJwtPayload, AccessAction, AccessControlConfig, DetailedAccessControlRule } from "../../types/auth";
 import { MsDuration } from "./utils/helpers/auth.controller.helpers";
+import { CookieOptions } from "express";
+import { ArkosSocket } from "../../components/arkos-gateway/types";
 /**
  * Handles various authentication-related tasks such as JWT signing, password hashing, and verifying user credentials.
  */
@@ -37,18 +39,13 @@ export declare class AuthService {
      * res.cookie('jwt', token, cookieOptions);
      * ```
      */
-    getJwtCookieOptions(req: ArkosRequest): {
-        expires: Date;
-        httpOnly: boolean;
-        secure: boolean;
-        sameSite: "none" | "strict" | "lax";
-    };
+    getJwtCookieOptions(req: ArkosRequest): CookieOptions;
     /**
-     * Is used by default internally by Arkos under `BaseService` class to check if the password is already hashed.
+     * Is used by default internally by Arkos under `ArkosPrismaService` class to check if the password is already hashed.
      *
-     * This was just added to prevent unwanted errors when someone just forgets that the `BaseService` class will automatically hash the password field using `authService.hashPassword` by default.
+     * This was just added to prevent unwanted errors when someone just forgets that the `ArkosPrismaService` class will automatically hash the password field using `authService.hashPassword` by default.
      *
-     * So now before `BaseService` hashes it will test it.
+     * So now before `ArkosPrismaService` hashes it will test it.
      *
      *
      * @param password The password to be tested if is hashed
@@ -70,24 +67,6 @@ export declare class AuthService {
      * @returns {Promise<string>} Returns the hashed password.
      */
     hashPassword(password: string): Promise<string>;
-    /**
-     * Checks if a password is strong, requiring uppercase, lowercase, and numeric characters as the default.
-     *
-     * **NB**: You must pay attention when using custom validation with zod or class-validator, try to use the same regex always.
-     *
-     * **Note**: You can define it when calling arkos.init()
-     * ```ts
-     * arkos.init({
-     *  authentication: {
-     *    passwordValidation:{ regex: /your-desired-regex/, message: 'password must contain...'}
-     *  }
-     * })
-     * ```
-     *
-     * @param {string} password - The password to check.
-     * @returns {boolean} Returns true if the password meets the strength criteria, otherwise false.
-     */
-    isPasswordStrong(password: string): boolean;
     /**
      * Checks if a user has changed their password after the JWT was issued.
      *
@@ -120,7 +99,7 @@ export declare class AuthService {
      * @returns True if user has permission, false otherwise
      * @throws Error if user doesn't have role/roles field
      */
-    protected checkStaticAccessControl(user: User, action: string, accessControl: AccessControlConfig): boolean;
+    checkStaticAccessControl(user: User, action: string, accessControl: AccessControlConfig): boolean;
     /**
      * Checks if a user has permission for a specific action and resource using dynamic access control.
      * Queries the database to verify user's role permissions.
@@ -130,40 +109,90 @@ export declare class AuthService {
      * @param resource - The resource being accessed
      * @returns Promise resolving to true if user has permission, false otherwise
      */
-    protected checkDynamicAccessControl(userId: string, action: string, resource: string): Promise<boolean>;
-    /**
-     * Middleware function to handle access control based on user roles and permissions.
-     *
-     * @param {AccessAction} action - The action being performed (e.g., create, update, delete, view).
-     * @param {string} resource - The resource name that the action is being performed on (e.g., "User", "Post").
-     * @param {AccessControlConfig} accessControl - The access control configuration.
-     * @returns {ArkosRequestHandler} The middleware function that checks if the user has permission to perform the action.
-     */
-    handleAccessControl(action: AccessAction, resource: string, accessControl?: AccessControlConfig): ArkosRequestHandler;
+    checkDynamicAccessControl(userId: string, action: string, resource: string): Promise<boolean>;
+    private extractRequestToken;
+    private extractSocketToken;
+    validateDecodedUser(decoded: AuthJwtPayload, action?: "logout" | "default"): Promise<User>;
     /**
      * Processes the cookies or authoriation token and returns the user.
-     * @param req
+     *
+     * @param ctx | socket
      * @returns {Promise<User | null>} - if authentication is turned off in arkosConfig it returns null
      * @throws {AppError} Throws an error if the token is invalid or the user is not logged in.
      */
-    getAuthenticatedUser(req: ArkosRequest): Promise<User | null>;
+    getAuthenticatedUser(ctx: ArkosRequest | ArkosSocket, action?: "logout" | "default"): Promise<User | null>;
     /**
-     * Middleware function to authenticate the user based on the JWT token.
+     * Middleware to authenticate the request by extracting and verifying the JWT token and setting `req.user`.
+     *
+     * Runs `authentication.hooks.authenticate` before/after the authentication logic.
+     *
+     * Hook execution flow:
+     * - `before` hooks run first — call `ctx.skip()` to bypass core logic and jump to `after` hooks,
+     *   call `ctx.next()` to stop the chain early, or return without calling anything to continue.
+     * - Core logic runs — extracts and verifies the JWT token, sets `req.user`.
+     * - `after` hooks run — call `ctx.next(err)` to abort or return without calling anything to continue.
+     * - `onError` hooks run if core logic throws — call `ctx.skip()` to suppress the error and jump to
+     *   `after` hooks, or call `ctx.next(err)` to forward it to the global error handler.
+     *
+     * On custom routes, hooks defined in `arkosConfig` still apply since they are baked into this method.
+     *
+     * @example
+     * ```ts
+     * // custom route - hooks still run
+     * router.get("/custom", authService.authenticate, handler);
+     * ```
      *
-     * @param {ArkosRequest} req - The request object.
-     * @param {ArkosResponse} res - The response object.
-     * @param {ArkosNextFunction} next - The next middleware function to be called.
-     * @returns {void}
+     * @example
+     * ```ts
+     * // skip built-in auth from a before hook
+     * before: (ctx) => {
+     *   ctx.req.user = myCustomAuth(ctx.req);
+     *   ctx.skip();
+     * }
+     * ```
+     *
+     * @see {@link https://www.arkosjs.com/docs/core-concepts/authentication/hooks}
      */
     authenticate: any;
     /**
-     * Handles authentication control by checking the `authenticationControl` configuration in the `authConfigs`.
+     * Middleware to authorize the authenticated user for a given action on a resource.
+     *
+     * Runs `authentication.hooks.authorize` before/after the authorization logic.
+     *
+     * Hook execution flow:
+     * - `before` hooks run first — call `ctx.skip()` to bypass core logic and jump to `after` hooks,
+     *   call `ctx.next()` to stop the chain early, or return without calling anything to continue.
+     * - Core logic runs — checks user role/permissions against the access control rules.
+     * - `after` hooks run — call `ctx.next(err)` to abort or return without calling anything to continue.
+     * - `onError` hooks run if authorization fails — call `ctx.skip()` to suppress the error and jump to
+     *   `after` hooks, or call `ctx.next(err)` to forward it to the global error handler.
+     *
+     * @param resource - The resource being accessed, in kebabCase (e.g. `"product"`, `"cart-item"`)
+     * @param action - The action being performed (e.g. `"View"`, `"Create"`, `"Delete"`)
+     * @param rule - Access control rules for this action. Accepts a role list, a wildcard, or a `DetailedAccessControlRule`.
+     *
+     * @example
+     * ```ts
+     * router.delete("/products/:id",
+     *   authService.authenticate,
+     *   authService.authorize("product", "Delete", ["admin"]),
+     *   handler
+     * );
+     * ```
+     *
+     * @example
+     * ```ts
+     * // skip built-in authorization from a before hook
+     * before: (ctx) => {
+     *   ctx.req.user.role = myCustomRoleResolver(ctx.req);
+     *   ctx.skip();
+     * }
+     * ```
      *
-     * @param {ControllerActions} action - The action being performed (e.g., create, update, delete, view).
-     * @param {AuthenticationControlConfig} authenticationControl - The authentication configuration object.
-     * @returns {ArkosRequestHandler} The middleware function that checks if authentication is required.
+     * @see {@link https://www.arkosjs.com/docs/core-concepts/authentication/hooks#authorize}
+     * @since v1.6.0-beta
      */
-    handleAuthenticationControl(action: AccessAction, authenticationControl?: AuthenticationControlConfig | undefined): ArkosRequestHandler;
+    authorize(action: AccessAction, resource: string, rule?: string[] | DetailedAccessControlRule | "*"): ArkosRequestHandler;
     /**
      * Creates a permission checker function for a specific action and resource.
      *

package/dist/types/modules/auth/utils/auth-hooks-manager.d.ts

@@ -0,0 +1,63 @@
+import { ArkosSocket } from "../../../components/arkos-gateway/types";
+import { ArkosRequest, User } from "../../../types";
+import { AuthAction } from "./services/auth-action.service";
+type ArkosBaseContext = ArkosRequest | ArkosSocket;
+interface ArkosMiddlewareAdapter<TContext extends ArkosBaseContext> {
+    context: TContext;
+    done: (error?: unknown | any) => void;
+}
+declare class AuthHookManager {
+    /**
+     * Runs the full authenticate pipeline — before hooks, core user resolution,
+     * after hooks — and calls `done` when finished.
+     *
+     * Shared by the HTTP authenticate middleware and the WebSocket auth ns.use().
+     *
+     * @param adapter.context - The request or socket being authenticated.
+     * @param adapter.done - Called with no args on success, or with an error to propagate.
+     * @param getUser - Async function that resolves the user from the context.
+     */
+    runAuthenticate<TContext extends ArkosBaseContext>(adapter: ArkosMiddlewareAdapter<TContext>, getUser: (context: TContext) => Promise<User | null>, keyName?: "user" | "currentUser"): Promise<void>;
+    /**
+     * Runs the full authorize pipeline — before hooks, core permission check,
+     * after hooks — and calls `done` when finished.
+     *
+     * Shared by the HTTP `authorize()` middleware and WebSocket per-event authorization.
+     *
+     * @param adapter.context - The request or socket being authorized.
+     * @param authAction {AuthAction}
+     * @param keyName {"user" | "currentUser"}
+     */
+    runAuthorize<TContext extends ArkosBaseContext>(adapter: ArkosMiddlewareAdapter<TContext>, authAction: Required<AuthAction>, keyName?: "user" | "currentUser"): Promise<void>;
+    /**
+     * Runs a chain of `after` hooks in sequence.
+     *
+     * - If a hook throws — chain aborts, error is forwarded to the global error handler.
+     * - If a hook returns — next hook in chain runs.
+     *
+     * @returns Promise resolving to `{ error? }`
+     */
+    private runAfterHooks;
+    /**
+     * Runs a chain of `before` hooks in sequence.
+     *
+     * - If a hook throws — chain aborts, error is forwarded to `onError` hooks.
+     * - If a hook calls `skip()` — chain stops, core logic is bypassed, jumps to `after` hooks.
+     * - If a hook returns — next hook in chain runs.
+     *
+     * @returns Promise resolving to `{ skipped, error? }`
+     */
+    private runHooks;
+    /**
+     * Runs a chain of `onError` hooks in sequence.
+     *
+     * - If a hook throws — chain aborts, error is forwarded to the global error handler.
+     * - If a hook calls `skip()` — suppresses the error and jumps to `after` hooks.
+     * - If a hook returns — next hook in chain runs.
+     *
+     * @returns Promise resolving to `{ skipped, error? }`
+     */
+    private runErrorHooks;
+}
+declare const authHookManager: AuthHookManager;
+export default authHookManager;

package/dist/types/modules/auth/utils/auth-openapi-generator.d.ts

@@ -0,0 +1,9 @@
+import { AuthRouterEndpoint } from "../../../types/router-config";
+import { ArkosRouteConfig } from "../../../exports";
+import { ExtendedOperationObject } from "../../../utils/arkos-router/types/openapi-config";
+declare class AuthOpenAPIGenerator {
+    getOpenApiConfig(endpointRouterConfig: Omit<ArkosRouteConfig, "path"> | undefined, endpoint: AuthRouterEndpoint): Partial<ExtendedOperationObject>;
+    private getAuthActionSchema;
+}
+declare const authOpenAPIGenerator: AuthOpenAPIGenerator;
+export default authOpenAPIGenerator;

package/dist/types/modules/auth/utils/auth-prisma-json-schema-generator.d.ts

@@ -0,0 +1,13 @@
+import { JsonSchema } from "../../../utils/prisma/types";
+declare class AuthPrismaJsonSchemaGenerator {
+    private userModel?;
+    private getUserModel;
+    private getPrismaArgs;
+    generateGetMeResponse(): JsonSchema;
+    generateUpdatePasswordSchema(): JsonSchema;
+    generateUpdateMeSchema(): JsonSchema;
+    generateSignupSchema(): JsonSchema;
+    generateLoginSchema(): JsonSchema;
+}
+declare const authPrismaJsonSchemaGenerator: AuthPrismaJsonSchemaGenerator;
+export default authPrismaJsonSchemaGenerator;

package/dist/types/modules/auth/utils/docs-links.d.ts

@@ -0,0 +1,3 @@
+export declare const authenticationDocsLinks: {
+    setup: string;
+};

package/dist/types/modules/auth/utils/services/auth-action.service.d.ts

@@ -1,5 +1,5 @@
 import { AccessControlConfig } from "../../../../types/auth";
-interface AuthAction {
+export interface AuthAction {
     roles?: string[] | "*";
     action: string;
     resource: string;
@@ -9,7 +9,7 @@ interface AuthAction {
 }
 declare class AuthActionService {
     authActions: AuthAction[];
-    add(action: string, resource: string, accessControl?: AccessControlConfig): void;
+    add(action: string, resource: string, accessControl?: AccessControlConfig): Required<AuthAction>;
     remove(action: string, resource: string): void;
     getAll(): AuthAction[];
     getOne(action: string, resource: string): AuthAction | undefined;

package/dist/types/modules/base/base.controller.d.ts

@@ -1,5 +1,5 @@
 import { ArkosRequest } from "../../types";
-import { BaseService } from "./base.service";
+import { ArkosPrismaService } from "./base.service";
 import { PrismaModels } from "../../generated";
 export interface OperationHooks {
     beforeQuery?: (req: ArkosRequest) => void | Promise<void>;
@@ -31,17 +31,17 @@ export interface OperationHooks {
  *
  * @param {string} modelName - The Prisma model name this controller handles.
  *
- * @see {@link https://www.arkosjs.com/docs/api-reference/the-base-controller-class}
+ * @see {@link https://www.arkosjs.com/docs/reference/base-controller}
  *--
  * **See about how Arkos handles routers**
- * @see {@link https://www.arkosjs.com/docs/guide/adding-custom-routers}
+ * @see {@link https://www.arkosjs.com/docs/core-concepts/routing/setup}
  */
 export declare class BaseController<TModuleName extends keyof PrismaModels<any>> {
     /**
      * Service instance to handle business logic operations
      * @public
      */
-    service: BaseService<TModuleName>;
+    service: ArkosPrismaService<TModuleName>;
     /**
      * Name of the model this controller handles
      * @private

package/dist/types/modules/base/base.middlewares.d.ts

@@ -1,10 +1,6 @@
 import { NextFunction, Request, Response } from "express";
-import { PrismaQueryOptions, ArkosRequest, ArkosRequestHandler, ArkosResponse, AuthPrismaQueryOptions } from "../../types";
-import { ZodSchema } from "zod";
-import { ClassConstructor } from "class-transformer";
-import { ValidatorOptions } from "class-validator";
+import { PrismaQueryOptions, ArkosRequest, ArkosResponse, AuthPrismaQueryOptions } from "../../types";
 import { ArkosRouteConfig } from "../../utils/arkos-router/types";
-export declare function callNext(_: Request, _1: Response, next: NextFunction): void;
 /**
  * Sends response with backward compatibility support
  * Compares current values against original values to detect middleware changes
@@ -30,6 +26,4 @@ export declare function addPrismaQueryOptionsToRequest<T extends Record<string,
  *
  */
 export declare function handleRequestLogs(req: Request, res: Response, next: NextFunction): void;
-export declare function handleRequestBodyValidationAndTransformation<T extends object>(schemaOrDtoClass?: ClassConstructor<T>, classValidatorValidationOptions?: ValidatorOptions): ArkosRequestHandler;
-export declare function handleRequestBodyValidationAndTransformation<T extends object>(schemaOrDtoClass?: ZodSchema<T>): ArkosRequestHandler;
 export declare function validateRequestInputs(routeConfig: ArkosRouteConfig): any;

package/dist/types/modules/base/base.service.d.ts

@@ -1,43 +1,34 @@
 import { ModelGroupRelationFields } from "./utils/helpers/base.service.helpers";
 import { PrismaClient } from "../../generated";
 import { CountFilters, CreateData, CreateManyData, CreateManyOptions, CreateOptions, DeleteManyFilters, DeleteOneFilters, FindManyFilters, FindManyOptions, FindOneFilters, FindOneOptions, GetPayload, Models, UpdateManyData, UpdateManyFilters, UpdateManyOptions, UpdateOneData, UpdateOneFilters, UpdateOneOptions } from "./types/base.service.types";
-import { ServiceHookContext } from "../../components/arkos-service-hook/types";
-export interface ServiceOperationHooks {
-    beforeOperation?: (params: any) => void | Promise<void>;
-    afterOperation?: (result: any, params: any) => void | Promise<void>;
-    beforePrisma?: (prismaArgs: any, params: any) => any | Promise<any>;
-    afterPrisma?: (result: any, params: any) => any | Promise<any>;
-}
+import { ServiceHookContext } from "./types/base.service.types";
 /**
  * Base service class for handling CRUD operations on a specific model.
  * This class provides standard implementation of data operations that can be extended
  * by model-specific service classes.
  *
- * @class BaseService
+ * @class ArkosPrismaService
  *
  * @example
  * ```ts
- * import { BaseService } from "arkos/services";
+ * import { ArkosPrismaService } from "arkos/services";
  *
- * export class UserService extends BaseService<"user"> {}
+ * export class UserService extends ArkosPrismaService<"user"> {}
  *
  * const userService = new UserService("user");
  * ```
  *
- * @see {@link https://www.arkosjs.com/docs/api-reference/the-base-service-class}
+ * @see {@link https://www.arkosjs.com/docs/reference/base-service}
  * @see {@link https://www.arkosjs.com/docs/guide/accessing-request-context-in-services}
  */
-export declare class BaseService<TModelName extends keyof Models = keyof Models> {
+export declare class ArkosPrismaService<TModelName extends keyof Models = keyof Models> {
     modelName: TModelName;
     relationFields: ModelGroupRelationFields;
-    prisma: PrismaClient;
+    private prismaInstace?;
     constructor(modelName: TModelName);
-    private getServiceHook;
+    get prisma(): PrismaClient;
     private executeOperation;
     private executeTransactionOperation;
-    private executeHooks;
-    private buildHookParams;
-    private buildTransactionHookParams;
     private handlePasswordHashing;
     private processRelationFieldsInBody;
     private buildPrismaArgs;

package/dist/types/modules/base/types/base.service.types.d.ts

@@ -1,5 +1,16 @@
 import { ExtractPrismaData, ExtractPrismaFilters, ExtractPrismaQueryOptions, PrismaModels } from "../../../generated";
+import { User } from "../../../types";
 export type Models = PrismaModels<any>;
+export interface ServiceHookContext {
+    /**
+     * The authenticated user making the request.
+     */
+    user?: User;
+    /**
+     * The access token from the request for authorization.
+     */
+    accessToken?: string;
+}
 export type Delegate<TModelName extends keyof Models> = Models[TModelName]["Delegate"];
 export type CreateData<TModelName extends keyof Models> = ExtractPrismaData<Models[TModelName]["CreateArgs"]>;
 export type CreateOptions<TModelName extends keyof Models> = ExtractPrismaQueryOptions<Models[TModelName]["CreateArgs"], "data">;

package/dist/types/modules/base/utils/helpers/base.service.helpers.d.ts

@@ -40,7 +40,7 @@ export declare function throwErrorIfApiActionIsInvalid(apiAction: string): void;
  * @param {string[]} ignoreActions - Optional list of apiAction values to ignore.
  * @returns {Record<string, any>} The transformed data with appropriate Prisma operations applied.
  */
-export declare function handleRelationFieldsInBody(body: Record<string, any>, relationFields: ModelGroupRelationFields, ignoreActions?: string[], isRelation?: boolean): Record<string, any>;
+export declare function handleRelationFieldsInBody(body: Record<string, any>, relationFields: ModelGroupRelationFields, ignoreActions?: string[], isRelation?: boolean, parentOperation?: "create" | "update" | null): Record<string, any>;
 export type ModelGroupRelationFields = ReturnType<typeof getGroupedModelReations>;
 declare function getGroupedModelReations(modelName: string): {
     singular: PrismaField[] | undefined;

package/dist/types/modules/base/utils/model-openapi-generator.d.ts

@@ -0,0 +1,12 @@
+import { ArkosRouteConfig } from "../../../exports";
+import { PrismaQueryOptions } from "../../../exports/prisma";
+import { RouterEndpoint } from "../../../types/router-config";
+import { ExtendedOperationObject } from "../../../utils/arkos-router/types/openapi-config";
+declare class ModelOpenAPIGenerator {
+    private getModel;
+    private getAuthErrorResponses;
+    private resolvePrismaQueryOptions;
+    getOpenApiConfig(endpointRouterConfig: Omit<ArkosRouteConfig, "path"> | undefined, endpoint: RouterEndpoint, modelNameInKebab: string, prismaQueryOptions?: PrismaQueryOptions<any>): Partial<ExtendedOperationObject>;
+}
+declare const modelOpenAPIGenerator: ModelOpenAPIGenerator;
+export default modelOpenAPIGenerator;

package/dist/types/modules/email/email.service.d.ts

@@ -25,7 +25,7 @@ export type SMTPConnectionOptions = {
 /**
  * A service class to handle email-related tasks, including sending emails.
  *
- * See the api reference [www.arkosjs.com/docs/api-reference/the-email-service-class](https://www.arkosjs.com/docs/api-reference/the-email-service-class)
+ * See the api reference [www.arkosjs.com/docs/reference/the-email-service-class](https://www.arkosjs.com/docs/reference/the-email-service-class)
  */
 export declare class EmailService {
     transporter: Transporter | null;

package/dist/types/modules/error-handler/utils/app-error.d.ts

@@ -5,7 +5,6 @@
  *
  * @property {number} statusCode - HTTP status code of the error.
  * @property {string} status - Status message derived from the status code (`fail` for 4xx, `error` for 5xx).
- * @property {boolean} [missing=false] - Flag to indicate if a resource is missing.
  * @property {boolean} isOperational - Indicates if the error is operational (intended for client visibility).
  * @property {string} [code] - Optional error code for categorization.
  * @property {Record<string, any>} [meta] - Additional metadata related to the error.
@@ -33,7 +32,6 @@
 declare class AppError extends Error {
     statusCode: number;
     status: string;
-    missing?: boolean;
     isOperational: boolean;
     code?: string;
     meta?: Record<string, any>;

package/dist/types/modules/error-handler/utils/catch-async.d.ts

@@ -1,4 +1,4 @@
-import { ArkosRequestHandler, ArkosErrorRequestHandler } from "../../../types";
+import { ArkosAnyRequestHandler } from "../../../types";
 /**
  * Used to wrap request handlers and middleware for automatic catch async errors and throw to next to invoke the global error handler
  *
@@ -16,7 +16,7 @@ import { ArkosRequestHandler, ArkosErrorRequestHandler } from "../../../types";
  * })
  * ```
  */
-declare const catchAsync: (fn: ArkosRequestHandler | ArkosErrorRequestHandler, options?: {
+declare const catchAsync: (fn: ArkosAnyRequestHandler, options?: {
     type: "error" | "normal";
 }) => any;
 export type CatchAsyncReturnType = ReturnType<typeof catchAsync>;

package/dist/types/modules/error-handler/utils/error-handler.helpers.d.ts

@@ -1,10 +1,4 @@
 import AppError from "./app-error";
-export interface PrismaError {
-    code?: string;
-    message: string;
-    meta?: Record<string, any>;
-    name?: string;
-}
 export declare function handleJWTError(): AppError;
 export declare function handleJWTExpired(): AppError;
 export declare function handlePrismaClientValidationError(err: AppError): AppError;
@@ -12,37 +6,17 @@ export declare function handleAuthenticationError(_: AppError): AppError;
 export declare function handleServerNotReachableError(_: AppError): AppError;
 export declare function handleConnectionTimeoutError(_: AppError): AppError;
 export declare function handleDatabaseNotFoundError(_: AppError): AppError;
-export declare function handleEnvironmentVariableError(err: AppError): AppError;
 export declare function handleFieldValueTooLargeError(err: AppError): AppError;
 export declare function handleRecordNotFoundError(_: AppError): AppError;
-export declare function handleUniqueConstraintError(err: AppError): AppError;
+export declare function handleUniqueConstraintError(err: any): AppError;
 export declare function handleForeignKeyConstraintError(_: AppError): AppError;
 export declare function handleConstraintFailedError(err: AppError): AppError;
-export declare function handleInvalidFieldValueError(err: AppError): AppError;
-export declare function handleInvalidFieldProvidedError(err: AppError): AppError;
-export declare function handleDataValidationError(_: AppError): AppError;
-export declare function handleQueryParsingError(err: AppError): AppError;
-export declare function handleInvalidQueryFormatError(err: AppError): AppError;
-export declare function handleRawQueryExecutionError(_: AppError): AppError;
-export declare function handleNullConstraintViolationError(err: AppError): AppError;
 export declare function handleSchemaCreationFailedError(_: AppError): AppError;
 export declare function handleMigrationAlreadyAppliedError(err: AppError): AppError;
 export declare function handleMigrationScriptFailedError(err: AppError): AppError;
 export declare function handleVersionMismatchError(_: AppError): AppError;
-export declare function handleMigrationFileReadError(err: AppError): AppError;
-export declare function handleSchemaDriftError(_: AppError): AppError;
-export declare function handleSchemaSyntaxError(_: AppError): AppError;
-export declare function handleClientTypeError(_: AppError): AppError;
-export declare function handleDynamicQueryError(_: AppError): AppError;
-export declare function handleRelationLoadingError(err: AppError): AppError;
-export declare function handleBinaryError(err: AppError): AppError;
-export declare function handleNetworkError(_: AppError): AppError;
-export declare function handleUnhandledPromiseError(_: AppError): AppError;
-export declare function handleDataTypeError(err: AppError): AppError;
-export declare function handleEmptyResultError(_: AppError): AppError;
 export declare function handleNonExistingRecord(err: {
     meta?: Record<string, any>;
     [x: string]: any;
 }): AppError;
 export declare function handlePrismaClientInitializationError(_: any): AppError;
-export declare function handleRequiredRelationViolationError(err: AppError): AppError;