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

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

@@ -0,0 +1,176 @@
+import AppError from "./app-error";
+/**
+ * 400 - Bad Request
+ * @example throw new BadRequestError("Invalid input", "InvalidInput", { field: "email" })
+ */
+export declare class BadRequestError extends AppError {
+    constructor(message?: string, code?: string, meta?: Record<string, any>);
+}
+/**
+ * 401 - Unauthorized
+ * @example throw new UnauthorizedError("Invalid token", "InvalidToken")
+ */
+export declare class UnauthorizedError extends AppError {
+    constructor(message?: string, code?: string, meta?: Record<string, any>);
+}
+/**
+ * 402 - Payment Required
+ * @example throw new PaymentRequiredError("Subscription expired", "PaymentRequired")
+ */
+export declare class PaymentRequiredError extends AppError {
+    constructor(message?: string, code?: string, meta?: Record<string, any>);
+}
+/**
+ * 403 - Forbidden
+ * @example throw new ForbiddenError("Access denied", "Forbidden", { resource: "admin" })
+ */
+export declare class ForbiddenError extends AppError {
+    constructor(message?: string, code?: string, meta?: Record<string, any>);
+}
+/**
+ * 404 - Not Found
+ * @example throw new NotFoundError("User not found", "NotFound", { id: 123 })
+ */
+export declare class NotFoundError extends AppError {
+    constructor(message?: string, code?: string, meta?: Record<string, any>);
+}
+/**
+ * 405 - Method Not Allowed
+ * @example throw new MethodNotAllowedError("POST not allowed", "MethodNotAllowed")
+ */
+export declare class MethodNotAllowedError extends AppError {
+    constructor(message?: string, code?: string, meta?: Record<string, any>);
+}
+/**
+ * 406 - Not Acceptable
+ * @example throw new NotAcceptableError("Unsupported format", "NotAcceptable")
+ */
+export declare class NotAcceptableError extends AppError {
+    constructor(message?: string, code?: string, meta?: Record<string, any>);
+}
+/**
+ * 408 - Request Timeout
+ * @example throw new RequestTimeoutError("Upload took too long", "RequestTimeout")
+ */
+export declare class RequestTimeoutError extends AppError {
+    constructor(message?: string, code?: string, meta?: Record<string, any>);
+}
+/**
+ * 409 - Conflict
+ * @example throw new ConflictError("Duplicate entry", "Conflict", { field: "email" })
+ */
+export declare class ConflictError extends AppError {
+    constructor(message?: string, code?: string, meta?: Record<string, any>);
+}
+/**
+ * 410 - Gone
+ * @example throw new GoneError("Resource deleted", "Gone")
+ */
+export declare class GoneError extends AppError {
+    constructor(message?: string, code?: string, meta?: Record<string, any>);
+}
+/**
+ * 411 - Length Required
+ * @example throw new LengthRequiredError("Content-Length missing", "LengthRequired")
+ */
+export declare class LengthRequiredError extends AppError {
+    constructor(message?: string, code?: string, meta?: Record<string, any>);
+}
+/**
+ * 412 - Precondition Failed
+ * @example throw new PreconditionFailedError("ETag mismatch", "PreconditionFailed")
+ */
+export declare class PreconditionFailedError extends AppError {
+    constructor(message?: string, code?: string, meta?: Record<string, any>);
+}
+/**
+ * 413 - Payload Too Large
+ * @example throw new PayloadTooLargeError("File exceeds 10MB", "PayloadTooLarge", { max: "10MB" })
+ */
+export declare class PayloadTooLargeError extends AppError {
+    constructor(message?: string, code?: string, meta?: Record<string, any>);
+}
+/**
+ * 414 - URI Too Long
+ * @example throw new UriTooLongError("Query string too long", "UriTooLong")
+ */
+export declare class UriTooLongError extends AppError {
+    constructor(message?: string, code?: string, meta?: Record<string, any>);
+}
+/**
+ * 415 - Unsupported Media Type
+ * @example throw new UnsupportedMediaTypeError("Expected JSON", "UnsupportedMediaType")
+ */
+export declare class UnsupportedMediaTypeError extends AppError {
+    constructor(message?: string, code?: string, meta?: Record<string, any>);
+}
+/**
+ * 416 - Range Not Satisfiable
+ * @example throw new RangeNotSatisfiableError("Invalid byte range", "RangeNotSatisfiable")
+ */
+export declare class RangeNotSatisfiableError extends AppError {
+    constructor(message?: string, code?: string, meta?: Record<string, any>);
+}
+/**
+ * 417 - Expectation Failed
+ * @example throw new ExpectationFailedError("Expect header failed", "ExpectationFailed")
+ */
+export declare class ExpectationFailedError extends AppError {
+    constructor(message?: string, code?: string, meta?: Record<string, any>);
+}
+/**
+ * 418 - I'm a teapot
+ * @example throw new ImATeapotError("Cannot brew coffee", "ImATeapot")
+ */
+export declare class ImATeapotError extends AppError {
+    constructor(message?: string, code?: string, meta?: Record<string, any>);
+}
+/**
+ * 422 - Unprocessable Content
+ * @example throw new UnprocessableContentError("Validation failed", "ValidationFailed", { errors: [...] })
+ */
+export declare class UnprocessableContentError extends AppError {
+    constructor(message?: string, code?: string, meta?: Record<string, any>);
+}
+/**
+ * 429 - Too Many Requests
+ * @example throw new TooManyRequestsError("Rate limit exceeded", "RateLimitExceeded", { retryAfter: 60 })
+ */
+export declare class TooManyRequestsError extends AppError {
+    constructor(message?: string, code?: string, meta?: Record<string, any>);
+}
+/**
+ * 500 - Internal Server Error
+ * @example throw new InternalServerError("Database connection failed", "DatabaseError")
+ */
+export declare class InternalServerError extends AppError {
+    constructor(message?: string, code?: string, meta?: Record<string, any>);
+}
+/**
+ * 501 - Not Implemented
+ * @example throw new NotImplementedError("Feature coming soon", "NotImplemented")
+ */
+export declare class NotImplementedError extends AppError {
+    constructor(message?: string, code?: string, meta?: Record<string, any>);
+}
+/**
+ * 502 - Bad Gateway
+ * @example throw new BadGatewayError("Upstream timeout", "BadGateway")
+ */
+export declare class BadGatewayError extends AppError {
+    constructor(message?: string, code?: string, meta?: Record<string, any>);
+}
+/**
+ * 503 - Service Unavailable
+ * @example throw new ServiceUnavailableError("Maintenance mode", "ServiceUnavailable", { retryAfter: 300 })
+ */
+export declare class ServiceUnavailableError extends AppError {
+    constructor(message?: string, code?: string, meta?: Record<string, any>);
+}
+/**
+ * 504 - Gateway Timeout
+ * @example throw new GatewayTimeoutError("Upstream timeout", "GatewayTimeout")
+ */
+export declare class GatewayTimeoutError extends AppError {
+    constructor(message?: string, code?: string, meta?: Record<string, any>);
+}

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

@@ -0,0 +1 @@
+export declare function getHandledError(err: any): any;

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

@@ -0,0 +1,7 @@
+import multer from "multer";
+import AppError from "./app-error";
+declare class MulterErrorHandler {
+    handle(err: multer.MulterError): AppError;
+}
+declare const multerErrorHandler: MulterErrorHandler;
+export default multerErrorHandler;

package/dist/types/modules/file-upload/file-upload.controller.d.ts

@@ -2,7 +2,6 @@
  * Handles file uploads and allows to be extended via route hooks.
  */
 export declare class FileUploadController {
-    private handleUploadError;
     private getRouteHook;
     private getAfterHook;
     /**
@@ -33,7 +32,13 @@ export declare class FileUploadController {
 /**
  * Controller instance responsible for handling file upload operations.
  *
- * @see {@link https://www.arkosjs.com/docs/api-reference/file-upload-controller-object}
+ * @remarks
+ * This controller handles various file upload operations including validation,
+ * storage, and response management.
+ *
+ * @instance
+ * @constant
+ * @see {@link https://www.arkosjs.com/docs/reference/file-upload-controller-object}
  */
 declare const fileUploadController: FileUploadController;
 export default fileUploadController;

package/dist/types/modules/file-upload/utils/file-upload-json-schema-generator.d.ts

@@ -0,0 +1,12 @@
+import { FileUploadRouterEndpoint } from "../../../types/router-config";
+import { ArkosRouteConfig } from "../../../exports";
+import { ExtendedOperationObject } from "../../../utils/arkos-router/types/openapi-config";
+declare class FileUploadJsonSchemaGenerator {
+    private formatBytes;
+    private getFileTypeDescription;
+    private getMultipartRequestBody;
+    private getImageQueryParameters;
+    getOpenApiConfig(endpointRouterConfig: Omit<ArkosRouteConfig, "path"> | undefined, endpoint: FileUploadRouterEndpoint): Partial<ExtendedOperationObject>;
+}
+declare const fileUploadJsonSchemaGenerator: FileUploadJsonSchemaGenerator;
+export default fileUploadJsonSchemaGenerator;

package/dist/types/modules/swagger/swagger.router.d.ts

@@ -1,6 +1,5 @@
-import { Router } from "express";
 import { ArkosNextFunction, ArkosRequest, ArkosResponse } from "../../exports";
 import { Arkos } from "../../types/arkos";
 import { UserArkosConfig } from "../../utils/define-config";
-export declare function getSwaggerRouter(arkosConfig: UserArkosConfig, app: Arkos): Router;
+export declare function getSwaggerRouter(arkosConfig: UserArkosConfig, app: Arkos): import("../../exports").IArkosRouter;
 export declare function scalarMiddleware(scalarHandler: any, swaggerSpecification: object, swaggerConfigs: any): (req: ArkosRequest, res: ArkosResponse, next: ArkosNextFunction) => Promise<any>;

package/dist/types/modules/swagger/utils/get-open-api-login-html.d.ts

@@ -0,0 +1 @@
+export default function getOpenApiLoginHtml(): string;

package/dist/types/modules/swagger/utils/helpers/get-swagger-default-configs.d.ts

@@ -1,3 +1,48 @@
-import { OpenAPIV3 } from "openapi-types";
-import { ArkosConfig } from "../../../../exports";
-export default function getSwaggerDefaultConfig(defaultModelsPaths: Record<string, any>, defaultJsonSchemas: OpenAPIV3.PathsObject<{}, {}>): ArkosConfig["swagger"];
+export default function getSwaggerDefaultConfig(defaultModelsPaths: Record<string, any>): {
+    endpoint: string;
+    mode: string;
+    strict: boolean;
+    options: {
+        definition: {
+            openapi: string;
+            info: {
+                title: string;
+                version: string;
+                description: string;
+            };
+            servers: {
+                url: string;
+                description: string;
+            }[];
+            paths: Record<string, any>;
+            components: {
+                securitySchemes: {
+                    BearerAuth: {
+                        type: string;
+                        scheme: string;
+                        bearerFormat: string;
+                    };
+                };
+            };
+            security: never[];
+        };
+        apis: string[];
+        deepLinking: boolean;
+        tryItOutEnabled: boolean;
+        persistAuthorization: boolean;
+    };
+    scalarApiReferenceConfiguration: {
+        theme: string;
+        darkMode: boolean;
+        layout: string;
+        showSidebar: boolean;
+        hideDownloadButton: boolean;
+        cdn: string;
+        metaData: {
+            title: string;
+            description: string;
+        };
+        pageTitle: string;
+        customCss: string;
+    };
+};

package/dist/types/modules/swagger/utils/helpers/openapi-schema-converter.d.ts

@@ -120,7 +120,12 @@ declare class OpenAPIchemaConverter {
      * @param visitedRefs - Set to track circular references
      * @returns Array of OpenAPI parameter objects
      */
-    jsonSchemaToOpenApiParameters(paramType: string, schema: any, prefix?: string, visitedRefs?: Set<string>): any[];
+    jsonSchemaToOpenApiParameters(paramType: string, schema: any, prefix?: string, visitedRefs?: Set<string>): {
+        in: string;
+        name: string;
+        required: boolean;
+        schema: any;
+    }[];
     resolveRef(rootSchema: any, refPath: string): any;
 }
 declare const openApiSchemaConverter: OpenAPIchemaConverter;

package/dist/types/types/arkos-config/utils.d.ts

@@ -0,0 +1,68 @@
+import { ArkosRequest } from "..";
+import { AccessAction, DetailedAccessControlRule } from "../auth";
+/** Context passed to `before` hooks of `authenticate`. */
+export interface AuthenticateBeforeHookContext {
+    /** The incoming request object. */
+    req: ArkosRequest;
+    /** Bypasses core logic and jumps directly to `after` hooks. */
+    skip: () => void;
+}
+/** Context passed to `after` hooks of `authenticate`. */
+export interface AuthenticateAfterHookContext {
+    /** The incoming request object. */
+    req: ArkosRequest;
+}
+/** Context passed to `onError` hooks of `authenticate`. */
+export interface AuthenticateErrorHookContext {
+    /** The incoming request object. */
+    req: ArkosRequest;
+    /** The error thrown during authentication. */
+    error: unknown;
+    /** Suppresses the error and jumps to `after` hooks. */
+    skip: () => void;
+}
+export type AuthenticateHookHandler = (ctx: AuthenticateBeforeHookContext) => void | Promise<void>;
+export type AuthenticateAfterHookHandler = (ctx: AuthenticateAfterHookContext) => void | Promise<void>;
+export type AuthenticateErrorHookHandler = (ctx: AuthenticateErrorHookContext) => void | Promise<void>;
+/** Context passed to `before` hooks of `authorize`. */
+export interface AuthorizeBeforeHookContext {
+    /** The incoming request object. */
+    req: ArkosRequest;
+    /** The action being authorized (e.g. `"Create"`, `"Delete"`). */
+    action: AccessAction;
+    /** The resource being accessed in kebab-case (e.g. `"post"`, `"cart-item"`). */
+    resource: string;
+    /** The access control rule for this action. */
+    rule?: string[] | DetailedAccessControlRule | "*";
+    /** Bypasses core logic and jumps directly to `after` hooks. */
+    skip: () => void;
+}
+/** Context passed to `after` hooks of `authorize`. */
+export interface AuthorizeAfterHookContext {
+    /** The incoming request object. */
+    req: ArkosRequest;
+    /** The action that was authorized (e.g. `"Create"`, `"Delete"`). */
+    action: AccessAction;
+    /** The resource that was accessed in kebab-case (e.g. `"post"`, `"cart-item"`). */
+    resource: string;
+    /** The access control rule that was applied. */
+    rule?: string[] | DetailedAccessControlRule | "*";
+}
+/** Context passed to `onError` hooks of `authorize`. */
+export interface AuthorizeErrorHookContext {
+    /** The incoming request object. */
+    req: ArkosRequest;
+    /** The error thrown during authorization. */
+    error: unknown;
+    /** The action being authorized (e.g. `"Create"`, `"Delete"`). */
+    action: AccessAction;
+    /** The resource being accessed in kebab-case (e.g. `"post"`, `"cart-item"`). */
+    resource: string;
+    /** The access control rule for this action. */
+    rule?: string[] | DetailedAccessControlRule | "*";
+    /** Suppresses the error and jumps to `after` hooks. */
+    skip: () => void;
+}
+export type AuthorizeHookHandler = (ctx: AuthorizeBeforeHookContext) => void | Promise<void>;
+export type AuthorizeAfterHookHandler = (ctx: AuthorizeAfterHookContext) => void | Promise<void>;
+export type AuthorizeErrorHookHandler = (ctx: AuthorizeErrorHookContext) => void | Promise<void>;

package/dist/types/types/arkos-prisma-input.d.ts

@@ -131,9 +131,10 @@ type StripPrismaFilters<T> = T extends {
     OR?: any;
 } | {
     NOT?: any;
-} ? never : T;
+} ? Omit<T, "equals" | "in" | "notIn" | "lt" | "lte" | "gt" | "gte" | "AND" | "OR" | "NOT"> : T;
+type StripToScalar<T> = T extends string | number | boolean | Date | null | undefined ? T : never;
 type FlattenRelations<T> = {
-    [K in keyof T]: IsArrayRelation<T[K]> extends true ? FlattenArrayRelation<T[K]> : IsObjectRelation<T[K]> extends true ? XOR<FlattenObjectRelation<T[K]>, T[K]> : StripPrismaFilters<T[K]> extends never ? never : T[K] extends object ? T[K] extends Date | null | undefined ? T[K] : FlattenRelations<StripPrismaFilters<T[K]>> : StripPrismaFilters<T[K]>;
+    [K in keyof T]: IsArrayRelation<T[K]> extends true ? FlattenArrayRelation<T[K]> | undefined : IsObjectRelation<T[K]> extends true ? XOR<FlattenObjectRelation<T[K]> | undefined, T[K]> : StripPrismaFilters<T[K]> extends never ? never : T[K] extends object ? T[K] extends Date | null | undefined ? T[K] : FlattenRelations<StripPrismaFilters<T[K]>> | undefined : StripToScalar<T[K]> extends never ? StripPrismaFilters<T[K]> : StripToScalar<T[K]>;
 };
 /**
  * Flattens Prisma relation inputs into a simpler, developer-friendly format
@@ -152,7 +153,7 @@ type FlattenRelations<T> = {
  * ]}
  * ```
  *
- * @see {@link https://wwww.arkosjs.com/docs/api-reference/arkos-prisma-input}
+ * @see {@link https://wwww.arkosjs.com/docs/reference/arkos-prisma-input}
  * @template T - The Prisma input type (e.g., Prisma.UserCreateInput)
  * @returns A flattened version of the input type with simplified relation handling
  */

package/dist/types/types/arkos.d.ts

@@ -1,7 +1,8 @@
 import { Express } from "express";
 import { IncomingMessage, Server, ServerResponse } from "http";
 import { ArkosAuthRouteHookInstance, ArkosFileUploadRouteHookInstance, ArkosRouteHookInstance } from "../components/arkos-route-hook/types";
-import { ArkosServiceHookInstance } from "../components/arkos-service-hook/types";
+import { IArkosRouter } from "../exports";
+type ArkosRouterMethods = "get" | "post" | "put" | "patch" | "delete" | "options" | "head" | "all" | "use" | "trace" | "route" | "use" | "load";
 /**
  * Creates and configures an Arkos application instance.
  *
@@ -43,20 +44,8 @@ import { ArkosServiceHookInstance } from "../components/arkos-service-hook/types
  *
  * @see {@link https://www.arkosjs.com/docs/core-concepts/routing/setup}
  */
-export interface Arkos extends Omit<Express, "listen"> {
+export interface Arkos extends Omit<Express, "listen" | ArkosRouterMethods>, Pick<IArkosRouter, ArkosRouterMethods> {
     (req: IncomingMessage, res: ServerResponse): void;
-    /**
-     * Loads Arkos-specific instances into the app for internal usage.
-     * Unlike use(), load() has no order — it simply makes the loaded
-     * data available for Arkos to apply where needed.
-     */
-    load(...items: ArkosLoadable[]): this;
-    /**
-     * Loads Arkos-specific instances into the app for internal usage.
-     * Unlike use(), load() has no order — it simply makes the loaded
-     * data available for Arkos to apply where needed.
-     */
-    load(items: ArkosLoadable[] | ArkosLoadable): this;
     /**
      * Applies all loaded items to the app by adding them as middleware,
      * routers, or handlers at the end of the stack.
@@ -85,4 +74,5 @@ export interface Arkos extends Omit<Express, "listen"> {
  * Union of all valid types that can be passed to `app.load()`.
  * Grows as new Arkos-specific loadable types are introduced.
  */
-export type ArkosLoadable = ArkosRouteHookInstance<any> | ArkosAuthRouteHookInstance | ArkosFileUploadRouteHookInstance | ArkosServiceHookInstance<any, any>;
+export type ArkosLoadable = ArkosRouteHookInstance<any> | ArkosAuthRouteHookInstance | ArkosFileUploadRouteHookInstance;
+export {};

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

@@ -25,7 +25,7 @@ export type DetailedAccessControlRule = {
  * Rules defining access control for different controller actions.
  * The array contains role names that are allowed to perform the action.
  *
- * @see {@link https://www.arkosjs.com/docs/core-concepts/authentication-system#using-auth-config-to-customize-endpoint-behavior}
+ * @see {@link https://www.arkosjs.com/docs/core-concepts/authentication/setup#using-auth-config-to-customize-endpoint-behavior}
  * @example
  *
  * const rules: AccessControlRules = {
@@ -46,7 +46,7 @@ export type AccessControlRules = {
 /**
  * Rules defining authentication requirements for different controller actions.
  *
- * @see {@link https://www.arkosjs.com/docs/core-concepts/authentication-system#using-auth-config-to-customize-endpoint-behavior}
+ * @see {@link https://www.arkosjs.com/docs/core-concepts/authentication/setup#using-auth-config-to-customize-endpoint-behavior}
  * @example
  * const authRules: AuthenticationControlRules = {
  *   Create: true,
@@ -75,7 +75,7 @@ export type AuthenticationControlConfig = boolean | Partial<AuthenticationContro
 /**
  * Configuration for access control.
  *
- * @see {@link https://www.arkosjs.com/docs/core-concepts/authentication-system#auth-config-files---static-rbac}
+ * @see {@link https://www.arkosjs.com/docs/core-concepts/authentication/setup#auth-config-files---static-rbac}
  * @example
  * // All actions allowed for these roles
  * const config1: AccessControlConfig = ["Admin", "Manager"];
@@ -90,7 +90,7 @@ export type AccessControlConfig = UserRole[] | Partial<AccessControlRules> | "*"
 /**
  * Configuration for authentication and access control.
  *
- * @see {@link https://www.arkosjs.com/docs/core-concepts/authentication-system#using-auth-config-to-customize-endpoint-behavior}
+ * @see {@link https://www.arkosjs.com/docs/core-concepts/authentication/setup#using-auth-config-to-customize-endpoint-behavior}
  * @example
  * export const authConfig: AuthConfigs = {
  *   authenticationControl: {

package/dist/types/types/index.d.ts

@@ -1,6 +1,6 @@
-import { ErrorRequestHandler, NextFunction, RequestHandler, Response, Request } from "express";
+import { NextFunction, Response, Request } from "express";
 import { PrismaModels } from "../generated";
-export type PrismaOperations = "findMany";
+import { ArkosFile } from "./upload";
 /**
  * Type definition for authentication-related Prisma query operations
  * @template T - The Prisma model delegate type
@@ -121,53 +121,6 @@ type BasePrismaQueryOptions<T extends Record<string, any>> = {
  * @template ModelName - The model name (defaults to string for standard models)
  */
 export type PrismaQueryOptions<T extends Record<string, any>, ModelName extends string = string> = ModelName extends "auth" ? AuthPrismaQueryOptions<T> : BasePrismaQueryOptions<T>;
-/**
- * Interface defining the minimum structure required for Prisma model delegates
- * This allows us to constraint TModel without requiring Prisma imports
- */
-export type PrismaModelDelegate = {
-    create: (args: {
-        data: never;
-        [key: string]: never;
-    }) => Promise<any>;
-    createMany: (args: {
-        data: never;
-        [key: string]: never;
-    }) => Promise<any>;
-    findMany: (args: {
-        [key: string]: never;
-    }) => Promise<any[]>;
-    findFirst: (args: {
-        where: never;
-        [key: string]: never;
-    }) => Promise<any>;
-    findUnique: (args: {
-        where: never;
-        [key: string]: never;
-    }) => Promise<any>;
-    update: (args: {
-        where: never;
-        data: never;
-        [key: string]: never;
-    }) => Promise<any>;
-    updateMany: (args: {
-        where: never;
-        data: never;
-        [key: string]: never;
-    }) => Promise<any>;
-    delete: (args: {
-        where: never;
-        [key: string]: never;
-    }) => Promise<any>;
-    deleteMany: (args: {
-        where: never;
-        [key: string]: never;
-    }) => Promise<any>;
-    count: (args: {
-        where: never;
-        [key: string]: never;
-    }) => Promise<number>;
-};
 export interface BaseUser extends Record<string, any> {
     id: string;
     isSuperUser: boolean;
@@ -187,19 +140,19 @@ export type UserRole = User extends {
 } ? R[number] : User extends {
     role: infer R;
 } ? R : string;
-export interface ArkosRequest<P extends Record<string, any> = any, ResBody = any, ReqBody = any, Query extends Record<string, any> = any> extends Request<P, ResBody, ReqBody, Query> {
+export interface ArkosRequest<P extends Record<string, any> = any, ResBody = any, ReqBody = any, Query extends Record<string, any> = any, Locals extends Record<string, any> = Record<string, any>> extends Request<P, ResBody, ReqBody, Query, Locals> {
     /**
      * Authenticated user
      */
     user?: User;
     /**
-     * Single uploaded file, populated when using `multer.single()`
+     * Single uploaded file, populated when using `{ uploads: { type: "single" }}`
      */
-    file?: Express.Multer.File;
+    file?: ArkosFile;
     /**
-     * Uploaded files, populated when using `multer.array()` or `multer.fields()`.
+     * Uploaded files, populated when using `{ uploads: { type: "array" }}` or `{ uploads: { type: "fileds" }}`.
      */
-    files?: Express.Multer.File[] | Record<string, Express.Multer.File[]>;
+    files?: ArkosFile[] | Record<string, ArkosFile[]>;
     /**
      * Fields to include in relational queries
      */
@@ -253,8 +206,7 @@ export interface ArkosResponse<ResBody = any, Locals extends Record<string, any>
 }
 export interface ArkosNextFunction extends NextFunction {
 }
-export interface ArkosRequestHandler<P extends Record<string, any> = any, ResBody = any, ReqBody = any, ReqQuery = qs.ParsedQs, Locals extends Record<string, any> = Record<string, any>> extends RequestHandler<P, ResBody, ReqBody, ReqQuery, Locals> {
-}
-export interface ArkosErrorRequestHandler<P extends Record<string, any> = any, ResBody = any, ReqBody = any, ReqQuery = qs.ParsedQs, Locals extends Record<string, any> = Record<string, any>> extends ErrorRequestHandler<P, ResBody, ReqBody, ReqQuery, Locals> {
-}
+export type ArkosRequestHandler<P extends Record<string, any> = any, ResBody = any, ReqBody = any, ReqQuery extends Record<string, any> = any, Locals extends Record<string, any> = Record<string, any>> = (req: ArkosRequest<P, ResBody, ReqBody, ReqQuery>, res: ArkosResponse<ResBody, Locals>, next: ArkosNextFunction) => unknown;
+export type ArkosErrorRequestHandler<P extends Record<string, any> = any, ResBody = any, ReqBody = any, ReqQuery extends Record<string, any> = any, Locals extends Record<string, any> = Record<string, any>> = (err: any, req: ArkosRequest<P, ResBody, ReqBody, ReqQuery>, res: ArkosResponse<ResBody, Locals>, next: ArkosNextFunction) => unknown;
+export type ArkosAnyRequestHandler<P extends Record<string, any> = any, ResBody = any, ReqBody = any, ReqQuery extends Record<string, any> = any, Locals extends Record<string, any> = Record<string, any>> = ArkosRequestHandler<P, ResBody, ReqBody, ReqQuery, Locals> | ArkosErrorRequestHandler<P, ResBody, ReqBody, ReqQuery, Locals> | Array<ArkosRequestHandler<P, ResBody, ReqBody, ReqQuery, Locals> | ArkosErrorRequestHandler<P, ResBody, ReqBody, ReqQuery, Locals>>;
 export {};