arkos 2.0.0-next.3 → 2.0.0-next.30

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

@@ -1,3 +1,4 @@
+import type { ArkosFile, UploadPrepare, UploadPrepareFile, UploadUrlPath } from "../../../types/upload";
 export type UploadConfig = 
 /**
  * Creates middleware that processes a single file associated with the
@@ -10,13 +11,13 @@ export type UploadConfig =
  * uploads: {
  *   type: "single",
  *   field: "avatar",
- *   uploadDir: "images",
+ *   uploadDir: "/images",
  *   maxSize: 1024 * 1024 * 5 // 5MB
  * }
  */
 ({
     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)
 /**
@@ -34,15 +35,17 @@ export type UploadConfig =
  *   field: "gallery",
  *   maxCount: 10,
  *   minCount: 1,
- *   uploadDir: "images"
+ *   uploadDir: "/images"
  * }
  */
  | ({
     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" | "image" | "uploadDir" | "urlPath" | "serve" | "prepare" | "prepareFile" | "overwrite">) | ({
     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.
@@ -86,6 +143,65 @@ export type ArkosRouterBaseUploadConfig = {
      * @default Depends on the file type which is descovered by the file mimetype, otherwise falls to files.
      */
     uploadDir?: string;
+    /**
+     * Public URL for the uploaded files, relative to the file upload `baseRoute`.
+     *
+     * A string is a folder: the stored filename is appended. An object with
+     * `exact` is the complete public path relative to `baseRoute`: nothing is
+     * appended, and the path must be static.
+     *
+     * Requires `uploadDir` to be set.
+     *
+     * @since 1.8.0-rc
+     *
+     * @example
+     * // Files stored in uploads/storage/acme but served at /api/uploads/private/files
+     * uploadDir: "/storage/acme",
+     * urlPath: "/private/files"
+     *
+     * @example
+     * // The response URL is always /api/uploads/users/me/photo
+     * uploadDir: "/users/:userId/photo",
+     * urlPath: { exact: "/users/me/photo" }
+     */
+    urlPath?: UploadUrlPath;
+    /**
+     * Resolves the disk parameters for this upload folder. Required for every
+     * dynamic folder (`:param` in `uploadDir`). It may be async and may throw to
+     * deny the request.
+     *
+     * URL parameters are merged into the disk parameter map, with values
+     * returned by `prepare` taking precedence.
+     *
+     * @since 1.8.0-rc
+     */
+    prepare?: UploadPrepare;
+    /**
+     * Resolves per-file data before the file is written. Only `filename` is
+     * consumed. The returned filename is treated as a base name: the final
+     * saved extension is always preserved.
+     *
+     * May be async.
+     *
+     * @since 1.8.0-rc
+     */
+    prepareFile?: UploadPrepareFile;
+    /**
+     * Whether a file with the same target name may be replaced.
+     *
+     * @default true
+     * @since 1.8.0-rc
+     */
+    overwrite?: boolean;
+    /**
+     * Set to `false` to opt this upload directory out of the startup coverage
+     * check when `fileUpload.serving` is `"registered"`.
+     *
+     * Only `false` has meaning.
+     *
+     * @since 1.8.0-rc
+     */
+    serve?: boolean;
     /**
      * Whether to automatically delete uploaded files if an error occurs during request processing.
      * Cleanup happens when errors are thrown and not caught within the route handler.
@@ -105,7 +221,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.
@@ -139,6 +255,38 @@ export type ArkosRouterBaseUploadConfig = {
      * @default true
      */
     required?: boolean;
+    /**
+     * Image optimization options applied through Sharp for image uploads.
+     * When omitted, images fall back to the framework defaults (webp conversion).
+     *
+     * @example
+     * image: { resizeTo: 1200, quality: 80 }
+     * image: { format: "png", width: 800 }
+     * image: { optimize: false } // store original bytes untouched
+     */
+    image?: {
+        /**
+         * Set to `false` to skip optimization entirely and store the original
+         * bytes as-is, e.g. to let users upload an image "as a document".
+         *
+         * @default true
+         */
+        optimize?: boolean;
+        /** Output format, defaults to `webp` */
+        format?: string;
+        /** Output quality (1-100) for lossy formats (webp, jpeg, avif) */
+        quality?: number;
+        /** Target width, keeping aspect ratio */
+        width?: number;
+        /** Target height, keeping aspect ratio */
+        height?: number;
+        /** Target size to fit within, keeping aspect ratio */
+        resizeTo?: number;
+        /** Resize strategy, defaults to `inside` */
+        fit?: "cover" | "contain" | "fill" | "inside" | "outside";
+        /** Prevent upscaling images smaller than the requested dimensions */
+        withoutEnlargement?: boolean;
+    };
     /**
      * Open API field description
      */

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

@@ -1,50 +1,35 @@
 import { UploadConfig } from "../../types/upload-config";
 import { ArkosNextFunction, ArkosRequest, ArkosResponse } from "../../../../exports";
+import { UploadDirParams, UploadPrepare, UploadPrepareFile, UploadUrlPath } from "../../../../types/upload";
 import { RequestHandler } from "express";
+type UploadSettings = {
+    uploadDir?: string;
+    urlPath?: UploadUrlPath;
+    prepare?: UploadPrepare;
+    prepareFile?: UploadPrepareFile;
+    overwrite?: boolean;
+    key: string;
+};
+type ResolvedUploadSettings = {
+    dirParams: UploadDirParams;
+    uploadDir: string;
+    urlPath: string;
+    urlPathExact: boolean;
+};
 declare class UploadManager {
+    getUploadSettingsForFile(config: UploadConfig | undefined, file: Express.Multer.File): UploadSettings;
+    resolveUploadSettings(req: ArkosRequest, file: Express.Multer.File, settings: UploadSettings): Promise<ResolvedUploadSettings>;
+    nextFileIndex(req: ArkosRequest, file: Express.Multer.File): number;
+    cleanupRequestFiles(req: ArkosRequest): Promise<void>;
     private getUpload;
     getMiddleware(config: UploadConfig): RequestHandler;
+    registerUploadConfig(config: UploadConfig, route: string): void;
     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/dependency-version-check.d.ts

@@ -0,0 +1,15 @@
+export declare const SUPPORTED_ZOD_MAJOR = 4;
+/**
+ * Reads the version range declared for a dependency in the user's package.json.
+ *
+ * @returns The declared range (e.g. "^3.24.2") or `null` when not declared.
+ */
+export declare function getDeclaredDependencyVersion(packageName: string): string | null;
+/**
+ * Asserts every package version requirement of the user's project.
+ *
+ * New dependency checks can be added here as Arkos requirements evolve.
+ *
+ * @throws {Error} When a required package version is not supported.
+ */
+export declare function assertRequiredPackageVersion(): void;

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,9 +15,63 @@ 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> & {
+export declare function defineConfig<const T extends ArkosConfig>(config: T): ResolveArkosConfig<T>;
+/**
+ * The literal defaults `defineConfig` fills in for omitted options.
+ *
+ * Defaults that are runtime/environment dependent (`port`, `host`,
+ * `source.entryPoint`, `swagger.authenticate`) stay broad; the
+ * rest are pinned to their exact literal so the generated `RuntimeArkosConfig`
+ * exposes them as-is.
+ */
+export type UserArkosConfigDefaults = {
+    welcomeMessage: "Welcome to our RESTful API generated by Arkos, find out more about Arkos at www.arkosjs.com";
+    globalPrefix: "/api";
+    port: number;
+    host: string;
+    source: {
+        entryPoint: string;
+    };
+    request: {
+        parameters: {
+            allowDangerousPrismaQueryOptions: false;
+        };
+    };
+    fileUpload: {
+        baseUploadDir: "uploads";
+        baseRoute: "/api/uploads";
+        serving: "all";
+    };
+    routers: {
+        strict: false;
+    };
+    swagger: {
+        enableAfterBuild: true;
+        authenticate: boolean;
+    };
+    debugging: {
+        requests: {
+            level: 1;
+        };
+        dynamicLoader: {
+            level: 0;
+        };
+    };
+};
+/**
+ * Overlays the declared config on top of the literal defaults: a declared value
+ * always wins, otherwise the default applies. Shared nested objects are merged
+ * so both the user's keys and the unwritten defaulted keys are present.
+ */
+type ResolveArkosConfig<T> = DeepOverride<UserArkosConfigDefaults, T> & {
+    __loader: "defineConfig";
+};
+type DeepOverride<D, T> = T extends readonly unknown[] ? T : T extends object ? D extends object ? {
+    readonly [K in keyof T | keyof D]: K extends keyof T ? K extends keyof D ? DeepOverride<D[K], T[K]> : T[K] : K extends keyof D ? D[K] : never;
+} : T : T;
+export type UserArkosConfig = Partial<ArkosConfig> & {
     __loader: "defineConfig";
 };
+export {};

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

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

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

@@ -1,3 +1,4 @@
+export declare let lastLoadedEnvFiles: string[];
 /**
  * Loads and expands environment variables in a prioritized order
  *

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

@@ -1,4 +1,5 @@
-import { UserArkosConfig } from "../define-config";
+import { UserArkosConfig } from '../define-config';
+export declare function readArkosConfig(): void;
 export declare function isUsingAuthentication(): "static" | "dynamic" | undefined;
 export declare function isAuthenticationEnabled(): boolean | undefined;
 /**
@@ -7,3 +8,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";

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

@@ -1,5 +1,6 @@
 export declare function getPackageJson(): any;
 export declare function isEsm(): boolean;
+export declare const userRequire: NodeJS.Require;
 export declare function importModule(modulePath: string, options?: {
     fixExtension: boolean;
 }): Promise<any>;

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

@@ -1,4 +1,4 @@
 export declare let prismaInstance: any;
-export declare function loadPrismaModule(): Promise<import("../../generated").PrismaClient>;
+export declare function loadPrismaModule(): import("../../generated").PrismaClient | undefined;
 export declare function handlePrismaGet(target: any, prop: string, receiver: any): any;
 export declare function getPrismaInstance(): any;

package/dist/types/utils/helpers/query-parser.helpers.d.ts

@@ -8,5 +8,5 @@ export interface Options {
     parseDoubleUnderscore?: boolean;
 }
 export declare const parse: (target: ParsedQuery, options: Options) => ParsedQuery;
-export declare const queryParser: (options: Options) => (req: ArkosRequest, res: ArkosResponse, next: ArkosNextFunction) => void;
+export declare const queryParser: (options: Options) => (req: ArkosRequest, _: ArkosResponse, next: ArkosNextFunction) => void;
 export {};

package/dist/types/utils/helpers/url-helpers.d.ts

@@ -0,0 +1 @@
+export declare function lenientDecode(str: string): string;

package/dist/types/utils/initialize-app.d.ts

@@ -1,2 +1,3 @@
 import { Arkos } from "../types/arkos";
 export default function initializeApp(app: Arkos): Arkos;
+export declare function addGlobalErrorHandler(app: Arkos): Arkos;