arkos 2.0.0-next.2 → 2.0.0-next.20

package/dist/types/utils/arkos-router/index.d.ts

@@ -1,6 +1,85 @@
 import { RouterOptions } from "express";
 import { IArkosRouter } from "./types";
 import { OpenAPIV3 } from "openapi-types";
+import { Arkos } from "../../types/arkos";
+import { ArkosRouterBaseUploadConfig } from "./types/upload-config";
+export type ArkosRouterOptions = {
+    /**
+     * Prefix to apply to all routes in this router.
+     * Nested routers inherit and concatenate prefixes from parent routers.
+     *
+     * @since 1.5.0-beta
+     * @example
+     * // All routes in this router will be prefixed with "/api"
+     * prefix: "/api"
+     */
+    prefix?: string | RegExp | Array<string | RegExp>;
+    /**
+     * OpenAPI metadata to apply to all routes in this router.
+     * Nested routers inherit from parent routers unless explicitly overridden.
+     * Route-level openapi config fully replaces inherited values when defined.
+     *
+     * @since 1.6.0-beta
+     * @example
+     * openapi: {
+     *   tags: ["Users"],
+     *   security: [{ bearerAuth: [] }]
+     * }
+     */
+    openapi?: {
+        /**
+         * Tags to apply to all routes in this router, used to group them in OpenAPI documentation.
+         * Route-level tags fully replaces this value when defined.
+         *
+         * @since 1.6.0-beta
+         * @example
+         * // Group all routes in this router under "Users"
+         * tags: ["Users"]
+         */
+        tags?: string[];
+        /**
+         * Security requirements to apply to all routes in this router.
+         * Route-level security fully replaces this value when defined.
+         *
+         * @since 1.6.2-canary.1
+         * @example
+         * // Require bearer auth for all routes in this router
+         * security: [{ bearerAuth: [] }]
+         *
+         * // Explicitly make all routes public (overridable per route)
+         * security: []
+         */
+        security?: OpenAPIV3.SecurityRequirementObject[];
+        /**
+         * Server definitions to apply to all routes in this router.
+         * Follows the OpenAPI 3.0 Server Object specification.
+         * Route-level servers fully replaces this value when defined.
+         *
+         * @since 1.6.2-canary.1
+         * @example
+         * servers: [{ url: "https://api.example.com/v2", description: "V2 API" }]
+         */
+        servers?: OpenAPIV3.ServerObject[];
+        /**
+         * External documentation to apply to all routes in this router.
+         * Route-level externalDocs fully replaces this value when defined.
+         *
+         * @since 1.6.2-canary.1
+         * @example
+         * externalDocs: {
+         *   description: "Find more information here",
+         *   url: "https://docs.example.com/users"
+         * }
+         */
+        externalDocs?: OpenAPIV3.ExternalDocumentationObject;
+    };
+    /**
+     * Allow customizing uploads on route level
+     *
+     * @since 1.7.0-canary.39
+     */
+    uploads?: ArkosRouterBaseUploadConfig;
+};
 /**
  * Creates an enhanced Express Router with features like OpenAPI documentation capabilities and smart data validation.
  *
@@ -23,15 +102,11 @@ import { OpenAPIV3 } from "openapi-types";
  *
  * @returns {IArkosRouter} A proxied Express Router instance with enhanced OpenAPI capabilities
  *
- * @see {@link ArkosRouteConfig} for configuration options
+ * @see {@link https://www.arkosjs.com/docs/reference/arkos-router} for configuration options
+ * @since 1.4.0-beta
  */
-export default function ArkosRouter(options?: RouterOptions & {
-    prefix?: string | RegExp | Array<string | RegExp>;
-    openapi?: {
-        tags?: string[];
-    };
-}): IArkosRouter;
-export declare function generateOpenAPIFromApp(app: any): Record<string, Record<string, Partial<{
+export default function ArkosRouter(options?: RouterOptions & ArkosRouterOptions): IArkosRouter;
+export declare function generateOpenAPIFromApp(app: Arkos): Record<string, Record<string, Partial<{
     tags?: string[];
     summary?: string;
     description?: string;

package/dist/types/utils/arkos-router/types/index.d.ts

@@ -1,15 +1,31 @@
-import { IRoute, IRouter } from "express";
-import { ZodSchema } from "zod";
+import { Application, IRoute, IRouter, IRouterHandler, IRouterMatcher, Locals } from "express";
+import { ZodType } from "zod";
 import { Options as RateLimitOptions } from "express-rate-limit";
 import { Options as QueryParserOptions } from "../../../utils/helpers/query-parser.helpers";
 import { DetailedAccessControlRule } from "../../../types/auth";
-import { ArkosErrorRequestHandler, ArkosRequestHandler } from "../../../types";
+import { ArkosAnyRequestHandler, ArkosErrorRequestHandler, ArkosRequestHandler } from "../../../types";
 import compression from "compression";
 import { OpenApiConfig } from "./openapi-config";
 import { UploadConfig } from "./upload-config";
 import { BodyParserConfig } from "./body-parser-config";
+import { ArkosRouterOptions } from "..";
+import { Validator } from "../../../types/validation/validator";
+import { ArkosLoadable } from "../../../exports";
+export type ArkosUseConfig = Pick<ArkosRouteConfig, "authentication" | "rateLimit" | "compression" | "queryParser" | "bodyParser" | "disabled"> & {
+    path?: PathParams;
+};
+type InferValidationType<T, Fallback> = T extends ZodType ? T : T extends new (...args: any[]) => infer I ? I : Fallback;
 export type PathParams = string | RegExp | Array<string | RegExp>;
-export type ArkosAnyRequestHandler = ArkosRequestHandler | ArkosErrorRequestHandler | Array<ArkosRequestHandler | ArkosErrorRequestHandler>;
+export type InternalIArkosRouter = IArkosRouter & {
+    _arkos: {
+        options?: ArkosRouterOptions;
+        routes: Array<{
+            handler: ArkosAnyRequestHandler;
+            config: ArkosRouteConfig;
+            method: string;
+        }>;
+    };
+};
 /**
  * Handler function for HTTP methods that accepts route configuration and request handlers.
  *
@@ -17,9 +33,30 @@ export type ArkosAnyRequestHandler = ArkosRequestHandler | ArkosErrorRequestHand
  * @param {...(ArkosRequestHandler | ArkosErrorRequestHandler)[]} handlers - Request and error handlers for the route.
  * @returns {IRouter} The Express router instance.
  */
-type RouterMethodHandler<T> = (config: ArkosRouteConfig | PathParams, ...handlers: Array<ArkosAnyRequestHandler>) => T;
-export type ArkosRouteMethodHandler<T> = (config: ArkosAnyRequestHandler | Omit<ArkosRouteConfig, "path">, ...handlers: Array<ArkosRequestHandler | ArkosErrorRequestHandler | Array<ArkosRequestHandler | ArkosErrorRequestHandler>>) => T;
-export interface ArkosIRoute extends IRoute {
+type IArkosRouterMethodHandler<T> = IRouterHandler<T> & IRouterMatcher<T> & {
+    <TQuery extends Validator = any, TBody extends Validator = any, TParams extends Validator = any>(config: ArkosRouteConfig<TQuery, TBody, TParams>, ...handlers: Array<ArkosRequestHandler<InferValidationType<TParams, Record<string, any>>, any, InferValidationType<TBody, any>, InferValidationType<TQuery, qs.ParsedQs>, any> | Array<ArkosRequestHandler<InferValidationType<TParams, Record<string, string>>, any, InferValidationType<TBody, any>, InferValidationType<TQuery, qs.ParsedQs>, any>>>): T;
+    <TQuery extends Validator = any, TBody extends Validator = any, TParams extends Validator = any>(config: ArkosRouteConfig<TQuery, TBody, TParams> | PathParams, ...handlers: Array<ArkosAnyRequestHandler<InferValidationType<TParams, Record<string, string>>, any, InferValidationType<TBody, any>, InferValidationType<TQuery, qs.ParsedQs>, any> | Array<ArkosAnyRequestHandler<InferValidationType<TParams, Record<string, string>>, any, InferValidationType<TBody, any>, InferValidationType<TQuery, qs.ParsedQs>, any> | Array<ArkosErrorRequestHandler<InferValidationType<TParams, Record<string, string>>, any, InferValidationType<TBody, any>, InferValidationType<TQuery, qs.ParsedQs>, any>>>>): T;
+    <TQuery extends Validator = any, TBody extends Validator = any, TParams extends Validator = any>(config: ArkosRouteConfig<TQuery, TBody, TParams>, subApplication: Application): T;
+};
+export type ArkosRouteMethodHandler<T> = {
+    <TQuery extends Validator = any, TBody extends Validator = any, TParams extends Validator = any>(config: ArkosAnyRequestHandler | Omit<ArkosRouteConfig, "path">, ...handlers: Array<ArkosAnyRequestHandler<InferValidationType<TParams, Record<string, string>>, any, InferValidationType<TBody, any>, InferValidationType<TQuery, qs.ParsedQs>, Locals>>): T;
+    <TQuery extends Validator = any, TBody extends Validator = any, TParams extends Validator = any>(config: Omit<ArkosRouteConfig<TQuery, TBody, TParams>, "path">, ...handlers: Array<ArkosAnyRequestHandler<InferValidationType<TParams, Record<string, string>>, any, InferValidationType<TBody, any>, InferValidationType<TQuery, qs.ParsedQs>, Locals> | Array<ArkosRequestHandler<InferValidationType<TParams, Record<string, string>>, any, InferValidationType<TBody, any>, InferValidationType<TQuery, qs.ParsedQs>, Locals>>>): T;
+    <TQuery extends Validator = any, TBody extends Validator = any, TParams extends Validator = any>(config: Omit<ArkosRouteConfig<TQuery, TBody, TParams>, "path">, ...handlers: Array<ArkosAnyRequestHandler<InferValidationType<TParams, Record<string, string>>, any, InferValidationType<TBody, any>, InferValidationType<TQuery, qs.ParsedQs>, Locals> | Array<ArkosAnyRequestHandler<InferValidationType<TParams, Record<string, string>>, any, InferValidationType<TBody, any>, InferValidationType<TQuery, qs.ParsedQs>, Locals>>>): T;
+};
+/**
+ * Handler function for `use` that accepts route configuration and middleware handlers.
+ *
+ * @param {ArkosUseConfig} config - The use configuration object or path.
+ * @param {...ArkosAnyRequestHandler} handlers - Middleware handlers.
+ * @returns {T} The router instance.
+ */
+export type UseMethodHandler<T> = IRouterHandler<T> & IRouterMatcher<T> & {
+    (config: ArkosUseConfig, ...handlers: Array<ArkosRequestHandler | Array<ArkosRequestHandler>>): T;
+    (config: ArkosUseConfig, ...handlers: Array<ArkosErrorRequestHandler | Array<ArkosErrorRequestHandler>>): T;
+    (config: ArkosUseConfig, ...handlers: Array<ArkosRequestHandler | ArkosErrorRequestHandler | Array<ArkosRequestHandler | ArkosErrorRequestHandler>>): T;
+    (...handlers: Array<ArkosRequestHandler | ArkosErrorRequestHandler | Array<ArkosRequestHandler | ArkosErrorRequestHandler>>): T;
+};
+export interface IArkosRoute extends IRoute {
     /** GET method handler with route configuration support */
     get: ArkosRouteMethodHandler<this>;
     /** POST method handler with route configuration support */
@@ -64,29 +101,42 @@ export interface ArkosIRoute extends IRoute {
  */
 export interface IArkosRouter extends IRouter {
     /** GET method handler with route configuration support */
-    get: RouterMethodHandler<this>;
+    get: IArkosRouterMethodHandler<this>;
     /** POST method handler with route configuration support */
-    post: RouterMethodHandler<this>;
+    post: IArkosRouterMethodHandler<this>;
     /** PUT method handler with route configuration support */
-    put: RouterMethodHandler<this>;
+    put: IArkosRouterMethodHandler<this>;
     /** PATCH method handler with route configuration support */
-    patch: RouterMethodHandler<this>;
+    patch: IArkosRouterMethodHandler<this>;
     /** DELETE method handler with route configuration support */
-    delete: RouterMethodHandler<this>;
+    delete: IArkosRouterMethodHandler<this>;
     /** OPTIONS method handler with route configuration support */
-    options: RouterMethodHandler<this>;
+    options: IArkosRouterMethodHandler<this>;
     /** HEAD method handler with route configuration support */
-    head: RouterMethodHandler<this>;
-    trace: RouterMethodHandler<this>;
+    head: IArkosRouterMethodHandler<this>;
+    trace: IArkosRouterMethodHandler<this>;
     /** ALL methods handler with route configuration support */
-    all: RouterMethodHandler<this>;
-    route<T extends string>(prefix: T): ArkosIRoute;
-    route(prefix: PathParams): ArkosIRoute;
+    all: IArkosRouterMethodHandler<this>;
+    use: UseMethodHandler<this>;
+    route<T extends string>(prefix: T): IArkosRoute;
+    route(prefix: PathParams): IArkosRoute;
+    /**
+     * 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;
 }
 /**
  * Configuration object for defining routes in Arkos.js.
  */
-export type ArkosRouteConfig = {
+export type ArkosRouteConfig<TQuery extends Validator = any, TBody extends Validator = any, TParams extends Validator = any> = {
     /**
      * Disables the route by not mounting it internally.
      */
@@ -115,13 +165,14 @@ export type ArkosRouteConfig = {
      *
      * @remarks
      * - Set to `false` to disable all validation.
+     * - Set to `null` to forbidden all request inputs.
      * - Provide an object with `query`, `body`, and/or `params` properties to validate specific parts of the request.
      * - Each property accepts a Zod schema, a class constructor, or `false` to disable validation for that part.
      */
-    validation?: false | {
-        query?: ZodSchema | (new (...args: any[]) => object) | false;
-        body?: ZodSchema | (new (...args: any[]) => object) | false;
-        params?: ZodSchema | (new (...args: any[]) => object) | false;
+    validation?: false | null | {
+        query?: TQuery;
+        body?: TBody;
+        params?: TParams;
     };
     /**
      * Rate limiting configuration for this route.

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

@@ -1,10 +1,11 @@
 import { OpenAPIV3 } from "openapi-types";
 import { ZodSchema } from "zod";
+import { JsonSchema } from "../../prisma/types";
 /**
  * Represents a schema-like object that can be used for OpenAPI documentation.
  * Accepts Zod schemas, class constructors (DTOs), or plain JSON Schema objects.
  */
-type SchemaLike = ZodSchema | (new (...args: any[]) => object) | OpenAPIV3.SchemaObject;
+type SchemaLike = ZodSchema | (new (...args: any[]) => object) | OpenAPIV3.SchemaObject | JsonSchema;
 /**
  * Extended media type object that accepts SchemaLike in addition to standard OpenAPI schemas.
  */
@@ -131,7 +132,7 @@ type RequestBodyDefinition = SchemaLike | {
  * Defining both validation and openapi schemas for the same field will cause
  * a startup error to prevent documentation drift.
  */
-type ExtendedOperationObject = Omit<OpenAPIV3.OperationObject, "responses" | "requestBody"> & {
+export type ExtendedOperationObject = Omit<OpenAPIV3.OperationObject, "responses" | "requestBody"> & {
     /**
      * Response definitions keyed by HTTP status code.
      * Supports shorthand, medium, and full OpenAPI formats.

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

@@ -1,3 +1,4 @@
+import { ArkosFile } from "../../../exports";
 export type UploadConfig = 
 /**
  * Creates middleware that processes a single file associated with the
@@ -16,7 +17,7 @@ export type UploadConfig =
  */
 ({
     type: "single";
-    /** Name of the multipart form field to process */
+    /** Name of the multipart form field to process. Supports bracket notation, including nested array paths (e.g. "banners[][image]") */
     field: string;
 } & ArkosRouterBaseUploadConfig)
 /**
@@ -39,10 +40,12 @@ export type UploadConfig =
  */
  | ({
     type: "array";
-    /** Shared name of the multipart form fields to process */
+    /** Shared name of the multipart form fields to process. Supports bracket notation, including nested array paths (e.g. "banners[][images]") */
     field: string;
     /** Maximum number of files to process (defaults to framework config) */
     maxCount?: number;
+    /** Minimum number of files required */
+    minCount?: number;
 } & ArkosRouterBaseUploadConfig)
 /**
  * Creates middleware that processes multiple files associated with the
@@ -52,18 +55,25 @@ export type UploadConfig =
  * maps each field name to an array of the associated file information
  * objects.
  *
- * @throws `MulterError('LIMIT_UNEXPECTED_FILE')` if more than `maxCount` files are associated with `fieldName` for any field
+ * Each field entry is a full single or array upload config with a `name`
+ * property. Field names support bracket notation, including nested array
+ * paths (e.g. "banners[][images]").
  *
  * @example
  * uploads: {
  *   type: "fields",
  *   fields: [
- *     { field: "avatar", maxCount: 1, uploadDir: "images" },
- *     { field: "resume", maxCount: 1, uploadDir: "documents" }
+ *     { name: "avatar", type: "single", uploadDir: "images" },
+ *     { name: "resume", type: "single", uploadDir: "documents" },
+ *     { name: "banners[][images]", type: "array", maxCount: 5, uploadDir: "banners" }
  *   ]
  * }
  */
  | ({
+    type: "fields";
+    /** Array of field configurations describing multipart form fields to process */
+    fields: UploadConfigFieldEntry[];
+} & Pick<ArkosRouterBaseUploadConfig, "deleteOnError">) | ({
     type: "fields";
     /** Array of field configurations describing multipart form fields to process */
     fields: {
@@ -71,12 +81,59 @@ export type UploadConfig =
         name: string;
         /** Maximum number of files for this field (defaults to framework config) */
         maxCount?: number;
+        minCount?: number;
     }[];
 } & ArkosRouterBaseUploadConfig);
 /**
- * Base configuration options for file uploads.
- * These settings can override framework-level defaults for specific routes.
+ * A single field entry inside a `fields` upload config.
+ * Each entry is a full single or array upload config with an additional
+ * `name` property identifying the form field.
+ *
+ * Field names support bracket notation, including nested array paths
+ * (e.g. "banners[][images]"). For nested array paths, multer validation
+ * is bypassed and constraints (allowedFileTypes, maxSize, minCount, maxCount)
+ * are enforced per group after upload.
+ */
+export type UploadConfigFieldEntry = 
+/**
+ * A single-file field entry.
+ *
+ * @example
+ * { name: "avatar", type: "single", uploadDir: "images", required: true }
+ *
+ * @example
+ * // nested array path — one image per banner
+ * { name: "banners[][image]", type: "single", uploadDir: "banners" }
+ */
+({
+    /** Name of the form field. Supports bracket notation including nested array paths. */
+    name: string;
+    type: "single";
+} & Omit<ArkosRouterBaseUploadConfig, "deleteOnError">)
+/**
+ * A multi-file field entry.
+ *
+ * @example
+ * { name: "gallery", type: "array", maxCount: 6, uploadDir: "gallery" }
+ *
+ * @example
+ * // nested array path — multiple images per banner, min 1 max 5
+ * { name: "banners[][images]", type: "array", minCount: 1, maxCount: 5, uploadDir: "banners" }
  */
+ | ({
+    /** Name of the form field. Supports bracket notation including nested array paths. */
+    name: string;
+    type?: "array";
+    /** Maximum number of files for this field (defaults to framework config) */
+    maxCount?: number;
+    /** Minimum number of files required for this field */
+    minCount?: number;
+} & Omit<ArkosRouterBaseUploadConfig, "deleteOnError">); /**
+
+/**
+* Base configuration options for file uploads.
+* These settings can override framework-level defaults for specific routes.
+*/
 export type ArkosRouterBaseUploadConfig = {
     /**
      * Directory category where files will be stored.
@@ -105,7 +162,7 @@ export type ArkosRouterBaseUploadConfig = {
      * When using validation, the attached format will be available in your validated body.
      * For array/fields uploads, an array of the specified format will be attached.
      */
-    attachToBody?: "pathname" | "url" | "file" | false;
+    attachToBody?: "pathname" | "url" | "file" | false | ((file: ArkosFile) => any);
     /**
      * Maximum file size in bytes.
      * Overrides the framework-level default for this uploadDir category.

package/dist/types/utils/arkos-router/utils/helpers/apply-arkos-router-proxy.d.ts

@@ -0,0 +1,6 @@
+import { IRouter, RouterOptions } from "express";
+import { IArkosRouter } from "../../types";
+import { ArkosRouterOptions } from "../..";
+import { Arkos } from "../../../../types/arkos";
+import { Express } from "express";
+export declare function applyArkosRouterProxy<T extends Express | IRouter>(target: T, options?: RouterOptions & ArkosRouterOptions, component?: "app" | "router"): T extends Express ? Arkos : IArkosRouter;

package/dist/types/utils/arkos-router/utils/helpers/index.d.ts

@@ -1,10 +1,8 @@
 import { ArkosRouteConfig } from "../../types";
-export declare function extractArkosRoutes(app: any, basePath?: string): Array<{
-    path: string;
-    method: string;
-    config?: ArkosRouteConfig;
-}>;
-export declare function getMiddlewareStack(config: ArkosRouteConfig): any[];
+import { ArkosRouterOptions } from "../..";
+export declare function extractArkosRoutes(app: any, basePath?: string, inheritedRouteOptions?: ArkosRouterOptions): any[];
+export declare function extractLayerPath(layer: any): string;
+export declare function getMiddlewareStack(config: ArkosRouteConfig | Omit<ArkosRouteConfig, "path">): any[];
 /**
  * Extracts path parameters from an Express route path
  *

package/dist/types/utils/arkos-router/utils/helpers/upload-manager.d.ts

@@ -5,46 +5,11 @@ declare class UploadManager {
     private getUpload;
     getMiddleware(config: UploadConfig): RequestHandler;
     handleUpload(config: UploadConfig, oldFilePath?: string): any;
-    /**
-     * Validates that all required upload files are present in the request.
-     * Checks req.file or req.files based on upload configuration type.
-     *
-     * @param {UploadConfig} uploadConfig - The upload configuration from config.experimental.uploads
-     * @throws {AppError} If required files are missing
-     *
-     * @example
-     * // Single file upload - checks req.file
-     * validateRequiredFiles(
-     *   { type: 'single', field: 'avatar', required: true },
-     *   req,
-     *   '/users/:id/avatar'
-     * )
-     *
-     * @example
-     * // Array file upload - checks req.files array
-     * validateRequiredFiles(
-     *   { type: 'array', field: 'photos', required: true },
-     *   req,
-     *   '/gallery/upload'
-     * )
-     *
-     * @example
-     * // Multiple fields - checks req.files object
-     * validateRequiredFiles(
-     *   { type: 'fields', fields: [{ name: 'avatar' }, { name: 'resume' }], required: true },
-     *   req,
-     *   '/profile/upload'
-     * )
-     */
     validateRequiredFiles(uploadConfig: UploadConfig): any;
     handleFileCleanup(config: UploadConfig): (err: any, req: ArkosRequest, _: ArkosResponse, next: ArkosNextFunction) => Promise<void>;
     handlePostUpload(config: UploadConfig): any;
-    /**
-     * Validates the file's type and MIME type.
-     * @param {Express.Multer.File} file - The uploaded file.
-     * @param {Function} cb - The callback function to indicate if file is valid.
-     */
     private fileFilter;
+    isAllFieldRequired(uploadConfig: UploadConfig): boolean;
 }
 declare const uploadManager: UploadManager;
 export default uploadManager;

package/dist/types/utils/bundler.d.ts

@@ -87,7 +87,7 @@ export declare class Bundler {
      * @param filePath - Absolute path to the JSON file
      * @returns Parsed object, or empty object if parsing fails
      */
-    private readJsonWithComments;
+    readJsonWithComments(filePath: string): any;
     /**
      * Resolves a single import path to its final rewritten form.
      *

package/dist/types/utils/cli/build.d.ts

@@ -5,5 +5,5 @@ interface BuildOptions {
 /**
  * Main build function for the arkos CLI
  */
-export declare function buildCommand(options?: BuildOptions): void;
+export declare function buildCommand(options?: BuildOptions): Promise<void>;
 export {};

package/dist/types/utils/cli/generate.d.ts

@@ -10,21 +10,30 @@ export type GenerateOptions = {
     shouldPrintError?: boolean;
     isBulk?: boolean;
 };
+export interface GenerateConfig {
+    templateName: string;
+    fileSuffix?: string;
+    customValidation?: (modelName: string) => void;
+    customImports?: (names: any) => any;
+    customPath?: string;
+    prefix?: string;
+    allowedModules: string[] | "*";
+    ext?: string;
+    attachModuleName?: boolean;
+}
 export declare const generateCommand: {
     controller: (options: GenerateOptions) => Promise<void>;
     service: (options: GenerateOptions) => Promise<void>;
     router: (options: GenerateOptions) => Promise<void>;
     policy: (options: GenerateOptions) => Promise<void>;
-    routeHook: (options: GenerateOptions) => Promise<void>;
-    serviceHook: (options: GenerateOptions) => Promise<void>;
-    createSchema: (options: GenerateOptions) => Promise<void>;
-    updateSchema: (options: GenerateOptions) => Promise<void>;
-    baseSchema: (options: GenerateOptions) => Promise<void>;
-    querySchema: (options: GenerateOptions) => Promise<void>;
     createDto: (options: GenerateOptions) => Promise<void>;
     updateDto: (options: GenerateOptions) => Promise<void>;
     baseDto: (options: GenerateOptions) => Promise<void>;
     queryDto: (options: GenerateOptions) => Promise<void>;
     prismaModel: (options: GenerateOptions) => Promise<void>;
+    loginDto: (options: GenerateOptions) => Promise<void>;
+    signupDto: (options: GenerateOptions) => Promise<void>;
+    updateMeDto: (options: GenerateOptions) => Promise<void>;
+    updatePasswordDto: (options: GenerateOptions) => Promise<void>;
     multipleComponents: (options: MultipleComponentsGenerateOptions) => Promise<void>;
 };

package/dist/types/utils/cli/start.d.ts

@@ -1,11 +1,13 @@
 interface StartOptions {
     port?: string;
     host?: string;
+    stamp?: false;
+    shouldThrow?: true;
 }
 /**
  * Production start command for the arkos CLI
  */
-export declare function startCommand(options?: StartOptions): void;
+export declare function startCommand(options?: StartOptions): Promise<void>;
 /**
  * Help function to help other processes to terminate the production server child process
  */

package/dist/types/utils/cli/utils/template-generator/templates/class-validator-dto-generator.d.ts

@@ -8,10 +8,21 @@ export declare class ClassValidatorDtoGenerator {
     private getFilterTypeForField;
     private generateFilterClasses;
     private generateNestedDtoClass;
+    /**
+     * Builds a @Transform decorator that coerces raw incoming values
+     * (e.g. strings from multipart/form-data or query params) into the
+     * correct native type before class-validator runs its checks.
+     * Mirrors the z.coerce.* behavior used in the Zod schema generator.
+     */
+    private generateTransformDecorator;
     private generateClassValidatorField;
     private generateClassValidatorFieldForUpdate;
     private getValidatorsForType;
     private mapPrismaTypeToTS;
+    generateLoginDto(_: TemplateOptions): string;
+    generateSignupDto(_: TemplateOptions): string;
+    generateUpdateMeDto(_: TemplateOptions): string;
+    generateUpdatePasswordDto(_: TemplateOptions): string;
 }
 declare const classValidatorDtoGenerator: ClassValidatorDtoGenerator;
 export default classValidatorDtoGenerator;

package/dist/types/utils/cli/utils/template-generator/templates/zod-schema-generator.d.ts

@@ -9,6 +9,10 @@ export declare class ZodSchemaGenerator {
     private generateFilterSchemas;
     private generateZodField;
     private mapPrismaTypeToZod;
+    generateLoginSchema(_: TemplateOptions): string;
+    generateSignupSchema(_: TemplateOptions): string;
+    generateUpdateMeSchema(_: TemplateOptions): string;
+    generateUpdatePasswordSchema(_: TemplateOptions): string;
 }
 declare const zodSchemaGenerator: ZodSchemaGenerator;
 export default zodSchemaGenerator;

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

@@ -15,7 +15,7 @@ import { ArkosConfig } from "../exports";
  * });
  * ```
  *
- * @see {@link https://www.arkosjs.com/docs/api-reference/define-config}
+ * @see {@link https://www.arkosjs.com/docs/reference/define-config}
  */
 export declare function defineConfig(config: ArkosConfig): ArkosConfig;
 export type UserArkosConfig = ReturnType<typeof defineConfig> & {

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

@@ -0,0 +1 @@
+export declare const baseDocsLink = "https://www.arkosjs.com";

package/dist/types/utils/dynamic-loader.d.ts

@@ -1,4 +1,4 @@
-import { ZodTypeAny } from "zod";
+import { ZodType } from "zod";
 export declare function isClass(value: any): boolean;
-export declare function isZodSchema(value: any): value is ZodTypeAny;
+export declare function isZodSchema(value: any): value is ZodType;
 export declare const appModules: string[];

package/dist/types/utils/features/api.features.d.ts

@@ -1,4 +1,3 @@
-import { Request } from "express";
 import { ArkosRequest } from "../../types";
 type ModelName = string;
 export default class APIFeatures {
@@ -9,7 +8,7 @@ export default class APIFeatures {
     reqFiltersSearchParam: any;
     modelName?: ModelName;
     excludedFields: string[];
-    constructor(req?: Request, modelName?: ModelName);
+    constructor(req?: ArkosRequest, modelName?: ModelName);
     filter(): this;
     sort(): this;
     limitFields(): this;

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

@@ -7,3 +7,10 @@ export declare function isAuthenticationEnabled(): boolean | undefined;
  * @returns {ArkosConfig}
  */
 export declare function getArkosConfig(): UserArkosConfig;
+/**
+ * Returns true if application is being run through `arkos start` after `arkos build`
+ *
+ * @since 1.5.16-beta
+ */
+export declare function isProduction(): boolean;
+export declare function validateArkosConfig(): void;

package/dist/types/utils/helpers/fs.helpers.d.ts

@@ -12,19 +12,4 @@ export declare let userFileExtension: "ts" | "js" | undefined;
  * Returns 'ts' when TypeScript config exists and not in build mode, otherwise 'js'
  * @returns 'ts' | 'js'
  */
-export declare const getUserFileExtension: () => "ts" | "js";
-/**
- * Checks if a file exists at the specified file path.
- *
- * @param filePath - The path to the file to check
- * @returns {boolean} True if the file exists, false otherwise or if there's an error
- *
- * @example
- * ```ts
- * const exists = checkFileExists('./path/to/file.txt');
- * if (exists) {
- *   console.info('File exists!');
- * }
- * ```
- */
-export declare function checkFileExists(filePath: string): boolean;
+export declare const getUserFileExtension: (root?: string) => "ts" | "js";